| """utils — v8b (dense Qwen3-8B).""" |
| import json, logging, os, sys |
| from typing import Dict, List |
| import numpy as np |
| import torch |
|
|
|
|
| def think_segment(text: str) -> str: |
| """Return only the <think>...</think> reasoning content. |
| |
| Same semantics as stage-00 _extract_thinking: cut at the first |
| </think>, strip a leading <think>. If no </think> is present (the |
| model never closed the block, e.g. on collapse), the whole text is |
| treated as the thinking segment. Used so that ALL eval-side counting |
| (tokens, reflection markers, chars, repetition) is measured strictly |
| inside the think block — the same object the steering direction was |
| learned on. Answer grading still runs on the FULL output, since the |
| boxed answer lives after </think>. |
| """ |
| if "</think>" in text: |
| text = text.split("</think>", 1)[0] |
| s = text.strip() |
| if s.startswith("<think>"): |
| s = s[len("<think>"):] |
| return s.strip() |
|
|
|
|
| def json_safe(obj): |
| if isinstance(obj, dict): |
| return {json_safe(k): json_safe(v) for k, v in obj.items()} |
| if isinstance(obj, (list, tuple)): |
| return [json_safe(v) for v in obj] |
| if isinstance(obj, np.integer): |
| return int(obj) |
| if isinstance(obj, np.floating): |
| return float(obj) |
| if isinstance(obj, np.bool_): |
| return bool(obj) |
| if isinstance(obj, np.ndarray): |
| return obj.tolist() |
| if isinstance(obj, torch.Tensor): |
| return obj.tolist() |
| return obj |
|
|
|
|
| def write_json(obj, path: str): |
| os.makedirs(os.path.dirname(path), exist_ok=True) |
| with open(path, "w", encoding="utf-8") as f: |
| json.dump(json_safe(obj), f, indent=2, ensure_ascii=False) |
|
|
|
|
| def read_json(path: str): |
| with open(path, "r", encoding="utf-8") as f: |
| return json.load(f) |
|
|
|
|
| def read_jsonl(path: str) -> List[Dict]: |
| out = [] |
| with open(path, "r", encoding="utf-8") as f: |
| for line in f: |
| line = line.strip() |
| if line: |
| out.append(json.loads(line)) |
| return out |
|
|
|
|
| def write_jsonl(items: List[Dict], path: str): |
| os.makedirs(os.path.dirname(path), exist_ok=True) |
| with open(path, "w", encoding="utf-8") as f: |
| for it in items: |
| f.write(json.dumps(json_safe(it), ensure_ascii=False) + "\n") |
|
|
|
|
| def append_jsonl(item: Dict, path: str): |
| os.makedirs(os.path.dirname(path), exist_ok=True) |
| with open(path, "a", encoding="utf-8") as f: |
| f.write(json.dumps(json_safe(item), ensure_ascii=False) + "\n") |
|
|
|
|
| def setup_logger(name: str, log_file: str = None, level=logging.INFO): |
| logger = logging.getLogger(name) |
| logger.setLevel(level) |
| logger.handlers = [] |
| fmt = logging.Formatter( |
| "%(asctime)s | %(levelname)-5s | %(name)s | %(message)s", |
| datefmt="%H:%M:%S", |
| ) |
| ch = logging.StreamHandler(sys.stdout) |
| ch.setLevel(level) |
| ch.setFormatter(fmt) |
| logger.addHandler(ch) |
| if log_file: |
| os.makedirs(os.path.dirname(log_file), exist_ok=True) |
| fh = logging.FileHandler(log_file, mode="a", encoding="utf-8") |
| fh.setLevel(level) |
| fh.setFormatter(fmt) |
| logger.addHandler(fh) |
| return logger |
|
|
|
|
| def get_device() -> str: |
| return "cuda" if torch.cuda.is_available() else "cpu" |
|
|
|
|
| def load_model_and_tokenizer(device: str = "cuda"): |
| from transformers import AutoModelForCausalLM, AutoTokenizer |
| from configs.paths import MODEL_PATH |
| tok = AutoTokenizer.from_pretrained(MODEL_PATH, trust_remote_code=True) |
| model = AutoModelForCausalLM.from_pretrained( |
| MODEL_PATH, |
| torch_dtype=torch.bfloat16, |
| device_map=device, |
| trust_remote_code=True, |
| ) |
| model.eval() |
| return model, tok |
|
|
|
|
| def build_chat_prompt(tokenizer, problem: str, enable_thinking: bool = True, |
| system: str = "You are a helpful math assistant.") -> str: |
| msgs = [ |
| {"role": "system", "content": system}, |
| {"role": "user", "content": problem}, |
| ] |
| return tokenizer.apply_chat_template( |
| msgs, tokenize=False, add_generation_prompt=True, |
| enable_thinking=enable_thinking, |
| ) |
|
|
