Fix inference.py: use correct RVC import paths (infer.vc.pipeline, infer.module.models, infer.audio)

inference.py

@@ -5,30 +5,18 @@ import sys
 import torch
 import numpy as np
 import soundfile as sf
-import librosa
 from pathlib import Path
 
 # Add RVC to path
 rvc_path = Path("/app/rvc")
 sys.path.insert(0, str(rvc_path))
-sys.path.insert(0, str(rvc_path / "infer_lib"))
 
-# Import RVC modules - handle different possible import structures
-try:
-    # Try the common import paths
-    from infer_pack.models import SynthesizerTrnMs768NSFsid
-    from infer_pack.commons import get_hparams_from_file, load_audio
-    from infer_pack.infer import VoiceConverter
-except ImportError:
-    try:
-        # Alternative import paths
-        from infer.lib.infer_pack.models import SynthesizerTrnMs768NSFsid
-        from infer.lib.infer_pack.commons import get_hparams_from_file, load_audio
-        from infer.lib.infer_pack.infer import VoiceConverter
-    except ImportError as e:
-        print(f"Failed to import RVC modules: {e}")
-        print("Please ensure RVC is properly installed")
-        raise
+# Import RVC modules with correct paths
+from infer.vc.pipeline import Pipeline
+from infer.hubert import load_hubert_model, extract_hubert_features
+from infer.module.models import SynthesizerTrnMs768NSFsid, SynthesizerTrnMs768NSFsid_nono
+from infer.audio import load_audio
+from tools.cuda_graph import run_cuda_graph
 
 # Model paths
 MODEL_DIR = Path("/app/models")
@@ -36,11 +24,9 @@ ELDERLY_MODEL_DIR = MODEL_DIR / "elderly"
 
 def find_model_files():
     """Find the elderly voice model files."""
-    # Look for .pth and .index files
     pth_files = list(ELDERLY_MODEL_DIR.glob("*.pth"))
     index_files = list(ELDERLY_MODEL_DIR.glob("*.index"))
     
-    # If not found in elderly dir, look in weights or other common locations
     if not pth_files:
         pth_files = list((MODEL_DIR / "weights").glob("*.pth")) if (MODEL_DIR / "weights").exists() else []
     if not index_files:
@@ -55,93 +41,133 @@ MODEL_PATH, INDEX_PATH = find_model_files()
 
 # Device
 device = "cuda" if torch.cuda.is_available() else "cpu"
-print(f"Using device: {device}")
+is_half = torch.cuda.is_available()
+print(f"Using device: {device}, is_half: {is_half}")
 print(f"Model: {MODEL_PATH}")
 print(f"Index: {INDEX_PATH}")
 
-# Initialize voice converter
-vc = None
-if MODEL_PATH and os.path.exists(MODEL_PATH):
-    try:
-        vc = VoiceConverter(
-            model_path=MODEL_PATH,
-            index_path=INDEX_PATH,
-            device=device,
-            is_half=torch.cuda.is_available(),
-        )
-        print("Voice converter initialized successfully")
-    except Exception as e:
-        print(f"Failed to initialize voice converter: {e}")
-        vc = None
-else:
-    print("WARNING: No model found - will attempt to load at runtime or use demo mode")
+# Global objects (initialized lazily)
+_pipeline = None
+_hubert_model = None
+_net_g = None
+_tgt_sr = None
+_if_f0 = None
+_version = None
 
