Upload inversion_worker.py with huggingface_hub

inversion_worker.py

@@ -0,0 +1,389 @@
+"""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()