File size: 4,942 Bytes
d5049a2 | 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 130 131 132 133 | from __future__ import annotations
import argparse
import json
import threading
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
import torch
from peft import PeftModel
from .common import (
append_response_ids,
apply_chat_template,
build_messages,
infer_input_device,
move_to_device,
tokenizer_fingerprint,
)
from .losses import response_token_logps
from .modeling import load_base_model, load_processor
class TeacherState:
def __init__(self, args: argparse.Namespace) -> None:
self.model_path = args.model
self.num_views = args.num_views
self.max_length = args.max_length
self.processor = load_processor(args.model)
model = load_base_model(
args.model, attn_implementation=args.attn_implementation
)
if args.adapter_path:
model = PeftModel.from_pretrained(model, args.adapter_path, is_trainable=False)
self.model = model.cuda().eval()
self.device = infer_input_device(self.model)
self.fingerprint = tokenizer_fingerprint(self.processor.tokenizer)
self.lock = threading.Lock()
def health(self) -> dict:
return {
"ok": True,
"model": self.model_path,
"num_views": self.num_views,
"tokenizer_size": len(self.processor.tokenizer),
"tokenizer_sha256": self.fingerprint,
}
def score(self, payload: dict) -> dict:
response_list = payload.get("response_ids")
if not isinstance(response_list, list) or not response_list:
raise ValueError("response_ids must be a non-empty list")
response_ids = torch.tensor(
[response_list], dtype=torch.long, device=self.device
)
messages = build_messages(
str(payload["question"]),
dict(payload["image_paths"]),
self.num_views,
)
prompt = apply_chat_template(
self.processor,
messages,
add_generation_prompt=True,
max_length=self.max_length,
)
prompt = move_to_device(prompt, self.device)
batch, prompt_len = append_response_ids(prompt, response_ids)
if batch["input_ids"].shape[1] > self.max_length:
raise ValueError("prompt + response exceeds teacher max_length")
with self.lock, torch.inference_mode():
outputs = self.model(**batch, use_cache=False)
logps = response_token_logps(outputs.logits, response_ids, prompt_len)
return {
"token_logps": logps[0].float().cpu().tolist(),
"prompt_tokens": prompt_len,
"response_tokens": int(response_ids.shape[1]),
}
def handler_factory(state: TeacherState):
class Handler(BaseHTTPRequestHandler):
def _send(self, status: int, payload: dict) -> None:
body = json.dumps(payload, ensure_ascii=False).encode("utf-8")
self.send_response(status)
self.send_header("Content-Type", "application/json; charset=utf-8")
self.send_header("Content-Length", str(len(body)))
self.end_headers()
self.wfile.write(body)
def do_GET(self) -> None:
if self.path == "/health":
self._send(200, state.health())
else:
self._send(404, {"error": "not found"})
def do_POST(self) -> None:
if self.path != "/score":
self._send(404, {"error": "not found"})
return
try:
length = int(self.headers.get("Content-Length", "0"))
if length <= 0 or length > 4 * 1024 * 1024:
raise ValueError("invalid request size")
payload = json.loads(self.rfile.read(length))
self._send(200, state.score(payload))
except Exception as exc:
self._send(400, {"error": f"{type(exc).__name__}: {exc}"})
def log_message(self, fmt: str, *args) -> None:
print(f"teacher_http {self.address_string()} {fmt % args}", flush=True)
return Handler
def main() -> None:
parser = argparse.ArgumentParser(description="Sampled-token OPD teacher server")
parser.add_argument("--model", required=True)
parser.add_argument("--adapter-path", default=None)
parser.add_argument("--host", default="127.0.0.1")
parser.add_argument("--port", type=int, default=18080)
parser.add_argument("--num-views", type=int, default=6)
parser.add_argument("--max-length", type=int, default=4096)
parser.add_argument("--attn-implementation", default="sdpa")
args = parser.parse_args()
state = TeacherState(args)
print(json.dumps(state.health(), ensure_ascii=False), flush=True)
server = ThreadingHTTPServer((args.host, args.port), handler_factory(state))
server.serve_forever()
if __name__ == "__main__":
main()
|