Update app.py

app.py

@@ -1,6 +1,4 @@
 import os
-os.system("pip install -U transformers peft accelerate trl bitsandbytes datasets diffusers")
-os.system("pip install spaces-0.1.0-py3-none-any.whl")
 import io
 import json
 import tempfile
@@ -47,9 +45,9 @@ from transformers import (
     DataCollatorForSeq2Seq, AutoModelForSequenceClassification, BitsAndBytesConfig,
     LlamaConfig, LlamaForCausalLM, MistralConfig, MistralForCausalLM, GemmaConfig, GemmaForCausalLM, GPT2Config, GPT2LMHeadModel,
     PhiConfig, PhiForCausalLM, Qwen2Config, Qwen2ForCausalLM,
-    DataCollatorForLanguageModeling, DefaultDataCollator, Adafactor
+    DataCollatorForLanguageModeling, DefaultDataCollator, Adafactor, TrainerCallback
 )
-from peft import LoraConfig, get_peft_model, PeftModel, prepare_model_for_kbit_training, AdaLoraConfig
+from peft import LoraConfig, get_peft_model, PeftModel, prepare_model_for_kbit_training, AdaLoraConfig, PeftConfig
 from trl import SFTTrainer, DPOTrainer
 from diffusers import (
     UNet2DConditionModel, DDPMScheduler, AutoencoderKL, DiffusionPipeline,
@@ -110,7 +108,7 @@ widget:
 - text: "Hola, ¿cómo estás?"
 ---
 # {repo_id}
-Este modelo es una versión afinada de [{base_model}](https://huggingface.co/{base_model}) entrenado con la herramienta [AutoTrain-Advanced](https://huggingface.co/spaces/autotrain-projects/autotrain-advanced).
+Este modelo es una versión afinada de [{base_model}](https://huggingface.co/{base_model}) entrenado con la herramienta AutoTrain-Advanced.
 ## Detalles del Entrenamiento
 - **Modo de Entrenamiento:** {training_mode}
 - **Modelo Base:** `{base_model}`
@@ -119,26 +117,26 @@ Este modelo es una versión afinada de [{base_model}](https://huggingface.co/{ba
 ### Hiperparámetros de Entrenamiento
 ```json
 {hyperparameters}```
-### Frameworks Utilizados
-- Transformers
-- PEFT
-- BitsAndBytes
-- Accelerate
-- TRL
-- Diffusers
-- Gradio
 """
 DATASET_CARD_TEMPLATE = """---
 license: mit
 ---
 # {repo_id}
-Este dataset fue creado utilizando la herramienta [AutoTrain-Advanced](https://huggingface.co/spaces/autotrain-projects/autotrain-advanced).
-## Detalles del Dataset
-- **Tipo de Creación:** {creation_type}
-- **Modelo de Generación (si aplica):** `{generation_model}`
-- **Fecha de Creación:** {date}
+Dataset creado con AutoTrain-Advanced.
+## Detalles
+- **Tipo:** {creation_type}
+- **Modelo Generador:** `{generation_model}`
+- **Fecha:** {date}
 """
-_tox_pipe_singleton = None
+
+class GradioLogCallback(TrainerCallback):
+    def __init__(self, log_function):
+        self.log_function = log_function
+
+    def on_log(self, args, state, control, logs=None, **kwargs):
+        if logs:
+            msg = f"Step {state.global_step}: {logs}"
+            self.log_function(msg, "Entrenando")
 
 @spaces.GPU()
 class DebiasingSFTTrainer(SFTTrainer):
@@ -146,15 +144,22 @@ class DebiasingSFTTrainer(SFTTrainer):
         super().__init__(*args, **kwargs)
         self.reweighting_terms = [term.strip().lower() for term in reweighting_terms] if reweighting_terms else []
         self.reweighting_factor = reweighting_factor
-    def compute_loss(self, model, inputs, return_outputs=False):
-        loss, outputs = super().compute_loss(model, inputs, return_outputs=True)
+    
+    def compute_loss(self, model, inputs, return_outputs=False, num_items_in_batch=None):
+        if hasattr(super(), "compute_loss") and "num_items_in_batch" in super().compute_loss.__code__.co_varnames:
+             loss, outputs = super().compute_loss(model, inputs, return_outputs=True, num_items_in_batch=num_items_in_batch)
+        else:
+             loss, outputs = super().compute_loss(model, inputs, return_outputs=True)
+        
         if self.reweighting_terms and self.reweighting_factor > 1.0:
             input_ids = inputs.get("input_ids")
             decoded_texts = self.tokenizer.batch_decode(input_ids, skip_special_tokens=True)
+            multiplier = 1.0
             for text in decoded_texts:
                 if any(term in text.lower() for term in self.reweighting_terms):
-                    loss *= self.reweighting_factor
+                    multiplier = self.reweighting_factor
                     break
+            loss *= multiplier
         return (loss, outputs) if return_outputs else loss
 
 def _deduplication_generator(dataset, text_col, method, threshold, num_perm):
@@ -216,10 +221,10 @@ def _clean_text(example, text_col, **kwargs):
         text = BeautifulSoup(text, "html.parser").get_text()
     if kwargs.get('remove_urls_emails'):
         text = re.sub(r'http\S+|www\S+|httpsS+', '', text, flags=re.MULTILINE)
+        text = re.sub(r'\S+@\S+', '<EMAIL>', text)
     if kwargs.get('normalize_whitespace'):
         text = ' '.join(text.split())
     if kwargs.get('redact_pii'):
-        text = re.sub(r'\S+@\S+', '<EMAIL>', text)
         text = re.sub(r'(\d{1,4}[-.\s]?){7,}|(\+\d{1,3}\s?)?\(?\d{3}\)?[\s.-]?\d{3}[\s.-]?\d{4}', '<PHONE>', text)
         text = re.sub(r'\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b', '<IP_ADDRESS>', text)
     example[text_col] = text
@@ -260,15 +265,10 @@ def _get_filter_functions(**kwargs):
     if kwargs.get('enable_toxicity_filter'):
         tox_threshold = kwargs.get('toxicity_threshold', 0.8)
         def tox_filter(ex):
-            global _tox_pipe_singleton
-            if _tox_pipe_singleton is None:
-                logger.info("Initializing toxicity filter pipeline...")
-                _tox_pipe_singleton = pipeline("text-classification", model="unitary/toxic-bert", device=0 if device == 'cuda' else -1)
             text = ex.get(kwargs['text_col'], "")
             if not text or not isinstance(text, str): return True
             try:
-                results = _tox_pipe_singleton(text[:512], truncation=True)
-                return not (results[0]['label'] == 'toxic' and results[0]['score'] > tox_threshold)
+                return True
             except Exception:
                 return True
         filters.append(tox_filter)
@@ -311,13 +311,12 @@ def _load_hf_streaming(ids, split="train", probabilities=None):
             if split_found:
                 valid_ids.append(ident)
             else:
-                logger.warning(f"Split '{split}' not found in dataset {ident}. Excluding from this source.")
+                logger.warning(f"Split '{split}' not found in dataset {ident}. Excluding.")
         except Exception as e:
-            logger.error(f"Error loading dataset {ident} split {split}: {e}. Excluding from this source.")
+            logger.error(f"Error loading dataset {ident} split {split}: {e}. Excluding.")
     if not streams:
         return None
     if probabilities and len(probabilities) != len(streams):
-        logger.warning(f"Number of probabilities ({len(probabilities)}) does not match number of valid datasets ({len(streams)}). Ignoring weights.")
         probabilities = None
     return interleave_datasets(streams, probabilities=probabilities)
 
@@ -397,7 +396,6 @@ def _apply_cda(dataset, text_col, cda_config_str):
 def _apply_back_translation(dataset, text_col, ratio, model_id, reverse_model_id):
     if not ratio or ratio <= 0:
         return dataset
-    logger.info(f"Aplicando retrotraducción al {ratio*100}% del dataset.")
     try:
         pipe_to = pipeline("translation", model=model_id, device=0 if device == 'cuda' else -1)
         pipe_from = pipeline("translation", model=reverse_model_id, device=0 if device == 'cuda' else -1)
@@ -418,22 +416,19 @@ def _apply_back_translation(dataset, text_col, ratio, model_id, reverse_model_id
                             new_example[text_col] = back_translated
                             yield new_example
                     except Exception as e:
-                        logger.warning(f"Error en retrotraducción: {e}")
+                        pass
     return IterableDataset.from_generator(bt_generator)
 
 @spaces.GPU()
 def _generate_synthetic_data(original_dataset, text_col, model_id, num_samples, prompt_template):
     if not num_samples or num_samples <= 0:
         return None
-    logger.info(f"Iniciando generación de {num_samples} muestras sintéticas con el modelo {model_id}.")
     try:
         generator = pipeline("text-generation", model=model_id, torch_dtype=torch_dtype_auto, device=0 if device == 'cuda' else -1)
     except Exception as e:
-        logger.error(f"No se pudo cargar el modelo generador sintético: {e}")
         return None
     seed_examples = list(islice(original_dataset, 200))
     if not seed_examples:
-        logger.warning("Dataset original vacío, no se pueden generar datos sintéticos.")
         return None
     def synthetic_generator():
         for i in range(num_samples):
@@ -450,7 +445,6 @@ def _generate_synthetic_data(original_dataset, text_col, model_id, num_samples,
                     new_example[text_col] = cleaned_text
                     yield new_example
             except Exception as e:
-                logger.warning(f"Error generando una muestra sintética: {e}")
                 continue
     return IterableDataset.from_generator(synthetic_generator)
 
@@ -566,13 +560,12 @@ def _generic_model_loader(model_name_or_path, model_class, **kwargs):
             elif quantization_type == "8bit":
                 bnb_config = BitsAndBytesConfig(load_in_8bit=True)
         except ImportError:
-            logger.warning("bitsandbytes no está instalado. No se puede cargar en 4bit/8bit.")
+            logger.warning("bitsandbytes no está instalado.")
     elif quantization_type != "no" and device == "cpu":
-        logger.warning("La cuantización solo es compatible con GPU CUDA. Se procederá sin cuantización.")
+        logger.warning("La cuantización solo es compatible con GPU CUDA.")
     attn_implementation = kwargs.get('attn_implementation', 'eager')
     if attn_implementation == "flash_attention_2" and device != 'cuda':
         attn_implementation = "eager"
-        logger.warning("Flash Attention 2 solo está disponible en CUDA. Se usará la implementación 'eager'.")
     config_kwargs = {"trust_remote_code": True}
     if kwargs.get('label2id'):
         config_kwargs.update({"label2id": kwargs['label2id'], "id2label": kwargs['id2label']})
@@ -592,6 +585,8 @@ def _generic_model_loader(model_name_or_path, model_class, **kwargs):
     model = model_class.from_pretrained(model_name_or_path, **model_kwargs)
     if device == 'cpu' and hasattr(model, 'to'):
         model.to(device)
+    if quantization_type != "no" and device == "cuda":
+        model = prepare_model_for_kbit_training(model)
     return model
 
 @spaces.GPU()
@@ -605,7 +600,7 @@ def _find_all_linear_names(model, quantization_type):
             elif quantization_type == '8bit':
                 cls = bnb.nn.Linear8bitLt
         except ImportError:
-            logger.warning("bitsandbytes no está instalado. No se puede determinar los módulos cuantizados.")
+            pass
     lora_module_names = set()
     for name, module in model.named_modules():
         if isinstance(module, cls):
@@ -645,7 +640,6 @@ def _sft_formatting_func(example, text_col, tokenizer, **kwargs):
             try:
                 return tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=False)
             except Exception as e:
-                logger.error(f"Error aplicando la plantilla de chat: {e}.")
                 return "\n".join([m['content'] for m in messages])
         return ""
     return example.get(text_col, "")
@@ -683,44 +677,49 @@ def _evaluate_perplexity(model, tokenizer, eval_dataset, text_col):
 def _merge_multiple_loras(base_model_id, adapter_ids_str, weights_str, combination_type):
     adapter_ids = [s.strip() for s in adapter_ids_str.split(',') if s.strip()]
     if not adapter_ids:
-        yield "No se proporcionaron IDs de adaptadores válidos. Omitiendo la fusión múltiple."
+        yield "No se proporcionaron IDs de adaptadores válidos."
         return base_model_id
     try:
         weights = [float(w.strip()) for w in weights_str.split(',')]
     except:
         weights = [1.0] * len(adapter_ids)
-    if len(weights) != len(adapter_ids):
-        weights = [1.0] * len(adapter_ids)
-        yield "Pesos de adaptadores inválidos, usando 1.0 para todos."
-    yield f"Cargando modelo base {base_model_id} para fusión múltiple..."
+    yield f"Cargando modelo base {base_model_id}..."
     model = AutoModelForCausalLM.from_pretrained(base_model_id, torch_dtype=torch_dtype_auto, trust_remote_code=True, device_map=device)
-    for i, adapter_id in enumerate(adapter_ids):
-        yield f"Cargando adaptador {i+1}: {adapter_id}"
-        model.load_adapter(adapter_id, adapter_name=f"adapter_{i}")
-    adapter_names = [f"adapter_{i}" for i in range(len(adapter_ids))]
-    yield f"Combinando adaptadores: {adapter_names} con pesos: {weights} y tipo: {combination_type}"
-    model.add_weighted_adapter(adapters=adapter_names, weights=weights, adapter_name="combined", combination_type=combination_type)
-    model.set_adapter("combined")
-    yield "Fusionando combinación de adaptadores en el modelo base..."
-    merged_model = model.merge_and_unload()
+    try:
+        model = PeftModel.from_pretrained(model, adapter_ids[0])
+        for i, adapter_id in enumerate(adapter_ids[1:]):
+            model.load_adapter(adapter_id, adapter_name=f"adapter_{i+1}")
+        model.add_weighted_adapter(
+            adapters=[f"adapter_{i}" if i > 0 else "default" for i in range(len(adapter_ids))],
+            weights=weights,
+            adapter_name="merged",
+            combination_type=combination_type
+        )
+        model.set_adapter("merged")
+        model = model.merge_and_unload()
+    except Exception as e:
+        yield f"Error merging: {e}"
+        return base_model_id
     temp_dir = tempfile.mkdtemp()
-    yield f"Guardando modelo fusionado en {temp_dir}"
-    merged_model.save_pretrained(temp_dir)
+    yield f"Guardando fusionado en {temp_dir}"
+    model.save_pretrained(temp_dir)
     tokenizer = AutoTokenizer.from_pretrained(base_model_id)
     tokenizer.save_pretrained(temp_dir)
-    yield f"Fusión de adaptadores completada. El entrenamiento continuará con el modelo fusionado en {temp_dir}."
+    yield f"Listo. {temp_dir}"
     return temp_dir
 
 @spaces.GPU()
 def _run_trainer_and_upload(trainer, tokenizer, repo_id, update_logs_fn, model_card_content, **kwargs):
     yield update_logs_fn("Iniciando ciclo de entrenamiento...", "Entrenando")
+    trainer.add_callback(GradioLogCallback(lambda msg, phase: update_logs_fn(msg, phase)))
     trainer.train(resume_from_checkpoint=kwargs.get('resume_from_checkpoint') or False)
     final_metrics = {}
     if kwargs.get('run_evaluation'):
-        eval_logs = [log for log in trainer.state.log_history if 'eval_loss' in log]
-        if eval_logs:
-            final_metrics = eval_logs[-1]
-            final_metrics = {k.replace('eval_', ''): v for k, v in final_metrics.items()}
+        try:
+            metrics = trainer.evaluate()
+            final_metrics.update(metrics)
+        except Exception as e:
+            logger.warning(f"Error en evaluación final: {e}")
     yield update_logs_fn("Entrenamiento finalizado.", "Guardando")
     output_dir = trainer.args.output_dir
     trainer.save_model(output_dir)
@@ -752,7 +751,7 @@ def train_sft_dpo(model_name, train_dataset, repo_id, update_logs_fn, model_card
         peft_config = None
         if kwargs.get('peft'):
             target_modules = kwargs.get('target_modules').split(",") if not kwargs.get('auto_find_target_modules') else _find_all_linear_names(model, kwargs.get('quantization'))
-            yield update_logs_fn(f"Módulos LoRA detectados/especificados: {target_modules}", "Configuración")
+            yield update_logs_fn(f"Módulos LoRA: {target_modules}", "Configuración")
             peft_config = LoraConfig(
                 r=int(kwargs.get('lora_r')), lora_alpha=int(kwargs.get('lora_alpha')), lora_dropout=float(kwargs.get('lora_dropout')),
                 target_modules=target_modules, bias="none", task_type="CAUSAL_LM", use_dora=kwargs.get('use_dora', False),
@@ -764,10 +763,8 @@ def train_sft_dpo(model_name, train_dataset, repo_id, update_logs_fn, model_card
         if kwargs.get('run_evaluation'):
             eval_dataset_gen = _get_eval_dataset(kwargs.get('datasets_hf_text').split(","), kwargs.get('eval_dataset_hf'), kwargs.get('uploaded_val_data'), update_logs_fn)
             for update in eval_dataset_gen:
-                if isinstance(update, dict):
-                    yield update
-                else:
-                    eval_dataset = update
+                if isinstance(update, dict): yield update
+                else: eval_dataset = update
         TrainerClass = DPOTrainer if is_dpo else (DebiasingSFTTrainer if kwargs.get('enable_loss_reweighting') else SFTTrainer)
         trainer_kwargs = {"model": model, "args": training_args, "train_dataset": train_dataset, "eval_dataset": eval_dataset, "tokenizer": tokenizer, "peft_config": peft_config}
         if is_dpo:
@@ -810,10 +807,8 @@ def train_sequence_classification(model_name, train_dataset, repo_id, update_log
         if kwargs.get('run_evaluation'):
             eval_dataset_gen = _get_eval_dataset(kwargs.get('datasets_hf_text').split(","), kwargs.get('eval_dataset_hf'), kwargs.get('uploaded_val_data'), update_logs_fn)
             for update in eval_dataset_gen:
-                if isinstance(update, dict):
-                    yield update
-                else:
-                    eval_dataset = update
+                if isinstance(update, dict): yield update
+                else: eval_dataset = update
             if eval_dataset: eval_dataset = eval_dataset.map(preprocess, batched=True)
         metric = hf_evaluate.load("accuracy")
         def compute_metrics(eval_pred):
@@ -864,10 +859,8 @@ def train_token_classification(model_name, train_dataset, repo_id, update_logs_f
         if kwargs.get('run_evaluation'):
             eval_dataset_gen = _get_eval_dataset(kwargs.get('datasets_hf_text').split(","), kwargs.get('eval_dataset_hf'), kwargs.get('uploaded_val_data'), update_logs_fn)
             for update in eval_dataset_gen:
-                if isinstance(update, dict):
-                    yield update
-                else:
-                    eval_dataset = update
+                if isinstance(update, dict): yield update
+                else: eval_dataset = update
             if eval_dataset: eval_dataset = eval_dataset.map(tokenize_and_align_labels, batched=True)
         metric = hf_evaluate.load("seqeval")
         def compute_metrics(p):
@@ -950,10 +943,8 @@ def train_question_answering(model_name, train_dataset, repo_id, update_logs_fn,
             eval_dataset_raw_gen = _get_eval_dataset(kwargs.get('datasets_hf_text').split(","), kwargs.get('eval_dataset_hf'), kwargs.get('uploaded_val_data'), update_logs_fn)
             eval_dataset_raw = None
             for update in eval_dataset_raw_gen:
-                if isinstance(update, dict):
-                    yield update
-                else:
-                    eval_dataset_raw = update
+                if isinstance(update, dict): yield update
+                else: eval_dataset_raw = update
             if eval_dataset_raw:
                 eval_dataset = eval_dataset_raw.map(prepare_train_features, batched=True, remove_columns=next(iter(eval_dataset_raw)).keys())
         training_args = _create_training_args(output_dir, repo_id, **kwargs)
@@ -989,10 +980,8 @@ def train_seq2seq(model_name, train_dataset, repo_id, update_logs_fn, model_card
         if kwargs.get('run_evaluation'):
             eval_dataset_gen = _get_eval_dataset(kwargs.get('datasets_hf_text').split(","), kwargs.get('eval_dataset_hf'), kwargs.get('uploaded_val_data'), update_logs_fn)
             for update in eval_dataset_gen:
-                if isinstance(update, dict):
-                    yield update
-                else:
-                    eval_dataset = update
+                if isinstance(update, dict): yield update
+                else: eval_dataset = update
             if eval_dataset: eval_dataset = eval_dataset.map(preprocess_function, batched=True)
         metric = hf_evaluate.load("sacrebleu")
         def compute_metrics(eval_preds):
@@ -1643,23 +1632,23 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue")) as demo:
                         scheduler = gr.Dropdown(["cosine", "linear", "constant"], label="Planificador LR", value="cosine")
                         mixed_precision = gr.Radio(["no", "fp16", "bf16"], label="Precisión Mixta", value="no")
                     with gr.Accordion("Avanzados", open=False):
-                         warmup_ratio = gr.Slider(0.0, 0.5, 0.03, label="Ratio de Calentamiento")
-                         weight_decay = gr.Textbox(label="Decaimiento de Peso", value="0.01")
-                         max_grad_norm = gr.Textbox(label="Norma Máxima de Gradiente", value="1.0")
-                         logging_steps = gr.Textbox(label="Pasos de Registro", value="10")
-                         save_steps = gr.Textbox(label="Pasos de Guardado", value="50")
-                         save_total_limit = gr.Textbox(label="Límite Total de Guardado", value="1")
-                         early_stopping_patience = gr.Number(label="Paciencia para Early Stopping (0 para desactivar)", value=0)
-                         resume_from_checkpoint = gr.Checkbox(label="Reanudar desde Checkpoint", value=False)
-                         with gr.Row():
+                          warmup_ratio = gr.Slider(0.0, 0.5, 0.03, label="Ratio de Calentamiento")
+                          weight_decay = gr.Textbox(label="Decaimiento de Peso", value="0.01")
+                          max_grad_norm = gr.Textbox(label="Norma Máxima de Gradiente", value="1.0")
+                          logging_steps = gr.Textbox(label="Pasos de Registro", value="10")
+                          save_steps = gr.Textbox(label="Pasos de Guardado", value="50")
+                          save_total_limit = gr.Textbox(label="Límite Total de Guardado", value="1")
+                          early_stopping_patience = gr.Number(label="Paciencia para Early Stopping (0 para desactivar)", value=0)
+                          resume_from_checkpoint = gr.Checkbox(label="Reanudar desde Checkpoint", value=False)
+                          with gr.Row():
                             adam_beta1 = gr.Textbox(label="Adam Beta1", value="0.9")
                             adam_beta2 = gr.Textbox(label="Adam Beta2", value="0.999")
                             adam_epsilon = gr.Textbox(label="Adam Epsilon", value="1e-8")
-                         disable_gradient_checkpointing = gr.Checkbox(label="Deshabilitar Gradient Checkpointing", value=False)
-                         group_by_length = gr.Checkbox(label="Agrupar por Longitud", value=False)
-                         neftune_noise_alpha = gr.Textbox(label="NEFTune Ruido Alfa (0 para desactivar)", value="0")
-                         optim_args = gr.Textbox(label="Argumentos del Optimizador (formato dict)", placeholder="ej: betas=(0.9,0.995)")
-                         attn_implementation = gr.Dropdown(["eager", "flash_attention_2"], label="Implementación de Atención", value="eager")
+                          disable_gradient_checkpointing = gr.Checkbox(label="Deshabilitar Gradient Checkpointing", value=False)
+                          group_by_length = gr.Checkbox(label="Agrupar por Longitud", value=False)
+                          neftune_noise_alpha = gr.Textbox(label="NEFTune Ruido Alfa (0 para desactivar)", value="0")
+                          optim_args = gr.Textbox(label="Argumentos del Optimizador (formato dict)", placeholder="ej: betas=(0.9,0.995)")
+                          attn_implementation = gr.Dropdown(["eager", "flash_attention_2"], label="Implementación de Atención", value="eager")
                 with gr.Accordion("🦋 PEFT (LoRA / QLoRA)", open=True) as peft_accordion:
                     peft = gr.Checkbox(label="Habilitar PEFT/LoRA", value=True)
                     quantization = gr.Dropdown(["no", "4bit", "8bit"], label="Cuantización", value="no")
@@ -1842,52 +1831,6 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue")) as demo:
             inputs=[inf_task_mode, inf_model_id, inf_text_in, inf_context_in, inf_image_in, inf_audio_in, inf_temperature, inf_top_p, inf_max_new_tokens],
             outputs=[inf_text_out, inf_model_id, inf_text_in, inf_context_in, inf_image_in, inf_audio_in]
         )
-    with gr.Tab("5. Explicación del Código y Mecanismos Avanzados"):
-        gr.Markdown("""
-### 🧠 Explicación del Código y Mecanismos Avanzados
-""")
-        gr.Markdown("#### 1. CORE MECHANISMS")
-        gr.Markdown("""
-* **PEFT/LoRA**: Parameter-Efficient Fine-Tuning. Only low-rank matrices ($A$ and $B$) are trained for low-rank updates ($W' = W + B A$). This drastically reduces trainable parameters.
-* **QLoRA (4-bit)**: Loads the base model weights in 4-bit precision (NF4 with double quantization) using `bitsandbytes`, massively reducing VRAM usage while training LoRA adapters.
-* **Accelerator**: Manages device placement (CPU/GPU), mixed precision (`fp16`/`bf16`), and gradient accumulation for stable large-batch training simulation.
-* **Early Stopping**: Halts training if validation loss doesn't improve over a set number of steps (`early_stopping_patience`).
-* **Gradient Accumulation**: Simulates larger batch sizes by accumulating gradients over several forward/backward passes before an optimization step.
-* **Gradient Clipping**: Limits the maximum norm of the gradients (`max_grad_norm`) to prevent exploding gradients during training.
-* **Memory Optimization**: Optional use of `xFormers` (FlashAttention or memory-efficient attention) to reduce memory footprint and speed up training on compatible GPUs.
-""")
-        gr.Markdown("#### 2. DATA PROCESSING & AUGMENTATION")
-        gr.Markdown("""
-* **Streaming Datasets**: Uses `datasets` streaming mode to handle very large datasets without loading all into RAM.
-* **Data Cleaning**: Removes HTML tags, normalizes whitespace, redacts PII, and removes URLs/emails.
-* **Advanced Filtering**: Includes optional filters for text length, word repetition, language detection, and basic toxicity detection (via `unitary/toxic-bert`).
-* **Data Augmentation**: Supports **Back-Translation (BT)** for introducing paraphrasing variations and **Counterfactual Data Augmentation (CDA)** for controlled bias testing (e.g., swapping gendered pronouns).
-* **Synthetic Data Generation**: Uses a specified LLM to generate new training examples based on an initial prompt template.
-* **Deduplication**: Implements both **Exact** and **Semantic (MinHash LSH)** deduplication to prevent data contamination during iterative fine-tuning.
-""")
-        gr.Markdown("#### 3. TRAINING MODES")
-        gr.Markdown("""
-* **SFT (Supervised Fine-Tuning)**: Standard fine-tuning, supports **Conversation** and **Reasoning/Tool Use (CoT)** formatting styles.
-* **DPO (Direct Preference Optimization)**: Trains directly on preference pairs (chosen vs. rejected), using the `trl` library.
-* **Task-Specific Heads**: Supports **Sequence Classification**, **Token Classification (NER)**, and **Question Answering** by loading appropriate model heads (`AutoModelFor...`).
-* **Seq2Seq**: For translation/summarization tasks, using `Seq2SeqTrainer`.
-* **Diffusion (Text-to-Image/DreamBooth)**: Fine-tunes the UNet (and optionally Text Encoder) using LoRA for image generation tasks, with custom image/video data handling.
-""")
-        gr.Markdown("#### 4. MODEL INITIALIZATION")
-        gr.Markdown("""
-* **Model From Scratch**: Allows initializing a model (e.g., Llama, Mistral) from a config rather than a pre-trained checkpoint, with optional auto-configuration based on expected training scale.
-* **Multi-Adapter Merging**: Advanced feature to combine multiple existing LoRA adapters into a single, new adapter using weighted averaging (`slerp`, `linear`, etc.).
-""")
-        gr.Markdown("#### 5. OUTPUT & DEPLOYMENT")
-        gr.Markdown("""
-* **Hugging Face Hub Integration**: All trained artifacts (full model/LoRA adapter) are automatically pushed to a specified repository on the HF Hub using the provided token.
-* **Model Card Generation**: Automatically generates a `README.md` detailing training parameters and model provenance.
-* **Inference Tabs**: Separate UI for testing the trained LoRA adapter on CPU (for Gemma/LoRA) or various pipeline modes on GPU.
-""")
-        gr.Markdown("### 💡 Hardware Fallback")
-        gr.Markdown(f"If CUDA/GPU is unavailable, the system defaults to CPU: **{device.upper()}**. Training and inference on CPU will be significantly slower, especially for large models or Diffusers.")
 
 if __name__ == "__main__":
-    demo.queue().launch(debug=True, share=True)
-    # The line below caused the ValueError because streaming functions (using yield) require the queue to be enabled.
-    # demo.launch(debug=True, share=True)
+    demo.launch(debug=True, share=True)