4 Weekends · ₹0 Cost · Real Validation

# /kaggle/working/test_sentences.csv format:
# id,category,sentence,priority

ID    CATEGORY              SENTENCE                              COUNT
─────────────────────────────────────────────────────────────────────
T01   retroflex_contrast    ଟମାଟୋ ତମ ଘରେ ଅଛି                       30
T02   retroflex_lateral_ɭ   ଜଳ ଓ ଫଳ ସବୁଠାରୁ ଭଲ                      20
T03   conjunct_clusters     ସ୍କୁଲ ସ୍ୱାସ୍ଥ୍ୟ ଦ୍ୱାର                     30
T04   schwa_deletion        ଘର ବଜାର ଯିବାକୁ ସମୟ                      20
T05   yes_no_question       ତୁ ଆସିଛ କି?                              15
T06   wh_question           କେବେ ଆସିବ ତୁ?                            15
T07   exclamation           କେଡେ ସୁନ୍ଦର ଅଛି!                          10
T08   numbers_dates         ଆଜି ୧୫ ଅଗଷ୍ଟ ୨୦୨୪                         20
T09   news_register         ଭାରତ ସରକାର ନୂଆ ନୀତି ଘୋଷଣା                10
T10   conversational        ଆରେ ଭାଇ କୁଆଡେ ଯିବୁ?                       10
T11   long_sentence         (multi-clause sentences > 15 words)      10
T12   names_places          ଭୁବନେଶ୍ୱର, ସମ୍ବଲପୁର, କଟକ                   10

# DO NOT use GPT/Claude to generate Odia sentences.
# Source from: Odia Wikipedia, Odia news websites, Odia textbooks.
# Better: Have a native Odia speaker write 50 sentences from each category.

# Where to get reference voices (zero cost, today):

# Option A: YouTube Odia content (download with yt-dlp on your laptop)
#   • OTV news anchor — clean, formal, professional
#   • Odia podcast voice — conversational
#   • Doordarshan archive voice — broadcast standard

# Use yt-dlp on laptop, NOT Kaggle:
yt-dlp -x --audio-format wav --audio-quality 0 \
       --postprocessor-args "-ar 24000 -ac 1" \
       "https://youtube.com/watch?v=XXX"

# Then trim to a clean 6-10 second segment with no music:
ffmpeg -i input.wav -ss 00:00:30 -t 7 -ar 24000 -ac 1 ref_otv.wav

# What makes a GOOD reference clip:
#   ✓ 6-10 seconds (longer = better voice fingerprint)
#   ✓ Clear speech, no background music
#   ✓ Single speaker, no overlap
#   ✓ Natural prosody (not over-emphasized)
#   ✓ Matches the gender/style you want output to be

# What makes a BAD reference clip:
#   ✗ Too short (< 4s) — voice characteristics not captured
#   ✗ Background music — IndicF5 will copy the music too
#   ✗ Multiple speakers — model gets confused
#   ✗ Heavy emotion — biases all output to that emotion

# Kaggle.com → New Notebook → Settings:
#   Accelerator: GPU T4 x2  (or P100 if T4 unavailable)
#   Internet: ON  (required to download IndicF5)
#   Persistence: Files only

# In Notebook → Add-ons → Secrets:
#   Add: HF_TOKEN = your_hugging_face_token

# Cell 1 — Setup (run once per session)
import os
from kaggle_secrets import UserSecretsClient
os.environ['HF_TOKEN'] = UserSecretsClient().get_secret("HF_TOKEN")

!pip install -q git+https://github.com/ai4bharat/IndicF5.git 2>&1 | tail -5
!pip install -q soundfile librosa pandas 2>&1 | tail -3
!huggingface-cli login --token $HF_TOKEN

# Verify GPU
import torch
print(f"CUDA: {torch.cuda.is_available()}")
print(f"Device: {torch.cuda.get_device_name(0)}")
print(f"VRAM: {torch.cuda.get_device_properties(0).total_memory / 1e9:.1f} GB")
# Expected: T4, 14.7 GB

# Locally on your laptop:
mkdir odia-tts-baseline-data
cp test_sentences.csv odia-tts-baseline-data/
cp ref_otv.wav ref_dd.wav ref_podcast.wav odia-tts-baseline-data/
echo "OTV news anchor reference" > odia-tts-baseline-data/ref_otv_text.txt  # transcript of ref clip
# (write actual Odia transcript of each reference clip)

# Upload to Kaggle:
# kaggle.com/datasets → New Dataset → Upload folder
# Title: "odia-tts-baseline-data"
# License: CC0 if you own it, else "Other"
# Visibility: Private (it has your unreleased work)

# In Kaggle notebook → Add Data → search your dataset → Add
# It mounts at: /kaggle/input/odia-tts-baseline-data/

