Add TPU extractor

scripts/extract_mistral_hidden_states_tpu.py

@@ -0,0 +1,640 @@
+#!/usr/bin/env python3
+"""Memory-bounded Mistral-7B last-token hidden-state extraction on TPU.
+
+The extractor deliberately loads ``MistralModel`` (no LM head), disables the
+KV cache, and captures only one vector after each transformer block.  It does
+not request ``output_hidden_states=True`` and therefore does not retain a full
+``[batch, sequence, hidden]`` tensor for every layer.
+
+Output shards contain:
+
+* ``embedding``: ``[N, 4096]`` BF16 last-token input embeddings.
+* ``hidden_states``: ``[N, 32, 4096]`` BF16 last-token block states.  Layers
+  0..30 are post-block states and layer 31 is post-final-RMSNorm, matching the
+  32 tensors selected by ``outputs.hidden_states[1:]`` in Transformers.
+
+The script is resumable at shard granularity.  PyTorch/XLA compiles one graph
+per static ``(batch_size, bucket_length)`` shape.
+"""
+
+from __future__ import annotations
+
+import argparse
+import gc
+import hashlib
+import json
+import os
+import platform
+import re
+import sys
+import time
+from collections import defaultdict
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any, Iterable
+
+# Set these before importing torch_xla/JAX-backed packages.
+os.environ.setdefault("PJRT_DEVICE", "TPU")
+os.environ.setdefault("XLA_NO_SPECIAL_SCALARS", "1")
+os.environ.setdefault("TOKENIZERS_PARALLELISM", "true")
+os.environ.setdefault("OMP_NUM_THREADS", str(os.cpu_count() or 1))
+os.environ.setdefault("MALLOC_ARENA_MAX", "2")
+
+import torch
+import torch_xla
+from datasets import load_dataset
+from safetensors.torch import save_file
+from transformers import AutoTokenizer, MistralModel
+
+
+DEFAULT_MODEL = "mistralai/Mistral-7B-Instruct-v0.3"
+DEFAULT_MODEL_REVISION = "c170c708c41dac9275d15a8fff4eca08d52bab71"
+DEFAULT_BUCKETS = (128, 256, 512, 1024, 2048)
+
+
+@dataclass(frozen=True)
+class InputRecord:
+    source_index: int
+    text: str
+    question: str = ""
+    answer: str = ""
+    context: str = ""
+    label: int | None = None
+    original_answer: str = ""
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    source = parser.add_mutually_exclusive_group()
+    source.add_argument(
+        "--input-jsonl",
+        type=Path,
+        help="JSONL containing `text`, or paper-style question/context/answer fields.",
+    )
+    source.add_argument(
+        "--dataset",
+        default="stanfordnlp/coqa",
+        help="Hugging Face dataset id. CoQA receives paper-compatible flattening.",
+    )
+    parser.add_argument("--split", default="validation")
+    parser.add_argument(
+        "--answer-mode",
+        choices=("reference", "best_answer"),
+        default="reference",
+        help="For structured QA data, append a reference or pre-generated best answer.",
+    )
+    parser.add_argument(
+        "--answer-view",
+        choices=("full", "first_sentence"),
+        default="full",
+        help="Extract at the full answer's last token or apply the paper's FST rule first.",
+    )
+    parser.add_argument("--text-column", default="text")
+    parser.add_argument("--max-samples", type=int, default=1000)
+    parser.add_argument("--start-index", type=int, default=0)
+    parser.add_argument("--model-id", default=DEFAULT_MODEL)
+    parser.add_argument("--revision", default=DEFAULT_MODEL_REVISION)
+    parser.add_argument("--cache-dir", type=Path, default=Path("/content/hf-cache"))
+    parser.add_argument("--output-dir", type=Path, required=True)
+    parser.add_argument("--batch-size", type=int, default=1)
+    parser.add_argument("--shard-size", type=int, default=64)
+    parser.add_argument(
+        "--buckets",
+        type=int,
+        nargs="+",
+        default=list(DEFAULT_BUCKETS),
+        help="Static sequence lengths; overlength inputs are left-truncated to the largest.",
+    )
+    parser.add_argument(
+        "--attn-implementation",
+        choices=("sdpa", "eager"),
+        default="sdpa",
+    )
+    parser.add_argument("--overwrite", action="store_true")
+    parser.add_argument(
+        "--prepare-only",
+        action="store_true",
+        help="Materialize normalized inputs and manifest without loading Mistral.",
+    )
+    return parser.parse_args()
+
+
+def qa_prompt(context: str, question: str) -> str:
+    return (
+        "Answer the question as briefly as possible, based only on the context:\n"
+        f" Context:{context.strip()}\n Question:{question.strip()}\n Answer:"
+    )
+
+
+# Verbatim behavior of the released postprocess_answers/extract_first_sentence
+# path, reorganized into dependency-free functions.  This is deliberately not
+# nltk sentence tokenization: the paper uses this rule-based scanner.
+FST_FILTERS = (
+    "\n", "Q:", "A:", "question:", "answer:", "Question:", "Answer:",
+    "Questions:", "questions:", "QUESTION:", "ANSWER:", "REF", ".Forms",
+    "http", "php", "Question", "Answer",
+)
+FST_WORD_ABBREVIATIONS = {
+    "Mr", "Mrs", "Ms", "Dr", "Prof", "Sr", "Jr", "Gen", "Brig", "Adm",
+    "Rear", "Lt", "Col", "Maj", "Capt", "St", "vs", "etc", "Fig", "Eq", "No",
+}
+FST_MULTI_DOT_ABBREVIATION = re.compile(r"(?:[A-Za-z]\.){2,}$")
+FST_SINGLE_INITIAL = re.compile(r"^[A-Za-z]$")
+
+
+def extract_first_sentence(text: str) -> str:
+    text = text.strip()
+    length = len(text)
+    cursor = 0
+    while cursor < length:
+        char = text[cursor]
+        if char not in ".!?":
+            cursor += 1
+            continue
+        if char == "." and text[cursor : cursor + 3] == "...":
+            cursor += 3
+            continue
+        if (
+            char == "."
+            and 0 < cursor < length - 1
+            and text[cursor - 1].isdigit()
+            and text[cursor + 1].isdigit()
+        ):
+            cursor += 1
+            continue
+        left = cursor - 1
+        while left >= 0 and (text[left].isalpha() or text[left] == "."):
+            left -= 1
+        token = text[left + 1 : cursor].strip()
+        if char == ".":
+            right_is_letter_dot = (
+                cursor + 2 < length
+                and text[cursor + 1].isalpha()
+                and text[cursor + 2] == "."
+            )
+            if cursor > 0 and text[cursor - 1].isalpha() and right_is_letter_dot:
+                cursor += 1
+                continue
+        if "." in token and FST_MULTI_DOT_ABBREVIATION.match(token + "."):
+            cursor += 1
+            continue
+        if token in FST_WORD_ABBREVIATIONS:
+            if token == "No":
+                right = cursor + 1
+                while right < length and text[right].isspace():
+                    right += 1
+                if right < length and text[right].isdigit():
+                    cursor += 1
+                    continue
+            else:
+                cursor += 1
+                continue
+        if FST_SINGLE_INITIAL.match(token):
+            right = cursor + 1
+            while right < length and text[right].isspace():
+                right += 1
+            if right < length and text[right].isupper():
+                cursor += 1
+                continue
+        return text[: cursor + 1].strip()
+    return text
+
+
+def first_sentence_truncation(answer: str) -> str:
+    original = answer.strip()
+    cut_position = len(answer)
+    for marker in FST_FILTERS:
+        marker_position = answer.find(marker)
+        if 0 <= marker_position < cut_position:
+            cut_position = marker_position
+    filtered = answer[:cut_position].strip() or original
+    return extract_first_sentence(filtered)
+
+
+def select_answer_view(answer: str, args: argparse.Namespace) -> str:
+    return first_sentence_truncation(answer) if args.answer_view == "first_sentence" else answer
+
+
+def record_from_mapping(row: dict[str, Any], source_index: int, args: argparse.Namespace) -> InputRecord:
+    if args.text_column in row and row.get(args.text_column) not in (None, ""):
+        if args.answer_view != "full":
+            raise ValueError(
+                "--answer-view first_sentence requires structured context/question/answer fields, not a prejoined text field"
+            )
+        text = str(row[args.text_column])
+        return InputRecord(
+            source_index=source_index,
+            text=text,
+            question=str(row.get("question", "")),
+            answer=str(row.get("answer", row.get("best_answer", ""))),
+            context=str(row.get("context", "")),
+            label=int(row["label"]) if row.get("label") is not None else None,
+            original_answer=str(row.get("answer", row.get("best_answer", ""))),
+        )
+
+    context = str(row.get("context", row.get("story", "")))
+    question = str(row.get("question", ""))
+    if args.answer_mode == "best_answer":
+        original_answer = str(row.get("best_answer", ""))
+        if not original_answer:
+            raise ValueError(f"row {source_index} has no non-empty best_answer")
+    else:
+        answer_value = row.get("answer", row.get("answers", ""))
+        if isinstance(answer_value, dict):
+            answer_value = answer_value.get("input_text", answer_value.get("text", ""))
+        if isinstance(answer_value, (list, tuple)):
+            answer_value = answer_value[0] if answer_value else ""
+        original_answer = str(answer_value)
+    answer = select_answer_view(original_answer, args)
+    if not question or not answer:
+        raise ValueError(
+            f"row {source_index} cannot be converted: provide `text`, or question plus answer(s)"
+        )
+    text = f"{qa_prompt(context, question)} {answer}"
+    return InputRecord(
+        source_index=source_index,
+        text=text,
+        question=question,
+        answer=answer,
+        context=context,
+        label=int(row["label"]) if row.get("label") is not None else None,
+        original_answer=original_answer,
+    )
+
+
+def iter_coqa(args: argparse.Namespace) -> Iterable[InputRecord]:
+    dataset = load_dataset(
+        "stanfordnlp/coqa",
+        split=args.split,
+        cache_dir=str(args.cache_dir / "datasets"),
+    )
+    flat_index = 0
+    emitted = 0
+    stop = args.start_index + args.max_samples if args.max_samples else None
+    for sample in dataset:
+        story = sample["story"]
+        questions = sample["questions"]
+        answers = sample["answers"]["input_text"]
+        for question, answer in zip(questions, answers, strict=True):
+            if flat_index >= args.start_index and (stop is None or flat_index < stop):
+                selected_answer = select_answer_view(answer, args)
+                text = f"{qa_prompt(story, question)} {selected_answer}"
+                yield InputRecord(
+                    source_index=flat_index,
+                    text=text,
+                    question=question,
+                    answer=selected_answer,
+                    context=story,
+                    label=None,
+                    original_answer=answer,
+                )
+                emitted += 1
+            flat_index += 1
+            if stop is not None and flat_index >= stop:
+                return
+    if emitted == 0:
+        raise ValueError(f"start index {args.start_index} is outside flattened CoQA split")
+
+
+def load_records(args: argparse.Namespace) -> list[InputRecord]:
+    if args.input_jsonl:
+        records: list[InputRecord] = []
+        stop = args.start_index + args.max_samples if args.max_samples else None
+        with args.input_jsonl.open(encoding="utf-8") as handle:
+            for index, line in enumerate(handle):
+                if index < args.start_index:
+                    continue
+                if stop is not None and index >= stop:
+                    break
+                line = line.strip()
+                if line:
+                    records.append(record_from_mapping(json.loads(line), index, args))
+        return records
+    if args.dataset == "stanfordnlp/coqa":
+        return list(iter_coqa(args))
+
+    dataset = load_dataset(
+        args.dataset,
+        split=args.split,
+        cache_dir=str(args.cache_dir / "datasets"),
+    )
+    stop = args.start_index + args.max_samples if args.max_samples else len(dataset)
+    return [
+        record_from_mapping(dict(dataset[index]), index, args)
+        for index in range(args.start_index, min(stop, len(dataset)))
+    ]
+
+
+def assign_bucket(token_count: int, buckets: tuple[int, ...]) -> tuple[int, int]:
+    for bucket in buckets:
+        if token_count <= bucket:
+            return bucket, 0
+    return buckets[-1], token_count - buckets[-1]
+
+
+def write_jsonl(path: Path, rows: Iterable[dict[str, Any]]) -> None:
+    tmp = path.with_suffix(path.suffix + ".tmp")
+    with tmp.open("w", encoding="utf-8") as handle:
+        for row in rows:
+            handle.write(json.dumps(row, ensure_ascii=False, separators=(",", ":")) + "\n")
+    tmp.replace(path)
+
+
+class LastTokenCapture:
+    """Capture only small last-position slices from the embedding and blocks."""
+
+    def __init__(self, model: MistralModel):
+        self.embedding: torch.Tensor | None = None
+        self.layers: dict[int, torch.Tensor] = {}
+        self.handles = [model.embed_tokens.register_forward_hook(self._embedding_hook)]
+        # The final raw block output is replaced with post-final-norm below so
+        # the indexing agrees with Transformers output_hidden_states[1:].
+        for layer_index, layer in enumerate(model.layers[:-1]):
+            self.handles.append(layer.register_forward_hook(self._layer_hook(layer_index)))
+
+    def _embedding_hook(self, _module: Any, _inputs: Any, output: torch.Tensor) -> None:
+        self.embedding = output[:, -1, :].clone()
+
+    def _layer_hook(self, layer_index: int):
+        def hook(_module: Any, _inputs: Any, output: torch.Tensor) -> None:
+            self.layers[layer_index] = output[:, -1, :].clone()
+
+        return hook
+
+    def clear(self) -> None:
+        self.embedding = None
+        self.layers.clear()
+
+    def close(self) -> None:
+        for handle in self.handles:
+            handle.remove()
+
+
+def extract_batch(
+    model: MistralModel,
+    capture: LastTokenCapture,
+    device: torch.device,
+    input_ids: torch.Tensor,
+    attention_mask: torch.Tensor,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    capture.clear()
+    # PyTorch/XLA rotary-embedding buffers currently need tensor version
+    # counters, which torch.inference_mode() disables. no_grad() avoids
+    # autograd retention while remaining compatible with XLA views.
+    with torch.no_grad():
+        outputs = model(
+            input_ids=input_ids.to(device),
+            attention_mask=attention_mask.to(device),
+            use_cache=False,
+            return_dict=True,
+        )
+        final_state = outputs.last_hidden_state[:, -1, :].clone()
+        if capture.embedding is None or len(capture.layers) != model.config.num_hidden_layers - 1:
+            raise RuntimeError("incomplete hook capture")
+        hidden = torch.stack(
+            [capture.layers[index] for index in range(model.config.num_hidden_layers - 1)]
+            + [final_state],
+            dim=1,
+        )
+        # One device-to-host transfer per batch.  This is the XLA execution
+        # barrier and JIT-compiles the static bucket on its first occurrence.
+        packed = torch.cat((capture.embedding.unsqueeze(1), hidden), dim=1).cpu()
+    torch_xla.sync(wait=True)
+    return packed[:, 0].contiguous(), packed[:, 1:].contiguous()
+
+
+def existing_source_indices(metadata_path: Path) -> set[int]:
+    if not metadata_path.exists():
+        return set()
+    result: set[int] = set()
+    with metadata_path.open(encoding="utf-8") as handle:
+        for line in handle:
+            if line.strip():
+                result.add(int(json.loads(line)["source_index"]))
+    return result
+
+
+def main() -> None:
+    args = parse_args()
+    if args.batch_size < 1 or args.shard_size < args.batch_size:
+        raise ValueError("batch size must be positive and no larger than shard size")
+    buckets = tuple(sorted(set(args.buckets)))
+    if not buckets or buckets[0] < 1:
+        raise ValueError("buckets must contain positive lengths")
+
+    output_dir = args.output_dir.resolve()
+    shards_dir = output_dir / "states" / args.split
+    output_dir.mkdir(parents=True, exist_ok=True)
+    shards_dir.mkdir(parents=True, exist_ok=True)
+    inputs_path = output_dir / f"inputs-{args.split}.jsonl"
+    metadata_path = output_dir / f"metadata-{args.split}.jsonl"
+    manifest_path = output_dir / "manifest.json"
+
+    tokenizer = AutoTokenizer.from_pretrained(
+        args.model_id,
+        revision=args.revision,
+        cache_dir=str(args.cache_dir),
+        use_fast=True,
+    )
+    tokenizer.pad_token_id = tokenizer.eos_token_id
+    tokenizer.padding_side = "left"
+    tokenizer.truncation_side = "left"
+
+    records = load_records(args)
+    if not records:
+        raise ValueError("no input records")
+    prepared: list[dict[str, Any]] = []
+    by_bucket: dict[int, list[tuple[InputRecord, int, int]]] = defaultdict(list)
+    for record in records:
+        token_count = len(tokenizer(record.text, add_special_tokens=False)["input_ids"])
+        bucket, truncated_tokens = assign_bucket(token_count, buckets)
+        by_bucket[bucket].append((record, token_count, truncated_tokens))
+        prepared.append(
+            {
+                **asdict(record),
+                "input_sha256": hashlib.sha256(record.text.encode("utf-8")).hexdigest(),
+                "original_token_count": token_count,
+                "bucket_length": bucket,
+                "left_truncated_tokens": truncated_tokens,
+            }
+        )
+    write_jsonl(inputs_path, prepared)
+
+    manifest: dict[str, Any] = {
+        "schema_version": 1,
+        "model_id": args.model_id,
+        "model_revision": args.revision,
+        "architecture": "MistralModel (LM head omitted)",
+        "source": str(args.input_jsonl) if args.input_jsonl else args.dataset,
+        "split": args.split,
+        "answer_mode": args.answer_mode,
+        "answer_view": args.answer_view,
+        "num_records": len(records),
+        "start_index": args.start_index,
+        "dtype": "bfloat16",
+        "embedding_shape_per_record": [4096],
+        "hidden_states_shape_per_record": [32, 4096],
+        "hidden_state_semantics": {
+            "0..30": "post-transformer-block, pre-final-RMSNorm",
+            "31": "post-transformer-block-31 and post-final-RMSNorm",
+        },
+        "token_position": "last non-padding token (inputs are left padded)",
+        "use_cache": False,
+        "output_hidden_states": False,
+        "sequence_buckets": list(buckets),
+        "batch_size": args.batch_size,
+        "shard_size": args.shard_size,
+        "attn_implementation": args.attn_implementation,
+        "xla_no_special_scalars": os.environ["XLA_NO_SPECIAL_SCALARS"],
+        "python": sys.version,
+        "platform": platform.platform(),
+        "torch": torch.__version__,
+        "torch_xla": torch_xla.__version__,
+        "created_unix": time.time(),
+        "status": "prepared" if args.prepare_only else "extracting",
+    }
+    manifest_path.write_text(json.dumps(manifest, indent=2) + "\n", encoding="utf-8")
+    if args.prepare_only:
+        print(json.dumps({"status": "prepared", "records": len(records), "output": str(output_dir)}))
+        return
+
+    already_done = set() if args.overwrite else existing_source_indices(metadata_path)
+    if already_done:
+        print(f"Resuming: {len(already_done)} source indices already present")
+
+    device = torch_xla.device()
+    print(f"Loading {args.model_id}@{args.revision} as MistralModel BF16 on CPU")
+    model = MistralModel.from_pretrained(
+        args.model_id,
+        revision=args.revision,
+        cache_dir=str(args.cache_dir),
+        dtype=torch.bfloat16,
+        low_cpu_mem_usage=True,
+        attn_implementation=args.attn_implementation,
+    )
+    model.config.use_cache = False
+    model.eval()
+    print(f"Moving base model (no LM head) to {device}")
+    model.to(device)
+    torch_xla.sync(wait=True)
+    capture = LastTokenCapture(model)
+
+    shard_number = 0
+    if not args.overwrite:
+        existing_shards = sorted(shards_dir.glob("shard-*.safetensors"))
+        if existing_shards:
+            shard_number = max(int(path.stem.split("-")[-1]) for path in existing_shards) + 1
+
+    pending_embeddings: list[torch.Tensor] = []
+    pending_hidden: list[torch.Tensor] = []
+    pending_meta: list[dict[str, Any]] = []
+    all_metadata: list[dict[str, Any]] = []
+    if metadata_path.exists() and not args.overwrite:
+        with metadata_path.open(encoding="utf-8") as handle:
+            all_metadata = [json.loads(line) for line in handle if line.strip()]
+
+    start_time = time.monotonic()
+    completed_this_run = 0
+
+    def flush() -> None:
+        nonlocal shard_number
+        if not pending_meta:
+            return
+        shard_name = f"shard-{shard_number:05d}.safetensors"
+        shard_path = shards_dir / shard_name
+        tensors = {
+            "embedding": torch.cat(pending_embeddings, dim=0).to(torch.bfloat16),
+            "hidden_states": torch.cat(pending_hidden, dim=0).to(torch.bfloat16),
+        }
+        save_file(
+            tensors,
+            str(shard_path),
+            metadata={
+                "model_id": args.model_id,
+                "model_revision": args.revision,
+                "split": args.split,
+                "dtype": "bfloat16",
+            },
+        )
+        for offset, row in enumerate(pending_meta):
+            row["shard"] = f"states/{args.split}/{shard_name}"
+            row["offset"] = offset
+            row["embedding_key"] = "embedding"
+            row["hidden_states_key"] = "hidden_states"
+        all_metadata.extend(pending_meta)
+        write_jsonl(metadata_path, all_metadata)
+        print(f"Saved {shard_path.name}: {len(pending_meta)} records")
+        pending_embeddings.clear()
+        pending_hidden.clear()
+        pending_meta.clear()
+        shard_number += 1
+
+    try:
+        for bucket in buckets:
+            bucket_records = [item for item in by_bucket.get(bucket, []) if item[0].source_index not in already_done]
+            if not bucket_records:
+                continue
+            print(f"Bucket {bucket}: {len(bucket_records)} records")
+            for start in range(0, len(bucket_records), args.batch_size):
+                batch_items = bucket_records[start : start + args.batch_size]
+                # Pad the final partial batch with a duplicate so each bucket has
+                # exactly one compiled shape, then discard the duplicate output.
+                actual_size = len(batch_items)
+                while len(batch_items) < args.batch_size:
+                    batch_items.append(batch_items[-1])
+                texts = [item[0].text for item in batch_items]
+                encoded = tokenizer(
+                    texts,
+                    add_special_tokens=False,
+                    padding="max_length",
+                    truncation=True,
+                    max_length=bucket,
+                    return_tensors="pt",
+                )
+                embeddings, hidden = extract_batch(
+                    model,
+                    capture,
+                    device,
+                    encoded["input_ids"],
+                    encoded["attention_mask"],
+                )
+                embeddings = embeddings[:actual_size]
+                hidden = hidden[:actual_size]
+                pending_embeddings.append(embeddings)
+                pending_hidden.append(hidden)
+                for local_index, (record, token_count, truncated_tokens) in enumerate(batch_items[:actual_size]):
+                    last_token_id = int(encoded["input_ids"][local_index, -1])
+                    pending_meta.append(
+                        {
+                            "source_index": record.source_index,
+                            "input_sha256": hashlib.sha256(record.text.encode("utf-8")).hexdigest(),
+                            "original_token_count": token_count,
+                            "bucket_length": bucket,
+                            "left_truncated_tokens": truncated_tokens,
+                            "last_token_id": last_token_id,
+                            "last_token": tokenizer.decode([last_token_id]),
+                        }
+                    )
+                completed_this_run += actual_size
+                if len(pending_meta) >= args.shard_size:
+                    flush()
+                if completed_this_run % 10 == 0:
+                    rate = completed_this_run / max(time.monotonic() - start_time, 1e-9)
+                    print(f"Progress: {completed_this_run}/{len(records) - len(already_done)} ({rate:.2f} records/s)")
+        flush()
+    finally:
+        capture.close()
+
+    manifest["status"] = "complete"
+    manifest["completed_records"] = len(all_metadata)
+    manifest["num_shards"] = shard_number
+    manifest["elapsed_seconds_this_run"] = time.monotonic() - start_time
+    manifest["completed_unix"] = time.time()
+    manifest_path.write_text(json.dumps(manifest, indent=2) + "\n", encoding="utf-8")
+    del model
+    gc.collect()
+    print(json.dumps({"status": "complete", "records": len(all_metadata), "output": str(output_dir)}))
+
+
+if __name__ == "__main__":
+    main()