Update app.py

app.py

@@ -1,7 +1,8 @@
 import os
+os.system("pip install spaces-0.1.0-py3-none-any.whl")
 os.system("pip install -U gradio")
 os.system("pip install -U bitsandbytes diffusers torchaudio torchvision torch transformers peft accelerate trl datasets")
-os.system("pip install spaces-0.1.0-py3-none-any.whl")
+os.system("pip install spaces")
 os.system("pip install gradio_huggingfacehub_search packaging torchao llmcompressor")
 
 import io
@@ -81,6 +82,7 @@ from llmcompressor.modifiers.awq import AWQModifier
 logger = logging.getLogger(__name__)
 torch_dtype_auto = torch.float32
 
+@spaces.GPU
 def _sanitize_model_name_for_yaml(model_name):
     name = model_name.split('/')[-1] if '/' in model_name else model_name
     sanitized = re.sub(r'[^a-zA-Z0-9\-_\.]', '-', name)
@@ -173,11 +175,13 @@ _tox_pipe_singleton = None
 
 @spaces.GPU
 class DebiasingSFTTrainer(SFTTrainer):
+    @spaces.GPU
     def __init__(self, *args, reweighting_terms=None, reweighting_factor=1.0, **kwargs):
         super().__init__(*args, **kwargs)
         self.reweighting_terms = [term.strip().lower() for term in reweighting_terms] if reweighting_terms else []
         self.reweighting_factor = reweighting_factor
 
+    @spaces.GPU
     def compute_loss(self, model, inputs, return_outputs=False):
         loss, outputs = super().compute_loss(model, inputs, return_outputs=True)
         if self.reweighting_terms and self.reweighting_factor > 1.0:
@@ -191,6 +195,7 @@ class DebiasingSFTTrainer(SFTTrainer):
 
 @spaces.GPU
 class DeduplicatedIterableDataset(IterableDataset):
+    @spaces.GPU
     def __init__(self, dataset, text_col, method, threshold=0.85, num_perm=128):
         super().__init__(ex_iterable=iter([]))
         self.dataset = dataset
@@ -203,6 +208,7 @@ class DeduplicatedIterableDataset(IterableDataset):
         elif hasattr(dataset, 'info'):
             self._info = dataset.info
 
+    @spaces.GPU
     def __iter__(self):
         if self.method == 'Exacta':
             return self._exact_iter()
@@ -211,6 +217,7 @@ class DeduplicatedIterableDataset(IterableDataset):
         else:
             return iter(self.dataset)
 
+    @spaces.GPU
     def _exact_iter(self):
         seen_texts = set()
         for example in self.dataset:
@@ -222,6 +229,7 @@ class DeduplicatedIterableDataset(IterableDataset):
             else:
                 yield example
 
+    @spaces.GPU
     def _minhash_iter(self):
         lsh = MinHashLSH(threshold=self.threshold, num_perm=self.num_perm)
         for i, example in enumerate(self.dataset):
@@ -355,6 +363,7 @@ def _get_filter_functions(**kwargs):
     if kwargs.get('enable_language_filter'):
         allowed_langs = [lang.strip() for lang in kwargs.get('allowed_languages', 'en').split(',')]
         lang_threshold = kwargs.get('language_detection_threshold', 0.95)
+        @spaces.GPU
         def lang_filter(ex):
             text = ex.get(kwargs['text_col'], "")
             if not text or not isinstance(text, str) or len(text.split()) < 5: return True
@@ -366,6 +375,7 @@ def _get_filter_functions(**kwargs):
         filters.append(lang_filter)
     if kwargs.get('enable_toxicity_filter'):
         tox_threshold = kwargs.get('toxicity_threshold', 0.8)
+        @spaces.GPU
         def tox_filter(ex):
             global _tox_pipe_singleton
             if _tox_pipe_singleton is None:
@@ -386,6 +396,7 @@ def _get_filter_functions(**kwargs):
         filters.append(lambda ex: _apply_coherence_filter(ex, kwargs['text_col'], char_rep_thresh, ngram_rep_thresh, entropy_thresh))
     if any([kwargs.get('enable_readability_filter'), kwargs.get('enable_stopword_filter'), kwargs.get('enable_uniqueness_filter')]):
         stop_words = set(['the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'of', 'with', 'by', 'from', 'as', 'is', 'was', 'are', 'were', 'be', 'been', 'being', 'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'should', 'could', 'can', 'may', 'might', 'must', 'this', 'that', 'these', 'those', 'i', 'you', 'he', 'she', 'it', 'we', 'they', 'what', 'which', 'who', 'when', 'where', 'why', 'how'])
+        @spaces.GPU
         def stats_filter(ex):
             text = ex.get(kwargs['text_col'], "")
             if not isinstance(text, str) or not text: return True
@@ -483,6 +494,7 @@ def _apply_cda(dataset, text_col, cda_config_str):
     except (json.JSONDecodeError, ValueError) as e:
         logger.error(f"Configuración de CDA inválida: {e}.")
         return dataset
