cleanup: training scripts live in deploy/, not the dataset repo

train_ears_granite.py

@@ -1,160 +0,0 @@
-# /// script
-# dependencies = ["transformers>=4.52.1", "peft>=0.13", "accelerate>=0.34",
-#                 "datasets==2.21.0", "soundfile", "librosa", "torchaudio", "jiwer",
-#                 "evaluate", "huggingface_hub>=0.22", "trackio", "wandb"]
-# ///
-"""Fine-tune granite-4.0-1b-speech on MOH749/Bocalantics (LoRA) — HF Jobs uv script.
-
-Bocalantics-native: loads the unified dataset directly (audio 16k + text + lang),
-no manifest/wav extraction. IBM recipe: freeze encoder, train projector, LoRA the
-Granite LLM. Pushes the adapter to the Hub (ephemeral job env — must push).
-
-Config via env vars (HF Jobs injects HF_TOKEN via --secrets):
-  DATASET   (default MOH749/Bocalantics)
-  PUSH_REPO (default MOH749/yaatal-wa-ears-granite)
-  EPOCHS, BATCH, LR
-  SMOKE     (>0 → train on only N rows, 1 epoch — a cheap code-validation run)
-"""
-import dataclasses
-import io
-import os
-from typing import Any
-
-BASE = os.environ.get("BASE_MODEL", "ibm-granite/granite-4.0-1b-speech")
-DATASET = os.environ.get("DATASET", "MOH749/Bocalantics")
-PUSH_REPO = os.environ.get("PUSH_REPO", "MOH749/yaatal-wa-ears-granite")
-EPOCHS = int(os.environ.get("EPOCHS", "3"))
-BATCH = int(os.environ.get("BATCH", "4"))             # 4 = throughput (BATCH=1 was ~6x slower, ~20h/epoch)
-GRAD_ACCUM = int(os.environ.get("GRAD_ACCUM", "4"))   # effective batch ~16
-MAX_S = float(os.environ.get("MAX_S", "16"))           # collator SKIPS clips > MAX_S -> bounds OOM, no truncation
-SAVE_STEPS = int(os.environ.get("SAVE_STEPS", "1500")) # push a checkpoint ~hourly so a late fail loses <=1
-LR = float(os.environ.get("LR", "2e-4"))
-SMOKE = int(os.environ.get("SMOKE", "0"))
-# Metrics: "trackio" (HF-native, free dashboard Space) | "wandb" | "none".
-# trackio picks up TRACKIO_SPACE_ID + TRACKIO_PROJECT_NAME from env to persist the
-# dashboard past the ephemeral job; wandb picks up WANDB_API_KEY (secret) + WANDB_PROJECT.
-REPORT = os.environ.get("REPORT", "trackio")
-RUN_NAME = os.environ.get("RUN_NAME", f"granite-ears-{'smoke' if SMOKE else 'full'}")
-INSTR = "Please transcribe the following audio to text<|audio|>"
-
-
-@dataclasses.dataclass
-class Collator:
-    processor: Any
-    max_s: float = 30.0
-
-    def __call__(self, examples):
-        import torch
-        import soundfile as sf
-        tok = self.processor.tokenizer
-        tok.padding_side = "right"
-        sr_t = self.processor.audio_processor.sampling_rate
-        prompts, fulls, wavs = [], [], []
-        for ex in examples:
-            try:
-                arr, sr = sf.read(io.BytesIO(ex["audio"]["bytes"]), dtype="float32")
-            except Exception:
-                continue
-            if arr.ndim > 1:
-                arr = arr.mean(axis=1)
-            if sr != sr_t:
-                import librosa
-                arr = librosa.resample(arr, orig_sr=sr, target_sr=sr_t)
-            dur = len(arr) / sr_t
-            if dur < 0.5 or dur > self.max_s:  # skip too-short/long: bounds OOM, avoids audio/text mismatch
-                continue
-            txt = (ex.get("text") or "").strip()
-            if not txt:
-                continue
-            wavs.append(arr)
-            prompts.append(tok.apply_chat_template(
-                [{"role": "user", "content": INSTR}],
-                tokenize=False, add_generation_prompt=True))
-            fulls.append(tok.apply_chat_template(
-                [{"role": "user", "content": INSTR},
-                 {"role": "assistant", "content": txt}], tokenize=False))
-        if not wavs:  # whole batch skipped/bad -> 1-sample silent dummy (never emit a 0-row batch -> no reshape crash)
-            import numpy as np
-            wavs = [np.zeros(int(0.5 * sr_t), dtype="float32")]
-            prompts = [tok.apply_chat_template(
-                [{"role": "user", "content": INSTR}], tokenize=False, add_generation_prompt=True)]
-            fulls = [tok.apply_chat_template(
-                [{"role": "user", "content": INSTR}, {"role": "assistant", "content": "."}], tokenize=False)]
-        # Let the processor batch + pad input_features and expand the <|audio|>
-        # placeholders consistently — hand-padding features desyncs the audio-token
-        # count from the placeholders (the 165-vs-4 failure). Recover labels by
-        # masking the prompt span, sized from a prompt-only pass (same audio → same
-        # placeholder expansion, right-padding keeps the prompt a clean prefix).
-        out = self.processor(text=fulls, audio=wavs, return_tensors="pt", padding=True)
-        pout = self.processor(text=prompts, audio=wavs, return_tensors="pt", padding=True)
-        labels = out["input_ids"].clone()
-        labels[out["attention_mask"] == 0] = -100
-        for i in range(len(fulls)):
-            plen = int(pout["attention_mask"][i].sum().item())
-            labels[i, :plen] = -100
-        out["labels"] = labels
-        return dict(out)
-
-
-def main():
-    import torch
-    from datasets import load_dataset, Audio
-    from transformers import (GraniteSpeechForConditionalGeneration,
-                              GraniteSpeechProcessor, Trainer, TrainingArguments)
-    from peft import LoraConfig, get_peft_model
-
-    epochs = EPOCHS
-    if SMOKE > 0:
-        # Stream just the first rows — genuinely avoids the full 25.6GB pull
-        # (datasets 2.21 split-slicing still downloads every shard first).
-        from datasets import Dataset
-        print(f"[load] dataset {DATASET} (smoke stream {SMOKE})")
-        st = load_dataset(DATASET, split="train", streaming=True).cast_column(
-            "audio", Audio(decode=False))
-        sv = load_dataset(DATASET, split="validation", streaming=True).cast_column(
-            "audio", Audio(decode=False))
-        train = Dataset.from_list(list(st.take(SMOKE)))
-        val = Dataset.from_list(list(sv.take(64)))
-        epochs = 1
-        print(f"[smoke] train={len(train)} val={len(val)} (1 epoch)")
-    else:
-        print(f"[load] dataset {DATASET}")
-        ds = load_dataset(DATASET).cast_column("audio", Audio(decode=False))
-        train = ds["train"]
-        val = ds["validation"] if "validation" in ds else ds["train"]
-        print(f"[full] train={len(train)} val={len(val)} ({epochs} epochs)")
-
-    print(f"[load] model {BASE}")
-    proc = GraniteSpeechProcessor.from_pretrained(BASE)
-    model = GraniteSpeechForConditionalGeneration.from_pretrained(
-        BASE, torch_dtype=torch.bfloat16)
-    for p in model.model.encoder.parameters():
-        p.requires_grad = False
-    model = get_peft_model(model, LoraConfig(
-        r=16, lora_alpha=32, lora_dropout=0.05,
-        target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
-                        "gate_proj", "up_proj", "down_proj"],
-        bias="none", task_type="CAUSAL_LM"))
-    model.print_trainable_parameters()
-
-    args = TrainingArguments(
-        output_dir="out", num_train_epochs=epochs,
-        per_device_train_batch_size=BATCH, per_device_eval_batch_size=2,
-        learning_rate=LR, warmup_ratio=0.05, lr_scheduler_type="cosine",
-        bf16=torch.cuda.is_available(), gradient_accumulation_steps=GRAD_ACCUM,
-        gradient_checkpointing=False, eval_strategy="no", save_strategy="steps",
-        save_steps=SAVE_STEPS, save_total_limit=1, logging_steps=20, dataloader_num_workers=2,
-        remove_unused_columns=False, report_to=REPORT, run_name=RUN_NAME,
-        label_names=["labels"],
-        push_to_hub=True, hub_model_id=PUSH_REPO, hub_strategy="every_save",
-        hub_private_repo=True)
-    trainer = Trainer(model=model, args=args, train_dataset=train,
-                      eval_dataset=val, data_collator=Collator(processor=proc, max_s=MAX_S))
-    trainer.train()
-    trainer.push_to_hub()
-    proc.push_to_hub(PUSH_REPO, private=True)
-    print(f"[done] pushed adapter → {PUSH_REPO}")
-
-
-if __name__ == "__main__":
-    main()