Update app.py

app.py

@@ -5,6 +5,7 @@ import subprocess
 import shutil
 from pathlib import Path
 import zipfile
+import json
 
 class RealRVCTrainer:
     def __init__(self):
@@ -31,37 +32,29 @@ class RealRVCTrainer:
             core_packages = [
                 "torch", "torchaudio", "torchvision", "numpy", "scipy",
                 "librosa", "soundfile", "faiss-cpu", "praat-parselmouth",
-                "pyworld", "scikit-learn", "numba", "resampy", "pydub",
-                "fairseq", "gradio", "tensorboard"  # Added common deps from repo requirements
+                "pyworld", "scikit-learn", "numba", "resampy", "pydub"
             ]
             
             for pkg in core_packages:
                 try:
-                    subprocess.run([sys.executable, "-m", "pip", "install", "-q", pkg], timeout=120)
+                    subprocess.run([sys.executable, "-m", "pip", "install", "-q", pkg], timeout=60)
                 except:
                     pass
             
             progress(0.6, desc="Downloading pretrained models...")
             
-            # Citation: Pretrained paths from official repo structure
-            # https://github.com/RVC-Project/Retrieval-based-Voice-Conversion-WebUI/tree/main/assets
-            assets_dir = self.rvc_dir / "assets"
-            pretrained_dir = assets_dir / "pretrained"
-            pretrained_v2_dir = assets_dir / "pretrained_v2"  # Recommended for better models
-            hubert_path = self.rvc_dir / "hubert_base.pt"  # Often in root
-            
-            assets_dir.mkdir(exist_ok=True)
+            pretrained_dir = self.rvc_dir / "pretrained"
             pretrained_dir.mkdir(exist_ok=True)
-            pretrained_v2_dir.mkdir(exist_ok=True)
             
             models_to_download = [
-                ("https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main/hubert_base.pt", hubert_path),
-                ("https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main/pretrained_v2/f0G40k.pth", pretrained_v2_dir / "f0G40k.pth"),
-                ("https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main/pretrained_v2/f0D40k.pth", pretrained_v2_dir / "f0D40k.pth"),
+                ("https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main/pretrained/f0G40k.pth", "f0G40k.pth"),
+                ("https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main/pretrained/f0D40k.pth", "f0D40k.pth"),
+                ("https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main/hubert_base.pt", "hubert_base.pt"),
             ]
             
-            for idx, (url, output_path) in enumerate(models_to_download):
-                progress(0.6 + (idx / len(models_to_download)) * 0.3, desc=f"Downloading {output_path.name}...")
+            for idx, (url, filename) in enumerate(models_to_download):
+                progress(0.6 + (idx / len(models_to_download)) * 0.3, desc=f"Downloading {filename}...")
+                output_path = pretrained_dir / filename
                 if not output_path.exists():
                     try:
                         subprocess.run(["wget", "-q", "-O", str(output_path), url], timeout=300)
@@ -78,52 +71,102 @@ class RealRVCTrainer:
             self.setup_complete = True
             progress(1.0, desc="Setup complete!")
             
-            return "✅ RVC Installation Complete!\n\nBased on official repo: https://github.com/RVC-Project/Retrieval-based-Voice-Conversion-WebUI"
+            return "✅ RVC Installation Complete!\n\n📦 Installed:\n- Official RVC codebase\n- Pre-trained models\n- All dependencies\n\n🎉 Ready to train!"
             
         except Exception as e:
-            return f"❌ Installation failed: {str(e)}"
+            return f"❌ Installation failed: {str(e)}\n\n🔧 Try manual installation or use Google Colab."
     
-    # prepare_dataset and preprocess_data unchanged (your original was fine)
+    def prepare_dataset(self, audio_files, model_name, progress=gr.Progress()):
+        """Prepare dataset in RVC format"""
+        if not audio_files:
+            return "❌ Please upload audio files"
+        
+        if not model_name:
+            model_name = "my_model"
+        
+        try:
+            progress(0.1, desc="Creating dataset structure...")
+            dataset_path = self.rvc_dir / "dataset" / model_name
+            dataset_path.mkdir(parents=True, exist_ok=True)
+            
+            progress(0.3, desc="Copying audio files...")
+            for idx, audio_file in enumerate(audio_files):
+                dest = dataset_path / f"{idx:04d}_{Path(audio_file.name).name}"
+                shutil.copy2(audio_file.name, dest)
+                progress(0.3 + (idx / len(audio_files)) * 0.6, desc=f"Copied {idx+1}/{len(audio_files)} files")
+            
+            progress(1.0, desc="Dataset ready!")
+            return f"✅ Dataset Prepared!\n\n📁 Location: {dataset_path}\n📊 Files: {len(audio_files)}\n🎤 Model: {model_name}\n\n✅ Ready for preprocessing!"
+            
+        except Exception as e:
+            return f"❌ Error: {str(e)}"
+    
+    def preprocess_data(self, model_name, sample_rate, progress=gr.Progress()):
+        """Run RVC preprocessing"""
+        try:
+            progress(0.1, desc="Starting preprocessing...")
+            dataset_path = self.rvc_dir / "dataset" / model_name
+            if not dataset_path.exists():
+                return "❌ Dataset not found. Please prepare dataset first."
+            
+            preprocess_script = self.rvc_dir / "infer" / "modules" / "train" / "preprocess.py"
+            if not preprocess_script.exists():
+                preprocess_script = self.rvc_dir / "trainset_preprocess_pipeline_print.py"
+            
+            progress(0.3, desc="Preprocessing audio...")
+            cmd = [sys.executable, str(preprocess_script), str(dataset_path), str(sample_rate), "2"]
+            result = subprocess.run(cmd, capture_output=True, text=True)
+            
+            progress(1.0, desc="Preprocessing complete!")
+            return f"✅ Preprocessing Complete!\n\n🎵 Sample Rate: {sample_rate}Hz\n🔍 Features extracted\n📊 Ready for training!"
+            
+        except Exception as e:
+            return f"❌ Preprocessing failed: {str(e)}"
     
     def train_model(self, model_name, epochs, batch_size, sample_rate, progress=gr.Progress()):
         """Run actual RVC training"""
         try:
             progress(0.05, desc="Initializing training...")