+    @spaces.GPU
     def cda_generator():
         for example in dataset:
             original_text = example.get(text_col, "")
@@ -520,6 +532,7 @@ def _apply_back_translation(dataset, text_col, ratio, model_id, reverse_model_id
     except Exception as e:
         logger.error(f"No se pudieron cargar los modelos de traducción: {e}")
         return dataset
+    @spaces.GPU
     def bt_generator():
         for example in dataset:
             yield example
@@ -551,6 +564,7 @@ def _generate_synthetic_data(original_dataset, text_col, model_id, num_samples,
     if not seed_examples:
         logger.warning("Dataset original vacío, no se pueden generar datos sintéticos.")
         return None
+    @spaces.GPU
     def synthetic_generator():
         for i in range(num_samples):
             seed_example = random.choice(seed_examples)
@@ -570,6 +584,7 @@ def _generate_synthetic_data(original_dataset, text_col, model_id, num_samples,
                 continue
     return IterableDataset.from_generator(synthetic_generator)
 
+@spaces.GPU
 def _calculate_auto_config(block_size, is_gpt2_like, steps_per_epoch_estimate, batch_size, gradient_accumulation):
     safe_steps = int(steps_per_epoch_estimate or 10000)
     safe_batch_size = int(batch_size or 1)
@@ -610,6 +625,7 @@ def _get_eval_dataset(train_ds_id, eval_ds_id, uploaded_val_data, update_logs_fn
     yield update_logs_fn("No se proporcionó dataset de evaluación. Omitiendo.", "Evaluación")
     return None
 
+@spaces.GPU
 def _create_training_args(output_dir, repo_id, **kwargs):
     neftune_alpha = float(kwargs.get('neftune_noise_alpha', 0.0))
     optim_args_dict = {}
@@ -876,6 +892,7 @@ def train_sequence_classification(model_name, train_dataset, repo_id, update_log
         yield update_logs_fn(f"Cargando modelo '{model_name}'...", "Configuración")
         model = _generic_model_loader(model_name, AutoModelForSequenceClassification, num_labels=len(labels), label2id=label2id, id2label=id2label, **kwargs)
         model.config.pad_token_id = tokenizer.pad_token_id
+        @spaces.GPU
         def preprocess(examples):
             return tokenizer(examples[kwargs['text_col']], truncation=True, max_length=512)
         train_dataset = train_dataset.map(preprocess, batched=True)
@@ -889,6 +906,7 @@ def train_sequence_classification(model_name, train_dataset, repo_id, update_log
                     eval_dataset = update
             if eval_dataset: eval_dataset = eval_dataset.map(preprocess, batched=True)
         metric = hf_evaluate.load("accuracy")
+        @spaces.GPU
         def compute_metrics(eval_pred):
             logits, labels = eval_pred
             predictions = np.argmax(logits, axis=-1)
@@ -916,6 +934,7 @@ def train_token_classification(model_name, train_dataset, repo_id, update_logs_f
         tokenizer = AutoTokenizer.from_pretrained(tokenizer_id, trust_remote_code=True, add_prefix_space=True)
         yield update_logs_fn(f"Cargando modelo '{model_name}'...", "Configuración")
         model = _generic_model_loader(model_name, AutoModelForTokenClassification, num_labels=len(labels), label2id=label2id, id2label=id2label, **kwargs)
+        @spaces.GPU
         def tokenize_and_align_labels(examples):
             tokenized_inputs = tokenizer(examples["tokens"], truncation=True, is_split_into_words=True)
             labels = []
@@ -943,6 +962,7 @@ def train_token_classification(model_name, train_dataset, repo_id, update_logs_f
                     eval_dataset = update
             if eval_dataset: eval_dataset = eval_dataset.map(tokenize_and_align_labels, batched=True)
         metric = hf_evaluate.load("seqeval")
+        @spaces.GPU
         def compute_metrics(p):
             predictions, labels = p
             predictions = np.argmax(predictions, axis=2)
@@ -973,6 +993,7 @@ def train_question_answering(model_name, train_dataset, repo_id, update_logs_fn,
         model = _generic_model_loader(model_name, AutoModelForQuestionAnswering, **kwargs)
         max_length = 384
         doc_stride = 128
+        @spaces.GPU
         def prepare_train_features(examples):
             tokenized_examples = tokenizer(
                 examples["question"],
@@ -1049,6 +1070,7 @@ def train_seq2seq(model_name, train_dataset, repo_id, update_logs_fn, model_card
         tokenizer = AutoTokenizer.from_pretrained(tokenizer_id, trust_remote_code=True)
         yield update_logs_fn(f"Cargando modelo '{model_name}'...", "Configuración")
         model = _generic_model_loader(model_name, AutoModelForSeq2SeqLM, **kwargs)
+        @spaces.GPU
         def preprocess_function(examples):
             inputs = [ex[kwargs['text_col']] for ex in examples["translation"]]
             targets = [ex[kwargs['label_col']] for ex in examples["translation"]]
@@ -1068,6 +1090,7 @@ def train_seq2seq(model_name, train_dataset, repo_id, update_logs_fn, model_card
                     eval_dataset = update
             if eval_dataset: eval_dataset = eval_dataset.map(preprocess_function, batched=True)
         metric = hf_evaluate.load("sacrebleu")
+        @spaces.GPU
         def compute_metrics(eval_preds):
             preds, labels = eval_preds
             if isinstance(preds, tuple): preds = preds[0]
@@ -1125,6 +1148,7 @@ def train_text_to_image(model_name, train_dataset, repo_id, update_logs, model_c
             transforms.ToTensor(),
             transforms.Normalize([0.5], [0.5]),
         ])
+        @spaces.GPU
         def preprocess_train(examples):
             images = [image.convert("RGB") for image in examples[image_col]]
             examples["pixel_values"] = [image_transforms(image) for image in images]
@@ -1500,6 +1524,7 @@ def run_inference(task_mode, model_id, text_in, context_in, image_in, audio_in,
         return f"Resultado:\n\n{json.dumps(result, indent=2, ensure_ascii=False)}", model_id, gr.update(), gr.update(), gr.update(), gr.update()
     except Exception as e: return f"Error en Inferencia: {e}\n{traceback.format_exc()}", model_id, gr.update(), gr.update(), gr.update(), gr.update()
 
+@spaces.GPU
 def update_inference_ui(task_mode):
     task_name = TASK_TO_PIPELINE_MAP.get(task_mode, "")
     is_text_gen = task_name == "text-generation"
@@ -1625,6 +1650,7 @@ def gradio_preview_data_wrapper(*args):
     except Exception as e:
         yield f"Error al generar la vista previa: {e}\n{traceback.format_exc()}"
 
+@spaces.GPU
 def toggle_training_mode_ui(is_scratch):
     return (
         gr.update(visible=not is_scratch), 
@@ -1647,6 +1673,7 @@ def toggle_training_mode_ui(is_scratch):
         gr.update(visible=is_scratch),   
     )
 
+@spaces.GPU
 def toggle_task_specific_ui(training_mode):
     is_classification = "Classification" in training_mode
     is_dpo = "DPO" in training_mode
@@ -1661,17 +1688,21 @@ def toggle_task_specific_ui(training_mode):
         gr.update(visible=not is_diffusion)
     )
 
+@spaces.GPU
 def toggle_sft_format_ui(format_style):
     is_tool = format_style == "Razonamiento/Herramientas"
     return gr.update(visible=is_tool)
 
+@spaces.GPU
 def toggle_auto_modules_ui(is_auto):
     return gr.update(visible=not is_auto)
 
+@spaces.GPU
 def toggle_dataset_creator_ui(choice):
     is_synth = choice == "Sintético"
     return gr.update(visible=is_synth), gr.update(visible=not is_synth)
 
+@spaces.GPU
 def get_ao_username(token):
     try:
         api = HfApi(token=token)
@@ -1680,6 +1711,7 @@ def get_ao_username(token):
     except Exception:
         return "anonymous"
 
+@spaces.GPU
 def check_ao_model_exists(username, quantization_type, group_size, model_name, quantized_model_name, token):
     try:
         models = list_models(author=username, token=token)
@@ -1698,6 +1730,7 @@ def check_ao_model_exists(username, quantization_type, group_size, model_name, q
     except Exception as e:
         return f"Error checking model existence: {str(e)}"
 
+@spaces.GPU
 def create_ao_model_card(model_name, quantization_type, group_size, token):
     try:
         model_path = snapshot_download(repo_id=model_name, allow_patterns=["README.md"], repo_type="model", token=token)
@@ -1726,6 +1759,7 @@ tags:
         yaml_header += "\n\n# 📄 Original Model Info\n\n" + original_readme
     return yaml_header
 
+@spaces.GPU
 def quantize_ao_model(model_name, quantization_type, group_size=128, token=None, progress=gr.Progress()):
     print(f"Quantizing model: {quantization_type}")
     progress(0, desc="Preparing Quantization")
@@ -1753,6 +1787,7 @@ def quantize_ao_model(model_name, quantization_type, group_size=128, token=None,
     progress(0.45, desc="Quantization completed")
     return model
 
+@spaces.GPU
 def save_ao_model(model, model_name, quantization_type, group_size=128, quantized_model_name=None, public=True, token=None, progress=gr.Progress()):
     username = get_ao_username(token)
     progress(0.50, desc="Preparing to push")
@@ -1814,6 +1849,7 @@ def quantize_and_save_ao(model_name, quantization_type, group_size, quantized_mo
     except Exception as e:
         return f"<div class='error-box'><h3>❌ Error</h3><p>{str(e)}</p></div>"
 
+@spaces.GPU
 def get_awq_default_repo_name(model_id: str, scheme: str) -> str:
     if not model_id or not scheme:
         return ""
@@ -2337,4 +2373,4 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue")) as demo:
 """)
 
 if __name__ == "__main__":
-    demo.queue(max_size=1).launch()
+    demo.queue().launch(debug=True, share=True)