vfs

.gitattributes

@@ -1,35 +1,3 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
+.pkl filter=lfs diff=lfs merge=lfs -text
 *.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+tfidf_vectorizador2.pkl filter=lfs diff=lfs merge=lfs -text

.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

.idea/.name

@@ -0,0 +1 @@
+TFG

.idea/TFG.iml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/venv" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

.idea/alertDetection.iml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

.idea/misc.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Black">
+    <option name="sdkName" value="Python 3.9 (pythonProject1) (2)" />
+  </component>
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.9 (pythonProject1) (2)" project-jdk-type="Python SDK" />
+</project>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/TFG.iml" filepath="$PROJECT_DIR$/.idea/TFG.iml" />
+    </modules>
+  </component>
+</project>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>

main.py

@@ -0,0 +1,90 @@
+import streamlit as st
+import nltk
+from secciones.procesar_textos import procesar_textos  # Asegúrate de que esta ruta sea correcta
+from secciones.home_page import home_page
+from secciones.info_page import info_page
+
+
+def main():
+    """
+    Función principal que ejecuta la aplicación Streamlit.
+
+    Esta función se encarga de configurar la página, cargar el modelo y el vectorizador, y gestionar el menú de
+    navegación de la aplicación. Dependiendo de la opción seleccionada en el menú, renderiza diferentes vistas como
+    la página de inicio, la página de análisis de texto o la página de información.
+
+    :return: None. Ejecuta y mantiene activa la aplicación Streamlit.
+    """
+    # Configuración de la página
+    logo_log_bar = r'imagenes/Captura de pantalla 2024-01-06 a las 17.13.19.png'
+    st.set_page_config(page_title='Análisis sentimientos', page_icon=logo_log_bar, layout="wide")
+
+    # Descargar recursos de NLTK
+    @st.cache_data
+    def descargar_recursos_nltk():
+        """
+        Descarga los recursos necesarios de NLTK.
+
+        Esta función descarga los componentes 'punkt' y 'stopwords' de NLTK, que son necesarios para tokenizar y
+        preprocesar el texto en las funciones de análisis.
+
+        :return: None.
+        """
+        nltk.download('punkt')
+        nltk.download('stopwords')
+
+    descargar_recursos_nltk()
+
+    # Menú de opciones
+    with st.sidebar:
+        # Imagen y título del menú centrados
+        st.image("imagenes/uoc.png", width=290)  # Tamaño más grande para el logo
+        st.markdown('<h1 style="text-align: center; color: black;">Menú de Navegación</h2>', unsafe_allow_html=True)
+
+        # Opciones del menú con emojis como iconos
+        opciones_menu = {
+            "Home": "🏠 Home",
+            "Analizar texto": "🔍 Analizar texto",
+            "Info": "ℹ️ Info"
+        }
+        # Valor predeterminado para 'selected'
+        if 'selected' not in st.session_state:
+            st.session_state['selected'] = "Home"
+
+        # Estilo personalizado para los botones
+        btn_style = """
+            <style>
+                .css-2trqyj { 
+                    display: flex; 
+                    justify-content: center; 
+                    align-items: center; 
+                    font-size: 18px; 
+                    font-weight: bold;
+                }
+            </style>
+        """
+        st.markdown(btn_style, unsafe_allow_html=True)
+
+        # Crear botones en la barra lateral para cada opción del menú
+        for opcion, etiqueta in opciones_menu.items():
+            if st.button(etiqueta, key=opcion, use_container_width=True):
+                st.session_state['selected'] = opcion
+
+    # Vista de información
+    if st.session_state['selected'] == "Home":
+        st.image("imagenes/uoc2.png", use_column_width=True)
+        home_page()
+
+    # Analizar texto
+    elif st.session_state['selected'] == "Analizar texto":
+        st.image("imagenes/uoc2.png", use_column_width=True)
+        procesar_textos()
+
+    # Info
+    elif st.session_state['selected'] == "Info":
+        st.image("imagenes/uoc2.png", use_column_width=True)
+        info_page()
+
+
+if __name__ == "__main__":
+    main()

modelo_nn_g2.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:73c1fd2dd7ef4320ff37d6715da5be4b7d12a8074356271ba312267867b059f4
+size 6107894

secciones/home_page.py