# Cell 2 — Load IndicF5
from transformers import AutoModel
import numpy as np
import soundfile as sf
import pandas as pd
from pathlib import Path
import time

print("Loading IndicF5 (400M params, ~3 GB download)...")
t0 = time.time()
model = AutoModel.from_pretrained("ai4bharat/IndicF5", trust_remote_code=True)
model = model.to("cuda")
model.eval()
print(f"Loaded in {time.time()-t0:.1f}s")

# Cell 3 — Setup paths
DATA = Path("/kaggle/input/odia-tts-baseline-data")
OUT  = Path("/kaggle/working/baseline_outputs")
OUT.mkdir(exist_ok=True)

# Load test sentences
df = pd.read_csv(DATA / "test_sentences.csv")
print(f"Test sentences: {len(df)}")

# Load reference voices
REFS = {
    "otv":     (DATA / "ref_otv.wav",     open(DATA / "ref_otv_text.txt").read().strip()),
    "dd":      (DATA / "ref_dd.wav",      open(DATA / "ref_dd_text.txt").read().strip()),
    "podcast": (DATA / "ref_podcast.wav", open(DATA / "ref_podcast_text.txt").read().strip()),
}

# Cell 4 — Run inference (THE CRITICAL CELL)
results = []
errors = []

for i, row in df.iterrows():
    for ref_name, (ref_path, ref_text) in REFS.items():
        out_path = OUT / f"{row['id']}_{ref_name}.wav"

        # Skip if already done (in case session resumes)
        if out_path.exists():
            results.append({"id": row['id'], "ref": ref_name, "ok": True, "path": str(out_path)})
            continue

        try:
            t0 = time.time()
            audio = model(
                row['sentence'],
                ref_audio_path=str(ref_path),
                ref_text=ref_text,
            )
            elapsed = time.time() - t0

            # Normalize and save
            if audio.dtype == np.int16:
                audio = audio.astype(np.float32) / 32768.0
            sf.write(out_path, np.array(audio, dtype=np.float32), samplerate=24000)

            results.append({
                "id": row['id'], "category": row['category'],
                "sentence": row['sentence'], "ref": ref_name,
                "duration_s": len(audio) / 24000,
                "synth_time_s": elapsed,
                "rtf": elapsed / (len(audio) / 24000),
                "ok": True, "path": str(out_path),
            })
            print(f"[{i:3d}/{len(df)}] {row['id']}_{ref_name} · {elapsed:.1f}s")
        except Exception as e:
            errors.append({"id": row['id'], "ref": ref_name, "error": str(e)})
            print(f"[ERROR] {row['id']}_{ref_name}: {e}")

# Cell 5 — Save results manifest
results_df = pd.DataFrame(results)
results_df.to_csv("/kaggle/working/baseline_results.csv", index=False)
pd.DataFrame(errors).to_csv("/kaggle/working/baseline_errors.csv", index=False)
print(f"\nSuccess: {len(results)}/{len(df)*3}")
print(f"Mean synthesis time: {results_df['synth_time_s'].mean():.2f}s")
print(f"Mean RTF: {results_df['rtf'].mean():.3f}")  # Real-Time Factor

# Cell 6 — Package for evaluation
# Create a zip of all audio + a CSV that evaluators will fill in

import shutil

EVAL_DIR = Path("/kaggle/working/eval_package")
EVAL_DIR.mkdir(exist_ok=True)

# Copy audio
for r in results:
    shutil.copy(r['path'], EVAL_DIR / Path(r['path']).name)

# Build evaluator CSV
eval_df = pd.DataFrame(results)[['id', 'category', 'sentence', 'ref']]
eval_df['filename'] = eval_df['id'] + '_' + eval_df['ref'] + '.wav'
eval_df['naturalness_1to5'] = ''      # MOS
eval_df['intelligibility_1to5'] = ''  # Can you understand it?
eval_df['accent_correct_yn'] = ''     # Does it sound Odia (not Hindi-influenced)?
eval_df['mispronunciations'] = ''     # List specific words pronounced wrong
eval_df['overall_pass'] = ''          # 'pass' or 'fail' for production use
eval_df.to_csv(EVAL_DIR / "evaluation_form.csv", index=False)

# Build instructions for evaluator
instructions = '''
Odia TTS Baseline Evaluation
============================

You'll listen to ~600 audio clips of synthesized Odia speech.
For each clip, fill in the evaluation_form.csv:

1. naturalness_1to5: How natural does it sound? (1=robotic, 5=human)
2. intelligibility_1to5: How clearly can you understand? (1=unclear, 5=perfectly clear)
3. accent_correct_yn: Does it sound like Odia, not Hindi? (y/n)
4. mispronunciations: List any words you noticed mispronounced
5. overall_pass: Would this be acceptable in production? (pass/fail)

Listen on headphones in a quiet room.
Estimated time: 3-4 hours total. Spread across multiple sessions.
'''
(EVAL_DIR / "INSTRUCTIONS.txt").write_text(instructions)

