Construye una aplicación de análisis de sentimientos

Vista general

En esta guía, aprenderás a construir y ejecutar una aplicación de análisis de sentimientos. Construirás la aplicación usando Python con el Natural Language Toolkit (NLTK), y luego configurarás el entorno y ejecutarás la aplicación usando Docker.

La aplicación analiza el texto introducido por el usuario para determinar el sentimiento utilizando SentimentIntensityAnalyzer de NLTK y muestra si el sentimiento es positivo, negativo o neutro.

Requisitos previos

• Has instalado la última versión de Docker Desktop. Docker añade nuevas funciones con regularidad y algunas partes de esta guía podrían funcionar solo con la última versión de Docker Desktop.
• Tienes un cliente de Git. Los ejemplos de esta sección utilizan un cliente de Git basado en la línea de comandos, pero puedes utilizar cualquier cliente.

Obtener la aplicación de ejemplo

1. Abre una terminal y clona el repositorio de la aplicación de ejemplo con el siguiente comando.

   $ git clone https://github.com/harsh4870/Docker-NLP.git
   

2. Verifica que has clonado el repositorio.

   Deberías ver los siguientes archivos en tu directorio Docker-NLP.

   01_sentiment_analysis.py
   02_name_entity_recognition.py
   03_text_classification.py
   04_text_summarization.py
   05_language_translation.py
   entrypoint.sh
   requirements.txt
   Dockerfile
   README.md

Explorar el código de la aplicación

El código fuente de la aplicación de análisis de sentimientos se encuentra en el archivo Docker-NLP/01_sentiment_analysis.py. Abre 01_sentiment_analysis.py en un editor de texto o de código para explorar su contenido en los siguientes pasos.

1. Importa las librerías requeridas.

   import nltk
   from nltk.sentiment import SentimentIntensityAnalyzer
   import ssl

   • nltk: Esta es la librería Natural Language Toolkit utilizada para trabajar con datos del lenguaje humano en Python.
   • SentimentIntensityAnalyzer: Esta es una herramienta específica de NLTK utilizada para determinar el sentimiento de un fragmento de texto.
   • ssl: Este módulo proporciona acceso a funciones de Transport Layer Security (encriptación) utilizadas para conexiones web seguras.

2. Maneja la verificación de certificados SSL.

   try:
       _create_unverified_https_context = ssl._create_unverified_context
   except AttributeError:
       pass
   else:
       ssl._create_default_https_context = _create_unverified_https_context

   Este bloque es una solución alternativa para ciertos entornos donde la descarga de datos a través de NLTK podría fallar debido a problemas de verificación de certificados SSL. Le indica a Python que ignore la verificación de certificados SSL para solicitudes HTTPS.

3. Descarga los recursos de NLTK.

   nltk.download('vader_lexicon')
   nltk.download('punkt')

   • vader_lexicon: Este es un léxico utilizado por SentimentIntensityAnalyzer para el análisis de sentimientos.
   • punkt: NLTK lo utiliza para tokenizar oraciones. Es necesario para que SentimentIntensityAnalyzer funcione correctamente.

4. Crea una función de análisis de sentimientos.

   def perform_semantic_analysis(text):
       sid = SentimentIntensityAnalyzer()
       sentiment_score = sid.polarity_scores(text)
   
       if sentiment_score['compound'] >= 0.05:
           return "Positive"
       elif sentiment_score['compound'] <= -0.05:
           return "Negative"
       else:
           return "Neutral"

   • SentimentIntensityAnalyzer() crea una instancia del analizador.
   • polarity_scores(text) genera una puntuación de sentimiento para el texto de entrada.

   La función devuelve Positive, Negative o Neutral según la puntuación compuesta.

5. Crea el bucle principal.

   if __name__ == "__main__":
       while True:
           input_text = input("Enter the text for semantic analysis (type 'exit' to end): ")
   
           if input_text.lower() == 'exit':
               print("Exiting...")
               break
   
           result = perform_semantic_analysis(input_text)
           print(f"Sentiment: {result}")

   Esta parte del script ejecuta un bucle infinito para aceptar la entrada del usuario para el análisis. Si el usuario escribe exit, el programa termina. De lo contrario, imprime el sentimiento del texto proporcionado.

