Spaces:
Runtime error
Runtime error
| import gradio as gr | |
| import time | |
| import threading | |
| import random | |
| from datetime import datetime | |
| from datasets import load_dataset | |
| import pandas as pd | |
| # Global state | |
| class TrainingState: | |
| def __init__(self): | |
| self.status = "idle" | |
| self.progress = 0 | |
| self.logs = ["✅ System initialized"] | |
| self.start_time = None | |
| self.model_name = "tasal9/pashto-base-bloom" | |
| self.active_process = None | |
| self.dataset_loaded = False | |
| self.dataset_info = "No dataset loaded" | |
| self.dataset_sample = pd.DataFrame() | |
| def load_dataset(self): | |
| try: | |
| 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!\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"❌ Error loading dataset: {str(e)}") | |
| self.dataset_info = f"Error: {str(e)}" | |
| return False | |
| 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"📝 Data size: {size} characters") | |
| self.start_time = time.time() | |
| 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"📝 Data size: {size} characters") | |
| self.start_time = time.time() | |
| def update_progress(self, progress): | |
| self.progress = min(100, max(0, progress)) | |
| if progress >= 100: | |
| self.complete_process() | |
| 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}s") | |
| self.status = "idle" | |
| self.progress = 100 | |
| with gr.Tab("📊 Status"): | |
| with gr.Row(): | |
| 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 Status") | |
| refresh_btn.click(get_current_status, outputs=[status_box, progress_bar, log_output]) | |
| state = TrainingState() | |
| 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(options) | |
| def simulate_process(duration, process_type, data_size): | |
| 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) | |
| state.update_progress(int((i / steps) * 100)) | |
| if i % 3 == 0: | |
| 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(text): | |
| if not text.strip(): | |
| return "❌ Add training data.", "" | |
| if not state.dataset_loaded: | |
| return "❌ Load dataset first.", "" | |
| if state.status != "idle": | |
| return "⏳ Wait for current process.", "" | |
| threading.Thread(target=simulate_process, args=(15, "train", len(text)), daemon=True).start() | |
| return "✅ Training started", "" | |
| def finetune_model(text): | |
| if not text.strip(): | |
| return "❌ Add fine-tuning data.", "" | |
| if not state.dataset_loaded: | |
| return "❌ Load dataset first.", "" | |
| if state.status != "idle": | |
| 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(): | |
| ok = state.load_dataset() | |
| return { | |
| dataset_status: state.dataset_info, | |
| dataset_preview: state.dataset_sample if ok else pd.DataFrame(), | |
| dataset_btn: "✅ Loaded" if ok else "Retry" | |
| } | |
| def get_current_status(): | |
| return { | |
| status_box: state.get_status(), | |
| progress_bar: state.progress / 100, | |
| log_output: "\n".join(state.logs) if state.logs else "No logs yet" | |
| } | |
| 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") | |
| 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"): | |
| with gr.Row(): | |
| 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"): | |
| 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"): | |
| 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"): | |
| with gr.Row(): | |
| 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) | |
| if __name__ == "__main__": | |
| demo.launch(share=True) |