#!/usr/bin/env python3 """ Fine-tune Gemma 4 E2B-it for pronunciation assessment using PEFT LoRA (bf16). Dataset is loaded from HuggingFace Hub with embedded audio — fully portable. Usage: # Single GPU (H100) python finetune_gemma4_e2b.py --model google/gemma-4-E2B-it # With local model weights python finetune_gemma4_e2b.py --model /path/to/gemma-4-E2B-it # Override settings python finetune_gemma4_e2b.py --lr 1e-4 --epochs 3 --batch-size 2 --lora-rank 32 """ import argparse import os import torch import numpy as np from datasets import load_dataset, load_from_disk from transformers import ( AutoProcessor, Gemma4ForConditionalGeneration, TrainingArguments, Trainer, ) from peft import LoraConfig, get_peft_model # --------------------------------------------------------------------------- # Defaults # --------------------------------------------------------------------------- HF_DATASET = "aigc-x/Pronunciation-boldvoice" MODEL_ID = "google/gemma-4-E2B-it" TARGET_SR = 16000 SYSTEM_PROMPT = ( "You are an English pronunciation assessment system. " "Given an audio recording and the reference text, analyze pronunciation at the phoneme level. " "Output JSON with per-word expected/actual phonemes (ARPAbet) and a summary score." ) USER_PROMPT_TEMPLATE = ( 'The speaker is reading: "{reference_text}"\n\n' "For each word, compare the actual pronunciation against the expected phonemes. " "Output a JSON object with:\n" '- "words": array of per-word analysis with expected/actual phonemes and errors\n' '- "summary": total_phonemes, correct_phonemes, error_count, score (0-100)' ) # --------------------------------------------------------------------------- # Data collator # --------------------------------------------------------------------------- class PronunciationDataCollator: """Collate dataset rows into model inputs with audio. Expects each example to have: - audio: {"array": np.ndarray, "sampling_rate": int} (HF Audio feature) - reference_text: str - response: str (JSON) """ def __init__(self, processor, max_length=3072): self.processor = processor self.max_length = max_length self.start_of_turn_id = processor.tokenizer.convert_tokens_to_ids("") def __call__(self, examples): batch_messages = [] for ex in examples: # Extract audio array from HF Audio feature audio_data = ex["audio"] if isinstance(audio_data, dict): audio = np.array(audio_data["array"], dtype=np.float32) else: audio = np.array(audio_data, dtype=np.float32) if len(audio) == 0: continue user_text = USER_PROMPT_TEMPLATE.format( reference_text=ex["reference_text"] ) messages = [ {"role": "system", "content": [{"type": "text", "text": SYSTEM_PROMPT}]}, { "role": "user", "content": [ {"type": "audio", "audio": audio}, {"type": "text", "text": user_text}, ], }, { "role": "assistant", "content": [ {"type": "text", "text": ex["response"]}, ], }, ] batch_messages.append(messages) if not batch_messages: audio = np.zeros(TARGET_SR, dtype=np.float32) batch_messages = [[ {"role": "user", "content": [ {"type": "audio", "audio": audio}, {"type": "text", "text": "N/A"}, ]}, {"role": "assistant", "content": [ {"type": "text", "text": '{"words":[],"summary":{"total_phonemes":0,"correct_phonemes":0,"error_count":0,"score":0}}'}, ]}, ]] # NOTE: Do NOT pass truncation=True — it incorrectly truncates input_features (audio). inputs = self.processor.apply_chat_template( batch_messages, tokenize=True, return_dict=True, return_tensors="pt", padding=True, ) # If too long, truncate assistant response and re-encode if inputs["input_ids"].shape[1] > self.max_length: for msg_list in batch_messages: for msg in msg_list: if msg["role"] == "assistant": text = msg["content"][0]["text"] msg["content"][0]["text"] = text[:len(text) // 2] + \ ']},"summary":{"total_phonemes":0,"correct_phonemes":0,"error_count":0,"score":0}}' inputs = self.processor.apply_chat_template( batch_messages, tokenize=True, return_dict=True, return_tensors="pt", padding=True, ) # Labels: mask everything before assistant response labels = inputs["input_ids"].clone() if self.processor.tokenizer.pad_token_id is not None: labels[labels == self.processor.tokenizer.pad_token_id] = -100 for i in range(labels.shape[0]): ids = inputs["input_ids"][i].tolist() positions = [j for j, t in enumerate(ids) if t == self.start_of_turn_id] if positions: last_start = positions[-1] mask_end = min(last_start + 3, labels.shape[1]) labels[i, :mask_end] = -100 inputs["labels"] = labels return inputs # --------------------------------------------------------------------------- # LoRA target discovery # --------------------------------------------------------------------------- def find_lora_targets(model) -> list[str]: """Find language model Linear layers for LoRA. Excludes vision/audio encoders (Gemma4ClippableLinear, unsupported by PEFT). """ target_names = {"q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"} return [name for name, mod in model.named_modules() if name.split(".")[-1] in target_names and "language_model" in name] # --------------------------------------------------------------------------- # Main # --------------------------------------------------------------------------- def main(): parser = argparse.ArgumentParser(description="Fine-tune Gemma 4 E2B for pronunciation assessment") parser.add_argument("--model", default=MODEL_ID, help="Model ID or local path") parser.add_argument("--dataset", default=HF_DATASET, help="HF dataset ID or local path") parser.add_argument("--output", default="./finetune_output") parser.add_argument("--epochs", type=int, default=3) parser.add_argument("--batch-size", type=int, default=1) parser.add_argument("--grad-accum", type=int, default=16) parser.add_argument("--lr", type=float, default=2e-4) parser.add_argument("--max-length", type=int, default=3072) parser.add_argument("--lora-rank", type=int, default=16) parser.add_argument("--lora-alpha", type=int, default=32) parser.add_argument("--lora-dropout", type=float, default=0.05) parser.add_argument("--eval-split", type=float, default=0.02) parser.add_argument("--save-steps", type=int, default=200) parser.add_argument("--logging-steps", type=int, default=10) parser.add_argument("--warmup-steps", type=int, default=100) parser.add_argument("--max-samples", type=int, default=0, help="Limit samples (0=all)") args = parser.parse_args() print(f"Model: {args.model}") print(f"Dataset: {args.dataset}") print(f"Output: {args.output}") # ----------------------------------------------------------------------- # Load processor # ----------------------------------------------------------------------- processor = AutoProcessor.from_pretrained(args.model) if processor.tokenizer.pad_token is None: processor.tokenizer.pad_token = processor.tokenizer.eos_token # ----------------------------------------------------------------------- # Load model # ----------------------------------------------------------------------- print("Loading model in bfloat16...") n_gpus = torch.cuda.device_count() max_memory = {i: f"{torch.cuda.get_device_properties(i).total_memory // (1024**3) - 4}GiB" for i in range(n_gpus)} model = Gemma4ForConditionalGeneration.from_pretrained( args.model, torch_dtype=torch.bfloat16, attn_implementation="sdpa", device_map="auto", max_memory=max_memory, ) # ----------------------------------------------------------------------- # Apply LoRA # ----------------------------------------------------------------------- targets = find_lora_targets(model) print(f"LoRA targeting {len(targets)} modules in language_model") lora_config = LoraConfig( r=args.lora_rank, lora_alpha=args.lora_alpha, lora_dropout=args.lora_dropout, target_modules=targets, bias="none", task_type="CAUSAL_LM", ) model = get_peft_model(model, lora_config) model.print_trainable_parameters() model.enable_input_require_grads() # ----------------------------------------------------------------------- # Load dataset (from HF Hub or local) # ----------------------------------------------------------------------- print(f"Loading dataset...") if os.path.isdir(args.dataset): ds = load_from_disk(args.dataset) else: ds = load_dataset(args.dataset, split="train") if args.max_samples > 0: ds = ds.select(range(min(args.max_samples, len(ds)))) if args.eval_split > 0: split = ds.train_test_split(test_size=args.eval_split, seed=42) train_ds, eval_ds = split["train"], split["test"] print(f"Train: {len(train_ds)}, Eval: {len(eval_ds)}") else: train_ds, eval_ds = ds, None print(f"Train: {len(train_ds)}, Eval: None") # ----------------------------------------------------------------------- # Train # ----------------------------------------------------------------------- collator = PronunciationDataCollator(processor, max_length=args.max_length) training_args = TrainingArguments( output_dir=args.output, num_train_epochs=args.epochs, per_device_train_batch_size=args.batch_size, per_device_eval_batch_size=args.batch_size, gradient_accumulation_steps=args.grad_accum, learning_rate=args.lr, lr_scheduler_type="cosine", warmup_steps=args.warmup_steps, weight_decay=0.01, bf16=True, logging_steps=args.logging_steps, save_steps=args.save_steps, save_total_limit=3, eval_strategy="steps" if eval_ds else "no", eval_steps=args.save_steps if eval_ds else None, dataloader_num_workers=0, remove_unused_columns=False, report_to="wandb", run_name="gemma4-e2b-pronunciation", gradient_checkpointing=True, gradient_checkpointing_kwargs={"use_reentrant": False}, ddp_find_unused_parameters=False, ) trainer = Trainer( model=model, args=training_args, train_dataset=train_ds, eval_dataset=eval_ds, data_collator=collator, processing_class=processor, ) print("Starting training...") trainer.train() final_path = os.path.join(args.output, "final_adapter") model.save_pretrained(final_path) processor.save_pretrained(final_path) print(f"Saved final adapter to {final_path}") if __name__ == "__main__": main()