@@ -0,0 +1,67 @@
+import streamlit as st
+
+
+def home_page():
+    """
+    Muestra la página principal de la aplicación Streamlit.
+
+    Esta función se encarga de renderizar la página de inicio de la aplicación de detección temprana de riesgo
+    de suicidio.
+    Incluye secciones que explican el propósito del proyecto, sus objetivos principales y cómo utilizar la herramienta.
+    Cada sección está claramente definida y contiene información detallada y relevante para el usuario.
+
+    La página de inicio se estructura en varias secciones, que incluyen:
+    - Una introducción al proyecto y su relevancia.
+    - Los objetivos principales del proyecto.
+    - Instrucciones detalladas sobre cómo utilizar la herramienta.
+
+    Las secciones están diseñadas para proporcionar a los usuarios una comprensión clara del propósito y
+    la funcionalidad de la herramienta, así como guiarlos en su uso efectivo.
+
+    :return: None. Renderiza los componentes de la página de inicio en la interfaz de usuario de Streamlit.
+    """
+    st.title("TFG: Detección Temprana de Riesgo de Suicidio Mediante Análisis de mensajes de texto")
+    with st.container():
+        st.write("""
+            Este proyecto emplea técnicas avanzadas de Procesamiento de Lenguaje Natural (PLN) y análisis de datos para 
+            explorar y detectar señales de comportamientos autolesivos en mensajes publicados en redes sociales. 
+            La iniciativa busca abordar una de las principales causas de preocupación en la salud mental global, 
+            ofreciendo una herramienta innovadora y valiosa para la identificación temprana de riesgos de suicidio.
+        """)
+    with st.container(border=True):
+        st.header("Objetivos Principales")
+        st.write("""
+            - **Análisis Profundo de Comunicaciones Digitales**: Implementación de algoritmos de PLN para analizar 
+            textos y detectar patrones de riesgo en comportamientos y estados emocionales.
+            - **Prevención de Comportamientos de Riesgo**: Utilización de la herramienta como un medio para identificar 
+            señales tempranas de crisis emocionales, proporcionando una base sólida para intervenciones oportunas y 
+            medidas preventivas.
+            - **Evaluación y Mejora de Estrategias de Prevención Actuales**: Contribución a la investigación y mejora de 
+            estrategias de prevención del suicidio mediante la incorporación de tecnologías avanzadas de análisis de 
+            datos.
+        """)
+    with st.container(border=True):
+        st.header("Cómo Utilizar la Herramienta")
+        st.write("""
+            1. **Acceso a la herramienta de análisis**: Para acceder a esta propiedad tan solo hay que dirigirse
+            al botón 'Analizar texto' que se encuentra en el menú de navegación.
+        """)
+        st.image("imagenes/Captura1.PNG", use_column_width="auto")
+        st.write("""
+            2. **Ingreso y procesamiento del texto**: Para llevar a cabo nuestro análisis tan solo se debe introducir 
+            en el cuadro respectivo el texto a analizar. Haga clic en el botón 'Procesar texto' para que la herramienta 
+            procese el texto. La herramienta utiliza modelos de PLN para analizar el contenido y la tonalidad 
+            emocional del texto.
+        """)
+        st.write("""
+            **Importante: Por ahora no esta permitido ingresar archivos de texto**
+        """)
+        st.image("imagenes/Captura2.PNG")
+        st.image("imagenes/Captura3.PNG")
+        st.write("""
+            4. **Interpretación de resultados y acciones sugeridas**: Los resultados proporcionan insights 
+            sobre el estado emocional del texto y posibles señales de riesgo. Estos incluyen análisis de sentimientos, 
+            emociones y una evaluación de riesgo de suicidio. Basado en el nivel de riesgo detectado, 
+            la herramienta ofrece recomendaciones sobre posibles pasos a seguir.
+        """)
+        st.image("imagenes/Captura4.PNG")

secciones/info_page.py