+def load_model():
+    """Load the RVC model and initialize pipeline."""
+    global _pipeline, _hubert_model, _net_g, _tgt_sr, _if_f0, _version
+    
+    if MODEL_PATH is None or not os.path.exists(MODEL_PATH):
+        raise RuntimeError(f"Model not found: {MODEL_PATH}")
+    
+    # Load hubert model
+    _hubert_model = load_hubert_model(device, is_half)
+    
+    # Load the model checkpoint
+    cpt = torch.load(MODEL_PATH, map_location=torch.device("cpu"))
+    cpt["config"][-3] = cpt["weight"]["emb_g.weight"].shape[0]
+    _if_f0 = cpt.get("f0", 1)
+    _version = cpt.get("version", "v1")
+    
+    if _version == "v1":
+        if _if_f0 == 1:
+            _net_g = SynthesizerTrnMs768NSFsid(*cpt["config"], is_half=False)
+        else:
+            _net_g = SynthesizerTrnMs768NSFsid_nono(*cpt["config"])
+    elif _version == "v2":
+        if _if_f0 == 1:
+            _net_g = SynthesizerTrnMs768NSFsid(*cpt["config"], is_half=False)
+        else:
+            _net_g = SynthesizerTrnMs768NSFsid_nono(*cpt["config"])
+    
+    del _net_g.enc_q
+    _net_g.load_state_dict(cpt["weight"], strict=False)
+    _net_g = _net_g.float()
+    _net_g.eval().to(device)
+    _net_g.remove_weight_norm()
+    
+    if is_half:
+        _net_g = _net_g.half()
+    else:
+        _net_g = _net_g.float()
+    
+    _tgt_sr = cpt["config"][-1]
+    
+    # Create config object for pipeline
+    class PipelineConfig:
+        def __init__(self, device, is_half):
+            self.device = torch.device(device)
+            self.is_half = is_half
+            if is_half:
+                self.x_pad, self.x_query, self.x_center, self.x_max = 3, 10, 60, 65
+            else:
+                self.x_pad, self.x_query, self.x_center, self.x_max = 1, 6, 38, 41
+    
+    config = PipelineConfig(device, is_half)
+    _pipeline = Pipeline(_tgt_sr, config)
+    
+    print("Model loaded successfully")
 
 def convert_voice(
     input_audio_path: str,
     output_audio_path: str,
-    f0_up_key: int = 0,           # Pitch shift (semitones)
-    f0_method: str = "rmvpe",     # Pitch extraction method
-    index_rate: float = 0.75,     # Index influence
-    filter_radius: int = 3,       # Filter radius
-    rms_mix_rate: float = 0.25,   # RMS mix rate
-    protect: float = 0.33,        # Protect voiceless consonants
-    f0_file: str = None,
-    f0_method_new: str = None,
-    file_index: str = None,
-    file_index2: str = None,
-    file_big_npy: str = None,
+    f0_up_key: int = 0,
+    f0_method: str = "rmvpe",
+    index_rate: float = 0.75,
+    filter_radius: int = 3,
+    rms_mix_rate: float = 0.25,
+    protect: float = 0.33,
 ):
     """
-    Convert input audio to elderly voice using RVC.
+    Convert input audio to elderly voice using RVC Pipeline.
     
     Args:
         input_audio_path: Path to input audio file
         output_audio_path: Path to save output audio
         f0_up_key: Pitch shift in semitones (negative = lower pitch)
-        f0_method: Pitch extraction method (pm, harvest, dio, crepe, rmvpe)
+        f0_method: Pitch extraction method (pm, rmvpe, fcpe)
         index_rate: Index influence (0-1)
-        filter_radius: Median filter radius for pitch
+        filter_radius: Median filter radius for pitch (not used in pipeline directly)
         rms_mix_rate: RMS mix rate for volume
         protect: Protect voiceless consonants
-        f0_file: F0 curve file (optional)
-        f0_method_new: F0 method file (optional)
-        file_index: Index file (optional, overrides INDEX_PATH)
-        file_index2: Index file 2 (optional)
-        file_big_npy: Big npy file (optional)
     """
-    if vc is None:
-        raise RuntimeError("Voice converter not initialized - no model available")
+    global _pipeline, _hubert_model, _net_g, _tgt_sr, _if_f0, _version
+    
+    # Lazy load model
+    if _pipeline is None:
+        load_model()
     
-    # Use provided index paths or fallback to defaults
-    index_path = file_index if file_index and os.path.exists(file_index) else INDEX_PATH
-    index_path2 = file_index2 if file_index2 and os.path.exists(file_index2) else ""
+    # Use provided index path or fallback
+    index_path = INDEX_PATH if INDEX_PATH and os.path.exists(INDEX_PATH) else ""
     
     # Load audio
-    audio, sr = load_audio(input_audio_path, 16000)
+    audio = load_audio(input_audio_path, 16000)
     
-    # Convert using RVC
-    audio_opt = vc.pipeline(
-        model=vc.net_g,
-        sid=0,  # speaker id (0 for single model)
+    # Prepare times array for profiling
+    times = [0.0, 0.0, 0.0]
+    
+    # Run pipeline
+    audio_opt = _pipeline.pipeline(
+        model=_hubert_model,
+        net_g=_net_g,
+        sid=0,
         audio=audio,
-        pitch=f0_file,
-        pitch_method=f0_method,
-        pitch_length=None,
-        index=index_path,
-        big_npy=file_big_npy,
+        times=times,
+        f0_up_key=f0_up_key,
+        f0_method=f0_method,
+        file_index=index_path,
         index_rate=index_rate,
-        if_f0=None,
-        filter_radius=filter_radius,
+        if_f0=_if_f0,
+        tgt_sr=_tgt_sr,
         resample_sr=0,
         rms_mix_rate=rms_mix_rate,
-        version="v2",  # Assuming RVC v2 model
+        version=_version,
         protect=protect,
-        f0_up_key=f0_up_key,
     )
     
     # Save output
-    sf.write(output_audio_path, audio_opt, 16000, subtype='PCM_16')
+    sf.write(output_audio_path, audio_opt, _tgt_sr, subtype='PCM_16')
     return output_audio_path