Update app.py

app.py

@@ -82,28 +82,43 @@ from modules.audio import mel_spectrogram
 
 to_mel = lambda x: mel_spectrogram(x, **mel_fn_args)
 
+# f0 conditioned model
+dit_checkpoint_path, dit_config_path = load_custom_model_from_hf("Plachta/Seed-VC",
+                                                "DiT_step_404000_seed_v2_uvit_facodec_small_wavenet_f0_pruned.pth",
+                                                "config_dit_mel_seed_facodec_small_wavenet_f0.yml")
+
+config = yaml.safe_load(open(dit_config_path, 'r'))
+model_params = recursive_munch(config['model_params'])
+model_f0 = build_model(model_params, stage='DiT')
+hop_length = config['preprocess_params']['spect_params']['hop_length']
+sr = config['preprocess_params']['sr']
+
+# Load checkpoints
+model_f0, _, _, _ = load_checkpoint(model_f0, None, dit_checkpoint_path,
+                                 load_only_params=True, ignore_modules=[], is_distributed=False)
+for key in model_f0:
+    model_f0[key].eval()
+    model_f0[key].to(device)
+model_f0.cfm.estimator.setup_caches(max_batch_size=1, max_seq_length=8192)
+
+# f0 extractor
+from modules.rmvpe import RMVPE
+
+model_path = load_custom_model_from_hf("lj1995/VoiceConversionWebUI", "rmvpe.pt", None)
+rmvpe = RMVPE(model_path, is_half=False, device=device)
+
+def adjust_f0_semitones(f0_sequence, n_semitones):
+    factor = 2 ** (n_semitones / 12)
+    return f0_sequence * factor
+
 @spaces.GPU
 @torch.no_grad()
 @torch.inference_mode()
 def voice_conversion(source, target, diffusion_steps, length_adjust, inference_cfg_rate, n_quantizers):
+    inference_module = model if not f0_condition else model_f0
     # Load audio
     source_audio = librosa.load(source, sr=sr)[0]
     ref_audio = librosa.load(target, sr=sr)[0]
-    # source_sr, source_audio = source
-    # ref_sr, ref_audio = target
-    # # if any of the inputs has 2 channels, take the first only
-    # if source_audio.ndim == 2:
-    #     source_audio = source_audio[:, 0]
-    # if ref_audio.ndim == 2:
-    #     ref_audio = ref_audio[:, 0]
-    #
-    # source_audio, ref_audio = source_audio / 32768.0, ref_audio / 32768.0
-    #
-    # # if source or audio sr not equal to default sr, resample
-    # if source_sr != sr:
-    #     source_audio = librosa.resample(source_audio, source_sr, sr)
-    # if ref_sr != sr:
-    #     ref_audio = librosa.resample(ref_audio, ref_sr, sr)
 
     # Process audio
     source_audio = torch.tensor(source_audio[:sr * 30]).unsqueeze(0).float().to(device)
