Update app.py

app.py

@@ -6,7 +6,7 @@ from datetime import datetime
 from datasets import load_dataset
 import pandas as pd
 
-# Global state to track training/fine-tuning status
+# Global state
 class TrainingState:
     def __init__(self):
         self.status = "idle"
@@ -21,245 +21,165 @@ class TrainingState:
 
     def load_dataset(self):
         try:
-            self.logs.append(f"⏳ Loading dataset: tasal9/ZamAi-Pashto-Datasets-V2")
+            self.logs.append("⏳ Loading dataset: tasal9/ZamAi-Pashto-Datasets-V2")
             dataset = load_dataset("tasal9/ZamAi-Pashto-Datasets-V2")
             self.dataset_loaded = True
-            self.dataset_info = f"✅ Dataset loaded successfully!\n- Name: ZamAi-Pashto-Datasets-V2\n- Size: {len(dataset['train'])} examples"
-            
-            # Create sample preview
-            sample_data = dataset['train'].select(range(5))
-            self.dataset_sample = pd.DataFrame(sample_data)
-            
-            self.logs.append(f"📊 Dataset loaded: {len(dataset['train'])} Pashto examples")
+            self.dataset_info = f"✅ Dataset loaded!\nName: ZamAi-Pashto-Datasets-V2\nSize: {len(dataset['train'])} examples"
+            self.dataset_sample = pd.DataFrame(dataset['train'].select(range(5)))
+            self.logs.append(f"📊 {len(dataset['train'])} Pashto examples loaded")
             return True
         except Exception as e:
-            self.logs.append(f"❌ Dataset loading failed: {str(e)}")
-            self.dataset_info = f"Error loading dataset: {str(e)}"
+            self.logs.append(f"❌ Error loading dataset: {str(e)}")
+            self.dataset_info = f"Error: {str(e)}"
             return False
 
-    def start_training(self, data_size):
+    def start_training(self, size):
         self.status = "training"
         self.progress = 0
         self.logs = [f"🏋️ Training started at {datetime.now().strftime('%H:%M:%S')}"]
-        self.logs.append(f"📝 Training data size: {data_size} characters")
+        self.logs.append(f"📝 Data size: {size} characters")
         self.start_time = time.time()
-        
-    def start_finetuning(self, data_size):
+
+    def start_finetuning(self, size):
         self.status = "fine-tuning"
         self.progress = 0
         self.logs = [f"🎯 Fine-tuning started at {datetime.now().strftime('%H:%M:%S')}"]
-        self.logs.append(f"📝 Fine-tuning data size: {data_size} characters")
+        self.logs.append(f"📝 Data size: {size} characters")
         self.start_time = time.time()
-        
+
     def update_progress(self, progress):
         self.progress = min(100, max(0, progress))
-        if progress >= 100 and self.status != "idle":
+        if progress >= 100:
             self.complete_process()
-            
-    def add_log(self, message):
-        self.logs.append(f"[{datetime.now().strftime('%H:%M:%S')}] {message}")
-        if len(self.logs) > 15:  # Keep only last 15 logs
+
+    def add_log(self, msg):
+        self.logs.append(f"[{datetime.now().strftime('%H:%M:%S')}] {msg}")
+        if len(self.logs) > 15:
             self.logs.pop(0)
-            
+
     def complete_process(self):
         elapsed = time.time() - self.start_time
-        self.add_log(f"🏁 {self.status.capitalize()} completed in {elapsed:.1f} seconds!")
+        self.add_log(f"🏁 {self.status.capitalize()} completed in {elapsed:.1f}s")
         self.status = "idle"
         self.progress = 100
-        
+
     def get_status(self):