# Zip everything
shutil.make_archive("/kaggle/working/odia_baseline_eval", 'zip', EVAL_DIR)
print(f"Package size: {Path('/kaggle/working/odia_baseline_eval.zip').stat().st_size / 1e6:.0f} MB")
# Download from Kaggle's Output panel — should be ~150-200 MB

# Sunday evening: collect 3 filled CSVs from evaluators
# Upload them to Kaggle as new dataset version

# Cell 7 — Analyze baseline
import pandas as pd
import numpy as np

ev1 = pd.read_csv("/kaggle/input/.../eval_v1.csv")
ev2 = pd.read_csv("/kaggle/input/.../eval_v2.csv")
ev3 = pd.read_csv("/kaggle/input/.../eval_v3.csv")
all_evals = pd.concat([ev1, ev2, ev3])

# Overall MOS by category
print("=== BASELINE MOS BY CATEGORY ===")
print(all_evals.groupby('category')['naturalness_1to5'].agg(['mean', 'std', 'count']))

# Per-reference comparison
print("\n=== MOS BY REFERENCE VOICE ===")
print(all_evals.groupby('ref')['naturalness_1to5'].agg(['mean', 'std']))

# Intelligibility breakdown
print("\n=== INTELLIGIBILITY ===")
print(f"Mean: {all_evals['intelligibility_1to5'].mean():.2f}")
print(f"% scoring >= 4: {(all_evals['intelligibility_1to5'] >= 4).mean() * 100:.1f}%")

# Accent correctness
print("\n=== ACCENT CORRECTNESS ===")
print(f"% rated as 'sounds Odia': {(all_evals['accent_correct_yn'] == 'y').mean() * 100:.1f}%")

# Top failure categories
print("\n=== WORST CATEGORIES (need fine-tuning attention) ===")
worst = all_evals.groupby('category')['naturalness_1to5'].mean().sort_values()
print(worst.head(5))

# Common mispronunciations (will guide G2P fixes)
print("\n=== TOP MISPRONUNCIATIONS ===")
mispron = all_evals['mispronunciations'].dropna().str.split(',').explode().str.strip()
print(mispron.value_counts().head(20))

# Best sources for Odia speech, ranked by expected yield:

#1 Doordarshan Odia (DD Odia)
   - Government broadcaster, formal Odia
   - Minimal background music in news segments
   - Consistent broadcast-quality audio
   - https://youtube.com/@ddodisha
   - Expected yield after filtering: 40-50%

#2 OTV (Odisha TV) - news only
   - Studio anchor segments, clear formal Odia
   - Skip field reports, debates, talk shows
   - Search: "OTV news anchor" or "OTV bulletin"
   - Expected yield: 25-30%

#3 Odia audiobook channels
   - Search "ଓଡ଼ିଆ ଗଳ୍ପ" (Odia stories) on YouTube
   - Single narrator, clean recording, narrative prosody
   - Expected yield: 50-60%

#4 Odia podcast channels (skip if amateur)
   - Only if professionally recorded
   - Expected yield: variable

# Avoid for Weekend 2 dataset:
✗ Movie/serial dialogues (heavy music, multiple speakers)
✗ Bhajans / religious chants (musical, repetitive)
✗ Phone-quality interviews (poor SNR)
✗ Outdoor / field reports (wind, traffic noise)

# On your laptop (Linux/Mac/WSL):
pip install yt-dlp

# Create a list of YouTube URLs (50-100 videos targeting ~40-50 hours total)
cat > odia_urls.txt << 'EOF'
https://www.youtube.com/watch?v=VIDEO_ID_1
https://www.youtube.com/watch?v=VIDEO_ID_2
... (50-100 URLs)
EOF

# Download audio only, 16kHz mono WAV
mkdir -p raw_audio
yt-dlp \
  --batch-file odia_urls.txt \
  --extract-audio \
  --audio-format wav \
  --audio-quality 0 \
  --postprocessor-args "-ar 16000 -ac 1" \
  --output "raw_audio/%(id)s.%(ext)s" \
  --write-info-json \
  --no-overwrites \
  --sleep-interval 3

# Check download size:
du -sh raw_audio/
# Expected: 30-40 GB for ~40 hours of audio at 16kHz mono

# Filter on laptop — saves Kaggle storage + GPU time

# Quick filter: drop very short or very long files
import os
from pathlib import Path

raw_dir = Path("raw_audio")
keep_dir = Path("filtered_audio")
keep_dir.mkdir(exist_ok=True)

for wav in raw_dir.glob("*.wav"):
    size_mb = wav.stat().st_size / 1e6
    # Roughly: 16kHz mono = 1MB per minute
    duration_min = size_mb
    if 5 <= duration_min <= 30:  # Keep 5-30 minute segments
        wav.rename(keep_dir / wav.name)

