| """Shared batched generation and measured, log-friendly progress (no prompt text).""" |
| import gc |
| import inspect |
| import sys |
| import threading |
| import time |
| from itertools import groupby |
|
|
| from token_cache import padded_batch |
|
|
|
|
| class Progress: |
| def __init__(self, label, total=0, quiet=False, interval=5): |
| self.label, self.total, self.quiet = label, total, quiet |
| self.interval = interval |
| self.done = self.tokens = 0 |
| self.stage = 'starting' |
| self.started = time.monotonic() |
| self.last = 0.0 |
| self.lock = threading.RLock() |
| self.stop = threading.Event() |
|
|
| def update(self, stage=None, done=None, tokens=None, force=False): |
| with self.lock: |
| if stage is not None: |
| self.stage = stage |
| if done is not None: |
| self.done = done |
| if tokens is not None: |
| self.tokens = tokens |
| self.render(force) |
|
|
| def render(self, force=False): |
| now = time.monotonic() |
| if self.quiet or (not force and now-self.last < self.interval): |
| return |
| self.last = now |
| elapsed = max(now-self.started, 1e-6) |
| rate = self.done/elapsed |
| eta = f'{(self.total-self.done)/rate:.0f}s' if rate and self.total else 'pending' |
| print(f'{self.label}: {self.stage} | {self.done}/{self.total} complete | ' |
| f'{self.tokens} generated tokens | {rate:.2f}/s | elapsed {elapsed:.0f}s | ETA {eta}', |
| file=sys.stderr, flush=True) |
|
|
| def __enter__(self): |
| self.update(force=True) |
| def heartbeat(): |
| while not self.stop.wait(self.interval): |
| with self.lock: |
| self.render() |
| self.thread = threading.Thread(target=heartbeat, daemon=True) |
| if not self.quiet: |
| self.thread.start() |
| return self |
|
|
| def __exit__(self, kind, value, tb): |
| self.stop.set() |
| if self.thread.is_alive(): |
| self.thread.join(timeout=1) |
| self.update(stage='failed' if kind else 'finished', force=True) |
|
|
|
|
| def eos_ids(model, tokenizer): |
| value = getattr(model.generation_config, 'eos_token_id', None) |
| if value is None: |
| value = tokenizer.eos_token_id |
| return set(value if isinstance(value, (list, tuple)) else [] if value is None else [value]) |
|
|
|
|
| class TokenProgress: |
| """Transformers streamer: count actual decode steps without decoding text.""" |
| def __init__(self, progress, batch_size, eos, base_tokens=0): |
| self.progress = progress |
| self.active = [True]*batch_size |
| self.eos = eos |
| self.first = True |
| self.count = 0 |
| self.base = base_tokens |
|
|
| def put(self, value): |
| if self.first: |
| self.first = False |
| return |
| values = value.tolist() |
| for i, token in enumerate(values): |
| if self.active[i]: |
| self.count += 1 |
| if token in self.eos: |
| self.active[i] = False |
| self.progress.update(stage='decoding', tokens=self.base+self.count) |
|
|
| def end(self): |
| pass |
|
|
|
|
| def trim_after_eos(sequences, eos): |
| result = [] |
| for tokens in sequences: |
| end = next((i+1 for i,t in enumerate(tokens) if t in eos), len(tokens)) |
| result.append(tokens[:end]) |
| return result |
|
|
|
|
| def generate_batches(model, tokenizer, compiled, rows, budget_for, batch_size, emit, |
| progress, is_seq2seq=False, keep_special_tokens=False): |
| """Length/budget buckets, KV cache, greedy decoding, and CUDA OOM backoff.""" |
| import torch |
| ordered = sorted(rows, key=lambda q: (budget_for(q), len(compiled[q['id']]['input_ids']))) |
| eos = eos_ids(model, tokenizer) |
| done = tokens_done = 0 |
| effective_batch = batch_size |
| stats = dict(batches=0, oom_retries=0, generated_tokens=0, input_tokens=0, padded_input_tokens=0) |
| |
| |
| generation_options = {} |
| forward = getattr(model, 'forward', None) |
| if forward is not None and not is_seq2seq: |
| parameters = inspect.signature(forward).parameters |
| for name in ('logits_to_keep', 'num_logits_to_keep'): |
| if name in parameters: |
| generation_options[name] = 1 |
| break |
| stats['last_token_logits'] = bool(generation_options) |
|
|
| def generate(group, budget): |
| data = padded_batch([compiled[q['id']] for q in group], tokenizer.pad_token_id, tokenizer.padding_side) |
| width = data['input_ids'].shape[1] |
| device = model.get_input_embeddings().weight.device |
| data = {k:v.to(device) for k,v in data.items()} |
| progress.update(stage=f'prefill batch={len(group)} input_width={width}', force=True) |
| stream = TokenProgress(progress, len(group), eos, tokens_done) |
| |
| output = model.generate(**data, max_new_tokens=budget, do_sample=False, num_beams=1, |
| num_return_sequences=1, pad_token_id=tokenizer.pad_token_id, |
| use_cache=True, streamer=stream, return_dict_in_generate=False, |
| output_scores=False, **generation_options) |
| prefix = 1 if is_seq2seq else width |
| sequences = trim_after_eos(output[:, prefix:].tolist(), eos) |
| answers = tokenizer.batch_decode(sequences, skip_special_tokens=not keep_special_tokens, |
| clean_up_tokenization_spaces=False) |
| if len(answers) != len(group): |
| raise RuntimeError('Generation returned an unexpected number of sequences') |
| return answers, [len(s) for s in sequences], width |
|
|
| with torch.inference_mode(): |
| for budget, family in groupby(ordered, key=budget_for): |
| family = list(family) |
| offset = 0 |
| while offset < len(family): |
| group = family[offset:offset+effective_batch] |
| try: |
| answers, lengths, width = generate(group, budget) |
| except torch.cuda.OutOfMemoryError: |
| if len(group) == 1: |
| raise |
| effective_batch = max(1, len(group)//2) |
| stats['oom_retries'] += 1 |
| progress.update(stage=f'CUDA OOM; retry batch={effective_batch}', tokens=tokens_done, force=True) |
| else: |
| emit([(q['id'], text, length) for q,text,length in zip(group,answers,lengths)]) |
| done += len(group) |
| tokens_done += sum(lengths) |
| stats['batches'] += 1 |
| stats['input_tokens'] += sum(len(compiled[q['id']]['input_ids']) for q in group) |
| stats['padded_input_tokens'] += width*len(group) |
| progress.update(stage='batch saved', done=done, tokens=tokens_done, force=True) |
| offset += len(group) |
| continue |
| |
| gc.collect() |
| if torch.cuda.is_available(): |
| torch.cuda.empty_cache() |
| stats.update(generated_tokens=tokens_done, final_batch_size=effective_batch) |
| return stats |
|
|
