Create process_for.grepp.py

process_for.grepp.py

@@ -0,0 +1,100 @@
+import json
+from vllm import LLM, SamplingParams
+import argparse
+from tqdm import tqdm
+
+def load_jsonl(file_path):
+    """Load JSONL file line by line."""
+    data = []
+    with open(file_path, 'r', encoding='utf-8') as f:
+        for line in f:
+            data.append(json.loads(line.strip()))
+    return data
+
+def save_jsonl(data, file_path):
+    """Save data to JSONL file."""
+    with open(file_path, 'w', encoding='utf-8') as f:
+        for item in data:
+            f.write(json.dumps(item, ensure_ascii=False) + '\n')
+
+def format_prompt(instruction, input_text):
+    """Format the prompt for code generation."""
+    return f"""Below is a coding problem with instructions and example inputs. Write a solution in code.
+
+Problem Description:
+{instruction}
+
+Example Inputs:
+{input_text}
+
+Write your solution code:"""
+
+def main():
+    parser = argparse.ArgumentParser(description='Process JSONL file with CodeLlama model')
+    parser.add_argument('--input_file', type=str, required=True, help='Input JSONL file path')
+    parser.add_argument('--output_file', type=str, required=True, help='Output JSONL file path')
+    parser.add_argument('--batch_size', type=int, default=4, help='Batch size for inference')
+    args = parser.parse_args()
+
+    # Initialize the model
+    print("Loading CodeLlama model...")
+    model = LLM(
+        model="codellama/CodeLlama-7b-hf",
+        trust_remote_code=True,
+        tensor_parallel_size=1
+    )
+    
+    # Set sampling parameters
+    sampling_params = SamplingParams(
+        temperature=0.2,  # Lower temperature for more focused code generation
+        top_p=0.95,
+        max_tokens=2048,  # Increased max tokens for longer code solutions
+        stop_tokens=["\n\n\n", "```"]  # Stop at clear code boundaries
+    )
+
+    # Load data
+    print("Loading input data...")
+    data = load_jsonl(args.input_file)
+    
+    # Prepare prompts
+    prompts = []
+    for item in data:
+        instruction = item.get('instruction', '')
+        input_text = item.get('input', '')
+        prompt = format_prompt(instruction, input_text)
+        prompts.append(prompt)
+
+    # Process in batches
+    print("Generating outputs...")
+    outputs = []
+    for i in tqdm(range(0, len(prompts), args.batch_size)):
+        batch_prompts = prompts[i:i + args.batch_size]
+        batch_outputs = model.generate(batch_prompts, sampling_params)
+        
+        # Process outputs
+        for j, output in enumerate(batch_outputs):
+            idx = i + j
+            if idx < len(data):
+                # Clean the output to extract only the code
+                generated_code = output.outputs[0].text.strip()
+                # Remove any markdown code blocks if present
+                if generated_code.startswith("```"):
+                    generated_code = generated_code.split("```")[1]
+                    if generated_code.startswith("python"):
+                        generated_code = generated_code[6:]
+                generated_code = generated_code.strip()
+                
+                result = {
+                    'instruction': data[idx]['instruction'],
+                    'input': data[idx]['input'],
+                    'output': generated_code
+                }
+                outputs.append(result)
+
+    # Save results
+    print("Saving results...")
+    save_jsonl(outputs, args.output_file)
+    print(f"Processing complete. Results saved to {args.output_file}")
+
+if __name__ == "__main__":
+    main()