Upload 4 files

README.md

@@ -1,13 +1,23 @@
----
-title: FinalVocal
-emoji: 💻
-colorFrom: yellow
-colorTo: indigo
-sdk: gradio
-sdk_version: 5.47.2
-app_file: app.py
-pinned: false
-short_description: 'ref mastered '
----
+# Reference Voice Conversion (HF Space)
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+Convert any vocal to match a **reference voice** (tone color) with [OpenVoice v2] and optional vocal separation via [Demucs]. Built with Gradio for fast UX.
+
+## ✨ Features
+- Upload **Reference** (clean 5–20 seconds) and **Track** or **Acapella**
+- Optional **Demucs** stem separation to extract vocals from full mix
+- Control **style strength**, **pitch**, **formant tilt**
+- **Remix** converted vocal with instrumental and gain controls
+
+## 🚀 Deploy
+1. Create a new **Hugging Face Space** (Python + Gradio). Hardware: **GPU recommended**.
+2. Add these files (`app.py`, `requirements.txt`, `README.md`).
+3. (Optional) Add `spaces.yml`:
+  ```yaml
+  sdk: gradio
+  python_version: 3.10
+  resources:
+    accelerators: ["gpu"]
+Commit & run. First build downloads models (~hundreds MB).
+🧪 Tips
+Reference should be clean, dry (no heavy FX), mono is fine.
+Better results

app.py

@@ -0,0 +1,240 @@
+app.py
+import os
+import tempfile
+import warnings
+warnings.filterwarnings("ignore")
+
+import gradio as gr
+import numpy as np
+import soundfile as sf
+import librosa
+
+from huggingface_hub import snapshot_download
+
+# ------------------------------
+# Model bootstrap
+# ------------------------------
+MODEL_DIR = os.path.join(os.getcwd(), "models")
+OPENVOICE_REPO = "myshell-ai/OpenVoiceV2"
+
+os.makedirs(MODEL_DIR, exist_ok=True)
+
+# Lazy import to speed up Space boot
+_openvoice_loaded = False
+_tone_converter = None
+_content_extractor = None
+
+_demucs_model = None
+
+def _ensure_openvoice():
+   global _openvoice_loaded, _tone_converter, _content_extractor
+   if _openvoice_loaded:
+       return
+   # Download model snapshots into ./models/openvoice
+   local_dir = snapshot_download(repo_id=OPENVOICE_REPO, local_dir=os.path.join(MODEL_DIR, "openvoice"), local_dir_use_symlinks=False)
+
+   # OpenVoice v2 layout ships python modules; import after download
+   import sys
+   if local_dir not in sys.path:
+       sys.path.append(local_dir)
+
+   # Import OpenVoice components
+   try:
+       from openvoice import se_extractor
+       from openvoice.api import ToneColorConverter, ContentVec
+   except Exception:
+       # Fallback to module paths used in some snapshots
+       from tone_color_converter.api import ToneColorConverter
+       from contentvec.api import ContentVec
+       from se_extractor import se_extractor
+
+   # Init content extractor (HuBERT-like)
+   content_ckpt = os.path.join(local_dir, "checkpoints", "contentvec", "checkpoint.pth")
+   _content_extractor = ContentVec(content_ckpt)
+
+   # Init tone color converter
+   tcc_ckpt = os.path.join(local_dir, "checkpoints", "tone_color_converter", "checkpoint.pth")
+   _tone_converter = ToneColorConverter(tcc_ckpt, device=os.environ.get("DEVICE", "cuda" if gr.cuda.is_available() else "cpu"))
+
+   _openvoice_loaded = True
+
+
+def _ensure_demucs():
+   global _demucs_model
+   if _demucs_model is not None:
+       return
+   from demucs.apply import apply_model
+   from demucs.pretrained import get_model
+   from demucs.audio import AudioFile
+   _demucs_model = {
+       "apply_model": apply_model,
+       "get_model": get_model,
+       "AudioFile": AudioFile,
+   }
+
+
+def separate_vocals(wav_path, stem="vocals"):
+   """Return path to separated vocals and accompaniment using htdemucs."""
+   _ensure_demucs()
+   apply_model = _demucs_model["apply_model"]
+   get_model = _demucs_model["get_model"]
+   AudioFile = _demucs_model["AudioFile"]
+
+   model = get_model(name="htdemucs")
+   model.cpu()
+
+   with AudioFile(wav_path).read(streams=0, samplerate=44100, channels=2) as mix:
+       ref = mix
+       out = apply_model(model, ref, shifts=1, split=True, overlap=0.25)
+       sources = {name: out[idx] for idx, name in enumerate(model.sources)}
+
+   # Save stems
+   base = os.path.splitext(os.path.basename(wav_path))[0]
+   out_dir = tempfile.mkdtemp(prefix="stems_")
+   vocal_path = os.path.join(out_dir, f"{base}_vocals.wav")
+   inst_path = os.path.join(out_dir, f"{base}_inst.wav")
+
+   sf.write(vocal_path, sources["vocals"].T, 44100)
+   # Combine other stems for instrumental
+   inst = sum([v for k, v in sources.items() if k != "vocals"]) / (len(model.sources) - 1)
+   sf.write(inst_path, inst.T, 44100)
+   return vocal_path, inst_path
+
+
+def load_audio(x, sr=44100, mono=True):
+   y, _sr = librosa.load(x, sr=sr, mono=mono)
+   return y, sr
+
+
+def save_audio(y, sr):
+   path = tempfile.mktemp(suffix=".wav")
+   sf.write(path, y, sr)
+   return path
+
+
+def match_length(a, b):
+   # Pad/trim a to match length of b
+   if len(a) < len(b):
+       a = np.pad(a, (0, len(b)-len(a)))
+   else:
+       a = a[:len(b)]
+   return a
+
+
+def convert_voice(reference_wav, source_vocal_wav, style_strength=0.8, pitch_shift=0.0, formant_shift=0.0):
+   _ensure_openvoice()
+
+   # Load audio
+   ref, sr = load_audio(reference_wav, sr=16000, mono=True)
+   src, _ = load_audio(source_vocal_wav, sr=16000, mono=True)
+
+   # Extract content features from source
+   content = _content_extractor.extract(src, sr)
+
+   # Extract speaker embedding / tone color from reference
+   # OpenVoice ships an SE (speaker encoder) util; we mimic via API if exposed.
+   try:
+       from openvoice import se_extractor
+       se = se_extractor.get_se(reference_wav, device=_tone_converter.device)
+   except Exception:
+       # Some snapshots provide a function name get_se_wav
+       from se_extractor import get_se
+       se = get_se(reference_wav)
+
+   # Run tone color conversion
+   converted = _tone_converter.convert(content, se, style_strength=style_strength)
+
+   y = converted
+
+   # Optional pitch & formant adjustments (light touch)
+   if abs(pitch_shift) > 1e-3:
+       y = librosa.effects.pitch_shift(y.astype(np.float32), 16000, n_steps=pitch_shift)
+   if abs(formant_shift) > 1e-3:
+       # crude formant-esque EQ tilt using shelving filter via librosa
+       import scipy.signal as sps
+       w = 2 * np.pi * 1500 / 16000
+       b, a = sps.iirfilter(2, Wn=w/np.pi, btype='high', ftype='butter') if formant_shift > 0 else sps.iirfilter(2, Wn=w/np.pi, btype='low', ftype='butter')
+       y = sps.filtfilt(b, a, y)
+
+   out_path = save_audio(y, 16000)
+   return out_path
+
+
+def process(reference, track, acapella=None, separate=False, style_strength=0.8, pitch_shift=0.0, formant_shift=0.0, remix=False, vocal_gain_db=0.0, inst_gain_db=0.0):
+   if reference is None:
+       raise gr.Error("Загрузите референс голоса (reference_wav)")
+
+   # Prepare vocals & instrumental
+   vocals_path = None
+   instrumental_path = None
+
+   if acapella is not None:
+       vocals_path = acapella
+   elif separate and track is not None:
+       vocals_path, instrumental_path = separate_vocals(track)
+   elif track is not None:
+       vocals_path = track
+   else:
+       raise gr.Error("Загрузите либо полный трек, либо акапеллу")
+
+   # Convert vocal
+   converted_vocal = convert_voice(reference, vocals_path, style_strength, pitch_shift, formant_shift)
+
+   if not remix:
+       return converted_vocal, None
+
+   # Remix back to instrumental (if missing, make silence)
+   if instrumental_path is None and track is not None and separate:
+       _, instrumental_path = separate_vocals(track)
+   if instrumental_path is None:
+       # create silent instrumental length matched to converted vocal
+       y, sr = load_audio(converted_vocal)
+       inst = np.zeros_like(y)
+       instrumental_path = save_audio(inst, sr)
+
+   cv, sr = load_audio(converted_vocal)
+   inst, isr = load_audio(instrumental_path)
+   if isr != sr:
+       inst = librosa.resample(inst, orig_sr=isr, target_sr=sr)
+
+   cv = match_length(cv, inst)
+   # apply gains
+   cv = cv * (10 ** (vocal_gain_db / 20.0))
+   inst = inst * (10 ** (inst_gain_db / 20.0))
+
+   mix = cv + inst
+   mix_path = save_audio(mix, sr)
+   return converted_vocal, mix_path
+
+
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+   gr.Markdown("""
+   # 🎙️ Reference Voice Conversion
+   Загрузите **референс** голоса и **трек/акапеллу** — получайте конвертированный вокал под тембр референса. Опционально: разделение вокала (Demucs) и ремикс в инструментал.
+   """)
+   with gr.Row():
+       with gr.Column():
+           ref = gr.Audio(label="Reference Voice (clean, 5–20s)", type="filepath")
+           track = gr.Audio(label="Source Track (full mix)", type="filepath")
+           acap = gr.Audio(label="Source Acapella (optional)", type="filepath")
+           separate = gr.Checkbox(label="Разделить вокал Demucs", value=True)
+           remix = gr.Checkbox(label="Сделать финальный микс (вокал + инструментал)", value=True)
+       with gr.Column():
+           style = gr.Slider(0.0, 1.0, value=0.85, step=0.01, label="Сила стиля (тембр)")
+           pitch = gr.Slider(-6, 6, value=0, step=0.5, label="Pitch shift (полутонов)")
+           formant = gr.Slider(-1.0, 1.0, value=0.0, step=0.1, label="Formant tilt (экспериментально)")
+           vgain = gr.Slider(-12, 12, value=0, step=0.5, label="Гейн вокала (dB)")
+           igain = gr.Slider(-12, 12, value=0, step=0.5, label="Гейн инструментала (dB)")
+           btn = gr.Button("Convert")
+   with gr.Row():
+       out_vocal = gr.Audio(label="Converted Vocal", type="filepath")
+       out_mix = gr.Audio(label="Remix (Vocal + Instrumental)", type="filepath")
+
+   btn.click(
+       fn=process,
+       inputs=[ref, track, acap, separate, style, pitch, formant, remix, vgain, igain],
+       outputs=[out_vocal, out_mix]
+   )
+
+if __name__ == "__main__":
+   demo.launch()

requirements .txt

@@ -0,0 +1,9 @@
+gradio>=4.36.1
+huggingface_hub>=0.23.0
+soundfile>=0.12.1
+librosa>=0.10.1
+numpy>=1.26.4
+scipy>=1.11.4
+torch>=2.1.0
+openvoice==0.2.0 ; python_version>="3.10"  # if available; otherwise models ship in repo
+demucs>=4.0.1

spaces.yml

@@ -0,0 +1,5 @@
+ ```yaml
+  sdk: gradio
+  python_version: 3.10
+  resources:
+    accelerators: ["gpu"]