# Check what survived
total_minutes = sum(f.stat().st_size / 1e6 for f in keep_dir.glob("*.wav"))
print(f"Kept: {len(list(keep_dir.glob('*.wav')))} files, ~{total_minutes/60:.1f} hours")
# Target: 30-40 hours of raw audio survives this filter

# Upload to Kaggle as new Dataset
# kaggle datasets create -p filtered_audio --dir-mode zip

# Kaggle notebook — Stage 1 of pipeline
!pip install -q silero-vad torch torchaudio soundfile

import torch, torchaudio
from silero_vad import load_silero_vad, read_audio, get_speech_timestamps
from pathlib import Path
import json

vad_model = load_silero_vad()

INPUT_DIR = Path("/kaggle/input/odia-raw-audio")
OUT_DIR = Path("/kaggle/working/segments")
OUT_DIR.mkdir(exist_ok=True)
manifest = []

for wav_file in INPUT_DIR.glob("*.wav"):
    audio = read_audio(str(wav_file), sampling_rate=16000)

    # Get speech segments
    segments = get_speech_timestamps(
        audio, vad_model,
        threshold=0.5,
        sampling_rate=16000,
        min_speech_duration_ms=3000,    # Min 3s segments for TTS
        max_speech_duration_s=20,       # Max 20s — keeps GPU memory bounded
        min_silence_duration_ms=500,
        speech_pad_ms=200,
    )

    for i, ts in enumerate(segments):
        start_s, end_s = ts['start'] / 16000, ts['end'] / 16000
        duration = end_s - start_s
        if duration < 3 or duration > 20:
            continue

        seg_audio = audio[ts['start']:ts['end']]
        seg_id = f"{wav_file.stem}_{i:04d}"
        seg_path = OUT_DIR / f"{seg_id}.wav"
        torchaudio.save(str(seg_path), seg_audio.unsqueeze(0), 16000)

        manifest.append({
            "segment_id": seg_id,
            "source_file": wav_file.name,
            "start_s": start_s, "end_s": end_s, "duration_s": duration,
            "path": str(seg_path),
        })

# Save manifest
import pandas as pd
pd.DataFrame(manifest).to_csv("/kaggle/working/segments_manifest.csv", index=False)
print(f"Total segments: {len(manifest)}")
print(f"Total speech hours: {sum(s['duration_s'] for s in manifest)/3600:.1f}")
# Expected: ~10-15 hours after VAD (from 30-40 hr raw)

# Kaggle notebook — Stage 2: Transcribe + filter low-confidence
!pip install -q faster-whisper

from faster_whisper import WhisperModel
import pandas as pd
import json
from pathlib import Path

# Load Whisper large-v3
print("Loading Whisper large-v3 (3 GB)...")
whisper = WhisperModel("large-v3", device="cuda", compute_type="float16")

manifest = pd.read_csv("/kaggle/working/segments_manifest.csv")
results = []

for i, row in manifest.iterrows():
    try:
        segments, info = whisper.transcribe(
            row['path'],
            language="or",                  # Force Odia
            word_timestamps=True,
            beam_size=5,
            temperature=0.0,
            condition_on_previous_text=False,
        )
        segments = list(segments)
        if not segments:
            continue

        text = " ".join(s.text for s in segments).strip()
        avg_logprob = sum(s.avg_logprob for s in segments) / len(segments)
        no_speech = max(s.no_speech_prob for s in segments)
        word_probs = [w.probability for s in segments for w in s.words]
        min_word_prob = min(word_probs) if word_probs else 0

        # FILTER: reject low-quality transcripts
        if avg_logprob < -0.7:        continue  # Whisper unsure
        if no_speech > 0.3:           continue  # Probably not speech
        if min_word_prob < 0.5:       continue  # Some word very unsure
        if len(text.split()) < 3:     continue  # Too short
        if len(text.split()) > 60:    continue  # Too long for TTS training
        if info.language_probability < 0.85: continue  # Not confidently Odia

        results.append({
            **row.to_dict(),
            "transcript": text,
            "whisper_confidence": float(avg_logprob),
            "lang_prob": float(info.language_probability),
        })

        if i % 100 == 0:
            print(f"[{i}/{len(manifest)}] Kept: {len(results)}")
    except Exception as e:
        print(f"[ERROR] {row['segment_id']}: {e}")

# Save filtered manifest
filtered_df = pd.DataFrame(results)
filtered_df.to_csv("/kaggle/working/transcribed_segments.csv", index=False)
print(f"\nAfter Whisper filter: {len(filtered_df)} segments")
print(f"Hours: {filtered_df['duration_s'].sum()/3600:.1f}")
# Expected: ~6-8 hours survive

