inversion_worker.py

"""Codec Inversion Worker — runs on cheap GPUs to invert JL clips.

Usage: python inversion_worker.py --shard-id 0 --num-shards 15
Each worker processes 806/num_shards clips.

Requires: Code2Wav checkpoint at /workspace/code2wav/ (downloaded from HF)
Outputs: /workspace/inverted_codes/{clip_idx}.pt files
"""
import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np
import soundfile as sf
import os, time, json, gc, argparse, sys

ts = lambda: time.strftime("%I:%M:%S %p")

# ============================================================
# Audio loss (proven in test6b)
# ============================================================
class AudioLoss(nn.Module):
    def __init__(self, sr=24000, n_mels=80,
                 n_ffts=[512, 1024, 2048], hop_lengths=[128, 256, 512]):
        super().__init__()
        self.sr = sr
        self.n_mels = n_mels
        self.n_ffts = n_ffts
        self.hop_lengths = hop_lengths
        self.mel_fbanks = nn.ParameterList()
        for n_fft in n_ffts:
            fbank = self._mel_filterbank(n_fft, n_mels, sr)
            self.mel_fbanks.append(nn.Parameter(fbank, requires_grad=False))

    def _mel_filterbank(self, n_fft, n_mels, sr):
        fmin, fmax = 0, sr // 2
        mel_low = 2595 * np.log10(1 + fmin / 700)
        mel_high = 2595 * np.log10(1 + fmax / 700)
        mel_points = np.linspace(mel_low, mel_high, n_mels + 2)
        hz_points = 700 * (10 ** (mel_points / 2595) - 1)
        bins = np.floor((n_fft + 1) * hz_points / sr).astype(int)
        fbank = np.zeros((n_mels, n_fft // 2 + 1))
        for m in range(1, n_mels + 1):
            f_left, f_center, f_right = bins[m-1], bins[m], bins[m+1]
            for k in range(f_left, f_center):
                if f_center > f_left:
                    fbank[m-1, k] = (k - f_left) / (f_center - f_left)
            for k in range(f_center, f_right):
                if f_right > f_center:
                    fbank[m-1, k] = (f_right - k) / (f_right - f_center)
        return torch.FloatTensor(fbank)

    def _stft(self, audio, n_fft, hop_length):
        audio = audio.reshape(-1)
        pad = n_fft // 2
        audio_pad = F.pad(audio, (pad, pad), mode='constant', value=0.0)
        window = torch.hann_window(n_fft, device=audio.device)
        stft = torch.stft(audio_pad, n_fft=n_fft, hop_length=hop_length,
                          win_length=n_fft, window=window, return_complex=True)
        return stft

    def forward(self, predicted, target):
        pred = predicted.squeeze()
        targ = target.squeeze()
        total_loss = 0
        for i, (n_fft, hop) in enumerate(zip(self.n_ffts, self.hop_lengths)):
            fbank = self.mel_fbanks[i]
            pred_stft = self._stft(pred, n_fft, hop)
            targ_stft = self._stft(targ, n_fft, hop)
            pred_mag = pred_stft.abs()
            targ_mag = targ_stft.abs()
            if pred_mag.dim() == 2:
                pred_mag = pred_mag.unsqueeze(0)
                targ_mag = targ_mag.unsqueeze(0)
            min_frames = min(pred_mag.shape[-1], targ_mag.shape[-1])
            pred_mag = pred_mag[..., :min_frames]
            targ_mag = targ_mag[..., :min_frames]
            stft_l1 = F.l1_loss(pred_mag, targ_mag)
            stft_log = F.l1_loss(torch.log(pred_mag.clamp(min=1e-5)),
                                  torch.log(targ_mag.clamp(min=1e-5)))
            fbank_dev = fbank.to(pred_mag.device)
            pred_mel = torch.log(torch.matmul(fbank_dev, pred_mag).clamp(min=1e-5))
            targ_mel = torch.log(torch.matmul(fbank_dev, targ_mag).clamp(min=1e-5))
            mel_l1 = F.l1_loss(pred_mel, targ_mel)
            total_loss = total_loss + stft_l1 + stft_log + mel_l1
        return total_loss / len(self.n_ffts)


# ============================================================
# STE Code2Wav forwards
# ============================================================
def deterministic_code2wav_forward(code2wav, logits, tau=1.0, hard=True):
    batch, nq, seq_len, cb_size = logits.shape
    probs = F.softmax(logits / tau, dim=-1)
    if hard:
        index = probs.argmax(dim=-1, keepdim=True)
        hard_onehot = torch.zeros_like(probs).scatter_(-1, index, 1.0)
        probs = hard_onehot - probs.detach() + probs
    embed_dim = code2wav.code_embedding.weight.shape[1]
    cb_weights = code2wav.code_embedding.weight
    soft_embeds = []
    for q in range(nq):
        q_embed = cb_weights[q * cb_size : (q + 1) * cb_size]
        q_soft = probs[:, q]
        q_result = torch.matmul(q_soft, q_embed.to(q_soft.dtype))
        soft_embeds.append(q_result)
    soft_embeds = torch.stack(soft_embeds, dim=1)
    hidden = soft_embeds.mean(1)
    hidden = code2wav.pre_transformer(inputs_embeds=hidden).last_hidden_state
    hidden = hidden.permute(0, 2, 1)
    for blocks in code2wav.upsample:
        for block in blocks:
            hidden = block(hidden)
    wav = hidden
    for block in code2wav.decoder:
        wav = block(wav)
    return wav.clamp(min=-1, max=1)


def soft_code2wav_forward(code2wav, logits, tau=1.0, hard=False):
    batch, nq, seq_len, cb_size = logits.shape
    soft = F.gumbel_softmax(logits, tau=tau, hard=hard, dim=-1)
    embed_dim = code2wav.code_embedding.weight.shape[1]
    cb_weights = code2wav.code_embedding.weight
    soft_embeds = []
    for q in range(nq):
        q_embed = cb_weights[q * cb_size : (q + 1) * cb_size]
        q_soft = soft[:, q]
        q_result = torch.matmul(q_soft, q_embed.to(q_soft.dtype))
        soft_embeds.append(q_result)
    soft_embeds = torch.stack(soft_embeds, dim=1)
    hidden = soft_embeds.mean(1)
    hidden = code2wav.pre_transformer(inputs_embeds=hidden).last_hidden_state
    hidden = hidden.permute(0, 2, 1)
    for blocks in code2wav.upsample:
        for block in blocks:
            hidden = block(hidden)
    wav = hidden
    for block in code2wav.decoder:
        wav = block(wav)
    return wav.clamp(min=-1, max=1)


# ============================================================
# Single clip inversion
# ============================================================
def invert_clip(c2w, target_tensor, loss_fn, config, total_upsample,
                warmup_steps=100, ste_steps=400):
    """Invert a single audio clip to codec tokens."""
    seq_len = len(target_tensor) // total_upsample
    if seq_len < 2:
        return None, float('inf'), 0.0

    device = target_tensor.device

    logits = torch.zeros(1, config.num_quantizers, seq_len, config.codebook_size,
                         device=device, dtype=torch.float32)
    logits += torch.randn_like(logits) * 0.01
    logits.requires_grad_(True)

    # Phase 1: Soft warmup
    optimizer = torch.optim.AdamW([logits], lr=0.1, weight_decay=0.0)
    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
        optimizer, T_max=warmup_steps, eta_min=0.01)

    for step in range(warmup_steps):
        optimizer.zero_grad()
        wav_out = soft_code2wav_forward(c2w, logits, tau=1.0, hard=False)
        loss = loss_fn(wav_out, target_tensor)
        loss.backward()
        torch.nn.utils.clip_grad_norm_([logits], max_norm=10.0)
        optimizer.step()
        scheduler.step()

    best_logits = logits.detach().clone()

    # Phase 2: STE refinement
    logits = best_logits.clone().requires_grad_(True)
    optimizer = torch.optim.AdamW([logits], lr=0.05, weight_decay=0.0)
    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
        optimizer, T_max=ste_steps, eta_min=0.001)

    best_loss = float('inf')
    for step in range(ste_steps):
        optimizer.zero_grad()
        wav_out = deterministic_code2wav_forward(c2w, logits, tau=1.0, hard=True)
        loss = loss_fn(wav_out, target_tensor)
        loss.backward()
        torch.nn.utils.clip_grad_norm_([logits], max_norm=5.0)
        optimizer.step()
        scheduler.step()

        if loss.item() < best_loss:
            best_loss = loss.item()
            best_logits = logits.detach().clone()

    final_codes = best_logits.argmax(dim=-1)

    # Cosine similarity
    with torch.no_grad():
        wav_final = c2w(final_codes)
        pred = wav_final.squeeze()
        targ = target_tensor.squeeze()
        n_fft, hop = 1024, 256
        window = torch.hann_window(n_fft, device=pred.device)
        p_stft = torch.stft(pred, n_fft=n_fft, hop_length=hop, win_length=n_fft,
                             window=window, return_complex=True)
        t_stft = torch.stft(targ, n_fft=n_fft, hop_length=hop, win_length=n_fft,
                             window=window, return_complex=True)
        p_mag = p_stft.abs().flatten()
        t_mag = t_stft.abs()[:, :p_stft.shape[1]].flatten()
        min_len = min(len(p_mag), len(t_mag))
        cosine = F.cosine_similarity(p_mag[:min_len].unsqueeze(0),
                                      t_mag[:min_len].unsqueeze(0)).item()

    return final_codes, best_loss, cosine


