Update app.py

app.py

@@ -1,18 +1,24 @@
 import os
-#os.system("pip install spaces-0.1.0-py3-none-any.whl")
-import torch
+import json
 import logging
 import multiprocessing
 import threading
-from itertools import chain
+import uuid
+import time
+import sys
+from datetime import datetime
 from concurrent.futures import ThreadPoolExecutor, as_completed
+from itertools import chain
+
+import torch
+import gradio as gr
+import transformers
+import datasets
+from dotenv import load_dotenv
 from datasets import load_dataset, get_dataset_config_names, IterableDataset
 from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments, Trainer, TrainerCallback
 from peft import LoraConfig, get_peft_model, PeftModel
 from huggingface_hub import login, whoami, create_repo, upload_folder
-from IPython.display import clear_output
-import gradio as gr
-from dotenv import load_dotenv
 import spaces
 
 try:
@@ -20,263 +26,526 @@ try:
 except:
     pass
 
-@spaces.GPU
-class GradioProgressCallback(TrainerCallback):
-    def __init__(self, progress_bar):
-        self.progress_bar = progress_bar
+transformers.logging.set_verbosity_error()
+datasets.logging.set_verbosity_error()
+logging.basicConfig(level=logging.ERROR)
+
+JOBS = {}
+
+class JobStatus:
+    def __init__(self):
+        self.id = str(uuid.uuid4())[:8]
+        self.status = "IDLE"
+        self.progress = 0.0
+        self.logs = []
+        self.result = None
+        self.error = None
+        self.created_at = datetime.now().strftime("%H:%M:%S")
+        self.repo_url = None
+
+    def add_log(self, message):
+        timestamp = datetime.now().strftime("%H:%M:%S")
+        self.logs.append(f"[{timestamp}] {message}")
+    
+    def set_progress(self, val, msg=None):
+        self.progress = val
+        if msg:
+            self.add_log(msg)
+
+class CustomTrainerCallback(TrainerCallback):
+    def __init__(self, job_id):
+        self.job_id = job_id
     
     def on_step_end(self, args, state, control, **kwargs):
-        if state.global_step > 0:
-            self.progress_bar(state.global_step / state.max_steps, desc=f"Paso {state.global_step}/{state.max_steps}")
+        if self.job_id in JOBS:
+            job = JOBS[self.job_id]
+            if state.max_steps > 0:
+                prog = state.global_step / state.max_steps
+                job.progress = 0.4 + (prog * 0.5)
+                if state.global_step % 5 == 0:
+                    loss = state.log_history[-1].get('loss', 'N/A') if state.log_history else '...'
+                    job.add_log(f"Step {state.global_step}/{state.max_steps} | Loss: {loss}")
         return control
 
-@spaces.GPU()
-def run_training(hf_token, model_name, new_repo_name, lora_r, lora_alpha, lora_dropout, 
-                 train_steps, learning_rate, batch_size, datasets_text, progress=gr.Progress()):
-    
-    os.environ["WANDB_DISABLED"] = "true"
-    os.environ["HF_TOKEN"] = hf_token
+@spaces.GPU(duration=300)
+def background_train_task(job_id, hf_token, model_name, new_repo_name, lora_r, lora_alpha, lora_dropout, 
+                          train_steps, learning_rate, batch_size, datasets_text, 
+                          reasoning_mode, c_conf, c_tok, c_gen):
     
+    job = JOBS[job_id]
+    job.status = "ACTIVE"
+    job.add_log("Initializing Nucleus Core...")
+
     try:
+        os.environ["WANDB_DISABLED"] = "true"
+        os.environ["HF_TOKEN"] = hf_token
+        os.environ["TRANSFORMERS_NO_ADVISORY_WARNINGS"] = "true"
+        
         login(token=hf_token)
-        username = whoami()["name"]
-    except Exception as e:
-        return f"Error de autenticación: {str(e)}"
+        try:
+            username = whoami()["name"]
+            job.add_log(f"Authenticated: {username}")
+        except:
+            raise Exception("Authentication Failed")
 
-#    device = "cuda" if torch.cuda.is_available() else "cpu"
-    num_workers = multiprocessing.cpu_count()
+        if not hasattr(torch, 'xla'):
+            class DummyXLA:
+                def __getattr__(self, name):
+                    return lambda *args, **kwargs: None
+            torch.xla = DummyXLA()
 