# Stage 3 — DNSMOS scoring (Microsoft's automatic MOS predictor)
!pip install -q onnxruntime-gpu requests
!wget -q https://github.com/microsoft/DNS-Challenge/raw/master/DNSMOS/DNSMOS/sig_bak_ovr.onnx
!wget -q https://github.com/microsoft/DNS-Challenge/raw/master/DNSMOS/DNSMOS/model_v8.onnx

import onnxruntime as ort
import librosa
import numpy as np

# DNSMOS scoring function (simplified — full code on MS DNS-Challenge GitHub)
sess = ort.InferenceSession("model_v8.onnx", providers=['CUDAExecutionProvider'])

def score_dnsmos(audio_path):
    audio, sr = librosa.load(audio_path, sr=16000)
    # DNSMOS expects 9-second windows
    if len(audio) < 9 * 16000:
        audio = np.pad(audio, (0, 9*16000 - len(audio)))
    audio = audio[:9*16000]

    # Run inference
    input_features = audio.astype(np.float32).reshape(1, -1)
    out = sess.run(None, {'input_1': input_features})
    return float(out[0][0][2])  # Overall MOS

# Score all transcribed segments
df = pd.read_csv("/kaggle/working/transcribed_segments.csv")
df['dnsmos'] = df['path'].apply(score_dnsmos)

# Final filter: only keep DNSMOS >= 3.5 (good quality)
final = df[df['dnsmos'] >= 3.5].copy()
final = final.sort_values('dnsmos', ascending=False)

# Cap at 5 hours total (we don't need more for prototype)
total_seconds = 0
keep_indices = []
for idx, row in final.iterrows():
    if total_seconds + row['duration_s'] > 5 * 3600:
        break
    keep_indices.append(idx)
    total_seconds += row['duration_s']

final_5hr = final.loc[keep_indices]
final_5hr.to_csv("/kaggle/working/training_dataset_v1.csv", index=False)
print(f"Final training set: {len(final_5hr)} segments, {total_seconds/3600:.2f} hours")
print(f"Mean DNSMOS: {final_5hr['dnsmos'].mean():.2f}")
print(f"Mean Whisper confidence: {final_5hr['whisper_confidence'].mean():.2f}")

# Save as Kaggle Dataset for Weekend 3
# Files to save: training_dataset_v1.csv + all the .wav files referenced in it

# Kaggle notebook for Weekend 3
# Settings: GPU T4 x2, Internet ON

!git clone https://github.com/SWivid/F5-TTS.git /kaggle/working/F5-TTS
%cd /kaggle/working/F5-TTS
!pip install -q -e ". [eval]"
!pip install -q peft accelerate

# Verify import
import sys
sys.path.insert(0, "/kaggle/working/F5-TTS/src")
from f5_tts.model import CFM, DiT
print("F5-TTS training code loaded")

# IndicF5 uses HF transformers wrapper. F5-TTS training expects raw checkpoint.
# We need to extract the underlying F5-TTS state_dict from IndicF5.

import torch
from transformers import AutoModel

# Load IndicF5
indicf5 = AutoModel.from_pretrained("ai4bharat/IndicF5", trust_remote_code=True)

# Extract the underlying model state
# (Inspect indicf5.named_parameters() to find the F5 backbone)
backbone_state = {}
for name, param in indicf5.named_parameters():
    # IndicF5 prefixes the F5 model — strip the prefix
    if name.startswith("model."):
        backbone_state[name.replace("model.", "")] = param.data.clone()

# Save as F5-TTS-compatible checkpoint
torch.save({
    "model_state_dict": backbone_state,
    "step": 0,  # We're starting fresh fine-tuning
    "ema_model_state_dict": backbone_state,  # Initialize EMA same as model
}, "/kaggle/working/indicf5_base_for_finetune.pt")

print(f"Backbone params: {len(backbone_state)}")
print("Saved as indicf5_base_for_finetune.pt")

# F5-TTS training expects: a directory of .wav files + a CSV with (audio_path, text)
# Format your Weekend 2 output to match

import pandas as pd
import shutil
from pathlib import Path

src_csv = "/kaggle/input/odia-training-data-v1/training_dataset_v1.csv"
src_audio = Path("/kaggle/input/odia-training-data-v1/")
out_dir = Path("/kaggle/working/training_data")
out_dir.mkdir(exist_ok=True)

df = pd.read_csv(src_csv)

# F5-TTS expects 24kHz audio. Resample if needed.
import librosa, soundfile as sf
ft_records = []
for i, row in df.iterrows():
    audio, sr = librosa.load(row['path'], sr=24000)
    out_path = out_dir / f"{row['segment_id']}.wav"
    sf.write(out_path, audio, 24000)
    ft_records.append({
        "audio_path": str(out_path),
        "text": row['transcript'],
        "duration": row['duration_s'],
    })

