Upload 2 files

app.py

@@ -0,0 +1,402 @@
+import gradio as gr
+import pandas as pd
+import spacy
+from textblob import TextBlob
+from transformers import pipeline
+import torch
+from io import BytesIO
+import numpy as np
+
+# Cargar modelos
+print("⏳ Cargando modelos...")
+
+# 1. Cargar modelo de spaCy para español
+try:
+    nlp = spacy.load("es_core_news_sm")
+    print("✅ Modelo spaCy cargado correctamente")
+except OSError:
+    print("❌ Modelo spaCy no encontrado. Usando análisis básico...")
+    nlp = None
+
+# 2. Cargar múltiples modelos de sentimiento
+models = {}
+
+# Modelo multilingüe principal
+try:
+    models['multilingual'] = pipeline(
+        "text-classification", 
+        model="tabularisai/multilingual-sentiment-analysis"
+    )
+    print("✅ Modelo multilingüe cargado")
+except Exception as e:
+    print(f"❌ Error con modelo multilingüe: {e}")
+    models['multilingual'] = None
+
+# Modelo BERT para sentimiento detallado
+try:
+    models['bert'] = pipeline(
+        "sentiment-analysis",
+        model="nlptown/bert-base-multilingual-uncased-sentiment",
+        tokenizer="nlptown/bert-base-multilingual-uncased-sentiment"
+    )
+    print("✅ Modelo BERT cargado")
+except Exception as e:
+    print(f"❌ Error con modelo BERT: {e}")
+    models['bert'] = None
+
+# Diccionario léxico mejorado para español
+palabras_positivas = {
+    'bueno', 'excelente', 'fantástico', 'maravilloso', 'perfecto', 'genial',
+    'increíble', 'amo', 'encanta', 'feliz', 'contento', 'satisfecho', 'agradable',
+    'recomiendo', 'magnífico', 'extraordinario', 'asombroso', 'increíble', 'estupendo',
+    'fabril', 'perfectamente', 'óptimo', 'superior', 'mejor', 'inmejorable', 'ideal'
+}
+
+palabras_negativas = {
+    'malo', 'terrible', 'horrible', 'pésimo', 'odio', 'decepcionado', 'fatal',
+    'triste', 'enojado', 'frustrado', 'pobre', 'deficiente', 'desastroso',
+    'insatisfecho', 'decepcionante', 'horroroso', 'desastroso', 'pésimo', 'malísimo',
+    'inútil', 'defectuoso', 'deplorable', 'lamentable', 'desagradable', 'terrible'
+}
+
+def analizar_sentimiento_multimodelo(texto):
+    """Combina múltiples métodos para análisis más preciso"""
+    resultados = {}
+    
+    # Método 1: Modelo multilingüe principal
+    if models['multilingual']:
+        try:
+            resultado = models['multilingual'](texto)[0]
+            resultados['multilingual'] = {
+                'label': resultado['label'],
+                'score': resultado['score'],
+                'normalized_score': resultado['score'] if resultado['label'] == 'POSITIVE' else -resultado['score']
+            }
+        except Exception as e:
+            resultados['multilingual'] = {'error': str(e)}
+    
+    # Método 2: Modelo BERT con estrellas
+    if models['bert']:
+        try:
+            resultado = models['bert'](texto)[0]
+            # Convertir estrellas a puntuación -1 a 1
+            star_mapping = {
+                '1 star': -1.0, '2 stars': -0.5, '3 stars': 0.0,
+                '4 stars': 0.5, '5 stars': 1.0
+            }
+            normalized_score = star_mapping.get(resultado['label'], 0.0)
+            resultados['bert'] = {
+                'label': resultado['label'],
+                'score': resultado['score'],
+                'normalized_score': normalized_score
+            }
+        except Exception as e:
+            resultados['bert'] = {'error': str(e)}
+    
+    # Método 3: Análisis léxico mejorado
+    if nlp:
+        try:
+            doc = nlp(texto.lower())
+            palabras = [token.lemma_ for token in doc if token.is_alpha and len(token.text) > 2]
+            
+            positivas = sum(1 for palabra in palabras if palabra in palabras_positivas)
+            negativas = sum(1 for palabra in palabras if palabra in palabras_negativas)
+            
+            total_relevantes = len(palabras)
+            if total_relevantes > 0:
+                polaridad = (positivas - negativas) / total_relevantes
+                # Normalizar a -1 a 1
+                polaridad = max(-1.0, min(1.0, polaridad * 5))
+            else:
+                polaridad = 0.0
+            
+            resultados['lexico'] = {
+                'positivas': positivas,
+                'negativas': negativas,
+                'total_palabras': total_relevantes,
+                'normalized_score': polaridad
+            }
+        except Exception as e:
+            resultados['lexico'] = {'error': str(e)}
+    
+    # Método 4: TextBlob (para inglés y español básico)
+    try:
+        blob = TextBlob(texto)
+        polaridad = blob.sentiment.polarity
+        resultados['textblob'] = {
+            'polarity': polaridad,
+            'subjectivity': blob.sentiment.subjectivity,
+            'normalized_score': polaridad
+        }
+    except Exception as e:
+        resultados['textblob'] = {'error': str(e)}
+    
+    return resultados
+
+def determinar_sentimiento_final(resultados):
+    """Combina resultados de todos los métodos"""
+    scores = []
+    pesos = {'multilingual': 0.4, 'bert': 0.3, 'lexico': 0.2, 'textblob': 0.1}
+    
+    for metodo, peso in pesos.items():
+        if metodo in resultados and 'normalized_score' in resultados[metodo]:
+            scores.append(resultados[metodo]['normalized_score'] * peso)
+    
+    if scores:
+        score_final = sum(scores)
+        
+        if score_final > 0.2:
+            return "😊 POSITIVO", score_final, "green"
+        elif score_final < -0.2:
+            return "😠 NEGATIVO", score_final, "red"
+        else:
+            return "😐 NEUTRO", score_final, "gray"
+    else:
+        return "❓ INDETERMINADO", 0.0, "orange"
+
+def analizar_lingüistica(texto):
+    """Análisis lingüístico con spaCy"""
+    if not nlp:
+        return {"error": "Modelo spaCy no disponible"}
+    
+    doc = nlp(texto)
+    
+    analisis = {
+        'estadisticas': {
+            'total_tokens': len(doc),
+            'total_palabras': len([token for token in doc if token.is_alpha]),
+            'total_oraciones': len(list(doc.sents)),
+            'total_entidades': len(doc.ents)
+        },
+        'tokens': [],
+        'entidades': [],
+        'oraciones': [sent.text for sent in doc.sents]
+    }
+    
+    # Análisis de tokens
+    for token in doc[:20]:  # Mostrar solo primeros 20 tokens
+        analisis['tokens'].append({
+            'texto': token.text,
+            'lemma': token.lemma_,
+            'POS': token.pos_,
+            'explicacion': spacy.explain(token.pos_) or ''
+        })
+    
+    # Entidades nombradas
+    for ent in doc.ents[:10]:  # Mostrar solo primeras 10 entidades
+        analisis['entidades'].append({
+            'texto': ent.text,
+            'tipo': ent.label_,
+            'explicacion': spacy.explain(ent.label_) or ''
+        })
+    
+    return analisis
+
+def analizar_texto_completo(texto):
+    """Función principal que combina todo el análisis"""
+    if not texto.strip():
+        return "❌ Por favor ingresa un texto para analizar", "", ""
+    
+    # Análisis de sentimiento
+    resultados = analizar_sentimiento_multimodelo(texto)
+    sentimiento_final, score_final, color = determinar_sentimiento_final(resultados)
+    
+    # Análisis lingüístico
+    analisis_ling = analizar_lingüistica(texto)
+    
+    # Crear resumen de resultados
+    resumen_html = f"""
+    <div style='background-color: {color}20; padding: 20px; border-radius: 10px; border-left: 5px solid {color};'>
+        <h2 style='margin: 0; color: {color};'>{sentimiento_final}</h2>
+        <p style='margin: 5px 0;'><strong>Puntuación final:</strong> {score_final:.3f}</p>
+        <p style='margin: 5px 0;'><strong>Longitud del texto:</strong> {len(texto)} caracteres</p>
+    </div>
+    """
+    
+    # Detalles por método
+    detalles_html = "<h3>📊 Resultados por Método:</h3>"
+    for metodo, resultado in resultados.items():
+        detalles_html += f"<div style='margin-bottom: 15px;'>"
+        detalles_html += f"<strong>{metodo.upper()}:</strong><br>"
+        
+        if 'error' in resultado:
+            detalles_html += f"<span style='color: red;'>Error: {resultado['error']}</span>"
+        else:
+            if 'label' in resultado:
+                detalles_html += f"Etiqueta: {resultado['label']}<br>"
+            if 'score' in resultado:
+                detalles_html += f"Confianza: {resultado['score']:.3f}<br>"
+            if 'normalized_score' in resultado:
+                detalles_html += f"Puntuación: {resultado['normalized_score']:.3f}<br>"
+            if 'positivas' in resultado:
+                detalles_html += f"Palabras positivas: {resultado['positivas']}<br>"
+                detalles_html += f"Palabras negativas: {resultado['negativas']}<br>"
+        
+        detalles_html += "</div>"
+    
+    # Análisis lingüístico
+    ling_html = "<h3>📝 Análisis Lingüístico:</h3>"
+    if 'error' in analisis_ling:
+        ling_html += f"<p style='color: red;'>{analisis_ling['error']}</p>"
+    else:
+        stats = analisis_ling['estadisticas']
+        ling_html += f"""
+        <p><strong>Estadísticas:</strong></p>
+        <ul>
+            <li>Total de tokens: {stats['total_tokens']}</li>
+            <li>Palabras: {stats['total_palabras']}</li>
+            <li>Oraciones: {stats['total_oraciones']}</li>
+            <li>Entidades: {stats['total_entidades']}</li>
+        </ul>
+        """
+        
+        if analisis_ling['entidades']:
+            ling_html += "<p><strong>Entidades detectadas:</strong></p>"
+            for ent in analisis_ling['entidades']:
+                ling_html += f"• {ent['texto']} ({ent['tipo']})<br>"
+    
+    return resumen_html, detalles_html, ling_html
+
+def analizar_archivo_excel(archivo):
+    """Analizar archivo Excel con textos"""
+    try:
+        df = pd.read_excel(archivo)
+        
+        # Buscar columnas con texto
+        columnas_texto = []
+        for col in df.columns:
+            if df[col].dtype == 'object':
+                # Verificar si contiene texto
+                muestras = df[col].dropna()[:5]
+                if any(isinstance(x, str) and len(str(x).strip()) > 10 for x in muestras):
+                    columnas_texto.append(col)
+        
+        if not columnas_texto:
+            return pd.DataFrame({"Resultado": ["❌ No se encontraron columnas con texto suficiente para analizar"]})
+        
+        resultados = []
+        for col in columnas_texto[:2]:  # Analizar máximo 2 columnas
+            for idx, texto in enumerate(df[col].dropna()[:50]):  # Máximo 50 filas por columna
+                if isinstance(texto, str) and len(texto.strip()) > 5:
+                    resultado_sentimiento = analizar_sentimiento_multimodelo(texto)
+                    sentimiento, score, _ = determinar_sentimiento_final(resultado_sentimiento)
+                    
+                    resultados.append({
+                        'Columna': col,
+                        'Fila': idx + 1,
+                        'Texto': texto[:100] + '...' if len(texto) > 100 else texto,
+                        'Sentimiento': sentimiento,
+                        'Puntuación': f"{score:.3f}",
+                        'Longitud': len(texto)
+                    })
+        
+        if not resultados:
+            return pd.DataFrame({"Resultado": ["❌ No se pudieron analizar los textos del archivo"]})
+        
+        df_resultados = pd.DataFrame(resultados)
+        return df_resultados
+        
+    except Exception as e:
+        return pd.DataFrame({"Error": [f"❌ Error al procesar el archivo: {str(e)}"]})
+
+# Interfaz Gradio simplificada
+with gr.Blocks(theme="soft", title="Análisis Completo de Texto") as demo:
+    gr.Markdown("""
+    # 🎯 Análisis Completo de Texto - Multimodelo
+    
+    **Combina análisis lingüístico + múltiples métodos de sentimiento para máxima precisión**
+    """)
+    
+    with gr.Tab("📝 Análisis de Texto Individual"):
+        with gr.Row():
+            with gr.Column():
+                texto_input = gr.Textbox(
+                    label="Ingresa tu texto",
+                    placeholder="Escribe aquí tu texto en español, inglés, francés o portugués...",
+                    lines=5
+                )
+                analizar_btn = gr.Button("🔍 Analizar Texto", variant="primary")
+                
+                gr.Markdown("### Ejemplos rápidos:")
+                ejemplos = gr.Examples(
+                    examples=[
+                        ["Me encanta este producto! Es excelente y superó mis expectativas completamente."],
+                        ["No estoy para nada satisfecho, la calidad es pésima y el servicio terrible."],
+                        ["El producto cumple su función básica, pero podría mejorar en algunos aspectos."],
+                        ["I love this amazing product! It works perfectly and the quality is outstanding."],
+                        ["C'est un produit fantastique, je le recommande vivement à tous mes amis."],
+                        ["Este serviço é muito bom, atendimento excelente e qualidade superior."]
+                    ],
+                    inputs=texto_input
+                )
+            
+            with gr.Column():
+                resultado_resumen = gr.HTML(label="🎯 Resultado Principal")
+                resultado_detalles = gr.HTML(label="📊 Detalles por Método")
+                resultado_linguistica = gr.HTML(label="📝 Análisis Lingüístico")
+    
+    with gr.Tab("📊 Análisis de Archivos Excel"):
+        with gr.Row():
+            with gr.Column():
+                archivo_input = gr.File(
+                    label="Sube tu archivo Excel",
+                    file_types=[".xlsx", ".xls"]
+                )
+                analizar_excel_btn = gr.Button("📈 Analizar Archivo", variant="primary")
+                
+                gr.Markdown("""
+                **Formato esperado:**
+                - Archivo Excel (.xlsx o .xls)
+                - Columnas con texto (reseñas, comentarios, etc.)
+                - Mínimo 5-10 palabras por texto para mejor análisis
+                """)
+            
+            with gr.Column():
+                resultado_excel = gr.Dataframe(label="Resultados del Análisis")
+    
+    with gr.Tab("ℹ️ Información del Sistema"):
+        gr.Markdown("""
+        ## 🔧 Métodos de Análisis Utilizados
+        
+        ### 🤖 Modelos de Machine Learning
+        - **Multilingual Sentiment**: Modelo especializado en múltiples idiomas
+        - **BERT Multilingual**: Modelo transformer con clasificación por estrellas (1-5)
+        
+        ### 📚 Análisis Léxico
+        - Diccionario de palabras positivas/negativas en español
+        - Lematización y análisis morfológico
+        
+        ### 📊 TextBlob
+        - Análisis tradicional de sentimientos
+        - Compatible con múltiples idiomas
+        
+        ### 📝 Análisis Lingüístico (spaCy)
+        - Tokenización y POS tagging
+        - Reconocimiento de entidades
+        - Análisis de dependencias
+        
+        ## 🎯 Combinación Inteligente
+        Los resultados se combinan usando pesos ponderados para mayor precisión
+        """)
+    
+    # Conectar eventos
+    analizar_btn.click(
+        fn=analizar_texto_completo,
+        inputs=texto_input,
+        outputs=[resultado_resumen, resultado_detalles, resultado_linguistica]
+    )
+    
+    texto_input.submit(
+        fn=analizar_texto_completo,
+        inputs=texto_input,
+        outputs=[resultado_resumen, resultado_detalles, resultado_linguistica]
+    )
+    
+    analizar_excel_btn.click(
+        fn=analizar_archivo_excel,
+        inputs=archivo_input,
+        outputs=resultado_excel
+    )
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,7 @@
+gradio>=4.0.0
+transformers>=4.20.0
+torch>=1.9.0
+spacy>=3.0.0
+textblob>=0.17.1
+pandas>=1.3.0
+numpy>=1.21.0