-    if not hasattr(torch, 'xla'):
-        class DummyXLA:
-            def __getattr__(self, name):
-                return lambda *args, **kwargs: None
-        torch.xla = DummyXLA()
+        raw_items = datasets_text.replace('\n', ',').split(',')
+        dataset_list = [item.strip() for item in raw_items if item.strip()]
 
-    logging.basicConfig(level=logging.INFO)
-    logger = logging.getLogger(__name__)
+        if reasoning_mode:
+            job.add_log("Reasoning Core: ACTIVATED")
+            job.add_log("Injecting Logic & CoT Datasets...")
+            dataset_list.append("gsm8k")
+            dataset_list.append("openai/gsm8k")
+            dataset_list.append("microsoft/orca-math-word-problems-200k")
 
-    raw_items = datasets_text.replace('\n', ',').split(',')
-    dataset_list = [item.strip() for item in raw_items if item.strip()]
+        def load_single(ds_name, cfg):
+            try:
+                ds = load_dataset(ds_name, cfg if cfg else "main", split="train", streaming=True, trust_remote_code=False)
+                try:
+                    next(iter(ds))
+                    return ds
+                except:
+                    return None
+            except:
+                return None
 
-    def get_sample_text(ds):
-        try:
-            sample = next(iter(ds))
-            if isinstance(sample, dict):
-                return sample.get("text", str(sample))
-            return str(sample)
-        except:
-            return None
+        streams = []
+        job.set_progress(0.1, "Analyzing Vector Streams...")
+        
+        with ThreadPoolExecutor(max_workers=4) as executor:
+            futures = []
+            for ds_name in dataset_list:
+                futures.append(executor.submit(load_single, ds_name, None))
+            
+            for future in as_completed(futures):
+                res = future.result()
+                if res:
+                    streams.append(res)
 
-    def load_single(ds_name, cfg):
-        try:
-            ds = load_dataset(ds_name, cfg, streaming=True, trust_remote_code=True)
-            if isinstance(ds, dict):
-                ds = next(iter(ds.values()))
+        if not streams:
+            raise Exception("Data Stream Failure: No valid inputs")
+
+        job.set_progress(0.2, f"Stream Locked: {len(streams)} Sources")
+
+        job.add_log("Tokenizing Input Stream...")
+        tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=False, padding_side="left", add_eos_token=True, add_bos_token=True)
+        tokenizer.pad_token = tokenizer.eos_token
+
+        def process_stream_generator():
+            iterator = chain.from_iterable(streams)
+            batch_buffer = []
             
-            if get_sample_text(ds):
-                return ds
-            return None
-        except:
-            return None
+            for item in iterator:
+                try:
+                    text = ""
+                    if "question" in item and "answer" in item:
+                        text = f"Question: {item['question']}\nAnswer: {item['answer']}"
+                    elif "text" in item:
+                        text = item["text"]
+                    else:
+                        text = str(item)
+                    
+                    batch_buffer.append(text)
+                    
+                    if len(batch_buffer) >= 50:
+                        for txt in batch_buffer:
+                            tokens = tokenizer(txt, truncation=True, max_length=1024)
+                            tokens["labels"] = tokens["input_ids"].copy()
+                            yield tokens
+                        batch_buffer = []
+                except:
+                    continue
+            
+            for txt in batch_buffer:
+                tokens = tokenizer(txt, truncation=True, max_length=1024)
+                tokens["labels"] = tokens["input_ids"].copy()
+                yield tokens
 
-    def load_all_datasets():
-        streams = []
-        tasks = []
-        progress(0.1, desc="Analizando configuraciones...")
+        job.set_progress(0.3, "Loading Neural Weights...")
+        original_model = AutoModelForCausalLM.from_pretrained(model_name, trust_remote_code=False, device_map="auto")
         