ft_df = pd.DataFrame(ft_records)
ft_df.to_csv("/kaggle/working/training_manifest_f5.csv", index=False)
print(f"Training manifest: {len(ft_df)} samples, {ft_df['duration'].sum()/3600:.2f} hrs")

from peft import LoraConfig, get_peft_model, TaskType
import torch
from f5_tts.model import CFM, DiT

# Load base F5-TTS architecture
model = CFM(
    transformer=DiT(
        dim=1024, depth=22, heads=16, ff_mult=2,
        text_dim=512, conv_layers=4,
    ),
    mel_spec_kwargs=dict(
        n_fft=1024, hop_length=256, win_length=1024,
        n_mel_channels=100, target_sample_rate=24000,
    ),
)

# Load IndicF5 weights into it
ckpt = torch.load("/kaggle/working/indicf5_base_for_finetune.pt", map_location="cpu")
model.load_state_dict(ckpt['model_state_dict'], strict=False)
print("Loaded IndicF5 weights into F5-TTS architecture")

# Configure LoRA — target attention layers in transformer
lora_config = LoraConfig(
    r=16,                              # Low rank — fits Kaggle VRAM
    lora_alpha=32,
    target_modules=[
        "to_q", "to_v",                # Attention query+value
        "ff.0", "ff.2",                # FFN layers (sometimes named differently)
    ],
    lora_dropout=0.1,
    bias="none",
)

model = get_peft_model(model, lora_config)
model.print_trainable_parameters()
# Expected: ~4-8M trainable / 400M total (1-2%)

# Move to GPU
model = model.to("cuda")
print(f"VRAM: {torch.cuda.memory_allocated() / 1e9:.1f} GB")
# Should be ~4-5 GB — plenty of room on T4 16 GB

# Critical: Kaggle sessions die at 12 hours. Build resumability from the start.

import torch
from torch.utils.data import DataLoader
from pathlib import Path

CHECKPOINT_DIR = Path("/kaggle/working/lora_checkpoints")
CHECKPOINT_DIR.mkdir(exist_ok=True)

def save_checkpoint(model, optimizer, step, loss):
    ckpt = {
        "step": step,
        "lora_state_dict": {k: v for k, v in model.state_dict().items() if "lora" in k.lower()},
        "optimizer_state_dict": optimizer.state_dict(),
        "loss": loss,
    }
    # Atomic write — don't corrupt mid-save
    tmp = CHECKPOINT_DIR / f"latest.pt.tmp"
    torch.save(ckpt, tmp)
    tmp.rename(CHECKPOINT_DIR / "latest.pt")
    # Also keep periodic snapshots
    if step % 500 == 0:
        torch.save(ckpt, CHECKPOINT_DIR / f"step_{step}.pt")

def load_checkpoint(model, optimizer):
    latest = CHECKPOINT_DIR / "latest.pt"
    if not latest.exists():
        return 0
    ckpt = torch.load(latest, map_location="cuda")
    # Load only LoRA params
    model.load_state_dict({**model.state_dict(), **ckpt['lora_state_dict']}, strict=False)
    optimizer.load_state_dict(ckpt['optimizer_state_dict'])
    print(f"Resumed from step {ckpt['step']}")
    return ckpt['step']

# Optimizer — only train LoRA params
optimizer = torch.optim.AdamW(
    [p for p in model.parameters() if p.requires_grad],
    lr=1e-4,
    weight_decay=0.01,
)

# Resume if checkpoint exists
start_step = load_checkpoint(model, optimizer)

# Training loop — the actual thing
from f5_tts.dataset import F5TTSDataset  # adapt to your installed version
from torch.utils.data import DataLoader

# Build dataset
dataset = F5TTSDataset(
    csv_path="/kaggle/working/training_manifest_f5.csv",
    target_sample_rate=24000,
    max_duration=20.0,
)
loader = DataLoader(
    dataset, batch_size=4,             # Small batch for T4 VRAM
    num_workers=2, shuffle=True,
)

# Train
TOTAL_STEPS = 5000                     # ~6-8 hrs on T4
LOG_EVERY = 50
SAVE_EVERY = 200

model.train()
step = start_step
import time
t_start = time.time()
running_loss = 0

while step < TOTAL_STEPS:
    for batch in loader:
        if step >= TOTAL_STEPS: break

        # Move to GPU
        mel = batch['mel'].to("cuda")
        text = batch['text']
        durations = batch['durations'].to("cuda")

        # Forward + flow-matching loss
        loss, _ = model(mel, text=text, lens=durations)

        # Backward
        loss.backward()
        torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
        optimizer.step()
        optimizer.zero_grad()

        running_loss += loss.item()
        step += 1

        # Logging
        if step % LOG_EVERY == 0:
            avg_loss = running_loss / LOG_EVERY
            elapsed = time.time() - t_start
            eta = (elapsed / step) * (TOTAL_STEPS - step)
            print(f"step {step:5d} | loss {avg_loss:.4f} | "
                  f"elapsed {elapsed/60:.1f}m | ETA {eta/60:.1f}m")
            running_loss = 0

        # Checkpoint
        if step % SAVE_EVERY == 0:
            save_checkpoint(model, optimizer, step, loss.item())

