Update app.py

app.py

@@ -48,20 +48,20 @@ class ComparadorSentimientos:
 
     def _cargar_modelos(self):
         """Carga ambos modelos una sola vez al inicio."""
-        print("🚀 Cargando modelos de análisis de sentimiento...")
+        print("Cargando modelos de analisis de sentimiento...")
 
         for nombre, modelo_path in MODELOS.items():
-            print(f"  📥 Cargando {nombre}: {modelo_path}")
+            print(f"  Cargando {nombre}: {modelo_path}")
             try:
                 self.modelos[nombre] = pipeline(
                     "sentiment-analysis", model=modelo_path, return_all_scores=False
                 )
-                print(f"  ✅ {nombre} cargado exitosamente")
+                print(f"  {nombre} cargado exitosamente")
             except Exception as e:
-                print(f"  ❌ Error cargando {nombre}: {str(e)}")
+                print(f"  Error cargando {nombre}: {str(e)}")
                 self.modelos[nombre] = None
 
-        print("🎉 Modelos cargados!\n")
+        print("Modelos cargados!\n")
 
     def extraer_texto_web(self, url: str) -> str:
         """
@@ -85,7 +85,7 @@ class ComparadorSentimientos:
             return "❌ URL inválida"
 
         try:
-            print(f"🌐 Extrayendo texto de: {url}")
+            print(f"Extrayendo texto de: {url}")
 
             # Headers para evitar bloqueos
             headers = {
@@ -115,21 +115,77 @@ class ComparadorSentimientos:
             if len(texto_limpio) > 5000:
                 texto_limpio = texto_limpio[:5000] + "..."
 
-            print(f"✅ Texto extraído: {len(texto_limpio)} caracteres")
+            print(f"Texto extraido: {len(texto_limpio)} caracteres")
             return texto_limpio
 
         except requests.exceptions.Timeout:
-            return "❌ Timeout: La página tardó demasiado en responder"
+            return "ERROR: Timeout - La pagina tardo demasiado en responder"
         except requests.exceptions.ConnectionError:
-            return "❌ Error de conexión: Verifica la URL"
+            return "ERROR: Error de conexion - Verifica la URL"
         except requests.exceptions.HTTPError as e:
-            return f"❌ Error HTTP: {e}"
+            return f"ERROR: Error HTTP: {e}"
         except Exception as e:
-            return f"❌ Error inesperado: {str(e)}"
+            return f"ERROR: Error inesperado: {str(e)}"
+
+    def _chunk_text(self, texto: str, max_tokens: int = 400) -> list:
+        """
+        Divide texto largo en chunks más pequeños.
+
+        Args:
+            texto: Texto a dividir
+            max_tokens: Máximo tokens por chunk (aproximado)
+
+        Returns:
+            Lista de chunks de texto
+        """
+        # Aproximación: ~4 caracteres por token
+        max_chars = max_tokens * 4
+
+        if len(texto) <= max_chars:
+            return [texto]
+
+        # Dividir por oraciones para mantener contexto
+        oraciones = texto.split(".")
+        chunks = []
+        chunk_actual = ""
+
+        for oracion in oraciones:
+            oracion = oracion.strip() + "."
+
+            # Si agregar esta oración supera el límite, guardar chunk actual
+            if len(chunk_actual) + len(oracion) > max_chars and chunk_actual:
+                chunks.append(chunk_actual.strip())
+                chunk_actual = oracion
+            else:
+                chunk_actual += oracion
+
+        # Agregar último chunk
+        if chunk_actual:
+            chunks.append(chunk_actual.strip())
+
+        return chunks
+
+    def _analizar_chunk(self, modelo, chunk: str) -> Optional[Dict]:
+        """
+        Analiza un chunk individual de texto.
+
+        Args:
+            modelo: Pipeline de transformers
+            chunk: Chunk de texto a analizar
+
+        Returns:
+            Resultado del análisis o None si hay error
+        """
+        try:
+            resultado = modelo(chunk)[0]
+            return {"label": resultado["label"], "score": resultado["score"]}
+        except Exception as e:
+            print(f"Error analizando chunk: {str(e)}")
+            return None
 
     def analizar_texto(self, texto: str) -> Dict[str, Dict[str, float]]:
         """
-        Analiza el sentimiento usando ambos modelos.
+        Analiza el sentimiento usando ambos modelos con chunking para textos largos.
 
         Args:
             texto: Texto a analizar
@@ -146,6 +202,12 @@ class ComparadorSentimientos:
 
         resultados = {}
 
+        # Límites de tokens para cada modelo
+        limites_tokens = {
+            "RoBERTuito": 400,  # Más conservador que 512
+            "BETO": 100,  # Más conservador que 128
+        }
+
         for nombre_modelo, modelo in self.modelos.items():
             if modelo is None:
                 resultados[nombre_modelo] = {"Error": 1.0}
