Download test_posttrain_chat.py from zerdovzad/WarpStateAI: direct link, hf CLI and curl.
- Browser
- Download file 8.69 kB
-
https://huggingface.co/zerdovzad/WarpStateAI/resolve/main/test_posttrain_chat.py
- Command line
-
hf download hf://zerdovzad/WarpStateAI/test_posttrain_chat.py
-
curl -L -o test_posttrain_chat.py https://huggingface.co/zerdovzad/WarpStateAI/resolve/main/test_posttrain_chat.py
8.69 kB
| """CPU tests for posttraining prompt serialization and cached inference math.""" | |
| import copy | |
| import json | |
| import pytest | |
| import torch | |
| from ops import posttrain_chat as chat | |
| from ops.posttrain_data import encode_messages | |
| from ops.residual_experiment import apply_bf16_residuals | |
| from warpstate import WarpStateConfig, WarpStateLM | |
| class SegmentTokenizer: | |
| def vocab_size(self): | |
| return 256 | |
| def eos_id(self): | |
| return 2 | |
| def bos_id(self): | |
| return 1 | |
| def encode(self, text, out_type=int): | |
| # Segment marker makes concat-then-tokenize observably different. | |
| return [3] + [ord(character) + 10 for character in text] | |
| def decode(self, tokens): | |
| return ','.join(str(value) for value in tokens) | |
| def conversation(): | |
| return [{'role': 'system', 'content': 'Be concise.'}, | |
| {'role': 'user', 'content': 'Say hello.'}, | |
| {'role': 'assistant', 'content': 'Hello.'}, | |
| {'role': 'user', 'content': 'Two plus two?'}] | |
| def test_prompt_is_exact_training_prefix_with_real_eos_only_for_history(original_tokenizer): | |
| if original_tokenizer: | |
| import sentencepiece as spm | |
| tokenizer = spm.SentencePieceProcessor(model_file=str(chat.PACKAGE / 'tokenizer.model')) | |
| else: | |
| tokenizer = SegmentTokenizer() | |
| messages = conversation() | |
| prompt = chat.encode_prompt(messages, tokenizer) | |
| encoded = encode_messages(messages + [{'role': 'assistant', 'content': 'Four.'}], tokenizer) | |
| answer_tokens = tokenizer.encode('Four.', out_type=int) | |
| assert encoded['input_ids'][:len(prompt)] == prompt | |
| assert encoded['input_ids'][len(prompt):len(prompt) + len(answer_tokens)] == answer_tokens | |
| assert encoded['labels'][len(prompt)] != -100 | |
| assert prompt[0] == tokenizer.bos_id() | |
| assert prompt.count(tokenizer.eos_id()) == 1 | |
| assert prompt[-len(tokenizer.encode('<|assistant|>\n', out_type=int)):] == tokenizer.encode('<|assistant|>\n', out_type=int) | |
| def test_prompt_rejects_invalid_conversations(messages): | |
| with pytest.raises(ValueError): | |
| chat.encode_prompt(messages, SegmentTokenizer()) | |
| def tiny_model(parallel=True): | |
| with torch.random.fork_rng(devices=[]): | |
| torch.manual_seed(23) | |
| cfg = WarpStateConfig(vocab_size=64, d_model=32, n_heads=4, n_cores=2, | |
| logical_depth=3, ffn_hidden=64, chunk_size=4, dropout=0.0, | |
| parallel_memory=parallel, gradient_checkpointing=False) | |
| model = WarpStateLM(cfg).eval().requires_grad_(False) | |
| model.embed.weight.normal_(std=0.2) | |
| model.depth_scale.normal_(std=0.05) | |
| model.depth_bias.normal_(std=0.01) | |
| for core in model.cores: | |
| core.in_proj.weight.normal_(std=0.15) | |
| core.out_proj.weight.normal_(std=0.12) | |
| return model | |
| def test_cached_logits_match_full_forward_across_seven_chunks(parallel, dtype): | |
| torch.set_num_threads(1) | |
| model = tiny_model(parallel) | |
| original = {name: parameter.clone() for name, parameter in model.named_parameters()} | |
| full = copy.deepcopy(model) | |
| apply_bf16_residuals(full) | |
| decoder = chat.CachedDecoder(model, dtype=dtype) | |
| tokens = torch.arange(28).reshape(1, -1) % model.cfg.vocab_size | |
| with torch.inference_mode(), torch.autocast('cpu', dtype=torch.bfloat16, | |
| enabled=dtype == torch.bfloat16, cache_enabled=False): | |
| expected = full(tokens) | |
| caches = decoder.new_caches() | |
| actual = torch.cat([decoder.step(tokens[:, index:index + 1], caches) | |
| for index in range(tokens.shape[1])], dim=1) | |
| # Shape-dependent GEMM/SDPA rounding is expected in BF16. FP32 verifies the | |
| # recurrence itself tightly, including shared cores with separate caches. | |
| tolerance = dict(rtol=0.025, atol=0.025) if dtype == torch.bfloat16 else dict(rtol=1e-5, atol=2e-6) | |
| torch.testing.assert_close(actual, expected, **tolerance) | |
| assert all(cache.position == 0 and cache.fast.dtype == dtype for cache in caches) | |
| assert all(len(cache.writes) == (7 if parallel else 0) for cache in caches) | |
| for name, parameter in model.named_parameters(): | |
| assert parameter.dtype == torch.float32 and torch.equal(parameter, original[name]) | |
| class FakeDecoder: | |
| device = torch.device('cpu') | |
| def __init__(self, prefix_length, sequence): | |
| self.prefix_length, self.sequence, self.calls = prefix_length, sequence, 0 | |
| def new_caches(self): | |
| return [] | |
| def step(self, token, caches): | |
| self.calls += 1 | |
| index = max(0, self.calls - self.prefix_length) | |
| value = self.sequence[min(index, len(self.sequence) - 1)] | |
| logits = torch.full((1, 1, 256), -100.) | |
| logits[0, 0, value] = 100. | |
| return logits | |
| def test_generation_stops_on_eos_and_excludes_eos_from_response(): | |
| tokenizer = SegmentTokenizer() | |
| messages = [{'role': 'user', 'content': 'Question'}] | |
| prefix = chat.encode_prompt(messages, tokenizer) | |
| decoder = FakeDecoder(len(prefix), [7, 8, tokenizer.eos_id()]) | |
| emitted = [] | |
| result = chat.generate(decoder, tokenizer, messages, max_new_tokens=10, | |
| on_token=lambda tokens: emitted.append((tokens, decoder.calls))) | |
| assert result['token_ids'] == [7, 8] and result['response'] == '7,8' | |
| assert result['generated_tokens'] == 2 and result['sampled_tokens'] == 3 | |
| assert result['stop_reason'] == 'eos' | |
| assert decoder.calls == len(prefix) + 2 | |
| assert emitted == [((7,), len(prefix)), ((7, 8), len(prefix) + 1)] | |
| assert result['elapsed_seconds'] >= result['first_token_seconds'] >= 0 | |
| def test_generation_preserves_prompt_and_respects_context_limit(): | |
| tokenizer = SegmentTokenizer() | |
| messages = [{'role': 'user', 'content': 'Question'}] | |
| prefix = chat.encode_prompt(messages, tokenizer) | |
| decoder = FakeDecoder(len(prefix), [7]) | |
| result = chat.generate(decoder, tokenizer, messages, max_new_tokens=10, max_context=len(prefix) + 2) | |
| assert result['prompt_tokens'] == len(prefix) and result['generated_tokens'] == 2 | |
| assert result['stop_reason'] == 'context_limit' | |
| with pytest.raises(ValueError, match='context limit'): | |
| chat.generate(decoder, tokenizer, messages, max_context=len(prefix)) | |
| def test_suite_preserves_ids_and_ignores_rubric_fields(tmp_path): | |
| path = tmp_path / 'prompts.json' | |
| rows = [{'id': 'math', 'prompt': 'Two plus two?', 'expected_exact': '4', 'rubric': 'Correct arithmetic'}] | |
| path.write_text(json.dumps(rows)) | |
| assert chat.read_prompts(path) == rows | |
| path.write_text(json.dumps({'prompts': rows})) | |
| assert chat.read_prompts(path) == rows | |
| path.write_text(json.dumps(rows * 2)) | |
| with pytest.raises(ValueError, match='distinct'): | |
| chat.read_prompts(path) | |
| def test_ctrl_c_cancels_typing_and_generation_preserving_completed_history(monkeypatch, capsys): | |
| inputs = iter(['first', KeyboardInterrupt(), 'cancel reply', 'next', '/quit']) | |
| calls = [] | |
| def read(prompt): | |
| value = next(inputs) | |
| if isinstance(value, BaseException): | |
| raise value | |
| return value | |
| def reply(messages, *, seed): | |
| calls.append(copy.deepcopy(messages)) | |
| if messages[-1]['content'] == 'cancel reply': | |
| raise KeyboardInterrupt() | |
| return {'response': 'completed'} | |
| monkeypatch.setattr('builtins.input', read) | |
| assert chat.interactive_chat(reply, lambda prompt: [{'role': 'user', 'content': prompt}], seed=42) == 0 | |
| assert calls[-1] == [ | |
| {'role': 'user', 'content': 'first'}, | |
| {'role': 'assistant', 'content': 'completed'}, | |
| {'role': 'user', 'content': 'next'}] | |
| assert capsys.readouterr().out.count('Cancelled.') == 2 | |
| def test_ctrl_c_unwinds_cached_parameter_views_and_allows_next_generation(monkeypatch): | |
| model = tiny_model() | |
| original = dict(model.named_parameters()) | |
| decoder = chat.CachedDecoder(model) | |
| step = chat._core_step | |
| def interrupt(*args): | |
| raise KeyboardInterrupt() | |
| monkeypatch.setattr(chat, '_core_step', interrupt) | |
| with pytest.raises(KeyboardInterrupt): | |
| decoder.step(torch.tensor([[4]]), decoder.new_caches()) | |
| assert all(parameter is original[name] for name, parameter in model.named_parameters()) | |
| monkeypatch.setattr(chat, '_core_step', step) | |
| assert torch.isfinite(decoder.step(torch.tensor([[4]]), decoder.new_caches())).all() | |