Upload app.py

app.py

@@ -1,131 +1,322 @@
 #!/usr/bin/env python3
 """
-YarnGPT Fine-tuning UI - Gradio App
+Morpheus-GPT v2 Training UI
+============================
+
+HuggingFace Space for training Morpheus-GPT v2 - Nigerian Female TTS
+
+Uses ALL available data:
+- UbuntuFarms/morpheus-gpt-training (5000+ samples)
+- ejiod/female-nigerian-tts
+- benjaminogbonna/nigerian_common_voice_dataset
+- MMS-TTS synthetic pronunciation data
+
+Base: saheedniyi/YarnGPT2b
+Output: UbuntuFarms/morpheus-gpt-v2
 """
 
 import gradio as gr
 import torch
 import threading
-from train import train_yarngpt
+import time
+from train_morpheus_gpt_v2 import TrainingConfig, prepare_training_data, train_model
 
 # Global state
-training_status = {"progress": 0, "message": "Ready to train", "running": False}
+training_state = {
+    "running": False,
+    "progress": 0.0,
+    "message": "Ready to train",
+    "log": [],
+}
 
 
-def update_progress(progress, message):
+def update_progress(progress: float, message: str):
     """Update training progress."""
-    global training_status
-    training_status["progress"] = progress
-    training_status["message"] = message
+    global training_state
+    training_state["progress"] = progress
+    training_state["message"] = message
+    training_state["log"].append(f"[{progress*100:.1f}%] {message}")
+
+
+def get_system_info():
+    """Get system information."""
+    info = []
+    info.append(f"PyTorch: {torch.__version__}")
 
+    if torch.cuda.is_available():
+        info.append(f"GPU: {torch.cuda.get_device_name(0)}")
+        mem = torch.cuda.get_device_properties(0).total_memory / 1e9
+        info.append(f"GPU Memory: {mem:.1f} GB")
+        info.append("Status: Ready for training!")
+    else:
+        info.append("GPU: Not available")
+        info.append("Status: CPU only (training will be slow)")
 
-def start_training(dataset_id, output_repo, epochs, batch_size, learning_rate, lora_r):
+    return "\n".join(info)
+
+
+def start_training(
+    output_repo: str,
+    epochs: int,
+    batch_size: int,
+    learning_rate: float,
+    lora_r: int,
+    use_morpheus_training: bool,
+    use_female_nigerian_tts: bool,
+    use_common_voice: bool,
+    use_mms_synthetic: bool,
+    female_only: bool,
+):
     """Start training in background thread."""
-    global training_status
+    global training_state
 
-    if training_status["running"]:
-        return "Training already in progress!"
+    if training_state["running"]:
+        return "Training already in progress!", get_progress_display()
 
-    training_status["running"] = True
-    training_status["progress"] = 0
-    training_status["message"] = "Starting..."
+    training_state["running"] = True
+    training_state["progress"] = 0.0
+    training_state["message"] = "Starting..."
+    training_state["log"] = []
 
     def train_thread():
-        global training_status
+        global training_state
         try:
-            result = train_yarngpt(
-                dataset_id=dataset_id,
-                output_repo=output_repo,
+            config = TrainingConfig(
+                output_repo=output_repo or "UbuntuFarms/morpheus-gpt-v2",
                 epochs=int(epochs),
                 batch_size=int(batch_size),
                 learning_rate=float(learning_rate),
                 lora_r=int(lora_r),
-                progress_callback=update_progress,
+                use_morpheus_training=use_morpheus_training,
+                use_female_nigerian_tts=use_female_nigerian_tts,
+                use_common_voice=use_common_voice,
+                use_mms_synthetic=use_mms_synthetic,
+                female_only=female_only,
             )
-            training_status["message"] = f"Complete! Model at: {result}"
+
+            # Prepare data
+            update_progress(0.1, "Loading training data...")
+            dataset = prepare_training_data(config)
+            update_progress(0.2, f"Loaded {len(dataset)} samples")
+
+            # Train
+            result = train_model(config, dataset, progress_callback=update_progress)
+
+            training_state["message"] = f"Complete! Model at: {result}"
+
         except Exception as e:
-            training_status["message"] = f"Error: {str(e)}"
+            import traceback
+            traceback.print_exc()
+            training_state["message"] = f"Error: {str(e)}"
+            training_state["log"].append(f"ERROR: {str(e)}")
+
         finally:
-            training_status["running"] = False
+            training_state["running"] = False
 
     thread = threading.Thread(target=train_thread)
     thread.start()
 
-    return "Training started! Check progress below."
+    return "Training started! Monitor progress below.", get_progress_display()
 
 
-def get_status():
-    """Get current training status."""
-    return f"{training_status['message']} ({training_status['progress']*100:.1f}%)"
+def get_progress_display():
+    """Get progress display string."""
+    global training_state
+    lines = [
+        f"Status: {training_state['message']}",
+        f"Progress: {training_state['progress']*100:.1f}%",
+        "",
+        "--- Log ---",
+    ]
+    lines.extend(training_state["log"][-20:])  # Last 20 log entries
+    return "\n".join(lines)
 
 
-def get_progress():
-    """Get progress value."""
-    return training_status["progress"]
+def refresh_progress():
+    """Refresh progress display."""
+    return get_progress_display(), training_state["progress"]
 
 
-# Check GPU
-device_info = f"GPU: {torch.cuda.get_device_name(0)}" if torch.cuda.is_available() else "CPU only (slow!)"
+# ============================================================
+# GRADIO UI
+# ============================================================
+
+with gr.Blocks(title="Morpheus-GPT v2 Trainer", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""
+    # 🎙️ Morpheus-GPT v2 Training
 
-# Gradio UI
-with gr.Blocks(title="YarnGPT Fine-tuning") as demo:
-    gr.Markdown(f"""
-    # YarnGPT Fine-tuning Trainer
+    **Train a Nigerian Female TTS model using ALL available data:**
 
-    Fine-tune YarnGPT2 on Nigerian speech data using LoRA.
+    | Data Source | Description |
+    |-------------|-------------|
+    | UbuntuFarms/morpheus-gpt-training | 5000+ samples (female Yoruba, Hausa, Igbo) |
+    | ejiod/female-nigerian-tts | Female Nigerian voices |
+    | benjaminogbonna/nigerian_common_voice_dataset | Yoruba, Hausa, Igbo |
+    | MMS-TTS Synthetic | Pronunciation training data |
 
-    **Device:** {device_info}
+    **Base Model:** saheedniyi/YarnGPT2b (Nigerian language optimized)
     """)
 
     with gr.Row():
-        with gr.Column():
-            dataset_input = gr.Textbox(
-                label="Dataset ID",
-                value="Imakandi-Labs/aasd-nigerian-tts-processed",
-                info="HuggingFace dataset with text transcriptions"
+        with gr.Column(scale=1):
+            sys_info = gr.Textbox(
+                label="System Info",
+                value=get_system_info(),
+                lines=5,
+                interactive=False,
+            )
+
+    gr.Markdown("---")
+    gr.Markdown("## Training Configuration")
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            output_repo = gr.Textbox(
+                label="Output Model Repository",
+                value="UbuntuFarms/morpheus-gpt-v2",
+                info="Where to save the trained model"
             )
-            output_repo_input = gr.Textbox(
-                label="Output Model Repo",
-                value="Imakandi-Labs/YarnGPT2-Nigerian-Finetuned",
-                info="Where to save the fine-tuned model"
+
+            with gr.Row():
+                epochs = gr.Slider(
+                    label="Epochs",
+                    minimum=1,
+                    maximum=20,
+                    value=5,
+                    step=1,
+                )
+                batch_size = gr.Slider(
+                    label="Batch Size",
+                    minimum=1,
+                    maximum=8,
+                    value=2,
+                    step=1,
+                )
+
+            with gr.Row():
+                learning_rate = gr.Number(
+                    label="Learning Rate",
+                    value=2e-4,
+                )
+                lora_r = gr.Slider(
+                    label="LoRA Rank",
+                    minimum=4,
+                    maximum=64,
+                    value=16,
+                    step=4,
+                )
+
+        with gr.Column(scale=1):
+            gr.Markdown("### Data Sources")
+
+            use_morpheus_training = gr.Checkbox(
+                label="UbuntuFarms/morpheus-gpt-training (5000+ samples)",
+                value=True,
+            )
+            use_female_nigerian_tts = gr.Checkbox(
+                label="ejiod/female-nigerian-tts",
+                value=True,
             )
+            use_common_voice = gr.Checkbox(
+                label="Nigerian Common Voice (Yoruba, Hausa, Igbo)",
+                value=True,
+            )
+            use_mms_synthetic = gr.Checkbox(
+                label="MMS-TTS Synthetic Pronunciation Data",
+                value=True,
+            )
+            female_only = gr.Checkbox(
+                label="Filter for Female Voices Only",
+                value=True,
+            )
+
+    with gr.Row():
+        train_btn = gr.Button("🚀 Start Training", variant="primary", size="lg")
+        refresh_btn = gr.Button("🔄 Refresh Progress", size="lg")
 
-        with gr.Column():
-            epochs_input = gr.Slider(1, 10, value=3, step=1, label="Epochs")
-            batch_size_input = gr.Slider(1, 16, value=4, step=1, label="Batch Size")
-            lr_input = gr.Number(value=2e-4, label="Learning Rate")
-            lora_r_input = gr.Slider(4, 64, value=16, step=4, label="LoRA Rank")
+    gr.Markdown("---")
+    gr.Markdown("## Training Progress")
 
-    train_btn = gr.Button("Start Training", variant="primary")
-    status_output = gr.Textbox(label="Status", interactive=False)
-    progress_bar = gr.Slider(0, 1, value=0, label="Progress", interactive=False)
+    with gr.Row():
+        progress_bar = gr.Slider(
+            label="Progress",
+            minimum=0,
+            maximum=1,
+            value=0,
+            interactive=False,
+        )
 
-    # Auto-refresh status
-    refresh_btn = gr.Button("Refresh Status")
+    progress_display = gr.Textbox(
+        label="Training Log",
+        value="Ready to train. Configure options above and click 'Start Training'.",
+        lines=15,
+        interactive=False,
+    )
 
+    # Event handlers
     train_btn.click(
-        start_training,
-        inputs=[dataset_input, output_repo_input, epochs_input, batch_size_input, lr_input, lora_r_input],
-        outputs=status_output
+        fn=start_training,
+        inputs=[
+            output_repo, epochs, batch_size, learning_rate, lora_r,
+            use_morpheus_training, use_female_nigerian_tts, use_common_voice,
+            use_mms_synthetic, female_only
+        ],
+        outputs=[progress_display, progress_display],
     )
 
-    refresh_btn.click(get_status, outputs=status_output)
-    refresh_btn.click(get_progress, outputs=progress_bar)
+    refresh_btn.click(
+        fn=refresh_progress,
+        outputs=[progress_display, progress_bar],
+    )
 
     gr.Markdown("""
-    ## Instructions
+    ---
+    ## How It Works
 
-    1. Click **Start Training** to begin fine-tuning
-    2. Click **Refresh Status** to check progress
-    3. Once complete, your model will be at the Output Model Repo
+    ```
+    ┌─────────────────────────────────────────────────────────────┐
+    │  DATA SOURCES                                               │
+    │  • morpheus-gpt-training (5000+ female Nigerian samples)   │
+    │  • female-nigerian-tts                                      │
+    │  • Nigerian Common Voice (Yoruba, Hausa, Igbo)             │
+    │  • MMS-TTS synthetic pronunciation                          │
+    └─────────────────────┬───────────────────────────────────────┘
+                          │
+                          ▼
+    ┌─────────────────────────────────────────────────────────────┐
+    │  COMBINED DATASET (Female Nigerian voices only)             │
+    └─────────────────────┬───────────────────────────────────────┘
+                          │
+                          ▼
+    ┌─────────────────────────────────────────────────────────────┐
+    │  BASE MODEL: saheedniyi/YarnGPT2b                           │
+    │  (Already optimized for Nigerian languages)                 │
+    │                         +                                   │
+    │  LoRA Fine-tuning (efficient, GPU-friendly)                │
+    └─────────────────────┬───────────────────────────────────────┘
+                          │
+                          ▼
+    ┌─────────────────────────────────────────────────────────────┐
+    │  OUTPUT: UbuntuFarms/morpheus-gpt-v2                        │
+    │  • Clear pronunciation                                      │
+    │  • Natural female voice                                     │
+    │  • Nigerian languages (Yoruba, Hausa, Igbo, Pidgin)        │
+    └─────────────────────────────────────────────────────────────┘
+    ```
 
     ## After Training
 
-    Update your TTS Space to use the fine-tuned model:
+    Use the trained model:
     ```python
-    from peft import PeftModel
-    model = PeftModel.from_pretrained(base_model, "Imakandi-Labs/YarnGPT2-Nigerian-Finetuned")
+    from transformers import AutoModelForCausalLM, AutoTokenizer
+
+    model = AutoModelForCausalLM.from_pretrained("UbuntuFarms/morpheus-gpt-v2")
+    tokenizer = AutoTokenizer.from_pretrained("UbuntuFarms/morpheus-gpt-v2")
     ```
     """)
 
-demo.launch(server_name="0.0.0.0", server_port=7860)
+
+demo.queue()
+
+if __name__ == "__main__":
+    demo.launch()