-        for ds_name in dataset_list:
-            try:
-                configs = get_dataset_config_names(ds_name)
-            except:
-                configs = []
-            
-            if not configs:
-                tasks.append((ds_name, None))
-            else:
-                for c in configs:
-                    tasks.append((ds_name, c))
-
-        progress(0.2, desc=f"Cargando {len(tasks)} fuentes...")
-        with ThreadPoolExecutor(max_workers=num_workers) as executor:
-            future_to_task = {executor.submit(load_single, d, c): (d, c) for d, c in tasks}
-            for future in as_completed(future_to_task):
+        target_mods = ["q_proj", "k_proj", "v_proj", "dense", "fc1", "fc2", "o_proj"]
+        if reasoning_mode:
+            target_mods.extend(["gate_proj", "up_proj", "down_proj"])
+
+        peft_config = LoraConfig(
+            r=int(lora_r) * 2 if reasoning_mode else int(lora_r),
+            lora_alpha=int(lora_alpha),
+            target_modules=target_mods,
+            bias="none",
+            lora_dropout=lora_dropout,
+            task_type="CAUSAL_LM"
+        )
+        
+        peft_model = get_peft_model(original_model, peft_config)
+        peft_model.config.use_cache = False
+
+        output_dir = f"checkpoints/{job_id}"
+        
+        training_args = TrainingArguments(
+            output_dir=output_dir,
+            per_device_train_batch_size=int(batch_size),
+            gradient_accumulation_steps=4,
+            max_steps=int(train_steps),
+            learning_rate=learning_rate,
+            optim="adamw_torch",
+            logging_steps=5,
+            save_strategy="no",
+            report_to="none",
+            fp16=True if torch.cuda.is_available() else False,
+            lr_scheduler_type="cosine" if reasoning_mode else "linear",
+            disable_tqdm=True
+        )
+
+        dataset_iterable = IterableDataset.from_generator(process_stream_generator)
+
+        trainer = Trainer(
+            model=peft_model,
+            train_dataset=dataset_iterable,
+            args=training_args,
+            callbacks=[CustomTrainerCallback(job_id)]
+        )
+
+        job.set_progress(0.4, "Executing Neural Plasticity Phase...")
+        trainer.train()
+        
+        job.set_progress(0.85, "Serializing Tensor Adapters...")
+        trainer.save_model(output_dir)
+
+        job.set_progress(0.9, "Fusing Tensor Layers...")
+        del peft_model
+        del original_model
+        torch.cuda.empty_cache()
+
+        base_reload = AutoModelForCausalLM.from_pretrained(
+            model_name,
+            return_dict=True,
+            torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
+            trust_remote_code=False,
+            device_map="auto"
+        )
+        
+        model_to_merge = PeftModel.from_pretrained(base_reload, output_dir)
+        final_model = model_to_merge.merge_and_unload()
+        
+        final_path = f"merged/{job_id}"
+        final_model.save_pretrained(final_path, safe_serialization=True)
+        tokenizer.save_pretrained(final_path)
+
+        def inject_json(content, fname):
+            if content and content.strip():
                 try:
-                    ds = future.result()
-                    if ds:
-                        streams.append(ds)
+                    data = json.loads(content)
+                    with open(os.path.join(final_path, fname), 'w') as f:
+                        json.dump(data, f, indent=2)
+                    job.add_log(f"Config Injection: {fname}")
                 except:
                     pass
-        return streams
 
-    loaded_streams = load_all_datasets()
-    if not loaded_streams:
-        return "Error: No se pudo cargar ningún dataset válido."
+        inject_json(c_conf, "config.json")
+        inject_json(c_tok, "tokenizer_config.json")
+        inject_json(c_gen, "generation_config.json")
 
-    def all_samples():
-        return chain.from_iterable(loaded_streams)
+        job.set_progress(0.95, "Uploading Artifacts to Hub...")
+        full_repo = f"{username}/{new_repo_name}"
+        create_repo(full_repo, token=hf_token, exist_ok=True)
+        upload_folder(folder_path=final_path, repo_id=full_repo, token=hf_token)
+
+        job.repo_url = f"https://huggingface.co/{full_repo}"
+        job.status = "COMPLETED"
+        job.set_progress(1.0, "Operation Successful")
 