# ============================================================
# Main
# ============================================================
def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('--shard-id', type=int, required=True)
    parser.add_argument('--num-shards', type=int, required=True)
    parser.add_argument('--total-clips', type=int, default=806)
    parser.add_argument('--output-dir', type=str, default='/workspace/inverted_codes')
    parser.add_argument('--hf-repo', type=str, default='msrcam/claudia_voice_dataset')
    parser.add_argument('--c2w-repo', type=str, default='msrcam/qwen3-omni-code2wav')
    args = parser.parse_args()

    os.makedirs(args.output_dir, exist_ok=True)

    print(f"[{ts()}] === Codec Inversion Worker {args.shard_id}/{args.num_shards} ===")

    # Calculate this shard's clip range
    clips_per_shard = args.total_clips // args.num_shards
    start_idx = args.shard_id * clips_per_shard
    end_idx = start_idx + clips_per_shard if args.shard_id < args.num_shards - 1 else args.total_clips
    my_clips = list(range(start_idx, end_idx))
    print(f"  Processing clips {start_idx}-{end_idx-1} ({len(my_clips)} clips)")

    # Load Code2Wav from standalone checkpoint
    print(f"[{ts()}] Loading Code2Wav from {args.c2w_repo}...")

    try:
        # Try loading from HF repo (standalone checkpoint)
        from huggingface_hub import hf_hub_download
        c2w_path = hf_hub_download(args.c2w_repo, "code2wav_state_dict.pt", repo_type="model")
        config_path = hf_hub_download(args.c2w_repo, "code2wav_config.json", repo_type="model")
        model_config_dir = hf_hub_download(args.c2w_repo, "config.json", repo_type="model")
        model_config_dir = os.path.dirname(model_config_dir)

        from transformers import AutoConfig, Qwen3OmniMoeForConditionalGeneration

        config_full = AutoConfig.from_pretrained(model_config_dir, trust_remote_code=True)

        # Create model shell on meta device (no actual weights loaded)
        with torch.device("meta"):
            model = Qwen3OmniMoeForConditionalGeneration._from_config(config_full)

        c2w = model.code2wav

        # Load real Code2Wav weights
        state_dict = torch.load(c2w_path, map_location="cuda:0", weights_only=True)
        c2w.load_state_dict(state_dict, assign=True)
        c2w = c2w.to("cuda:0")

        del model
        print(f"  Code2Wav loaded from standalone checkpoint")

    except Exception as e:
        print(f"  Standalone load failed ({e}), falling back to full model load...")
        from transformers import Qwen3OmniMoeForConditionalGeneration
        model = Qwen3OmniMoeForConditionalGeneration.from_pretrained(
            "/workspace/models/qwen3-omni",
            torch_dtype=torch.float32,
            device_map="cuda:0",
            trust_remote_code=True,
            attn_implementation="eager",
        )
        c2w = model.code2wav
        del model.thinker, model.talker
        torch.cuda.empty_cache()

    c2w.eval()
    for p in c2w.parameters():
        p.requires_grad_(False)

    config = c2w.config
    total_upsample = int(np.prod(config.upsample_rates + config.upsampling_ratios))
    print(f"  codebook={config.codebook_size}, quantizers={config.num_quantizers}, "
          f"upsample={total_upsample}")
    print(f"  GPU memory: {torch.cuda.memory_allocated()/1e9:.1f}GB")

    loss_fn = AudioLoss(sr=24000).to("cuda:0")

    # Download and process clips
    from huggingface_hub import hf_hub_download

    results = []
    t_start = time.time()

    for i, clip_idx in enumerate(my_clips):
        clip_name = f"{clip_idx:05d}"
        out_path = f"{args.output_dir}/{clip_name}.pt"

        # Skip if already done
        if os.path.exists(out_path):
            print(f"  [{i+1}/{len(my_clips)}] {clip_name} — already done, skipping")
            continue

        try:
            # Download clip
            wav_path = hf_hub_download(args.hf_repo, f"data/{clip_name}.wav", repo_type="dataset")
            audio, sr = sf.read(wav_path)

            # Resample to 24kHz
            if sr != 24000:
                target_len = int(len(audio) * 24000 / sr)
                audio = np.interp(
                    np.linspace(0, len(audio) - 1, target_len),
                    np.arange(len(audio)), audio
                ).astype(np.float32)

            # Cap at 10 seconds
            max_samples = 24000 * 10
            if len(audio) > max_samples:
                audio = audio[:max_samples]

            target_tensor = torch.FloatTensor(audio).to("cuda:0")

            # Invert
            t0 = time.time()
            codes, loss, cosine = invert_clip(c2w, target_tensor, loss_fn, config, total_upsample)
            elapsed = time.time() - t0

            if codes is not None:
                torch.save(codes.cpu(), out_path)
                status = "OK" if cosine > 0.7 else "LOW"
                print(f"  [{i+1}/{len(my_clips)}] {clip_name} — loss={loss:.3f} cos={cosine:.3f} "
                      f"t={elapsed:.0f}s [{status}]")
                results.append({"clip": clip_name, "loss": loss, "cosine": cosine,
                                "time": elapsed, "status": status})
            else:
                print(f"  [{i+1}/{len(my_clips)}] {clip_name} — too short, skipped")
                results.append({"clip": clip_name, "loss": -1, "cosine": 0, "status": "SKIP"})

        except Exception as e:
            print(f"  [{i+1}/{len(my_clips)}] {clip_name} — ERROR: {e}")
            results.append({"clip": clip_name, "loss": -1, "cosine": 0, "status": f"ERROR: {e}"})

        # Clear GPU cache between clips
        torch.cuda.empty_cache()
        gc.collect()

    total_time = time.time() - t_start
    n_ok = sum(1 for r in results if r.get("status") == "OK")
    n_low = sum(1 for r in results if r.get("status") == "LOW")
    avg_cosine = np.mean([r["cosine"] for r in results if r["cosine"] > 0]) if results else 0

    print(f"\n[{ts()}] === Worker {args.shard_id} Complete ===")
    print(f"  Clips: {len(my_clips)} | OK: {n_ok} | Low: {n_low}")
    print(f"  Mean cosine: {avg_cosine:.3f}")
    print(f"  Total time: {total_time/60:.1f} min ({total_time/len(my_clips):.1f}s/clip)")

    # Save manifest
    manifest_path = f"{args.output_dir}/manifest_shard{args.shard_id:02d}.json"
    with open(manifest_path, "w") as f:
        json.dump({"shard_id": args.shard_id, "results": results,
                   "total_time": total_time}, f, indent=2)
    print(f"  Manifest: {manifest_path}")

    # Upload results to HF
    try:
        from huggingface_hub import HfApi
        api = HfApi()
        api.upload_folder(
            folder_path=args.output_dir,
            repo_id="msrcam/claudia_inverted_codes",
            repo_type="dataset",
            path_in_repo=f"shard_{args.shard_id:02d}",
        )
        print(f"  Uploaded to HF: msrcam/claudia_inverted_codes/shard_{args.shard_id:02d}")
    except Exception as e:
        print(f"  HF upload failed: {e} — results saved locally")


if __name__ == "__main__":
    main()