@@ -0,0 +1,34 @@
+import streamlit as st
+
+
+def info_page():
+
+    with st.container():
+        st.markdown("""
+            <style>
+
+                .logo {
+                    display: inline-block;
+                    margin-right: 5px;
+                    width: 20px; /* Ajusta el tamaño del logo aquí */
+                }
+                .about-container{
+                    text-align: center;
+                }
+            </style>
+            <div class="about-container" >
+                <h1 >Acerca de este TFG</h1>
+                <p>
+                    <h2>Ignacio Macías Martínez</h2><br>
+                    <strong>Grado de ciencia de datos aplicada</strong>: Trabajo final de grado 22.536.<br>
+                    <strong>Tutora TFG</strong>: Teresa Divorra Vallhonrat.<br>
+                    <strong>Profesor responsable de la asignatura</strong>: David Merino Arranz.<br>
+                    <strong>Contacto</strong>: /
+                    <a href="https://github.com/imaciasm"><img class="logo" 
+                    src="https://github.githubassets.com/images/modules/logos_page/GitHub-Mark.png"/>GitHub</a> \\ /
+                    <a href="https://www.linkedin.com/in/imaciasm/"><img class="logo" 
+                    src="https://upload.wikimedia.org/wikipedia/commons/c/ca/LinkedIn_logo_initials.png"/>LinkedIn</a> 
+                    \\
+                </p>
+            </div>
+        """, unsafe_allow_html=True)

secciones/model_utils.py

@@ -0,0 +1,10 @@
+import joblib
+import streamlit as st
+
+
+# Cargar el modelo y el vectorizador
+@st.cache_data
+def cargar_modelo_y_vectorizador():
+    modelo = joblib.load('modelo_nn_g2.pkl')
+    tfidf_vectorizador = joblib.load('tfidf_vectorizador2.pkl')
+    return modelo, tfidf_vectorizador

secciones/procesar_textos.py