-    progress(0.3, desc="Cargando Tokenizer...")
-    try:
-        tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True, padding_side="left", add_eos_token=True, add_bos_token=True)
-        tokenizer.pad_token = tokenizer.eos_token
-    except Exception as e:
-        return f"Error cargando tokenizer: {str(e)}"
-
-    def create_text_lines(sample):
-        if isinstance(sample, dict):
-            text = sample.get("text", "\n".join(str(v) for v in sample.values() if isinstance(v, str)))
-        else:
-            text = str(sample)
-        return [line.strip() for line in text.splitlines() if line.strip()]
-
-    def process_sample(sample):
-        lines = create_text_lines(sample)
-        results = []
-        for line in lines:
-            tok = tokenizer(line, truncation=False)
-            tok["labels"] = tok["input_ids"].copy()
-            results.append(tok)
-        return results
-
-    def processed_samples_generator():
-        batch = []
-        for sample in all_samples():
-            batch.append(sample)
-            if len(batch) >= 100:
-                with ThreadPoolExecutor(max_workers=num_workers) as executor:
-                    futures = [executor.submit(process_sample, s) for s in batch]
-                    for future in as_completed(futures):
-                        try:
-                            res = future.result()
-                            for tok in res:
-                                yield tok
-                        except:
-                            pass
-                batch.clear()
-        
-        if batch:
-            with ThreadPoolExecutor(max_workers=num_workers) as executor:
-                futures = [executor.submit(process_sample, s) for s in batch]
-                for future in as_completed(futures):
-                    try:
-                        res = future.result()
-                        for tok in res:
-                            yield tok
-                    except:
-                        pass
-
-    progress(0.4, desc="Cargando Modelo...")
-    try:
-        original_model = AutoModelForCausalLM.from_pretrained(model_name, trust_remote_code=True)
     except Exception as e:
-        return f"Error cargando modelo: {str(e)}"
-    
-    peft_config = LoraConfig(
-        r=int(lora_r),
-        lora_alpha=int(lora_alpha),
-        target_modules=["q_proj", "k_proj", "v_proj", "dense"],
-        bias="none",
-        lora_dropout=lora_dropout,
-        task_type="CAUSAL_LM"
-    )
+        job.status = "FAILED"
+        job.error = str(e)
+        job.add_log(f"CRITICAL FAILURE: {str(e)}")
+
+def start_training_wrapper(hf_token, model_name, new_repo_name, lora_r, lora_alpha, lora_dropout, 
+                           train_steps, learning_rate, batch_size, datasets_text, 
+                           reasoning_mode, c_conf, c_tok, c_gen):
     
-    peft_model = get_peft_model(original_model, peft_config)
-    peft_model.config.use_cache = False
-
-    output_dir = "/content/final-checkpoint"
-    max_steps_val = int(train_steps)
-    save_steps_val = max_steps_val // 2 if max_steps_val > 10 else 1
-
-    training_args = TrainingArguments(
-        output_dir=output_dir,
-        per_device_train_batch_size=int(batch_size),
-        gradient_accumulation_steps=1,
-        max_steps=max_steps_val,
-        learning_rate=learning_rate,
-        optim="adamw_torch",
-        logging_steps=5,
-        save_strategy="steps",
-        save_steps=save_steps_val,
-        report_to="none"
-    )
+    if not hf_token or not model_name:
+        return "MISSING_CREDENTIALS", gr.update(visible=False)
 
-    processed_dataset = IterableDataset.from_generator(processed_samples_generator)
+    new_job = JobStatus()
+    JOBS[new_job.id] = new_job
 