# Final save
save_checkpoint(model, optimizer, step, loss.item())
print(f"\nTraining complete: {TOTAL_STEPS} steps in {(time.time()-t_start)/3600:.1f} hours")

# Sunday morning: generate fine-tuned outputs on the SAME 200 sentences from Weekend 1

# Load fine-tuned model
ft_ckpt = torch.load(CHECKPOINT_DIR / "latest.pt", map_location="cuda")
model.load_state_dict({**model.state_dict(), **ft_ckpt['lora_state_dict']}, strict=False)
model.eval()

# Inference on test sentences
import pandas as pd
test_df = pd.read_csv("/kaggle/input/odia-baseline-data/test_sentences.csv")
OUT_FT = Path("/kaggle/working/finetune_outputs")
OUT_FT.mkdir(exist_ok=True)

for i, row in test_df.iterrows():
    for ref_name, (ref_path, ref_text) in REFS.items():  # Same refs as Weekend 1
        out_path = OUT_FT / f"{row['id']}_{ref_name}_ft.wav"
        with torch.no_grad():
            audio = model.sample(
                text=row['sentence'],
                ref_audio=ref_path,
                ref_text=ref_text,
                steps=32,
                cfg_strength=2.0,
            )
        sf.write(out_path, audio.cpu().numpy(), 24000)

# Now: package side-by-side comparison for evaluators
EVAL = Path("/kaggle/working/comparison_eval")
EVAL.mkdir(exist_ok=True)

import shutil
for i, row in test_df.iterrows():
    for ref_name, _ in REFS.items():
        # Baseline (Weekend 1) and Fine-tuned (Weekend 3) — randomized labels for blind eval
        import random
        labels = ['A', 'B']
        random.shuffle(labels)
        baseline_label, ft_label = labels[0], labels[1]

        shutil.copy(
            f"/kaggle/input/baseline-outputs/{row['id']}_{ref_name}.wav",
            EVAL / f"{row['id']}_{ref_name}_{baseline_label}.wav"
        )
        shutil.copy(
            OUT_FT / f"{row['id']}_{ref_name}_ft.wav",
            EVAL / f"{row['id']}_{ref_name}_{ft_label}.wav"
        )

# Build blind A/B form
records = [{"id": row['id'], "ref": rn, "category": row['category'],
            "sentence": row['sentence'],
            "preferred_AB": "", "much_better_yn": ""}
           for _, row in test_df.iterrows() for rn in REFS]
pd.DataFrame(records).to_csv(EVAL / "ab_form.csv", index=False)

# Create new Space at huggingface.co/new-space
# - Owner: your username
# - Space name: odia-tts-demo
# - SDK: Gradio
# - Hardware: CPU basic (free) — add GPU later if traffic warrants
# - Visibility: Public

# In the Space repo, create app.py:

import gradio as gr
import torch
from transformers import AutoModel
from peft import PeftModel
import soundfile as sf
import numpy as np
import tempfile

# Load base IndicF5
print("Loading IndicF5...")
base_model = AutoModel.from_pretrained("ai4bharat/IndicF5", trust_remote_code=True)

# Load YOUR LoRA adapter (uploaded as separate HF model)
# After Weekend 3, upload the lora_state_dict to:
# huggingface.co/YOUR_USERNAME/odia-tts-lora-v1
# Then reference it here:
# (Note: actual LoRA loading depends on how IndicF5 was wrapped — adjust as needed)

REFERENCE_VOICES = {
    "OTV Anchor": ("examples/ref_otv.wav", "OTV reference transcript here"),
    "DD Odia":    ("examples/ref_dd.wav",  "DD Odia reference transcript"),
    "Narrative":  ("examples/ref_pod.wav", "Podcast narrator transcript"),
}

def synthesize(text, voice_choice, use_finetune):
    ref_path, ref_text = REFERENCE_VOICES[voice_choice]

    # Pick model
    model = ft_model if use_finetune else base_model

    audio = model(text, ref_audio_path=ref_path, ref_text=ref_text)
    if audio.dtype == np.int16:
        audio = audio.astype(np.float32) / 32768.0

    out = tempfile.NamedTemporaryFile(suffix=".wav", delete=False)
    sf.write(out.name, audio, 24000)
    return out.name