@@ -153,17 +215,49 @@ class ComparadorSentimientos:
 
             try:
                 inicio = time.time()
-                resultado = modelo(texto)[0]
+
+                # Dividir texto en chunks según límite del modelo
+                chunks = self._chunk_text(texto, limites_tokens[nombre_modelo])
+
+                print(f"Procesando {len(chunks)} chunks con {nombre_modelo}")
+
+                # Analizar cada chunk
+                resultados_chunks = []
+                for i, chunk in enumerate(chunks):
+                    resultado = self._analizar_chunk(modelo, chunk)
+                    if resultado:
+                        resultados_chunks.append(resultado)
+
+                if not resultados_chunks:
+                    resultados[nombre_modelo] = {
+                        "Error": 1.0,
+                        "_error": "No se pudo procesar ningún chunk",
+                    }
+                    continue
+
+                # Combinar resultados (votación mayoritaria + promedio de confianza)
+                votos = {"POS": 0, "NEG": 0, "NEU": 0}
+                suma_confianza = 0
+
+                for resultado in resultados_chunks:
+                    votos[resultado["label"]] += 1
+                    suma_confianza += resultado["score"]
+
+                # Determinar etiqueta ganadora
+                etiqueta_ganadora = max(votos, key=votos.get)
+                confianza_promedio = suma_confianza / len(resultados_chunks)
+
                 tiempo = time.time() - inicio
 
                 # Convertir etiqueta a español
-                etiqueta_original = resultado["label"]
-                etiqueta_es = ETIQUETAS_ES.get(etiqueta_original, etiqueta_original)
+                etiqueta_es = ETIQUETAS_ES.get(etiqueta_ganadora, etiqueta_ganadora)
 
                 resultados[nombre_modelo] = {
-                    etiqueta_es: round(resultado["score"], 4),
+                    etiqueta_es: round(confianza_promedio, 4),
                     "_tiempo": round(tiempo, 3),
-                    "_confianza": round(resultado["score"], 4),
+                    "_confianza": round(confianza_promedio, 4),
+                    "_chunks_procesados": len(resultados_chunks),
+                    "_total_chunks": len(chunks),
                 }
 
             except Exception as e:
@@ -193,28 +287,32 @@ def analizar_sentimiento(texto: str) -> Tuple[str, str]:
     beto_text = ""
 
     if "error" in resultados:
-        robertuito_text = f"❌ {resultados['error']}"
-        beto_text = f"❌ {resultados['error']}"
+        robertuito_text = f"ERROR: {resultados['error']}"
+        beto_text = f"ERROR: {resultados['error']}"
     else:
         # RoBERTuito
         robertuito = resultados.get("RoBERTuito", {"Error": 1.0})
         if "Error" in robertuito:
-            robertuito_text = "❌ Error en RoBERTuito"
+            robertuito_text = "ERROR en RoBERTuito"
         else:
             etiqueta = list(robertuito.keys())[0]
             confianza = robertuito[etiqueta]
             tiempo = robertuito.get("_tiempo", 0)
-            robertuito_text = f"🎯 {etiqueta}: {confianza:.1%} ({tiempo:.2f}s)"
+            chunks = robertuito.get("_chunks_procesados", 1)
+            total_chunks = robertuito.get("_total_chunks", 1)
+            robertuito_text = f"-> {etiqueta}: {confianza:.1%} ({tiempo:.2f}s, {chunks}/{total_chunks} chunks)"
 
         # BETO
         beto = resultados.get("BETO", {"Error": 1.0})
         if "Error" in beto:
-            beto_text = "❌ Error en BETO"
+            beto_text = "ERROR en BETO"
         else:
             etiqueta = list(beto.keys())[0]
             confianza = beto[etiqueta]
             tiempo = beto.get("_tiempo", 0)
-            beto_text = f"🎯 {etiqueta}: {confianza:.1%} ({tiempo:.2f}s)"
+            chunks = beto.get("_chunks_procesados", 1)
+            total_chunks = beto.get("_total_chunks", 1)
+            beto_text = f"-> {etiqueta}: {confianza:.1%} ({tiempo:.2f}s, {chunks}/{total_chunks} chunks)"
 
     return robertuito_text, beto_text
 
@@ -484,7 +582,7 @@ with gr.Blocks(
 
 # Punto de entrada
 if __name__ == "__main__":
-    print("🚀 Iniciando aplicación de comparación de modelos...")
+    print("Iniciando aplicacion de comparacion de modelos...")
     demo.launch(
         server_name="0.0.0.0",  # Para Hugging Face Spaces
         server_port=7860,