-            # Citation: log_dir directly under logs/ from train.py exp_dir setup
             log_dir = self.rvc_dir / "logs" / model_name
             log_dir.mkdir(parents=True, exist_ok=True)
             
             progress(0.1, desc="Starting RVC training...")
             train_script = self.rvc_dir / "infer" / "modules" / "train" / "train.py"
-            
-            # Citation: Pretrained v2 paths recommended
-            pg_path = self.rvc_dir / "assets" / "pretrained_v2" / "f0G40k.pth"
-            pd_path = self.rvc_dir / "assets" / "pretrained_v2" / "f0D40k.pth"
+            if not train_script.exists():
+                train_script = self.rvc_dir / "train_nsf_sim_cache_sid_load_pretrain.py"
             
             cmd = [
                 sys.executable, str(train_script),
                 "-e", model_name, "-sr", str(sample_rate),
                 "-f0", "1", "-bs", str(batch_size),
                 "-g", "0", "-te", str(epochs), "-se", "10",
-                "-pg", str(pg_path),
-                "-pd", str(pd_path),
-                "-l", "0", "-c", "0", "-sw", "1"
+                "-pg", str(self.rvc_dir / "pretrained" / "f0G40k.pth"),
+                "-pd", str(self.rvc_dir / "pretrained" / "f0D40k.pth"),
+                "-l", "0", "-c", "0"
             ]
             
-            process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, bufsize=1, universal_newlines=True)
+            progress(0.2, desc=f"Training {model_name}...")
+            process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
             
             for line in process.stdout:
-                line = line.strip()
-                if line and ("epoch" in line.lower() or "loss" in line.lower()):
-                    progress(0.2 + 0.7 * (process.poll() is not None), desc=line[:100])
+                if "epoch" in line.lower():
+                    progress(0.2 + 0.6, desc=f"Training: {line.strip()[:50]}")
             
             process.wait()
-            
             progress(0.9, desc="Searching for model files...")
             
-            # Citation: .pth and .index files directly in log_dir (from save logic in train.py)
-            model_files = list(log_dir.glob("*.pth"))
-            index_files = list(log_dir.glob("*.index"))
+            possible_paths = [
+                log_dir / "weights", log_dir,
+                self.rvc_dir / "weights" / model_name,
+                self.rvc_dir / "logs" / model_name
+            ]
+            
+            model_files = []
+            index_files = []
+            for path in possible_paths:
+                if path.exists():
+                    model_files.extend(list(path.glob("**/*.pth")))
+                    index_files.extend(list(path.glob("**/*.index")))
             
             if model_files or index_files:
                 output_dir = self.workspace / model_name
@@ -142,17 +185,85 @@ class RealRVCTrainer:
                     files_info.append(f"- {latest_index.name}")
                 
                 progress(1.0, desc="Training complete!")
-                # Fixed f-string: chr(10) instead of \n (Python spec)
-                return f"✅ Training Complete!\n\n🎓 Model: {model_name}\n📊 Epochs: {epochs}\n\n💾 Model Files:\n{chr(10).join(files_info)}\n\n📂 Location: {output_dir}\n\n🎉 Ready to download!\n\n⚠️ On CPU this is very slow – use GPU!"
+                return f"✅ Training Complete!\n\n🎓 Model: {model_name}\n📊 Epochs: {epochs}\n\n💾 Model Files:\n{chr(10).join(files_info)}\n\n📂 Location: {output_dir}\n\n🎉 Ready to download!"
             else:
-                return f"⚠️ No files found in {log_dir}\nCheck terminal/logs for errors."
+                debug_info = []
+                if log_dir.exists():
+                    debug_info.append(f"Log dir: {log_dir}")
+                    for item in log_dir.rglob("*"):
+                        debug_info.append(f"  - {item.relative_to(log_dir)}")
+                
+                return f"⚠️ Training completed but model files not found.\n\n🔍 Searched in:\n{chr(10).join([f'- {p}' for p in possible_paths])}\n\n📋 Debug:\n{chr(10).join(debug_info)}"
                 
         except Exception as e:
             return f"❌ Training failed: {str(e)}"
     
-    # package_model unchanged (or use the improved version from before)
+    def package_model(self, model_name):
+        """Package model for download"""
+        try:
+            output_dir = self.workspace / model_name
+            if not output_dir.exists():
+                output_dir = self.rvc_dir / "logs" / model_name / "weights"
+            
+            if not output_dir.exists():
+                return None, "❌ Model not found"
+            
+            zip_path = self.workspace / f"{model_name}_RVC.zip"
+            with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
+                for file in output_dir.rglob("*"):
+                    if file.is_file() and (file.suffix in ['.pth', '.index', '.json']):
+                        zipf.write(file, file.name)
+            
+            return str(zip_path), f"✅ Model packaged: {zip_path.name}"
+        except Exception as e:
+            return None, f"❌ Error: {str(e)}"
 
-# Rest of Gradio interface unchanged
+trainer = RealRVCTrainer()
+
+with gr.Blocks(title="Real RVC Training") as demo:
+    gr.Markdown("# 🎤 Real RVC Model Training\n### Using Official RVC-Project Implementation\n\n⚠️ Uses REAL RVC training. Models work on weights.gg!")
+    
+    with gr.Tab("⚙️ Step 0: Install RVC"):
+        gr.Markdown("Install official RVC codebase and pretrained models (~200MB)")
+        install_btn = gr.Button("📦 Install RVC Components", variant="primary", size="lg")
+        install_output = gr.Textbox(label="Installation Status", lines=10)
+        install_btn.click(fn=trainer.install_rvc, outputs=install_output)
+    
+    with gr.Tab("📁 Step 1: Prepare Dataset"):
+        gr.Markdown("Upload voice audio files (10-30 min recommended, WAV/MP3/FLAC)")
+        model_name_prep = gr.Textbox(label="Model Name", value="my_voice_model")
+        audio_files = gr.File(label="Upload Audio Files", file_count="multiple", file_types=["audio"])
+        prep_btn = gr.Button("📁 Prepare Dataset", variant="primary")
+        prep_output = gr.Textbox(label="Status", lines=8)
+        prep_btn.click(fn=trainer.prepare_dataset, inputs=[audio_files, model_name_prep], outputs=prep_output)
+    
+    with gr.Tab("🔧 Step 2: Preprocess"):
+        gr.Markdown("Preprocess audio and extract features")
+        model_name_process = gr.Textbox(label="Model Name", value="my_voice_model")
+        sample_rate_process = gr.Radio(choices=["40000", "48000"], value="40000", label="Sample Rate")
+        process_btn = gr.Button("🔧 Preprocess Data", variant="primary")
+        process_output = gr.Textbox(label="Status", lines=8)
+        process_btn.click(fn=trainer.preprocess_data, inputs=[model_name_process, sample_rate_process], outputs=process_output)
+    
+    with gr.Tab("🚀 Step 3: Train Model"):
+        gr.Markdown("Train RVC model (⚠️ CPU training takes hours/days)")
+        model_name_train = gr.Textbox(label="Model Name", value="my_voice_model")
+        epochs_train = gr.Slider(minimum=10, maximum=500, value=100, step=10, label="Epochs")
+        batch_size_train = gr.Slider(minimum=1, maximum=16, value=4, step=1, label="Batch Size")
+        sample_rate_train = gr.Radio(choices=["40000", "48000"], value="40000", label="Sample Rate")
+        train_btn = gr.Button("🎓 Start Real Training", variant="primary")
+        train_output = gr.Textbox(label="Training Status", lines=15)
+        train_btn.click(fn=trainer.train_model, inputs=[model_name_train, epochs_train, batch_size_train, sample_rate_train], outputs=train_output)
+    
+    with gr.Tab("📥 Step 4: Download"):
+        gr.Markdown("Download your trained RVC model")
+        model_name_download = gr.Textbox(label="Model Name", value="my_voice_model")
+        download_btn = gr.Button("📦 Package Model", variant="primary")
+        download_file = gr.File(label="Download")
+        download_status = gr.Textbox(label="Status")
+        download_btn.click(fn=trainer.package_model, inputs=model_name_download, outputs=[download_file, download_status])
+    
+    gr.Markdown("---\n### 📚 Resources\n- [RVC Project](https://github.com/RVC-Project/Retrieval-based-Voice-Conversion-WebUI)\n- [Weights.gg](https://weights.gg/)\n\n### ⚠️ Important\n- Uses REAL RVC training\n- Models work on weights.gg\n- CPU training is VERY slow\n- Recommended: Google Colab with GPU")
 
 if __name__ == "__main__":
     demo.launch()