Spaces:
Running
on
Zero
Running
on
Zero
File size: 5,738 Bytes
3629250 7634b6c 3629250 7634b6c 3629250 7634b6c 3629250 7634b6c 3629250 7634b6c 3629250 7634b6c 3629250 7634b6c 3629250 7634b6c 3629250 9730071 4a7a319 9730071 4a7a319 9730071 3629250 7634b6c |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 |
import torch
import librosa
import soundfile as sf
import gradio as gr
import torchaudio
import os
from huggingface_hub import hf_hub_download
from Amphion.models.ns3_codec import (
FACodecEncoder,
FACodecDecoder,
FACodecRedecoder,
)
fa_encoder = FACodecEncoder(
ngf=32,
up_ratios=[2, 4, 5, 5],
out_channels=256,
)
fa_decoder = FACodecDecoder(
in_channels=256,
upsample_initial_channel=1024,
ngf=32,
up_ratios=[5, 5, 4, 2],
vq_num_q_c=2,
vq_num_q_p=1,
vq_num_q_r=3,
vq_dim=256,
codebook_dim=8,
codebook_size_prosody=10,
codebook_size_content=10,
codebook_size_residual=10,
use_gr_x_timbre=True,
use_gr_residual_f0=True,
use_gr_residual_phone=True,
)
fa_redecoder = FACodecRedecoder()
# encoder_ckpt = hf_hub_download(repo_id="amphion/naturalspeech3_facodec", filename="ns3_facodec_encoder.bin")
# decoder_ckpt = hf_hub_download(repo_id="amphion/naturalspeech3_facodec", filename="ns3_facodec_decoder.bin")
# redecoder_ckpt = hf_hub_download(repo_id="amphion/naturalspeech3_facodec", filename="ns3_facodec_redecoder.bin")
encoder_ckpt = "ns3_facodec_encoder.bin"
decoder_ckpt = "ns3_facodec_decoder.bin"
redecoder_ckpt = "ns3_facodec_redecoder.bin"
fa_encoder.load_state_dict(torch.load(encoder_ckpt))
fa_decoder.load_state_dict(torch.load(decoder_ckpt))
fa_redecoder.load_state_dict(torch.load(redecoder_ckpt))
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
fa_encoder = fa_encoder.to(device)
fa_decoder = fa_decoder.to(device)
fa_redecoder = fa_redecoder.to(device)
fa_encoder.eval()
fa_decoder.eval()
fa_redecoder.eval()
def codec_inference(speech_path):
with torch.no_grad():
wav, sr = librosa.load(speech_path, sr=16000)
wav = torch.tensor(wav).to(device).unsqueeze(0).unsqueeze(0)
enc_out = fa_encoder(wav)
vq_post_emb, vq_id, _, quantized, spk_embs = fa_decoder(
enc_out, eval_vq=False, vq=True
)
recon_wav = fa_decoder.inference(vq_post_emb, spk_embs)
os.makedirs("temp", exist_ok=True)
result_path = "temp/result.wav"
sf.write(result_path, recon_wav[0, 0].cpu().numpy(), 16000)
return result_path
def codec_voice_conversion(speech_path_a, speech_path_b):
with torch.no_grad():
wav_a, sr = librosa.load(speech_path_a, sr=16000)
wav_a = torch.tensor(wav_a).to(device).unsqueeze(0).unsqueeze(0)
wav_b, sr = librosa.load(speech_path_b, sr=16000)
wav_b = torch.tensor(wav_b).to(device).unsqueeze(0).unsqueeze(0)
enc_out_a = fa_encoder(wav_a)
enc_out_b = fa_encoder(wav_b)
vq_post_emb_a, vq_id_a, _, quantized, spk_embs_a = fa_decoder(
enc_out_a, eval_vq=False, vq=True
)
vq_post_emb_b, vq_id_b, _, quantized, spk_embs_b = fa_decoder(
enc_out_b, eval_vq=False, vq=True
)
recon_wav_a = fa_decoder.inference(vq_post_emb_a, spk_embs_a)
recon_wav_b = fa_decoder.inference(vq_post_emb_b, spk_embs_b)
vq_post_emb_a_to_b = fa_redecoder.vq2emb(
vq_id_a, spk_embs_b, use_residual=False
)
recon_wav_a_to_b = fa_redecoder.inference(vq_post_emb_a_to_b, spk_embs_b)
os.makedirs("temp", exist_ok=True)
recon_a_result_path = "temp/result_a.wav"
recon_b_result_path = "temp/result_b.wav"
vc_result_path = "temp/result_vc.wav"
sf.write(vc_result_path, recon_wav_a_to_b[0, 0].cpu().numpy(), 16000)
sf.write(recon_a_result_path, recon_wav_a[0, 0].cpu().numpy(), 16000)
sf.write(recon_b_result_path, recon_wav_b[0, 0].cpu().numpy(), 16000)
return recon_a_result_path, recon_b_result_path, vc_result_path
demo_inputs = [
gr.Audio(
sources=["upload", "microphone"],
label="Upload the source speech file",
type="filepath",
),
gr.Audio(
sources=["upload", "microphone"],
label="Upload the reference speech file",
type="filepath",
),
]
demo_outputs = [
gr.Audio(label="Source speech reconstructed"),
gr.Audio(label="Reference speech reconstructed"),
gr.Audio(label="Voice conversion result"),
]
with gr.Blocks() as demo:
gr.Interface(
fn=codec_voice_conversion,
inputs=demo_inputs,
outputs=demo_outputs,
title="NaturalSpeech3 FACodec",
description="""
## FACodec: Speech Codec with Attribute Factorization used for NaturalSpeech 3
[](https://arxiv.org/pdf/2403.03100.pdf)
[](https://speechresearch.github.io/naturalspeech3/)
[](https://huggingface.co/amphion/naturalspeech3_facodec)
## Overview
FACodec is a core component of the advanced text-to-speech (TTS) model NaturalSpeech 3. FACodec converts complex speech waveform into disentangled subspaces representing speech attributes of content, prosody, timbre, and acoustic details and reconstruct high-quality speech waveform from these attributes. FACodec decomposes complex speech into subspaces representing different attributes, thus simplifying the modeling of speech representation.
Research can use FACodec to develop different modes of TTS models, such as non-autoregressive based discrete diffusion (NaturalSpeech 3) or autoregressive models (like VALL-E).
""",
)
gr.Examples(
examples=[
[
"default/source/test.wav",
"default/ref/test.wav",
],
],
inputs=demo_inputs,
)
if __name__ == "__main__":
demo.launch()
|