@@ -157,24 +172,61 @@ def voice_conversion(source, target, diffusion_steps, length_adjust, inference_c
     feat2 = feat2 - feat2.mean(dim=0, keepdim=True)
     style2 = campplus_model(feat2.unsqueeze(0))
 
+    if f0_condition:
+        waves_16k = torchaudio.functional.resample(waves_24k, sr, 16000)
+        converted_waves_16k = torchaudio.functional.resample(converted_waves_24k, sr, 16000)
+        F0_ori = rmvpe.infer_from_audio(waves_16k[0], thred=0.03)
+        F0_alt = rmvpe.infer_from_audio(converted_waves_16k[0], thred=0.03)
+
+        F0_ori = torch.from_numpy(F0_ori).to(device)[None]
+        F0_alt = torch.from_numpy(F0_alt).to(device)[None]
+
+        voiced_F0_ori = F0_ori[F0_ori > 1]
+        voiced_F0_alt = F0_alt[F0_alt > 1]
+
+        log_f0_alt = torch.log(F0_alt + 1e-5)
+        voiced_log_f0_ori = torch.log(voiced_F0_ori + 1e-5)
+        voiced_log_f0_alt = torch.log(voiced_F0_alt + 1e-5)
+        median_log_f0_ori = torch.median(voiced_log_f0_ori)
+        median_log_f0_alt = torch.median(voiced_log_f0_alt)
+        # mean_log_f0_ori = torch.mean(voiced_log_f0_ori)
+        # mean_log_f0_alt = torch.mean(voiced_log_f0_alt)
+
+        # shift alt log f0 level to ori log f0 level
+        shifted_log_f0_alt = log_f0_alt.clone()
+        if auto_f0_adjust:
+            shifted_log_f0_alt[F0_alt > 1] = log_f0_alt[F0_alt > 1] - median_log_f0_alt + median_log_f0_ori
+        shifted_f0_alt = torch.exp(shifted_log_f0_alt)
+        if pitch_shift != 0:
+            shifted_f0_alt[F0_alt > 1] = adjust_f0_semitones(shifted_f0_alt[F0_alt > 1], pitch_shift)
+    else:
+        F0_ori = None
+        F0_alt = None
+        shifted_f0_alt = None
+
     # Length regulation
-    cond = model.length_regulator(S_alt, ylens=target_lengths, n_quantizers=int(n_quantizers))[0]
-    prompt_condition = model.length_regulator(S_ori, ylens=target2_lengths, n_quantizers=int(n_quantizers))[0]
+    cond = inference_module.length_regulator(S_alt, ylens=target_lengths, n_quantizers=int(n_quantizers), f0=shifted_f0_alt)[0]
+    prompt_condition = inference_module.length_regulator(S_ori, ylens=target2_lengths, n_quantizers=int(n_quantizers), f0=F0_ori)[0]
     cat_condition = torch.cat([prompt_condition, cond], dim=1)
 
     # Voice Conversion
-    vc_target = model.cfm.inference(cat_condition, torch.LongTensor([cat_condition.size(1)]).to(mel2.device),
+    vc_target = inference_module.cfm.inference(cat_condition, torch.LongTensor([cat_condition.size(1)]).to(mel2.device),
                                     mel2, style2, None, diffusion_steps, inference_cfg_rate=inference_cfg_rate)
     vc_target = vc_target[:, :, mel2.size(-1):]
 
     # Convert to waveform
-    vc_wave = hift_gen.inference(vc_target)
+    # if f0_condition:
+    #     f04vocoder = torch.nn.functional.interpolate(shifted_f0_alt.unsqueeze(1), size=vc_target.size(-1),
+    #                                                  mode='nearest').squeeze(1)
+    # else:
+    f04vocoder = None
+    vc_wave = hift_gen.inference(vc_target, f0=f04vocoder)
 
     return sr, vc_wave.squeeze(0).cpu().numpy()
 
 
 if __name__ == "__main__":
-    description = "Zero-shot voice conversion with in-context learning. Check out our [GitHub repository](https://github.com/Plachtaa/seed-vc) for details and updates."
+        description = "Zero-shot voice conversion with in-context learning. Check out our [GitHub repository](https://github.com/Plachtaa/seed-vc) for details and updates."
     inputs = [
         gr.Audio(type="filepath", label="Source Audio"),
         gr.Audio(type="filepath", label="Reference Audio"),
@@ -182,9 +234,13 @@ if __name__ == "__main__":
         gr.Slider(minimum=0.5, maximum=2.0, step=0.1, value=1.0, label="Length Adjust", info="<1.0 for speed-up speech, >1.0 for slow-down speech"),
         gr.Slider(minimum=0.0, maximum=1.0, step=0.1, value=0.7, label="Inference CFG Rate", info="has subtle influence"),
         gr.Slider(minimum=1, maximum=3, step=1, value=3, label="N Quantizers", info="the less quantizer used, the less prosody of source audio is preserved"),
+        gr.Checkbox(label="Use F0 conditioned model", value=False, info="Must set to true for singing voice conversion"),
+        gr.Checkbox(label="Auto F0 adjust", value=True,
+                    info="Roughly adjust F0 to match target voice. Only works when F0 conditioned model is used."),
+        gr.Slider(label='Pitch shift', minimum=-24, maximum=24, step=1, value=0, info='Pitch shift in semitones, only works when F0 conditioned model is used'),
     ]
 
-    examples = [["examples/source/yae_0.wav", "examples/reference/dingzhen_0.wav", 50, 1.0, 0.7, 1]]
+    examples = [["examples/source/yae_0.wav", "examples/reference/dingzhen_0.wav", 50, 1.0, 0.7, 1, False, True, 0],]
 
     outputs = gr.Audio(label="Output Audio")