with gr.Blocks(title="Sovereign Odia TTS Demo") as demo:
    gr.Markdown("# 🎙 ସ୍ଵାଧୀନ ଓଡ଼ିଆ ସ୍ୱର — Sovereign Odia TTS")
    gr.Markdown("Compare base IndicF5 vs our fine-tuned version on Odia text.")

    with gr.Row():
        text = gr.Textbox(label="Odia Text", placeholder="ଆଜି ଭୁବନେଶ୍ୱରରେ...", lines=3)
    with gr.Row():
        voice = gr.Dropdown(choices=list(REFERENCE_VOICES.keys()), value="OTV Anchor", label="Reference Voice")
        ft = gr.Checkbox(label="Use fine-tuned model", value=True)

    btn = gr.Button("Synthesize", variant="primary")
    audio_out = gr.Audio(label="Output", type="filepath")

    btn.click(synthesize, inputs=[text, voice, ft], outputs=audio_out)

    gr.Markdown("---")
    gr.Markdown("Built by [you] using IndicF5 (AI4Bharat). Apache 2.0.")
    gr.Markdown("Feedback: [your-email] · GitHub: [link]")

demo.launch()

# Push your fine-tuned LoRA weights to HF for the Space to use

from huggingface_hub import HfApi, create_repo

create_repo("YOUR_USERNAME/odia-tts-lora-v1", private=False, exist_ok=True)

api = HfApi()
api.upload_file(
    path_or_fileobj="/kaggle/working/lora_checkpoints/latest.pt",
    path_in_repo="adapter_model.bin",
    repo_id="YOUR_USERNAME/odia-tts-lora-v1",
)

# Add a model card describing what this is
README = '''
# Sovereign Odia TTS — LoRA adapter v1

LoRA fine-tune of [ai4bharat/IndicF5](https://huggingface.co/ai4bharat/IndicF5)
on 5 hours of clean Odia speech (DD Odia + OTV news).

- Base model: IndicF5 (400M params)
- LoRA rank: 16, alpha: 32
- Training: 5000 steps, ~6 hours on T4
- License: MIT (matches base)

This is an early prototype. Quality is being evaluated.

## Usage
[code snippet here]

## Evaluation
[link to MOS results]
'''
with open("/tmp/README.md", "w") as f:
    f.write(README)
api.upload_file(path_or_fileobj="/tmp/README.md", path_in_repo="README.md",
                repo_id="YOUR_USERNAME/odia-tts-lora-v1")

# Add to app.py — examples that showcase the model

EXAMPLES = [
    ["ଆଜି ଭୁବନେଶ୍ୱରରେ ବର୍ଷା ହେଉଛି ।", "OTV Anchor", True],
    ["ତୁ ସକାଳେ କଣ ଖାଇଛୁ?", "Narrative", True],
    ["ସରକାର ନୂଆ ନୀତି ଘୋଷଣା କରିଛନ୍ତି।", "DD Odia", True],
    ["୨୦୨୪ ମସିହାରେ ଭାରତ ଚନ୍ଦ୍ରଯାନ ୩ ଉତ୍ସର୍ଗ କରିଥିଲା।", "DD Odia", True],
]

with gr.Blocks(...):
    # ...
    gr.Examples(examples=EXAMPLES, inputs=[text, voice, ft])

# Make the Space discoverable:
# - Add tags: "odia", "indic", "tts", "sovereign-ai"
# - Add proper README to the Space
# - Submit to https://huggingface.co/spaces/lhoestq/awesome-spaces lists

# Post in these communities — be specific, ask for feedback:

# r/Odia subreddit (~5k members)
"""
Built a sovereign Odia TTS prototype, free demo: [HF Space link]
Compares fine-tuned IndicF5 vs base. Feedback specifically wanted on:
- Does it sound like Odia or Hindi-influenced?
- Mispronunciation of common words?
- Voice quality on news vs conversational text?
"""

# Twitter/X — tag @ai4bharat, @indianai, Odia influencers
# LinkedIn — your network, mention Bhashini Mission
# Telegram Odia tech groups — search for active ones
# Direct outreach: 5-10 Odia journalists, Odia Wikipedia editors

# What you're optimizing for:
# - 50+ unique users try the demo
# - 10+ leave structured feedback
# - 1-2 connections that lead to funding conversations

# Add basic analytics to your Space (Gradio supports this)

import gradio as gr
import json
from datetime import datetime

def synthesize_with_logging(text, voice, ft):
    # Log usage
    log = {
        "ts": datetime.utcnow().isoformat(),
        "text_length": len(text),
        "voice": voice,
        "finetuned": ft,
    }
    with open("/data/usage.jsonl", "a") as f:
        f.write(json.dumps(log) + "\n")

    return synthesize(text, voice, ft)

# Add feedback button
with gr.Row():
    good_btn = gr.Button("👍 Good")
    bad_btn  = gr.Button("👎 Bad")
    detail   = gr.Textbox(label="What was wrong? (optional)")
    submit   = gr.Button("Submit feedback")