-        status_map = {
+        m = {
             "idle": "✅ Ready",
-            "training": "🏋️ Training in progress",
-            "fine-tuning": "🎯 Fine-tuning in progress"
+            "training": "🏋️ Training",
+            "fine-tuning": "🎯 Fine-tuning"
         }
-        return status_map.get(self.status, "❓ Unknown status")
+        return m.get(self.status, "❓ Unknown") + (f" - {self.progress}%" if self.status != "idle" else "")
 
-# Create global state
 state = TrainingState()
 
-def test_model(input_text):
-    """Enhanced test function with response variations"""
-    if not input_text.strip():
-        return "Please enter some text to test."
-    
-    responses = [
-        f"Processed: '{input_text}'",
-        f"Model response to: {input_text}",
-        f"Analysis: This appears to be Pashto text with {len(input_text)} characters",
-        f"✅ Received: {input_text}",
-        f"Generated continuation: {input_text}... [simulated output]",
-        f"Pashto analysis: Text contains {len(input_text.split())} words",
-        f"🔍 Detected language: Pashto (confidence: 95%)"
+def test_model(text):
+    if not text.strip():
+        return "❗ Enter text to test."
+    options = [
+        f"Processed: '{text}'",
+        f"Model response to: {text}",
+        f"Pashto analysis: {len(text)} characters",
+        f"✅ Got it: {text}",
+        f"Generated: {text}... [simulated]",
+        f"🔍 Words: {len(text.split())}"
     ]
-    return random.choice(responses)
+    return random.choice(options)
 
 def simulate_process(duration, process_type, data_size):
-    """Simulate long-running training/fine-tuning process"""
     if process_type == "train":
         state.start_training(data_size)
     else:
         state.start_finetuning(data_size)
-    
     steps = 10
     for i in range(steps + 1):
         time.sleep(duration / steps)
-        progress = int((i / steps) * 100)
-        state.update_progress(progress)
-        
-        # Add simulated log messages
+        state.update_progress(int((i / steps) * 100))
         if i % 3 == 0:
-            messages = [
-                f"Processing batch {i*5}/{steps*5}",
-                f"Loss: {random.uniform(0.1, 1.0):.4f}",
-                f"Accuracy: {random.uniform(80, 95):.1f}%",
-                f"Learning rate: {random.uniform(1e-5, 1e-3):.6f}",
-                f"Pashto token accuracy: {random.uniform(85, 98):.1f}%",
-                f"GPU utilization: {random.randint(70, 95)}%"
-            ]
-            state.add_log(random.choice(messages))
-    
+            state.add_log(random.choice([
+                f"Batch {i}/{steps}",
+                f"Loss: {random.uniform(0.1, 1.0):.3f}",
+                f"LR: {random.uniform(1e-5, 1e-3):.6f}",
+                f"GPU: {random.randint(60, 95)}% (sim)",
+            ]))
     state.complete_process()
 
-def train_model(dataset_text):
-    """Training function with simulated processing"""
-    if not dataset_text.strip():
-        return "Please provide training data.", ""
-    
-    # Validate dataset requirements
+def train_model(text):
+    if not text.strip():
+        return "❌ Add training data.", ""
     if not state.dataset_loaded:
-        return "Please load the Pashto dataset first using the 'Load Dataset' button.", ""
-    
-    data_size = len(dataset_text)
+        return "❌ Load dataset first.", ""
     if state.status != "idle":
-        return "Another process is already running. Please wait.", ""
-    
-    # Start simulation in background thread
-    threading.Thread(
-        target=simulate_process,
-        args=(15, "train", data_size),
-        daemon=True
-    ).start()
-    
-    return "Training started successfully! Check status in the Status tab.", ""
+        return "⏳ Wait for current process.", ""
+    threading.Thread(target=simulate_process, args=(15, "train", len(text)), daemon=True).start()
+    return "✅ Training started", ""
 
-def finetune_model(dataset_text):
-    """Fine-tuning function with simulated processing"""
-    if not dataset_text.strip():
-        return "Please provide fine-tuning data.", ""
-    
-    # Validate dataset requirements
+def finetune_model(text):
+    if not text.strip():
+        return "❌ Add fine-tuning data.", ""
     if not state.dataset_loaded:
-        return "Please load the Pashto dataset first using the 'Load Dataset' button.", ""
-    
-    data_size = len(dataset_text)
+        return "❌ Load dataset first.", ""
     if state.status != "idle":
-        return "Another process is already running. Please wait.", ""
-    
-    # Start simulation in background thread
-    threading.Thread(
-        target=simulate_process,
-        args=(10, "fine-tune", data_size),
-        daemon=True
-    ).start()
-    
-    return "Fine-tuning started successfully! Check status in the Status tab.", ""
+        return "⏳ Wait for current process.", ""
+    threading.Thread(target=simulate_process, args=(10, "fine-tune", len(text)), daemon=True).start()
+    return "✅ Fine-tuning started", ""
 
 def load_hf_dataset():
-    """Load dataset from Hugging Face Hub"""
-    success = state.load_dataset()
-    if success:
-        return {
-            dataset_status: state.dataset_info,
-            dataset_preview: state.dataset_sample,
-            dataset_btn: "Dataset Loaded ✅"
-        }
+    ok = state.load_dataset()
     return {
         dataset_status: state.dataset_info,
-        dataset_preview: pd.DataFrame(),
-        dataset_btn: "Retry Loading Dataset"
+        dataset_preview: state.dataset_sample if ok else pd.DataFrame(),
+        dataset_btn: "✅ Loaded" if ok else "Retry"
     }
 
 def get_current_status():
-    """Get current system status"""
-    status_text = state.get_status()
-    
-    # Add progress information
-    if state.status != "idle":
-        status_text += f" - {state.progress}% complete"
-    
-    # Format logs
-    logs = "\n".join(state.logs) if state.logs else "No logs available"
-    
     return {
-        status_box: status_text,
-        progress_bar: state.progress / 100,  # Progress expects a value between 0 and 1
-        log_output: logs
+        status_box: state.get_status(),
+        progress_bar: state.progress / 100,
+        log_output: "\n".join(state.logs) if state.logs else "No logs yet"
     }
 
-# Create interface
-with gr.Blocks(title="Pashto-Base-Bloom Trainer", theme="soft") as demo:
-    gr.Markdown("# 🌸 Pashto-Base-Bloom Training Space")
-    gr.Markdown("Train and fine-tune Pashto language model tasal9/pashto-base-bloom")
-    
-    with gr.Tab("Dataset"):
-        gr.Markdown("### Load Pashto Dataset")
-        gr.Markdown("Dataset: [tasal9/ZamAi-Pashto-Datasets-V2](https://huggingface.co/datasets/tasal9/ZamAi-Pashto-Datasets-V2)")
+with gr.Blocks(title="Pashto Base Bloom Trainer", theme="soft") as demo:
+    gr.Markdown("# 🌸 Pashto-Base-Bloom Trainer")
+    gr.Markdown("Train & fine-tune Pashto model: `tasal9/pashto-base-bloom`")
+
+    with gr.Tab("📂 Dataset"):
+        gr.Markdown("### Load Dataset from Hugging Face")
         with gr.Row():
-            dataset_btn = gr.Button("Load Dataset", variant="primary")
-            dataset_status = gr.Textbox(label="Dataset Status", lines=3, interactive=False)
-        dataset_preview = gr.DataFrame(label="Dataset Preview (First 5 Examples)", interactive=False)
+            dataset_btn = gr.Button("Load Dataset")
+            dataset_status = gr.Textbox(label="Status", lines=2, interactive=False)
+        dataset_preview = gr.DataFrame(label="Sample Preview", interactive=False)
         dataset_btn.click(load_hf_dataset, outputs=[dataset_status, dataset_preview, dataset_btn])
-    
-    with gr.Tab("Test Model"):
-        gr.Markdown("### Test Model with Sample Text")
+
+    with gr.Tab("🧪 Test Model"):
         with gr.Row():
-            with gr.Column():
-                test_input = gr.Textbox(label="Input Text", lines=3, placeholder="Enter Pashto text here...")
-                test_btn = gr.Button("Run Test", variant="primary")
-            test_output = gr.Textbox(label="Model Output", lines=4, interactive=False)
+            test_input = gr.Textbox(label="Input", lines=3)
+            test_btn = gr.Button("Test")
+        test_output = gr.Textbox(label="Output", lines=3, interactive=False)
         test_btn.click(test_model, inputs=test_input, outputs=test_output)
-    
-    with gr.Tab("Train Model"):
-        gr.Markdown("### Train Model with New Data")
-        gr.Markdown("Note: Requires loaded Pashto dataset")
-        with gr.Row():
-            with gr.Column():
-                train_input = gr.Textbox(label="Training Data", lines=8, placeholder="Paste additional training data here...")
-                train_btn = gr.Button("Start Training", variant="primary")
-            train_output = gr.Textbox(label="Training Status", lines=2, interactive=False)
+
+    with gr.Tab("🏋️ Train"):
+        train_input = gr.Textbox(label="Training Data", lines=6)
+        train_btn = gr.Button("Start Training")
+        train_output = gr.Textbox(label="Status", lines=2, interactive=False)
         train_btn.click(train_model, inputs=train_input, outputs=train_output)
-    
-    with gr.Tab("Fine-tune Model"):
-        gr.Markdown("### Fine-tune Model with Specialized Data")
-        gr.Markdown("Note: Requires loaded Pashto dataset")
-        with gr.Row():
-            with gr.Column():
-                finetune_input = gr.Textbox(label="Fine-tuning Data", lines=8, placeholder="Paste fine-tuning dataset here...")
-                finetune_btn = gr.Button("Start Fine-tuning", variant="primary")
-            finetune_output = gr.Textbox(label="Fine-tuning Status", lines=2, interactive=False)
+
+    with gr.Tab("🎯 Fine-tune"):
+        finetune_input = gr.Textbox(label="Fine-tuning Data", lines=6)
+        finetune_btn = gr.Button("Start Fine-tuning")
+        finetune_output = gr.Textbox(label="Status", lines=2, interactive=False)
         finetune_btn.click(finetune_model, inputs=finetune_input, outputs=finetune_output)
-    
-    with gr.Tab("Status"):
-        gr.Markdown("### System Status")
+
+    with gr.Tab("📊 Status"):
         with gr.Row():
-            with gr.Column():
-                status_box = gr.Textbox(label="Current Status", interactive=False)
-                # CORRECTED: Using gr.Progress() instead of gr.ProgressBar()
-                progress_bar = gr.Progress()
-                refresh_btn = gr.Button("Refresh Status", variant="secondary")
-                auto_refresh = gr.Checkbox(label="Auto-refresh every 5 seconds", value=True)
-            log_output = gr.Textbox(label="Process Logs", lines=10, interactive=False)
-        
-        # Auto-refresh component
-        auto_refresh_component = gr.Interval(5, interactive=False)
-        
-        with gr.Blocks() as demo:
-            out = gr.Textbox()
-    def update():
-    return "Auto refreshed."
+            status_box = gr.Textbox(label="Current Status", interactive=False)
+            progress_bar = gr.Slider(minimum=0, maximum=1, value=0, step=0.01, interactive=False, label="Progress")
+        log_output = gr.Textbox(label="Logs", lines=10, interactive=False)
+        refresh_btn = gr.Button("🔄 Refresh")
+        auto_refresh = gr.Checkbox(label="Auto-refresh every 5s", value=True)
+        refresh_btn.click(get_current_status, outputs=[status_box, progress_bar, log_output])
+        auto_refresh_component = gr.Interval(5, visible=True)
+        auto_refresh_component.click(get_current_status, outputs=[status_box, progress_bar, log_output], every=5)
 
-    with gr.Blocks() as demo:
-    out = gr.Textbox()
 if __name__ == "__main__":
     demo.launch(share=True)