Scribd Logo
Cargar

¡Te damos la bienvenida a Scribd!

  • 9 vistas

    Análisis de Sentimiento Trabajo

    Cargado por

    Sky Blue

    Copyright:

    © All Rights Reserved
    Descargue como DOCX, PDF, TXT o lea en línea desde Scribd

    Análisis de Sentimiento Trabajo

    Cargado por

    Sky Blue
    9 vistas11 páginas

    Título original

    ANÁLISIS DE SENTIMIENTO TRABAJO

    Derechos de autor

    © © All Rights Reserved

    Formatos disponibles

    DOCX, PDF, TXT o lea en línea desde Scribd

    ¿Le pareció útil este documento?

    ¿Este contenido es inapropiado?

    Copyright:

    © All Rights Reserved
    Descargue como DOCX, PDF, TXT o lea en línea desde Scribd
    Descargar como docx, pdf o txt
    9 vistas11 páginas

    Análisis de Sentimiento Trabajo

    Cargado por

    Sky Blue

    Copyright:

    © All Rights Reserved
    Descargue como DOCX, PDF, TXT o lea en línea desde Scribd
    Descargar como docx, pdf o txt
    Está en la página 1de 11

    UNIVERSIDAD NACIONAL

    SANTIAGO ANTÚNEZ DE MAYOLO


    FACULTAD DE CIENCIAS

    ESCUELA ACADÉMICO-PROFESIONAL
    INGENIERÍA DE SISTEMAS E INFORMÁTICA

    ANÁLISIS DE SENTIMIENTOS: APLICATIVO Y


    PREGUNTAS

    DOCENTE:
    ING. ROMERO AGUILAR DANTE ENRIQUE

    PRESENTADO POR:
    - CAPCHA MOLINA DANA SCOLYN
    - MAZA TAMARIZ JEANPIER

    HUARAZ - PERU
    2024
    APLICATIVO

    CÓDIGO:

    1. Creamos una carpeta donde almacenaremos el dataset para entrenar a nuestro


    modelo

    !mkdir sentimientos

    2. Importamos las librerías necesarias

    import numpy as np
    import pandas as pd
    import tensorflow as tf
    from tensorflow.keras.preprocessing.text import Tokenizer
    from tensorflow.keras.preprocessing.sequence import pad_sequences
    from tensorflow.keras.models import Sequential
    from tensorflow.keras.layers import Embedding, LSTM, Dense, Dropout
    from sklearn.model_selection import train_test_split
    from sklearn.metrics import classification_report
    import nltk
    from nltk.corpus import stopwords

    3. Cargamos y procesamos los datos

    # Descargar stopwords en español


    nltk.download('stopwords')
    stop_words = set(stopwords.words('spanish'))

    # Cargar el dataset
    df =
    pd.read_csv("/content/sentimientos/dataset_2014_full_clean.csv",
    encoding='latin-1') # Reemplaza por tu dataset

    # Ejemplo: El dataset debe tener columnas 'texto' y 'sentimiento'


    print(df.head()) # Asegúrate de tener columnas correctas

    # Preprocesamiento del texto (limpiar y eliminar stopwords)


    def preprocess_text(text):
    text = text.lower() # Convertir a minúsculas
    words = text.split()
    words = [word for word in words if word not in stop_words] #
    Filtrar stopwords
    return " ".join(words)
    df['Texto'] = df['Texto'].apply(preprocess_text)

    4. Preparamos los datos

    # Definir hiperparámetros
    MAX_VOCAB_SIZE = 10000 # Máximo vocabulario
    MAX_SEQUENCE_LENGTH = 100 # Longitud máxima de las secuencias
    EMBEDDING_DIM = 100 # Dimensión del embedding

    # Tokenización
    tokenizer = Tokenizer(num_words=MAX_VOCAB_SIZE)
    tokenizer.fit_on_texts(df['Texto'])
    sequences = tokenizer.texts_to_sequences(df['Texto'])

    # Padding para que todas las secuencias tengan la misma longitud


    X = pad_sequences(sequences, maxlen=MAX_SEQUENCE_LENGTH)

    # Etiquetas: 0 = negativo, 1 = positivo


    y = df['Sentimiento'].replace({'Negativo': 0, 'Positivo':
    1}).values

    # Dividir los datos en entrenamiento y prueba


    X_train, X_test, y_train, y_test = train_test_split(X, y,
    test_size=0.2, random_state=42)

    5. Creamos el modelo LSTM para evitar sobreajustes en el modelo

    model = Sequential([
    Embedding(MAX_VOCAB_SIZE, EMBEDDING_DIM,
    input_length=MAX_SEQUENCE_LENGTH),
    LSTM(128, return_sequences=True),
    Dropout(0.5),
    LSTM(64),
    Dropout(0.5),
    Dense(1, activation='sigmoid') # Sigmoid para clasificación
    binaria
    ])
    model.compile(optimizer='adam', loss='binary_crossentropy',
    metrics=['accuracy'])

    # Mostrar resumen del modelo


    model.summary()

    6. Entrenamos el modelo

    BATCH_SIZE = 32 # Tamaño del lote


    EPOCHS = 5 # Número de épocas

    # Entrenar el modelo
    history = model.fit(
    X_train, y_train,
    validation_data=(X_test, y_test),
    batch_size=BATCH_SIZE,
    epochs=EPOCHS,
    verbose=1 # Mostrar progreso
    )

    7. Evaluamos el modelo

    # Evaluar en datos de prueba


    test_loss, test_accuracy = model.evaluate(X_test, y_test)
    print(f"Pérdida en los datos de prueba: {test_loss:.4f}")
    print(f"Precisión en los datos de prueba: {test_accuracy:.4f}")
    8. Visualimos el rendimiento del modelo

    import matplotlib.pyplot as plt

    # Gráfica de la pérdida (loss)


    plt.plot(history.history['loss'], label='Entrenamiento')
    plt.plot(history.history['val_loss'], label='Validación')
    plt.title('Pérdida del Modelo')
    plt.xlabel('Épocas')
    plt.ylabel('Pérdida')
    plt.legend()
    plt.show()

    # Gráfica de la precisión (accuracy)


    plt.plot(history.history['accuracy'], label='Entrenamiento')
    plt.plot(history.history['val_accuracy'], label='Validación')
    plt.title('Precisión del Modelo')
    plt.xlabel('Épocas')
    plt.ylabel('Precisión')
    plt.legend()
    plt.show()
    9. Realizamos las predicciones

    # Ejemplo de texto en español


    new_review = ["Este producto es increíble, lo recomiendo
    muchísimo"]

    # Preprocesar y convertir el texto en secuencia


    new_sequence = tokenizer.texts_to_sequences(new_review)
    new_padded = pad_sequences(new_sequence,
    maxlen=MAX_SEQUENCE_LENGTH)

    # Realizar la predicción
    prediction = model.predict(new_padded)

    # Mostrar el resultado
    if prediction > 0.5:
    print("Sentimiento: Positivo")
    else:
    print("Sentimiento: Negativo")

    PRUEBA:

    Prueba N° 1

    # Ejemplo de texto en español


    new_review = ["Este producto no es increíble, no lo adoro"]

    Prueba N° 2

    # Ejemplo de texto en español


    new_review = ["El producto llegó dañado y no funciona como
    debería"]

    Prueba N° 3

    # Ejemplo de texto en español


    new_review = ["No estoy muy feliz con el servicio recibido"]

    Prueba N° 4

    # Ejemplo de texto en español


    new_review = ["No recomendaría esta tienda, el servicio es
    terrible"]

    Prueba N° 5

    # Ejemplo de texto en español


    new_review = ["Cada vez que compro aquí, me siento muy satisfecho"]

    PREGUNTAS:

    1. ¿Como lo aplica en el mundo laboral y académico el análisis de sentimientos?

    - Apreciación de productos.
    Laboral - Estudio del mercado.
    - Mejora de experiencia.

    - Evaluación del bienestar emocional.


    Académico - Evaluación del compromiso del estudiante.
    - Mejoras en la retroalimentación

    2. ¿Qué operaciones, variables, listas, tuplas, diccionarios, estructuras selectivas de control


    y funciones empleó?

    Operaciones:

    - Asignación (=)
    - Comparación (==, !=, >, <, >=, <=)
    - Aritméticas (+, -, *, /, %, ``)**
    - Lógicas (and, or, not)
    - Llamada a funciones ()

    Variables:

    - X, y, X_train, X_test, y_train, y_test: Variables que almacenan datos y conjuntos de


    datos.
    - model, tokenizer, history: Variables que almacenan el modelo, el tokenizador y el
    historial de entrenamiento.
    - new_review, new_sequence, new_padded, prediction: Variables usadas para la
    predicción de nuevos textos.

    Listas:

    - new_review: Se usa para almacenar el nuevo texto a predecir.

    Tuplas:

    - No hay tuplas declaradas explícitamente, aunque se usan en funciones de TensorFlow.


    Diccionarios:

    - history.history: Almacena las métricas del entrenamiento como un diccionario.

    Estructuras de control:

    - if, else.
    - bucles for y while: se usan implícitamente en las funciones de TensorFlow/Keras

    Funciones:

    - preprocess_text(): Función personalizada para limpiar y preprocesar el texto.


    - model.fit(): Función de Keras para entrenar el modelo.
    - model.evaluate(): Función de Keras para evaluar el modelo.
    - model.predict(): Función de Keras para realizar predicciones.
    - Funciones de bibliotecas como pd.read_csv(), train_test_split(), etc.

    3. ¿Qué librerías, instalación e importación, atributos, métodos y clases empleó?

    Librerías:

    - Numpy: Para operaciones numéricas con arrays. Se importa como np.


    - Pandas: Para manipulación y análisis de datos. Se importa como pd.
    - TensorFlow: Para construir y entrenar el modelo de deep learning. Se importa como tf.
    - Scikit-learn: Para dividir los datos en conjuntos de entrenamiento y prueba, y para
    generar reportes de clasificación. Se importan train_test_split y classification_report.
    - NLTK: Para el procesamiento del lenguaje natural, específicamente para descargar y
    usar stopwords en español. Se importa como nltk.
    - Matplotlib: Para visualizar los resultados (gráficas de pérdida y precisión). Se importa
    como plt.

    Atributos:

    - history.history['loss']: Para acceder al historial de la pérdida durante el entrenamiento.


    - model.summary(): Para mostrar la arquitectura del modelo.
    - df['Texto']: Para acceder a la columna "Texto" del DataFrame.

    Métodos:

    - pd.read_csv(): Para leer el dataset desde un archivo CSV.


    - tokenizer.fit_on_texts(): Para entrenar el tokenizador en el texto.
    - model.compile(): Para compilar el modelo con un optimizador, función de pérdida y
    métricas.
    - model.fit(): Para entrenar el modelo.
    - model.predict(): Para hacer predicciones.
    - plt.plot(): Para graficar los resultados.

    Clases:

    - Tokenizer: Para convertir texto en secuencias numéricas.


    - Sequential: Para crear un modelo de deep learning secuencial.
    - Embedding, LSTM, Dense, Dropout: Capas del modelo de deep learning.
    4. ¿Qué dataSeries, dataFrame, fuentes de datos (offline, online) y análisis de datos
    empleó?

    Fuentes de Datos:

    - Offline: El código utiliza una fuente de datos offline, que es el archivo CSV
    "500sentimientos.csv". Este archivo debe estar ubicado en la carpeta "sentimientos"
    dentro del entorno de Colab.

    DataFrames:

    - df: Es el Dataframe principal que almacena el dataset completo, incluyendo las


    columnas 'Texto' y 'Sentimiento'. Se carga desde el archivo CSV "500sentimientos.csv".

    DataSeries:

    - df['Texto']: Es una DataSeries que contiene el texto preprocesado de las reseñas.


    - df['Sentimiento']: Es una DataSeries que contiene las etiquetas de sentimiento
    (Positivo o Negativo).

    Análisis de Datos:

    - Preprocesamiento de Texto: Se limpia el texto, se convierte a minúsculas y se eliminan


    las stopwords (palabras comunes que no aportan mucho significado).
    - Tokenización: Se convierte el texto en secuencias numéricas utilizando un tokenizador.
    - Padding: Se ajusta la longitud de las secuencias.
    - División de Datos: Se divide el dataset en conjuntos de entrenamiento y prueba.
    - Entrenamiento del Modelo: Se entrena un modelo de deep learning (LSTM) para
    clasificar el sentimiento del texto.
    - Evaluación del Modelo: Se evalúa el rendimiento del modelo en los datos de prueba
    utilizando métricas como la pérdida y la precisión.
    - Predicción: Se utiliza el modelo entrenado para predecir el sentimiento de nuevos
    textos.

    5. ¿Interpretar los gráficos con Malplotlib, Seaborn y otros?


    Línea Azul (Entrenamiento): Muestra la Línea Naranja (Validación): Muestra la
    pérdida durante el entrenamiento del pérdida en los datos de validación. Indica
    modelo. Idealmente, debería disminuir a cómo el modelo se generaliza a datos no
    medida que avanza el entrenamiento. vistos.

    Línea Azul (Entrenamiento): Muestra la Línea Naranja Naranja (Validación):


    precisión durante el entrenamiento. Muestra la precisión en los datos de
    validación.

    6. ¿A qué conclusiones llegó referente al tratamiento de datos (filtro, nulos,


    agrupamiento), análisis exploratorio de datos y mostrando resultados con scikit-learn?

    Tratamiento de datos:

    - El código aplica un filtro para eliminar las stopwords del texto. Esto se realiza para
    limpiar el texto y eliminar palabras comunes que no aportan mucho significado al
    análisis de sentimiento.
    - No hay un tratamiento explícito de valores nulos en el código. Sin embargo, se asume
    que el dataset no contiene valores nulos en las columnas relevantes ('Texto' y
    'Sentimiento').
    - Agrupamiento: No se realiza ningún tipo de agrupamiento de datos en el código. El
    análisis se centra en la clasificación individual de cada reseña como positiva o negativa.

    Mostrando resultados con scikit-learn:


    Scikit-learn: El código utiliza classification_report de scikit-learn para generar un reporte de
    clasificación que muestra métricas como la precisión y pérdida. Esto ayuda a evaluar el
    rendimiento del modelo de forma más completa.

    También podría gustarte