@@ -0,0 +1,245 @@
+import streamlit as st
+import pandas as pd
+import re
+import nltk
+import numpy as np
+from nltk.tokenize import word_tokenize
+from nltk.corpus import stopwords
+from nltk.stem import SnowballStemmer
+from transformers import pipeline
+from secciones.model_utils import cargar_modelo_y_vectorizador
+
+# Descargar recursos de NLTK
+nltk.download('punkt')
+nltk.download('stopwords')
+
+
+# Función de limpieza y preprocesamiento de texto
+def clean_text_stemming(text):
+    """
+    Realiza la limpieza y preprocesamiento de un texto. Convierte el texto a minúsculas,
+    elimina caracteres no alfabéticos, tokeniza, remueve stopwords y aplica stemming.
+
+    :param text: El texto a limpiar y preprocesar.
+    :return: Texto procesado y limpio.
+    """
+    text = text.lower()
+    text = re.sub(r'[^a-zñáéíóú]', ' ', text)
+    words = word_tokenize(text)
+    stop_words = set(stopwords.words('spanish'))
+    stemmer = SnowballStemmer('spanish')
+    stemmed_text = ' '.join([stemmer.stem(word) for word in words if word not in stop_words])
+    return stemmed_text
+
+
+# Cargar modelos de Hugging Face para análisis de sentimientos y emociones
+clasificador_sentimiento = pipeline('sentiment-analysis',
+                                    model='citizenlab/twitter-xlm-roberta-base-sentiment-finetunned')
+clasificador_emociones = pipeline("text-classification",
+                                  model="maxpe/bertin-roberta-base-spanish_sem_eval_2018_task_1")
+
+
+# Funciones para analizar sentimiento y emociones
+def analizar_sentimiento(texto):
+    """
+    Analiza el sentimiento de un texto dado utilizando un modelo preentrenado de Hugging Face.
+
+    :param texto: El texto a analizar.
+    :return: La etiqueta del sentimiento detectado (ej. "Positive", "Negative", "Neutral").
+             Retorna None si ocurre un error.
+    """
+    try:
+        results = clasificador_sentimiento(texto, truncation=True, max_length=512)
+        top_result = max(results, key=lambda x: x['score'])
+        return top_result['label']
+    except Exception as e:
+        print(f"Error al procesar el texto: {e}")
+        return None
+
+
+def analizar_emociones(texto):
+    """
+    Analiza las emociones presentes en un texto utilizando un modelo preentrenado de Hugging Face.
+
+    :param texto: El texto a analizar.
+    :return: La etiqueta de la emoción detectada (ej. "alegría", "tristeza").
+             Retorna None si ocurre un error.
+    """
+    try:
+        results = clasificador_emociones(texto, truncation=True, max_length=512)
+        top_result = max(results, key=lambda x: x['score'])
+        return top_result['label']
+    except Exception as e:
+        print(f"Error al procesar el texto: {e}")
+        return None
+
+
+# Normalización de la longitud del texto
+def normalizar_longitud(texto):
+    """
+    Normaliza la longitud de un texto dividiendo la longitud del texto por una longitud máxima observada.
+
+    :param texto: El texto cuya longitud se va a normalizar.
+    :return: Longitud normalizada del texto.
+    """
+    longitud_maxima_observada = 53352
+    return len(texto) / longitud_maxima_observada
+
+
+# Obtener características de polaridad y emociones
+def obtener_caracteristicas_polaridad(texto):
+    """
+    Obtiene características de polaridad (positiva, negativa, neutral) de un texto analizando su sentimiento.
+
+    :param texto: El texto a analizar.
+    :return: Un diccionario con las características de polaridad en formato binario.
+    """
+    polaridad = analizar_sentimiento(texto)
+    return {
+        "polarity_Negative": 1 if polaridad == "Negative" else 0,
+        "polarity_Neutral": 1 if polaridad == "Neutral" else 0,
+        "polarity_Positive": 1 if polaridad == "Positive" else 0
+    }
+
+
+def obtener_caracteristicas_emociones(texto):
+    """
+    Obtiene características de emociones (ira, anticipación, miedo, alegría, tristeza) de un texto.
+
+    :param texto: El texto a analizar.
+    :return: Un diccionario con las características de emociones en formato binario.
+    """
+    emocion = analizar_emociones(texto)
+    categorias = ["anger", "anticipation", "fear", "joy", "sadness"]
+    return {f"emotions_{cat}": 1 if emocion == cat else 0 for cat in categorias}
+
+
+# Función para realizar predicciones con información adicional
+def predecir_suicidio_con_info(texto, modelo, tfidf_vectorizador):
+    """
+    Realiza la predicción de comportamiento suicida en un texto dado, utilizando un modelo
+    de machine learning y un vectorizador TF-IDF. Incluye características adicionales
+    como longitud del texto, polaridad y emociones.
+
+    :param texto: Texto a analizar.
+    :param modelo: Modelo de machine learning para realizar la predicción.
+    :param tfidf_vectorizador: Vectorizador TF-IDF para procesar el texto.
+    :return: Un diccionario con los resultados de la clasificación y análisis.
+    """
+    texto_limpio = clean_text_stemming(texto)
+
+    # Obtener características
+    longitud_normalizada = normalizar_longitud(texto)
+    caracteristicas_polaridad = obtener_caracteristicas_polaridad(texto)
+    caracteristicas_emociones = obtener_caracteristicas_emociones(texto)
+    polaridad = analizar_sentimiento(texto)
+    emocion = analizar_emociones(texto)
+
+    # Vectorizar texto y combinar características
+    texto_tfidf = tfidf_vectorizador.transform([texto_limpio]).toarray()
+    caracteristicas_adicionales = np.array(
+        [longitud_normalizada] + list(caracteristicas_polaridad.values()) + list(caracteristicas_emociones.values()))
+    features = np.hstack((texto_tfidf, caracteristicas_adicionales.reshape(1, -1)))
+
+    # Asegúrate de que el DataFrame tenga los mismos nombres de columnas que se usaron durante el entrenamiento
+    column_names = tfidf_vectorizador.get_feature_names_out().tolist() + ['text_length', 'polarity_Negative',
+                                                                          'polarity_Neutral', 'polarity_Positive',
+                                                                          'emotions_anger', 'emotions_anticipation',
+                                                                          'emotions_fear', 'emotions_joy',
+                                                                          'emotions_sadness']
+    features_df = pd.DataFrame(features, columns=column_names)
+
+    # Realizar la predicción
+    pred = modelo.predict(features_df)
+    pred_proba = modelo.predict_proba(features_df)[0]
+
+    # Confianza y nivel de riesgo
+    confianza = abs(pred_proba[1] - pred_proba[0])
+    nivel_riesgo = 'alto' if pred_proba[1] > 0.75 else 'moderado' if pred_proba[1] > 0.5 else 'bajo'
+    accion = 'Se recomienda buscar ayuda profesional inmediatamente.' if nivel_riesgo == 'alto' \
+        else 'Se sugiere monitorear los sentimientos y considerar hablar con un profesional.' \
+        if nivel_riesgo == 'moderado' \
+        else 'Probablemente no hay riesgo inmediato, pero mantén una actitud positiva.'
+
+    # Traducciones de las etiquetas de polaridad y emociones al español
+    traducciones_polaridad = {
+        "Negative": "Negativa",
+        "Neutral": "Neutral",
+        "Positive": "Positiva"
+    }
+    traducciones_emociones = {
+        "anger": "ira",
+        "anticipation": "Anticipación",
+        "fear": "Miedo",
+        "joy": "Alegría",
+        "sadness": "Tristeza"
+    }
+
+    # Traducir polaridad y emociones
+    polaridad_traducida = traducciones_polaridad.get(polaridad, polaridad)
+    emocion_traducida = traducciones_emociones.get(emocion, emocion)
+
+    return {
+        "clasificacion": 'suicidio' if pred[0] == 1 else 'no suicidio',
+        "probabilidad_suicidio": pred_proba[1],
+        "confianza": confianza,
+        "nivel_riesgo": nivel_riesgo,
+        "sugerencia_accion": accion,
+        "polaridad": polaridad_traducida,
+        "emocion": emocion_traducida
+    }
+
+
+def procesar_textos():
+
+    """
+    Función principal para procesar textos en la aplicación Streamlit. Permite al usuario
+    ingresar o subir un texto, y luego utiliza el modelo y el vectorizador para analizarlo.
+
+    :param modelo: Modelo de machine learning para la predicción.
+    :param tfidf_vectorizador: Vectorizador TF-IDF utilizado en el modelo.
+    """
+    st.title("Analizar Texto")
+    modelo, tfidf_vectorizador = cargar_modelo_y_vectorizador()
+    # Opción para ingresar texto manualmente
+    text_input = st.text_area("Ingrese su texto aquí:")
+
+    # Opción para subir un archivo
+    uploaded_file = st.file_uploader("O suba un archivo de texto:", type=["txt"])
+
+    # Botón para procesar el texto
+    if st.button("Procesar Texto"):
+        text_to_process = ""
+        if uploaded_file is not None:
+            # Leer el archivo subido y almacenar su contenido
+            text_to_process = uploaded_file.read().decode("utf-8")
+        elif text_input:
+            # Utilizar el texto ingresado manualmente
+            text_to_process = text_input
+
+        if text_to_process:
+            # Llamar a la función de predicción con el texto procesado
+            resultado = predecir_suicidio_con_info(text_to_process, modelo, tfidf_vectorizador)
+
+            # Estilos personalizados según el nivel de riesgo
+            if resultado['nivel_riesgo'] == 'alto':
+                color = "red"
+            elif resultado['nivel_riesgo'] == 'moderado':
+                color = "orange"
+            else:
+                color = "green"
+
+            # Mostrar los resultados con estilos
+            st.markdown(f"<h2 style='color: {color};'>Resultado del Análisis:</h2>", unsafe_allow_html=True)
+            st.markdown(f"<b>Nivel de Riesgo:</b> <span style='color: {color};'>{resultado['nivel_riesgo']}</span>",
+                        unsafe_allow_html=True)
+            st.markdown(f"<b>Polaridad:</b> {resultado['polaridad']}", unsafe_allow_html=True)
+            st.markdown(f"<b>Emoción:</b> {resultado['emocion']}", unsafe_allow_html=True)
+            st.markdown(f"<b>Clasificación:</b> {resultado['clasificacion']}", unsafe_allow_html=True)
+            st.markdown(f"<b>Probabilidad de Suicidio:</b> {resultado['probabilidad_suicidio']:.4f}",
+                        unsafe_allow_html=True)
+            st.markdown(f"<b>Confianza:</b> {resultado['confianza']:.4f}", unsafe_allow_html=True)
+
+            st.markdown(f"<b>Sugerencia de Acción:</b> {resultado['sugerencia_accion']}", unsafe_allow_html=True)
+        else:
+            st.warning("Por favor, ingrese texto o suba un archivo.")

tfidf_vectorizador2.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:247005faccbe8acea43dccbcef558063a46250f489bd7e2ec4dc1ce59961612e
+size 238915493