Add Latin LLM streaming training script

Train an LLM on Latin using streaming datasets from FineWeb-2.
Demonstrates continued pretraining without downloading data.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

latin-llm-streaming.py

@@ -0,0 +1,278 @@
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#     "unsloth",
+#     "datasets",
+#     "trl",
+#     "huggingface_hub",
+#     "wandb",
+# ]
+# ///
+"""
+Train an LLM on Latin using streaming datasets.
+
+Demonstrates continued pretraining with streaming - no disk space needed.
+Uses FineWeb-2's Latin subset (1.47M texts, ~1.7GB).
+
+Run locally (if you have a GPU):
+    uv run latin-llm-streaming.py
+
+Run on HF Jobs:
+    hf jobs uv run latin-llm-streaming.py --flavor a100-large --secrets HF_TOKEN
+
+With custom settings:
+    hf jobs uv run latin-llm-streaming.py --flavor a100-large --secrets HF_TOKEN -- \
+        --max-steps 1000 --output-repo your-username/qwen-latin
+"""
+
+import argparse
+import time
+import os
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="Train an LLM on Latin using streaming datasets"
+    )
+    parser.add_argument(
+        "--base-model",
+        default="unsloth/Qwen3-0.6B-Base-unsloth-bnb-4bit",
+        help="Base model to fine-tune",
+    )
+    parser.add_argument(
+        "--output-repo",
+        default=None,
+        help="HF Hub repo to push model to (e.g., 'username/qwen-latin')",
+    )
+    parser.add_argument(
+        "--max-steps",
+        type=int,
+        default=500,
+        help="Number of training steps (default: 500)",
+    )
+    parser.add_argument(
+        "--batch-size",
+        type=int,
+        default=4,
+        help="Per-device batch size (default: 4)",
+    )
+    parser.add_argument(
+        "--gradient-accumulation",
+        type=int,
+        default=4,
+        help="Gradient accumulation steps (default: 4)",
+    )
+    parser.add_argument(
+        "--learning-rate",
+        type=float,
+        default=2e-4,
+        help="Learning rate (default: 2e-4)",
+    )
+    parser.add_argument(
+        "--max-seq-length",
+        type=int,
+        default=2048,
+        help="Maximum sequence length (default: 2048)",
+    )
+    parser.add_argument(
+        "--lora-r",
+        type=int,
+        default=16,
+        help="LoRA rank (default: 16)",
+    )
+    parser.add_argument(
+        "--save-local",
+        default="latin-llm-output",
+        help="Local directory to save model (default: latin-llm-output)",
+    )
+    parser.add_argument(
+        "--wandb-project",
+        default="latin-llm-streaming",
+        help="Wandb project name (default: latin-llm-streaming)",
+    )
+    parser.add_argument(
+        "--wandb-run-name",
+        default=None,
+        help="Wandb run name (default: auto-generated)",
+    )
+    return parser.parse_args()
+
+
+def main():
+    args = parse_args()
+
+    print("=" * 70)
+    print("Latin LLM Training with Streaming Datasets")
+    print("=" * 70)
+    print(f"\nConfiguration:")
+    print(f"  Base model:      {args.base_model}")
+    print(f"  Max steps:       {args.max_steps}")
+    print(f"  Batch size:      {args.batch_size} x {args.gradient_accumulation} = {args.batch_size * args.gradient_accumulation}")
+    print(f"  Learning rate:   {args.learning_rate}")
+    print(f"  LoRA rank:       {args.lora_r}")
+    print(f"  Output repo:     {args.output_repo or '(local only)'}")
+    print(f"  Wandb project:   {args.wandb_project}")
+    print()
+
+    # Import here to show progress
+    from unsloth import FastLanguageModel
+    from datasets import load_dataset
+    from trl import SFTTrainer, SFTConfig
+    from huggingface_hub import login
+
+    # Login if pushing to hub
+    if args.output_repo:
+        token = os.environ.get("HF_TOKEN")
+        if token:
+            login(token=token)
+            print("✓ Logged in to Hugging Face Hub")
+        else:
+            print("⚠ HF_TOKEN not set - model will only be saved locally")
+            args.output_repo = None
+
+    # Initialize wandb
+    import wandb
+    wandb_key = os.environ.get("WANDB_API_KEY")
+    if wandb_key:
+        wandb.login(key=wandb_key)
+    wandb.init(
+        project=args.wandb_project,
+        name=args.wandb_run_name or f"latin-{args.max_steps}steps",
+        config={
+            "base_model": args.base_model,
+            "max_steps": args.max_steps,
+            "batch_size": args.batch_size,
+            "gradient_accumulation": args.gradient_accumulation,
+            "effective_batch_size": args.batch_size * args.gradient_accumulation,
+            "learning_rate": args.learning_rate,
+            "lora_r": args.lora_r,
+            "max_seq_length": args.max_seq_length,
+            "dataset": "HuggingFaceFW/fineweb-2 (lat_Latn)",
+        },
+    )
+    print(f"✓ Wandb initialized: {wandb.run.url}")
+
+    # 1. Load model
+    print("\n[1/5] Loading model...")
+    start = time.time()
+
+    model, tokenizer = FastLanguageModel.from_pretrained(
+        args.base_model,
+        max_seq_length=args.max_seq_length,
+        load_in_4bit=True,
+    )
+
+    model = FastLanguageModel.get_peft_model(
+        model,
+        r=args.lora_r,
+        lora_alpha=args.lora_r * 2,
+        lora_dropout=0,
+        target_modules=[
+            "q_proj", "k_proj", "v_proj", "o_proj",
+            "gate_proj", "up_proj", "down_proj"
+        ],
+        bias="none",
+        use_gradient_checkpointing="unsloth",
+        random_state=3407,
+    )
+    print(f"✓ Model loaded in {time.time() - start:.1f}s")
+
+    # 2. Load streaming dataset
+    print("\n[2/5] Loading streaming dataset (FineWeb-2 Latin)...")
+    start = time.time()
+
+    dataset = load_dataset(
+        "HuggingFaceFW/fineweb-2",
+        name="lat_Latn",
+        split="train",
+        streaming=True,
+    )
+
+    # Peek at the data
+    sample = next(iter(dataset))
+    print(f"✓ Dataset ready in {time.time() - start:.1f}s")
+    print(f"  Sample: {sample['text'][:100]}...")
+
+    # 3. Format dataset
+    print("\n[3/5] Preparing dataset...")
+
+    def format_text(example):
+        return {"text": example["text"] + tokenizer.eos_token}
+
+    formatted_dataset = dataset.map(format_text)
+
+    # 4. Train
+    print(f"\n[4/5] Training for {args.max_steps} steps...")
+    start = time.time()
+
+    trainer = SFTTrainer(
+        model=model,
+        tokenizer=tokenizer,
+        train_dataset=formatted_dataset,
+        args=SFTConfig(
+            per_device_train_batch_size=args.batch_size,
+            gradient_accumulation_steps=args.gradient_accumulation,
+            warmup_steps=min(10, args.max_steps // 10),
+            max_steps=args.max_steps,
+            learning_rate=args.learning_rate,
+            logging_steps=max(1, args.max_steps // 20),
+            optim="adamw_8bit",
+            weight_decay=0.01,
+            lr_scheduler_type="linear",
+            seed=3407,
+            output_dir=args.save_local,
+            report_to="wandb",
+            run_name=args.wandb_run_name or f"latin-{args.max_steps}steps",
+            dataset_text_field="text",
+            max_seq_length=args.max_seq_length,
+            packing=False,
+        ),
+    )
+
+    trainer.train()
+    train_time = time.time() - start
+
+    print(f"\n✓ Training completed in {train_time / 60:.1f} minutes")
+    print(f"  Speed: {args.max_steps / train_time:.2f} it/s")
+
+    # 5. Save and push
+    print("\n[5/5] Saving model...")
+
+    # Save locally
+    model.save_pretrained(args.save_local)
+    tokenizer.save_pretrained(args.save_local)
+    print(f"✓ Saved locally to {args.save_local}/")
+
+    # Push to hub if configured
+    if args.output_repo:
+        print(f"\nPushing to {args.output_repo}...")
+        model.push_to_hub(args.output_repo, tokenizer=tokenizer)
+        print(f"✓ Model available at: https://huggingface.co/{args.output_repo}")
+
+    # Quick inference test
+    print("\n" + "=" * 70)
+    print("Quick inference test:")
+    print("=" * 70)
+
+    FastLanguageModel.for_inference(model)
+
+    prompt = "Lingua Latina est"
+    inputs = tokenizer(prompt, return_tensors="pt").to("cuda")
+    outputs = model.generate(
+        **inputs,
+        max_new_tokens=64,
+        temperature=0.7,
+        do_sample=True,
+    )
+    generated = tokenizer.decode(outputs[0], skip_special_tokens=True)
+
+    print(f"\nPrompt: {prompt}")
+    print(f"Generated: {generated}")
+
+    print("\n" + "=" * 70)
+    print("Done!")
+    print("=" * 70)
+
+
+if __name__ == "__main__":
+    main()