Delete infer

infer/__init__.py

@@ -1 +0,0 @@
-# infer package

infer/onnx_export.py

@@ -1,38 +0,0 @@
-import torch
-import os
-
-def export_to_onnx(pth_path, onnx_path):
-    """
-    Converts PyTorch RVC model to ONNX (basic exporter)
-    """
-
-    device = "cpu"
-
-    # Load model
-    model = torch.load(pth_path, map_location=device)
-    model.eval()
-
-    # Dummy input (audio frame simulation)
-    dummy_input = torch.randn(1, 16000)
-
-    try:
-        torch.onnx.export(
-            model,
-            dummy_input,
-            onnx_path,
-            export_params=True,
-            opset_version=13,
-            do_constant_folding=True,
-            input_names=["input"],
-            output_names=["output"],
-            dynamic_axes={
-                "input": {0: "batch"},
-                "output": {0: "batch"}
-            }
-        )
-        print("ONNX export successful:", onnx_path)
-        return True
-
-    except Exception as e:
-        print("ONNX export failed:", e)
-        return False

infer/onnx_rvc.py

@@ -1,23 +0,0 @@
-import onnxruntime as ort
-import numpy as np
-import soundfile as sf
-
-class ONNXRVC:
-    def __init__(self, model_path):
-        self.session = ort.InferenceSession(model_path)
-
-    def infer(self, input_audio, output_path):
-        wav, sr = sf.read(input_audio)
-
-        if wav.ndim > 1:
-            wav = wav.mean(axis=1)
-
-        wav = wav.astype(np.float32)
-        wav = wav / (np.max(np.abs(wav)) + 1e-6)
-
-        # ONNX inference
-        ort_inputs = {"input": wav.reshape(1, -1)}
-        output = self.session.run(None, ort_inputs)[0]
-
-        sf.write(output_path, output.flatten(), sr)
-        return output_path

infer/rvc.py

@@ -1,36 +0,0 @@
-import os
-import torch
-import numpy as np
-from .utils import load_audio, save_audio
-
-class RVCInfer:
-    def __init__(self, model_path, index_path):
-        self.model_path = model_path
-        self.index_path = index_path
-        
-        # dummy model loader (replace with real weights later if needed)
-        self.device = "cpu"
-        self.model = self.load_model()
-
-    def load_model(self):
-        if os.path.exists(self.model_path):
-            print(f"Loaded model: {self.model_path}")
-        return None
-
-    def infer(self, input_audio_path, output_path):
-        # load audio
-        audio, sr = load_audio(input_audio_path)
-
-        # -------------------------
-        # SIMPLIFIED PROCESSING
-        # (HF-safe fallback conversion)
-        # -------------------------
-
-        # normalize audio
-        audio = audio / (np.max(np.abs(audio)) + 1e-6)
-
-        # fake "voice conversion effect"
-        audio = audio * 0.9 + np.roll(audio, 1) * 0.1
-
-        # save output
-        return save_audio(output_path, audio, sr)

infer/rvc_real.py

@@ -1,47 +0,0 @@
-import os
-import numpy as np
-import soundfile as sf
-import torch
-import onnxruntime
-import librosa
-import pyworld as pw
-
-class RVCReal:
-    def __init__(self, model_path, index_path):
-        self.model_path = model_path
-        self.index_path = index_path
-        self.device = "cpu"
-        self.load()
-
-    def load(self):
-        # load torch model
-        try:
-            self.net = torch.jit.load(self.model_path, map_location="cpu")
-        except Exception as e:
-            print("Model load error:", e)
-            self.net = None
-
-    def infer(self, audio_path, output_path):
-        # load audio
-        wav, sr = sf.read(audio_path)
-        if wav.ndim > 1:
-            wav = wav.mean(axis=1)
-
-        # preprocess f0
-        _f0, t = pw.dio(wav.astype(np.float64), sr)
-        f0 = pw.stonemask(wav.astype(np.float64), _f0, t, sr)
-
-        # normalize
-        wav = wav / np.max(np.abs(wav) + 1e-9)
-
-        # dummy forward
-        try:
-            x = torch.from_numpy(wav).float().unsqueeze(0)
-            y = self.net(x).squeeze().detach().numpy()
-        except Exception as e:
-            print("Inference error:", e)
-            y = wav
-
-        # save
-        sf.write(output_path, y, sr)
-        return output_path

infer/utils.py

@@ -1,21 +0,0 @@
-import numpy as np
-import soundfile as sf
-import torch
-
-def load_audio(file_path, sr=16000):
-    audio, sr = sf.read(file_path)
-    
-    if len(audio.shape) > 1:
-        audio = audio.mean(axis=1)
-
-    return audio, sr
-
-
-def save_audio(path, audio, sr):
-    audio = np.asarray(audio)
-    sf.write(path, audio, sr)
-    return path
-
-
-def to_tensor(audio):
-    return torch.FloatTensor(audio)