| import re |
| import time |
| from dataclasses import dataclass |
| from cure_wm import TestCase |
| CODE_FENCE = re.compile('```(?:python|py)?\\s*\\n(.*?)```', re.I | re.S) |
| TEST_INPUT = re.compile('\\*\\*Test Input:\\*\\*\\s*```[^\\n]*\\n(.*?)```', re.I | re.S) |
| TEST_OUTPUT = re.compile('\\*\\*Test Output:\\*\\*\\s*```[^\\n]*\\n(.*?)```', re.I | re.S) |
|
|
| def extract_code(text): |
| matches = CODE_FENCE.findall(text) |
| if matches: |
| return matches[-1].strip() + '\n' |
| tail = text.split('</think>')[-1].strip() |
| lines = tail.splitlines() |
| for (i, line) in enumerate(lines): |
| if line.startswith(('import ', 'from ', 'def ', 'class ', 'if __name__', 'n =', 'n=', 'a =', 'a=', 's =', 's=')): |
| return '\n'.join(lines[i:]).strip() + '\n' |
| return '' |
|
|
| @dataclass(frozen=True) |
| class Generation: |
| text: str |
| input_tokens: int |
| output_tokens: int |
| seconds: float |
|
|
| class FrozenCoder: |
|
|
| def __init__(self, model_path): |
| import torch |
| from transformers import AutoModelForCausalLM, AutoTokenizer |
| self.torch = torch |
| self.tokenizer = AutoTokenizer.from_pretrained(model_path, local_files_only=True) |
| self.model = AutoModelForCausalLM.from_pretrained(model_path, torch_dtype=torch.bfloat16, device_map='cuda:0', local_files_only=True).eval() |
|
|
| def _generate(self, user_prompt, *, n=1, seed=0, max_new_tokens=2048): |
| torch = self.torch |
| prompt = self.tokenizer.apply_chat_template([{'role': 'system', 'content': 'You are a helpful assistant for solving Python coding problems.'}, {'role': 'user', 'content': user_prompt}], tokenize=False, add_generation_prompt=True) |
| tokens = self.tokenizer(prompt, return_tensors='pt', truncation=False).to('cuda:0') |
| input_length = tokens['input_ids'].shape[1] |
| if input_length + max_new_tokens > 20000: |
| raise ValueError(f'Prompt too long: {input_length} tokens') |
| torch.manual_seed(seed) |
| started = time.monotonic() |
| with torch.inference_mode(): |
| outputs = self.model.generate(**tokens, do_sample=True, temperature=0.8, top_p=0.95, max_new_tokens=max_new_tokens, num_return_sequences=n, pad_token_id=self.tokenizer.eos_token_id) |
| elapsed = time.monotonic() - started |
| generations = [] |
| for seq in outputs: |
| continuation = seq[input_length:].tolist() |
| if self.tokenizer.eos_token_id in continuation: |
| output_tokens = continuation.index(self.tokenizer.eos_token_id) + 1 |
| else: |
| output_tokens = len(continuation) |
| generations.append(Generation(self.tokenizer.decode(continuation[:output_tokens], skip_special_tokens=True), input_length, output_tokens, elapsed / n)) |
| return tuple(generations) |
|
|
| def initial(self, problem, seed): |
| prompt = f'Think first, then write a complete Python script for the problem below. Read from standard input and print the answer to standard output. Put the final runnable script in one ```python block.\n\nProblem:\n{problem}' |
| raw = self._generate(prompt, seed=seed, max_new_tokens=4096)[0] |
| return (extract_code(raw.text), raw) |
|
|
| def refine(self, problem, current_code, feedback, visible_tests, *, k, seed): |
| lines = [] |
| for (test, result) in zip(visible_tests, feedback.results): |
| lines.append(f'Input: {test.input[:1000]!r}\nExpected: {test.expected[:500]!r}\nObserved: {result.actual[:500]!r}\nStatus: {result.status}\nError: {result.stderr[:500]}') |
| prompt = f'Revise the following Python script to solve the problem. Read from standard input and print to standard output. Use the observed test feedback to fix the program. Return a complete runnable script in one ```python block.\n\nProblem:\n{problem}\n\nCurrent script:\n```python\n{current_code}\n```\n\nVisible test feedback:\n' + '\n\n'.join(lines) |
| raws = self._generate(prompt, n=k, seed=seed, max_new_tokens=4096) |
| return tuple(((extract_code(raw.text), raw) for raw in raws)) |
|
|
