# 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](/get-started/get-docker/). 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](https://git-scm.com/downloads). 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. ```console $ 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`. ```text 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. ```python 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. ```python 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. ```python 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. ```python 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. ```python 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. ```text # 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](/reference/dockerfile/). 1. Especifica la imagen base. ```dockerfile 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. ```dockerfile 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. ```dockerfile 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. ```dockerfile 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. ```dockerfile 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. ```dockerfile 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`. ```dockerfile 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. ```dockerfile 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`. ```console $ 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](/reference/cli/docker/buildx/build/). 2. Ejecuta la imagen como un contenedor. En una terminal, ejecuta el siguiente comando. ```console $ 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](/reference/cli/docker/container/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. ```console 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. ```console 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](/reference/cli/docker/) - [Referencia de Dockerfile](/reference/dockerfile/) - [Natural Language Toolkit](https://www.nltk.org/) - [Documentación de Python](https://docs.python.org/3/) ## Pasos siguientes Explora más [guías de procesamiento del lenguaje natural](/guides/).