File size: 4,102 Bytes
f3801df | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 | """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,
)
|