6. Crea requirements.txt.

   La aplicación de ejemplo ya contiene el archivo requirements.txt para especificar los paquetes necesarios que importa la aplicación. Abre requirements.txt en un editor de código o texto para explorar su contenido.

   # 01 sentiment_analysis
   nltk==3.6.5
   
   ...

   Solo se requiere el paquete nltk para la aplicación de análisis de sentimientos.

Explorar el entorno de la aplicación

Utilizarás Docker para ejecutar la aplicación en un contenedor. Con Docker puedes contenedorizar la aplicación, lo que proporciona un entorno consistente y aislado para ejecutarla. Esto significa que la aplicación funcionará como se espera dentro de su contenedor Docker, independientemente de las diferencias del sistema subyacente.

Para ejecutar la aplicación en un contenedor, se requiere un Dockerfile. Un Dockerfile es un documento de texto que contiene todos los comandos que llamarías en la línea de comandos para ensamblar una imagen. Una imagen es una plantilla de solo lectura con instrucciones para crear un contenedor Docker.

La aplicación de ejemplo ya contiene un Dockerfile. Abre el Dockerfile en un editor de código o texto para explorar su contenido.

Los siguientes pasos explican cada parte del Dockerfile. Para obtener más detalles, consulta la referencia de Dockerfile.

1. Especifica la imagen base.

   FROM python:3.8-slim

   Este comando establece la base para la construcción. python:3.8-slim es una versión ligera de la imagen de Python 3.8, optimizada para tamaño y velocidad. El uso de esta imagen slim reduce el tamaño general de tu imagen de Docker, lo que resulta en descargas más rápidas y una menor superficie de exposición para vulnerabilidades de seguridad. Esto es especialmente útil para una aplicación basada en Python donde podrías no necesitar la imagen estándar completa de Python.

2. Establece el directorio de trabajo.

   WORKDIR /app

   WORKDIR establece el directorio de trabajo actual dentro de la imagen de Docker. Al establecerlo en /app, te aseguras de que todos los comandos posteriores en el Dockerfile (como COPY y RUN) se ejecuten en este directorio. Esto también ayuda a organizar tu imagen de Docker, ya que todos los archivos relacionados con la aplicación se encuentran en un directorio específico.

3. Copia el archivo de requisitos en la imagen.

   COPY requirements.txt /app

   El comando COPY transfiere el archivo requirements.txt desde tu máquina local a la imagen de Docker. Este archivo enumera todas las dependencias de Python requeridas por la aplicación. Copiarlo en el contenedor permite que el siguiente comando (RUN pip install) instale estas dependencias dentro del entorno de la imagen.

4. Instala las dependencias de Python en la imagen.

   RUN pip install --no-cache-dir -r requirements.txt

   Esta línea utiliza pip, el instalador de paquetes de Python, para instalar los paquetes enumerados en requirements.txt. La opción --no-cache-dir deshabilita la caché, lo que reduce el tamaño de la imagen de Docker al no almacenar datos de caché innecesarios.

5. Ejecuta comandos adicionales.

   RUN python -m spacy download en_core_web_sm

   Este paso es específico para aplicaciones de NLP que requieren la librería spaCy. Descarga el modelo en_core_web_sm, que es un modelo pequeño de idioma inglés para spaCy. Aunque no es necesario para esta aplicación, se incluye para compatibilidad con otras aplicaciones de NLP que podrían utilizar este Dockerfile.

6. Copia el código de la aplicación en la imagen.

   COPY *.py /app
   COPY entrypoint.sh /app

   Estos comandos copian tus scripts de Python y el script entrypoint.sh en el directorio /app de la imagen. Esto es crucial porque el contenedor necesita estos scripts para ejecutar la aplicación. El script entrypoint.sh es especialmente importante ya que dicta cómo se inicia la aplicación dentro del contenedor.

7. Establece los permisos para el script entrypoint.sh.

   RUN chmod +x /app/entrypoint.sh

   Este comando modifica los permisos de archivo de entrypoint.sh, haciéndolo ejecutable. Este paso es necesario para garantizar que el contenedor Docker pueda ejecutar este script para iniciar la aplicación.

8. Establece el punto de entrada.

   ENTRYPOINT ["/app/entrypoint.sh"]

   La instrucción ENTRYPOINT configura el contenedor para ejecutar entrypoint.sh como su ejecutable predeterminado. Esto significa que cuando el contenedor se inicia, ejecuta automáticamente el script.

   Puedes explorar el script entrypoint.sh abriéndolo en un editor de código o texto. Como el ejemplo contiene varias aplicaciones, con el script puedes especificar qué aplicación ejecutar cuando el contenedor se inicie.

