Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,8 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+evaluation/QP/QP_1 filter=lfs diff=lfs merge=lfs -text
+evaluation/QP/QP_2 filter=lfs diff=lfs merge=lfs -text
+evaluation/QP/QP_3 filter=lfs diff=lfs merge=lfs -text
+evaluation/QP/QP_4 filter=lfs diff=lfs merge=lfs -text
+evaluation/QP/QP_5 filter=lfs diff=lfs merge=lfs -text

evaluation/QP/.ipynb_checkpoints/net-checkpoint.py

@@ -0,0 +1,29 @@
+import torch
+from torch import nn, optim
+
+class LossPredictor(nn.Module):
+    def __init__(self, ssl_model, ssl_out_dim, dropout_rate=0.2):
+        super(LossPredictor, self).__init__()
+        self.ssl_model = ssl_model
+        self.ssl_features = ssl_out_dim
+        self.dropout = nn.Dropout(dropout_rate)
+        self.carac_interm = nn.Linear(self.ssl_features,1000) #num dim neurones
+        self.output_layer = nn.Linear(1000, 1) #1 neurones
+
+
+    def forward(self, wav):
+        wav = wav.squeeze(1)
+        res = self.ssl_model(wav, mask=False, features_only=True, layer=None)
+        x = res['x']
+        if 'layer_results' in res:
+            layer_outputs = [layer[0] for layer in res['layer_results']] #12 couches
+
+            concatenated_layers = torch.cat(layer_outputs, dim=-1)
+        
+            x = torch.mean(concatenated_layers, dim=0)
+        
+        x = self.carac_interm(x)
+        
+        x = self.dropout(x) ###Pour le MCDropout pendant train+ pred select candidate
+        x = self.output_layer(x)
+        return x.squeeze(1) #return loss

evaluation/QP/.ipynb_checkpoints/qp_pred-checkpoint.py

@@ -0,0 +1,48 @@
+def _load_sslmos_model(state):
+    """
+    Charge le backbone fairseq + LossPredictor, puis restaure ton checkpoint finetuné.
+    Retourne (net, target_sr).
+    """
+    device = state["device"]
+    target_sr = state.get("qp_target_sr", 24000)
+    ssl_out_dim = state.get("qp_ssl_out_dim", 9216)
+
+    base_model_ckpt = state["qp_fairseq_base_model"]          
+    finetuned_ckpt = state["qp_finetuned_checkpoint"]         
+
+    # --- patch torch.load (comme dans ton script) pour éviter weights_only=True par défaut ---
+    torch.serialization.add_safe_globals([__import__("argparse").Namespace])
+    original_torch_load = torch.load
+
+    def patched_torch_load(*args, **kwargs):
+        if "weights_only" not in kwargs:
+            kwargs["weights_only"] = False
+        return original_torch_load(*args, **kwargs)
+
+    torch.load = patched_torch_load
+    models, cfg, task = fairseq.checkpoint_utils.load_model_ensemble_and_task([base_model_ckpt])
+    torch.load = original_torch_load
+
+    ssl_model = models[0]
+    ssl_model.remove_pretraining_modules()
+    for p in ssl_model.parameters():
+        p.requires_grad = False
+
+    net = LossPredictor(ssl_model, ssl_out_dim).to(device)
+    net.load_state_dict(torch.load(finetuned_ckpt, map_location=device))
+    net.eval()
+
+    return net, target_sr
+
+
+def _load_and_resample_wav(wav_path: str, target_sr: int, device):
+    wav, sr = torchaudio.load(wav_path)  # wav: [C, T]
+    # mono
+    if wav.size(0) > 1:
+        wav = wav.mean(dim=0, keepdim=True)
+    # resample
+    if sr != target_sr:
+        wav = torchaudio.functional.resample(wav, orig_freq=sr, new_freq=target_sr)
+    # shape attendue: [B, C, T] -> ici B=1
+    wav = wav.unsqueeze(0).to(device)  # [1, 1, T]
+    return wav

evaluation/QP/QP_1

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e8b1330d505f76279ee19034f6cad43038ac973668fce9886dd2fe13cfec2254
+size 414444305

evaluation/QP/QP_2

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cd8994fde3a2333a2562533f8e2a3daf327736aff11fb6536ce4295b5142ec98
+size 414444305

evaluation/QP/QP_3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5615e54e056e0cc7e0bb7c0e19c17dbff6dbf7605b33a6d36167095133bdbe65
+size 414444305

evaluation/QP/QP_4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:349f2db578056ef776983661ae62d6f68ba14ae3c250f1913c47cb453a09f756
+size 414444305