-    trainer = Trainer(
-        model=peft_model,
-        train_dataset=processed_dataset,
-        args=training_args,
-        callbacks=[GradioProgressCallback(progress)]
+    thread = threading.Thread(
+        target=background_train_task,
+        args=(new_job.id, hf_token, model_name, new_repo_name, lora_r, lora_alpha, lora_dropout, 
+              train_steps, learning_rate, batch_size, datasets_text, reasoning_mode, c_conf, c_tok, c_gen)
     )
-
-    progress(0.5, desc="Entrenando...")
-    trainer.train()
+    thread.daemon = True
+    thread.start()
+
+    return new_job.id, gr.update(visible=True, value=f"SESSION ID: {new_job.id}")
+
+def get_job_update(job_id):
+    if job_id not in JOBS:
+        return (
+            "<span style='color: #ef4444'>INVALID SESSION ID</span>", 
+            "--:--", 
+            "0%", 
+            "", 
+            gr.update(visible=False)
+        )
     
-    progress(0.8, desc="Guardando...")
-    trainer.save_model(output_dir)
-
-    progress(0.9, desc="Fusionando...")
-    ft = PeftModel.from_pretrained(original_model, output_dir, torch_dtype=torch.float32, is_trainable=False).merge_and_unload()
+    job = JOBS[job_id]
     
-    final_path = "/content/merged_model"
-    ft.save_pretrained(final_path, safe_serialization=True)
-    tokenizer.save_pretrained(final_path)
-
-    progress(0.95, desc="Subiendo...")
-    full_repo = f"{username}/{new_repo_name}"
-    create_repo(full_repo, token=hf_token, exist_ok=True)
-    upload_folder(folder_path=final_path, repo_id=full_repo, token=hf_token)
-
-    return f"Completado: https://huggingface.co/{full_repo}"
-
-custom_css = """
-body {background-color: #0b0f19; color: #e0e6ed;}
-.gradio-container {max-width: 1200px !important; margin: 0 auto;}
-h1 {text-align: center; color: #00e5ff; font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif; text-transform: uppercase; letter-spacing: 2px;}
-.primary-btn {background: linear-gradient(135deg, #00C9FF 0%, #92FE9D 100%); border: none; color: #000; font-weight: 800; font-size: 16px; padding: 12px; transition: transform 0.2s;}
-.primary-btn:hover {transform: scale(1.02); filter: brightness(1.1);}
-.input-box textarea {font-family: 'Consolas', 'Monaco', monospace; font-size: 13px; background-color: #1a202c; color: #a0aec0; border: 1px solid #2d3748;}
-.gr-box {border-radius: 8px; background-color: #1a202c; border: 1px solid #2d3748;}
-label {color: #00e5ff !important; font-weight: bold;}
-"""
-
-with gr.Blocks(title="Entrenador LLM Ultimate") as demo:
-    gr.HTML(f"<style>{custom_css}</style>")
-    gr.HTML("""
-    <div style="text-align: center; margin-bottom: 20px;">
-        <h1 style="margin: 0;">⚡ INFINITE LLM TRAINER ⚡</h1>
-        <p style="color: #a0aec0;">Entrenamiento Multi-Dataset con Fusión Automática y Subida a Hub</p>
+    log_html = "<br>".join([f"<div class='log-line'>{l}</div>" for l in job.logs[-50:]])
+    
+    progress_html = f"""
+    <div class="p-bar-wrapper">
+        <div class="p-bar-fill" style="width: {job.progress * 100}%"></div>
     </div>
-    """)
+    <div class="p-text">{int(job.progress * 100)}% COMPLETE</div>
+    """
     
-    with gr.Row():
-        with gr.Column(scale=1):
-            hf_token_input = gr.Textbox(label="HuggingFace Token", type="password", placeholder="hf_...", value=os.getenv("HF_TOKEN", ""))
-            model_input = gr.Textbox(label="Modelo Base", value="", placeholder="Ej: Qwen/Qwen2.5-0.5B (Requerido)")
-            repo_input = gr.Textbox(label="Nombre Nuevo Repo", value="multi-dataset-model-v1")
-        
-        with gr.Column(scale=1):
-            with gr.Group():
-                gr.Markdown("### 🎛️ Configuración Avanzada LoRA")
-                r_input = gr.Slider(minimum=8, maximum=256, value=32, step=8, label="Rank (r)")
-                alpha_input = gr.Slider(minimum=8, maximum=512, value=32, step=8, label="Alpha")
-                dropout_input = gr.Slider(minimum=0.0, maximum=0.5, value=0.05, step=0.01, label="Dropout")
-
-    with gr.Row():
-        steps_input = gr.Number(label="Max Steps (Duración)", value=500, precision=0)
-        lr_input = gr.Number(label="Learning Rate", value=2e-4)
-        batch_input = gr.Number(label="Batch Size", value=1, precision=0)
-
-    datasets_input = gr.Textbox(label="Fuentes de Datos (Datasets)", value="", placeholder="Pega aquí tus datasets separados por coma o salto de línea.\nEjemplo:\nSalesforce/fineweb_deduplicated\nbigcode/the-stack, v2", lines=12, elem_classes="input-box")
+    status_map = {
+        "IDLE": "#94a3b8",
+        "ACTIVE": "#3b82f6",
+        "COMPLETED": "#10b981",
+        "FAILED": "#ef4444"
+    }
+    
+    status_html = f"<span style='color: {status_map.get(job.status, '#fff')}; font-weight: 900; letter-spacing: 1px;'>{job.status}</span>"
     
-    train_btn = gr.Button("🚀 INICIAR ENTRENAMIENTO", elem_classes="primary-btn")
-    status_output = gr.Textbox(label="Log del Sistema", interactive=False, lines=3)
-
-    train_btn.click(
-        fn=run_training,
-        inputs=[hf_token_input, model_input, repo_input, r_input, alpha_input, dropout_input, 
-                steps_input, lr_input, batch_input, datasets_input],
-        outputs=status_output
+    result_comp = gr.update(visible=False)
+    if job.status == "COMPLETED" and job.repo_url:
+        result_comp = gr.update(visible=True, value=f"ACCESS MODEL ARTIFACT: {job.repo_url}")
+    
+    return status_html, job.created_at, progress_html, log_html, result_comp
+
+css = """
+@import url('https://fonts.googleapis.com/css2?family=Space+Grotesk:wght@300;500;700&family=JetBrains+Mono:wght@400;700&display=swap');
+
+:root {
+    --bg-dark: #0a0a0f;
+    --panel-dark: #13131f;
+    --primary: #6366f1;
+    --accent: #8b5cf6;
+    --text-main: #e2e8f0;
+    --text-dim: #64748b;
+    --border: #1e1e2e;
+}
+
+body {
+    background-color: var(--bg-dark) !important;
+    font-family: 'Space Grotesk', sans-serif !important;
+}
+
+.gradio-container {
+    background-color: transparent !important;
+    max-width: 1400px !important;
+}
+
+.header-container {
+    text-align: center;
+    padding: 3rem 0;
+    background: radial-gradient(circle at center, rgba(99, 102, 241, 0.05) 0%, transparent 60%);
+    margin-bottom: 2rem;
+    border-bottom: 1px solid var(--border);
+}
+
+h1 {
+    font-size: 3.5rem;
+    background: linear-gradient(135deg, #fff 0%, #94a3b8 100%);
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+    text-transform: uppercase;
+    letter-spacing: -2px;
+    margin-bottom: 0.5rem;
+}
+
+.sub-header {
+    font-family: 'JetBrains Mono', monospace;
+    color: var(--primary);
+    font-size: 0.9rem;
+    letter-spacing: 2px;
+    text-transform: uppercase;
+}
+
+.gr-box, .gr-panel {
+    background: var(--panel-dark) !important;
+    border: 1px solid var(--border) !important;
+    border-radius: 4px !important;
+}
+
+.gr-input, .gr-textarea, .gr-number, .gr-dropdown {
+    background: #0d0d12 !important;
+    border: 1px solid var(--border) !important;
+    color: var(--text-main) !important;
+    font-family: 'JetBrains Mono', monospace;
+    font-size: 13px;
+    border-radius: 4px !important;
+}
+
+.gr-input:focus {
+    border-color: var(--primary) !important;
+    box-shadow: 0 0 0 1px var(--primary) !important;
+}
+
+.primary-btn {
+    background: var(--primary) !important;
+    border: none !important;
+    color: #fff !important;
+    font-family: 'JetBrains Mono', monospace !important;
+    text-transform: uppercase;
+    letter-spacing: 1px;
+    padding: 12px 24px !important;
+    border-radius: 2px !important;
+    transition: all 0.2s ease;
+}
+
+.primary-btn:hover {
+    background: var(--accent) !important;
+    box-shadow: 0 0 15px rgba(99, 102, 241, 0.3);
+}
+
+.p-bar-wrapper {
+    width: 100%;
+    height: 4px;
+    background: #1e1e2e;
+    margin-top: 15px;
+}
+
+.p-bar-fill {
+    height: 100%;
+    background: linear-gradient(90deg, var(--primary), var(--accent));
+    transition: width 0.4s cubic-bezier(0.4, 0, 0.2, 1);
+}
+
+.p-text {
+    font-family: 'JetBrains Mono', monospace;
+    font-size: 10px;
+    color: var(--primary);
+    text-align: right;
+    margin-top: 5px;
+}
+
+.log-line {
+    font-family: 'JetBrains Mono', monospace;
+    font-size: 11px;
+    color: var(--text-dim);
+    padding: 2px 0;
+    border-bottom: 1px solid rgba(255,255,255,0.03);
+}
+
+.session-box {
+    background: rgba(99, 102, 241, 0.1);
+    border: 1px solid var(--primary);
+    color: var(--primary);
+    font-family: 'JetBrains Mono', monospace;
+    padding: 1rem;
+    text-align: center;
+    font-size: 1.2rem;
+    margin: 1rem 0;
+}
+
+.label-wrap {
+    background: var(--panel-dark) !important;
+    border: 1px solid var(--border);
+    color: var(--text-main) !important;
+}
+"""
+
+with gr.Blocks(title="Nucleus Enterprise", css=css, theme=gr.themes.Base()) as demo:
+    with gr.Column():
+        gr.HTML("""
+        <div class="header-container">
+            <h1>Nucleus Enterprise</h1>
+            <div class="sub-header">Autonomous Neural Foundry // V.4.0</div>
+        </div>
+        """)
+        
+        with gr.Tabs():
+            with gr.TabItem("DEPLOYMENT", id="deploy"):
+                with gr.Row():
+                    with gr.Column(scale=2):
+                        with gr.Row():
+                            hf_token = gr.Textbox(label="HUGGINGFACE KEY", type="password", value=os.getenv("HF_TOKEN", ""))
+                            model_name = gr.Textbox(label="BASE MODEL ID", placeholder="Qwen/Qwen2.5-0.5B")
+                        
+                        repo_name = gr.Textbox(label="TARGET REPOSITORY", value="nucleus-build-v1")
+                        datasets = gr.Textbox(label="DATA STREAMS (CSV)", placeholder="Salesforce/fineweb_deduplicated", lines=4)
+                        
+                        reasoning_toggle = gr.Checkbox(label="ENABLE REASONING CORE (INJECTS LOGIC DATASETS)", value=False, elem_id="reasoning-switch")
+
+                    with gr.Column(scale=1):
+                        gr.Markdown("### HYPERPARAMETERS")
+                        train_steps = gr.Number(label="STEPS", value=100)
+                        lr = gr.Number(label="LEARNING RATE", value=2e-4)
+                        batch = gr.Number(label="BATCH SIZE", value=1)
+                        
+                        gr.Markdown("### LORA ADAPTERS")
+                        lora_r = gr.Slider(8, 256, 32, step=8, label="RANK")
+                        lora_a = gr.Slider(8, 512, 64, step=8, label="ALPHA")
+                        lora_d = gr.Slider(0, 0.5, 0.05, label="DROPOUT")
+
+                with gr.Accordion("ADVANCED CONFIGURATION INJECTION", open=False):
+                    with gr.Row():
+                        conf_json = gr.Code(label="CONFIG.JSON", language="json")
+                        tok_json = gr.Code(label="TOKENIZER_CONFIG.JSON", language="json")
+                        gen_json = gr.Code(label="GENERATION_CONFIG.JSON", language="json")
+
+                launch_btn = gr.Button("INITIALIZE TRAINING SEQUENCE", elem_classes="primary-btn")
+                
+                job_info_area = gr.Group(visible=False)
+                with job_info_area:
+                    new_job_id_display = gr.HTML()
+
+            with gr.TabItem("TELEMETRY", id="monitor"):
+                with gr.Row():
+                    input_job_id = gr.Textbox(label="SESSION ID", placeholder="ENTER 8-DIGIT ID")
+                    refresh_btn = gr.Button("ESTABLISH UPLINK", elem_classes="primary-btn")
+                
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        status_display = gr.HTML(label="STATUS")
+                        created_display = gr.Textbox(label="TIMESTAMP", interactive=False)
+                        final_link = gr.Markdown(visible=False)
+                    
+                    with gr.Column(scale=2):
+                        progress_display = gr.HTML()
+                        with gr.Accordion("SYSTEM LOGS", open=False):
+                            logs_display = gr.HTML()
+
+    timer = gr.Timer(3000, active=False)
+
+    def activate_timer():
+        return gr.Timer(active=True)
+
+    launch_btn.click(
+        start_training_wrapper,
+        inputs=[hf_token, model_name, repo_name, lora_r, lora_a, lora_d, train_steps, lr, batch, datasets, reasoning_toggle, conf_json, tok_json, gen_json],
+        outputs=[new_job_id_display, job_info_area]
+    ).then(
+        fn=lambda id: f"<div class='session-box'>{id}</div>",
+        inputs=[new_job_id_display],
+        outputs=[new_job_id_display]
+    )
+
+    refresh_btn.click(
+        get_job_update,
+        inputs=[input_job_id],
+        outputs=[status_display, created_display, progress_display, logs_display, final_link]
+    ).then(
+        activate_timer,
+        None,
+        timer
+    )
+
+    timer.tick(
+        get_job_update,
+        inputs=[input_job_id],
+        outputs=[status_display, created_display, progress_display, logs_display, final_link]
     )
 
-demo.launch(share=True, debug=True)
+if __name__ == "__main__":
+    demo.launch()