Ejecutar la aplicación

Para ejecutar la aplicación usando Docker:

1. Construye la imagen.

   En una terminal, ejecuta el siguiente comando dentro del directorio donde se encuentra el Dockerfile.

   $ docker build -t basic-nlp .
   

   A continuación se detalla el desglose del comando:

   • docker build: Este es el comando principal utilizado para construir una imagen de Docker a partir de un Dockerfile y un contexto. El contexto suele ser un conjunto de archivos en una ubicación específica, a menudo el directorio que contiene el Dockerfile.
   • -t basic-nlp: Esta es una opción para etiquetar la imagen. La bandera -t significa etiqueta (tag). Asigna un nombre a la imagen, que en este caso es basic-nlp. Las etiquetas son una forma conveniente de hacer referencia a las imágenes más adelante, especialmente al subirlas a un registro o ejecutar contenedores.
   • .: Esta es la última parte del comando y especifica el contexto de construcción. El punto (.) denota el directorio actual. Docker buscará un Dockerfile en este directorio. El contexto de construcción (el directorio actual, en este caso) se envía al demonio de Docker para permitir la construcción. Incluye todos los archivos y subdirectorios del directorio especificado.

   Docker muestra varios logs en tu consola a medida que construye la imagen. Verás cómo descarga e instala las dependencias. Dependiendo de tu conexión de red, esto puede tardar varios minutos. Docker tiene una función de almacenamiento en caché, por lo que las construcciones posteriores pueden ser más rápidas. La consola volverá a mostrar la línea de comandos cuando finalice.

   Para obtener más detalles, consulta la referencia de la CLI de docker build.

2. Ejecuta la imagen como un contenedor.

   En una terminal, ejecuta el siguiente comando.

   $ docker run -it basic-nlp 01_sentiment_analysis.py
   

   A continuación se detalla el desglose del comando:

   • docker run: Este es el comando principal utilizado para ejecutar un nuevo contenedor a partir de una imagen de Docker.
   • -it: Esta es una combinación de dos opciones:
     • -i o --interactive: Mantiene abierta la entrada estándar (STDIN) incluso si no está conectada. Permite que el contenedor siga ejecutándose en primer plano y sea interactivo.
     • -t o --tty: Asigna una pseudo-TTY, simulando esencialmente una terminal, como una consola o un shell. Es lo que te permite interactuar con la aplicación dentro del contenedor.
   • basic-nlp: Especifica el nombre de la imagen de Docker que se utilizará para crear el contenedor. En este caso, es la imagen llamada basic-nlp que creaste con el comando docker build.
   • 01_sentiment_analysis.py: Este es el script que deseas ejecutar dentro del contenedor Docker. Se pasa al script entrypoint.sh, que lo ejecuta cuando se inicia el contenedor.

   Para obtener más detalles, consulta la referencia de la CLI de docker run.

   Note

   Para los usuarios de Windows, es posible que obtengas un error al ejecutar el contenedor. Verifica que los finales de línea en entrypoint.sh sean LF (\n) y no CRLF (\r\n), luego vuelve a construir la imagen. Para obtener más detalles, consulta [Evita errores de sintaxis inesperados, usa finales de línea estilo Unix para archivos en contenedores](/desktop/troubleshoot-and-support/troubleshoot/topics/#Unexpected-syntax-errors-use-Unix-style-line endings-for-files-in-containers).

   Verás lo siguiente en tu consola después de que se inicie el contenedor.

   Enter the text for semantic analysis (type 'exit' to end):
   

3. Prueba la aplicación.

   Introduce un comentario para obtener el análisis de sentimientos.

   Enter the text for semantic analysis (type 'exit' to end): I love containers!
   Sentiment: Positive
   Enter the text for semantic analysis (type 'exit' to end): I'm still learning about containers.
   Sentiment: Neutral
   

Resumen

En esta guía, has aprendido a construir y ejecutar una aplicación de análisis de sentimientos. Aprendiste a construir la aplicación usando Python con NLTK, y luego a configurar el entorno y ejecutar la aplicación usando Docker.

Información relacionada:

• Referencia de la CLI de Docker
• Referencia de Dockerfile
• Natural Language Toolkit
• Documentación de Python

Pasos siguientes

Explora más guías de procesamiento del lenguaje natural.