evaluation/QP/QP_5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d5e2c442b8c6511bbbde3ef69059845817ea7a14d04b0b8800b078b5f8d11e1b
+size 414444305

evaluation/QP/net.py

@@ -0,0 +1,29 @@
+import torch
+from torch import nn, optim
+
+class LossPredictor(nn.Module):
+    def __init__(self, ssl_model, ssl_out_dim, dropout_rate=0.2):
+        super(LossPredictor, self).__init__()
+        self.ssl_model = ssl_model
+        self.ssl_features = ssl_out_dim
+        self.dropout = nn.Dropout(dropout_rate)
+        self.carac_interm = nn.Linear(self.ssl_features,1000) #num dim neurones
+        self.output_layer = nn.Linear(1000, 1) #1 neurones
+
+
+    def forward(self, wav):
+        wav = wav.squeeze(1)
+        res = self.ssl_model(wav, mask=False, features_only=True, layer=None)
+        x = res['x']
+        if 'layer_results' in res:
+            layer_outputs = [layer[0] for layer in res['layer_results']] #12 couches
+
+            concatenated_layers = torch.cat(layer_outputs, dim=-1)
+        
+            x = torch.mean(concatenated_layers, dim=0)
+        
+        x = self.carac_interm(x)
+        
+        x = self.dropout(x) ###Pour le MCDropout pendant train+ pred select candidate
+        x = self.output_layer(x)
+        return x.squeeze(1) #return loss

evaluation/QP/qp_pred.py

@@ -0,0 +1,73 @@
+import os
+from huggingface_hub import hf_hub_download
+
+def ensure_checkpoint_exists(checkpoint_path, repo_id="LIUM/TTSEval", subfolder="evaluation/QP"):
+    # Check if the file exists locally
+    if not os.path.exists(checkpoint_path):
+        print(f"File {checkpoint_path} not found. Downloading from Hugging Face...")
+        
+        # This downloads the file and returns the local path to the cached version
+        # Note: checkpoint_path here should be the filename within the HF repo
+        filename = os.path.basename(checkpoint_path)
+        
+        downloaded_path = hf_hub_download(
+            repo_id=repo_id,
+            filename=filename,
+            subfolder=subfolder,
+            repo_type="model"
+        )
+        return downloaded_path
+    
+    return checkpoint_path
+
+def _load_sslmos_model(state):
+    """
+    Charge le backbone fairseq + LossPredictor, puis restaure ton checkpoint finetuné.
+    Retourne (net, target_sr).
+    """
+    device = state["device"]
+    target_sr = state.get("qp_target_sr", 24000)
+    ssl_out_dim = state.get("qp_ssl_out_dim", 9216)
+
+    base_model_ckpt = state["qp_fairseq_base_model"]          
+    finetuned_ckpt = state["qp_finetuned_checkpoint"]
+    # Update paths if necessary
+    base_model_ckpt = ensure_checkpoint_exists(base_model_ckpt)
+    finetuned_ckpt = ensure_checkpoint_exists(finetuned_ckpt)
+
+    # --- patch torch.load (comme dans ton script) pour éviter weights_only=True par défaut ---
+    torch.serialization.add_safe_globals([__import__("argparse").Namespace])
+    original_torch_load = torch.load
+
+    def patched_torch_load(*args, **kwargs):
+        if "weights_only" not in kwargs:
+            kwargs["weights_only"] = False
+        return original_torch_load(*args, **kwargs)
+
+    torch.load = patched_torch_load
+    models, cfg, task = fairseq.checkpoint_utils.load_model_ensemble_and_task([base_model_ckpt])
+    torch.load = original_torch_load
+
+    ssl_model = models[0]
+    ssl_model.remove_pretraining_modules()
+    for p in ssl_model.parameters():
+        p.requires_grad = False
+
+    net = LossPredictor(ssl_model, ssl_out_dim).to(device)
+    net.load_state_dict(torch.load(finetuned_ckpt, map_location=device))
+    net.eval()
+
+    return net, target_sr
+
+
+def _load_and_resample_wav(wav_path: str, target_sr: int, device):
+    wav, sr = torchaudio.load(wav_path)  # wav: [C, T]
+    # mono
+    if wav.size(0) > 1:
+        wav = wav.mean(dim=0, keepdim=True)
+    # resample
+    if sr != target_sr:
+        wav = torchaudio.functional.resample(wav, orig_freq=sr, new_freq=target_sr)
+    # shape attendue: [B, C, T] -> ici B=1
+    wav = wav.unsqueeze(0).to(device)  # [1, 1, T]
+    return wav

evaluation/QP/wav2vec_small.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c66c39eaed1b79a61ea8573f71e08f6641ff156b6a8f458cfaab53877dfa4a26
+size 950500491