Upload src/mine_memorized.py with huggingface_hub

src/mine_memorized.py

@@ -0,0 +1,430 @@
+"""
+Memorization Mining
+
+Utilities for finding memorized sequences from training data.
+
+Based on: "From Memorization to Reasoning in the Spectrum of Loss Curvature"
+"""
+
+import torch
+import torch.nn as nn
+from torch import Tensor
+from typing import Optional, Iterator
+from dataclasses import dataclass
+import json
+from tqdm import tqdm
+import random
+
+
+@dataclass
+class MemorizedSequence:
+    """A memorized sequence with prefix and suffix."""
+    
+    prefix: str
+    suffix: str
+    prefix_ids: list[int]
+    suffix_ids: list[int]
+    source: str = ""  # Dataset source
+    
+    def to_dict(self) -> dict:
+        return {
+            "prefix": self.prefix,
+            "suffix": self.suffix,
+            "prefix_ids": self.prefix_ids,
+            "suffix_ids": self.suffix_ids,
+            "source": self.source,
+        }
+    
+    @classmethod
+    def from_dict(cls, d: dict) -> "MemorizedSequence":
+        return cls(**d)
+
+
+def sample_sequences(
+    dataset_name: str,
+    tokenizer,
+    num_sequences: int = 10000,
+    prefix_len: int = 64,
+    suffix_len: int = 48,
+    min_text_tokens: int = None,
+    seed: int = 42,
+    streaming: bool = True,
+    dataset_config: Optional[str] = None,
+    text_column: str = "text",
+) -> list[MemorizedSequence]:
+    """
+    Sample candidate (prefix, suffix) pairs from a dataset.
+    
+    The sequences are drawn by:
+    1. Streaming text from the dataset
+    2. Tokenizing each text
+    3. Extracting windows of (prefix_len + suffix_len) tokens
+    
+    Args:
+        dataset_name: HuggingFace dataset name
+        tokenizer: Tokenizer for the model
+        num_sequences: Number of sequences to sample
+        prefix_len: Length of prefix in tokens
+        suffix_len: Length of suffix in tokens
+        min_text_tokens: Minimum tokens in text to be considered
+        seed: Random seed
+        streaming: Use streaming mode
+        dataset_config: Dataset configuration/subset
+        text_column: Name of the text column
+    
+    Returns:
+        List of MemorizedSequence candidates
+    """
+    from datasets import load_dataset
+    
+    random.seed(seed)
+    
+    total_len = prefix_len + suffix_len
+    min_text_tokens = min_text_tokens or total_len + 10
+    
+    # Load dataset
+    if dataset_config:
+        ds = load_dataset(dataset_name, name=dataset_config, split="train", streaming=streaming)
+    else:
+        ds = load_dataset(dataset_name, split="train", streaming=streaming)
+    
+    if streaming:
+        ds = ds.shuffle(buffer_size=10000, seed=seed)
+    
+    sequences = []
+    seen_prefixes = set()  # For deduplication
+    
+    pbar = tqdm(total=num_sequences, desc="Sampling sequences")
+    
+    for example in ds:
+        if len(sequences) >= num_sequences:
+            break
+        
+        # Get text
+        text = example.get(text_column)
+        if not text:
+            continue
+        
+        # Tokenize
+        tokens = tokenizer.encode(text, add_special_tokens=False)
+        
+        if len(tokens) < min_text_tokens:
+            continue
+        
+        # Sample a random window
+        max_start = len(tokens) - total_len
+        if max_start <= 0:
+            continue
+        
+        start_idx = random.randint(0, max_start)
+        
+        prefix_ids = tokens[start_idx:start_idx + prefix_len]
+        suffix_ids = tokens[start_idx + prefix_len:start_idx + total_len]
+        
+        # Deduplicate by prefix
+        prefix_tuple = tuple(prefix_ids)
+        if prefix_tuple in seen_prefixes:
+            continue
+        seen_prefixes.add(prefix_tuple)
+        
+        # Decode back to text
+        prefix = tokenizer.decode(prefix_ids)
+        suffix = tokenizer.decode(suffix_ids)
+        
+        sequences.append(MemorizedSequence(
+            prefix=prefix,
+            suffix=suffix,
+            prefix_ids=prefix_ids,
+            suffix_ids=suffix_ids,
+            source=dataset_name,
+        ))
+        
+        pbar.update(1)
+    
+    pbar.close()
+    return sequences
+
+
+@torch.no_grad()
+def check_memorization_batch(
+    model: nn.Module,
+    tokenizer,
+    sequences: list[MemorizedSequence],
+    strict: bool = True,
+) -> list[tuple[MemorizedSequence, bool, float]]:
+    """
+    Check if a batch of sequences is memorized.
+    
+    Args:
+        model: Language model
+        tokenizer: Tokenizer
+        sequences: List of sequences to check
+        strict: If True, require exact match; if False, use overlap threshold
+    
+    Returns:
+        List of (sequence, is_memorized, overlap_score) tuples
+    """
+    model.eval()
+    device = next(model.parameters()).device
+    
+    # Prepare batch
+    prefixes = [seq.prefix for seq in sequences]
+    suffix_lengths = [len(seq.suffix_ids) for seq in sequences]
+    max_suffix_len = max(suffix_lengths)
+    
+    # Tokenize prefixes
+    encoded = tokenizer(
+        prefixes,
+        return_tensors="pt",
+        padding=True,
+        truncation=True,
+    )
+    input_ids = encoded["input_ids"].to(device)
+    attention_mask = encoded["attention_mask"].to(device)
+    
+    # Generate
+    from .evaluate import generate_greedy
+    generated = generate_greedy(
+        model, input_ids, max_suffix_len,
+        attention_mask=attention_mask,
+        pad_token_id=tokenizer.pad_token_id,
+    )
+    
+    results = []
+    for i, (seq, gen_ids) in enumerate(zip(sequences, generated)):
+        gen_list = gen_ids.tolist()[:len(seq.suffix_ids)]
+        target_list = seq.suffix_ids
+        
+        # Check match
+        is_exact = gen_list == target_list
+        
+        # Compute overlap
+        matches = sum(g == t for g, t in zip(gen_list, target_list))
+        overlap = matches / len(target_list) if target_list else 0
+        
+        is_memorized = is_exact if strict else (overlap >= 0.75)
+        
+        results.append((seq, is_memorized, overlap))
+    
+    return results
+
+
+def filter_memorized(
+    model: nn.Module,
+    tokenizer,
+    candidates: list[MemorizedSequence],
+    batch_size: int = 8,
+    strict: bool = True,
+    progress_bar: bool = True,
+) -> list[MemorizedSequence]:
+    """
+    Filter candidates to keep only memorized sequences.
+    
+    Args:
+        model: Language model
+        tokenizer: Tokenizer
+        candidates: List of candidate sequences
+        batch_size: Batch size for inference
+        strict: Require exact match
+        progress_bar: Show progress bar
+    
+    Returns:
+        List of memorized sequences
+    """
+    memorized = []
+    
+    iterator = range(0, len(candidates), batch_size)
+    if progress_bar:
+        iterator = tqdm(iterator, desc="Filtering memorized")
+    
+    for batch_start in iterator:
+        batch_end = min(batch_start + batch_size, len(candidates))
+        batch = candidates[batch_start:batch_end]
+        
+        results = check_memorization_batch(model, tokenizer, batch, strict)
+        
+        for seq, is_mem, overlap in results:
+            if is_mem:
+                memorized.append(seq)
+    
+    return memorized
+
+
+def mine_memorized_sequences(
+    model: nn.Module,
+    tokenizer,
+    dataset_name: str = "allenai/olmo-mix-1124",
+    target_count: int = 1000,
+    max_candidates: int = 50000,
+    prefix_len: int = 64,
+    suffix_len: int = 48,
+    batch_size: int = 8,
+    seed: int = 42,
+    dataset_config: Optional[str] = None,
+    strict: bool = True,
+) -> list[MemorizedSequence]:
+    """
+    Mine memorized sequences from training data.
+    
+    This is the main pipeline for finding sequences that the model
+    has memorized verbatim.
+    
+    Args:
+        model: Language model
+        tokenizer: Tokenizer
+        dataset_name: HuggingFace dataset name (should be training data)
+        target_count: Desired number of memorized sequences
+        max_candidates: Maximum candidates to sample
+        prefix_len: Prefix length in tokens
+        suffix_len: Suffix length in tokens
+        batch_size: Batch size for inference
+        seed: Random seed
+        dataset_config: Dataset configuration
+        strict: Require exact match
+    
+    Returns:
+        List of memorized sequences
+    """
+    print(f"Mining memorized sequences from {dataset_name}")
+    print(f"Target: {target_count} memorized, max candidates: {max_candidates}")
+    
+    # Sample candidates
+    print("\nStep 1: Sampling candidates...")
+    candidates = sample_sequences(
+        dataset_name=dataset_name,
+        tokenizer=tokenizer,
+        num_sequences=max_candidates,
+        prefix_len=prefix_len,
+        suffix_len=suffix_len,
+        seed=seed,
+        dataset_config=dataset_config,
+    )
+    print(f"Sampled {len(candidates)} candidates")
+    
+    # Filter for memorized
+    print("\nStep 2: Filtering for memorized sequences...")
+    memorized = filter_memorized(
+        model=model,
+        tokenizer=tokenizer,
+        candidates=candidates,
+        batch_size=batch_size,
+        strict=strict,
+    )
+    
+    print(f"\nFound {len(memorized)} memorized sequences "
+          f"({len(memorized)/len(candidates)*100:.1f}% of candidates)")
+    
+    # Truncate if we found more than needed
+    if len(memorized) > target_count:
+        random.seed(seed)
+        memorized = random.sample(memorized, target_count)
+        print(f"Truncated to {target_count} sequences")
+    
+    return memorized
+
+
+def save_sequences(sequences: list[MemorizedSequence], path: str) -> None:
+    """Save sequences to a JSON file."""
+    data = [seq.to_dict() for seq in sequences]
+    with open(path, "w") as f:
+        json.dump(data, f, indent=2)
+    print(f"Saved {len(sequences)} sequences to {path}")
+
+
+def load_sequences(path: str) -> list[MemorizedSequence]:
+    """Load sequences from a JSON file."""
+    with open(path, "r") as f:
+        data = json.load(f)
+    sequences = [MemorizedSequence.from_dict(d) for d in data]
+    print(f"Loaded {len(sequences)} sequences from {path}")
+    return sequences
+
+
+def split_sequences(
+    sequences: list[MemorizedSequence],
+    train_ratio: float = 0.8,
+    seed: int = 42,
+) -> tuple[list[MemorizedSequence], list[MemorizedSequence]]:
+    """
+    Split sequences into train and validation sets.
+    
+    Args:
+        sequences: List of sequences
+        train_ratio: Fraction for training set
+        seed: Random seed
+    
+    Returns:
+        Tuple of (train_sequences, val_sequences)
+    """
+    random.seed(seed)
+    shuffled = sequences.copy()
+    random.shuffle(shuffled)
+    
+    split_idx = int(len(shuffled) * train_ratio)
+    train = shuffled[:split_idx]
+    val = shuffled[split_idx:]
+    
+    return train, val
+
+
+def get_prefixes_and_suffixes(
+    sequences: list[MemorizedSequence],
+) -> tuple[list[str], list[str]]:
+    """
+    Extract prefix and suffix strings from sequences.
+    
+    Useful for passing to evaluation functions.
+    """
+    prefixes = [seq.prefix for seq in sequences]
+    suffixes = [seq.suffix for seq in sequences]
+    return prefixes, suffixes
+
+
+# Historical quotes dataset (for out-of-distribution testing)
+HISTORICAL_QUOTES = [
+    # Famous quotes that models often memorize
+    ("To be, or not to be, that is the question:", " Whether 'tis nobler in the mind to suffer"),
+    ("Four score and seven years ago our fathers brought forth", " on this continent, a new nation, conceived in Liberty"),
+    ("I have a dream that one day this nation will rise up", " and live out the true meaning of its creed"),
+    ("Ask not what your country can do for you", " — ask what you can do for your country"),
+    ("The only thing we have to fear is", " fear itself"),
+    ("In the beginning God created", " the heavens and the earth"),
+    ("It was the best of times, it was the worst of times,", " it was the age of wisdom, it was the age of foolishness"),
+    ("Call me Ishmael. Some years ago—never mind how long precisely", "—having little or no money in my purse"),
+    ("All happy families are alike; each unhappy family is", " unhappy in its own way"),
+    ("It is a truth universally acknowledged, that a single man in possession", " of a good fortune, must be in want of a wife"),
+]
+
+
+def create_quotes_dataset(
+    tokenizer,
+    additional_quotes: Optional[list[tuple[str, str]]] = None,
+) -> list[MemorizedSequence]:
+    """
+    Create a dataset of historical quotes for OOD memorization testing.
+    
+    Args:
+        tokenizer: Tokenizer
+        additional_quotes: Additional (prefix, suffix) tuples to include
+    
+    Returns:
+        List of MemorizedSequence objects
+    """
+    quotes = HISTORICAL_QUOTES.copy()
+    if additional_quotes:
+        quotes.extend(additional_quotes)
+    
+    sequences = []
+    for prefix, suffix in quotes:
+        prefix_ids = tokenizer.encode(prefix, add_special_tokens=False)
+        suffix_ids = tokenizer.encode(suffix, add_special_tokens=False)
+        
+        sequences.append(MemorizedSequence(
+            prefix=prefix,
+            suffix=suffix,
+            prefix_ids=prefix_ids,
+            suffix_ids=suffix_ids,
+            source="historical_quotes",
+        ))
+    
+    return sequences