# Construye una aplicación de reconocimiento de texto ## Vista general En esta guía, aprenderás a crear y ejecutar una aplicación de reconocimiento de texto. Construirás la aplicación usando Python con scikit-learn y el Natural Language Toolkit (NLTK). Luego configurarás el entorno y ejecutarás la aplicación usando Docker. La aplicación analiza el sentimiento del texto de entrada de un usuario mediante `SentimentIntensityAnalyzer` de NLTK. Permite al usuario introducir texto, que luego se procesa para determinar su sentimiento, clasificándolo como positivo o negativo. Además, muestra la precisión y un informe detallado de clasificación de su modelo de análisis de sentimientos basado en un conjunto de datos predefinido. ## 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 clasificación de texto se encuentra en el archivo `Docker-NLP/03_text_classification.py`. Abre `03_text_classification.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 from sklearn.metrics import accuracy_score, classification_report from sklearn.model_selection import train_test_split import ssl ``` - `nltk`: Una librería popular de Python para el procesamiento del lenguaje natural (NLP). - `SentimentIntensityAnalyzer`: Un componente de `nltk` para el análisis de sentimientos. - `accuracy_score`, `classification_report`: Funciones de scikit-learn para evaluar el modelo. - `train_test_split`: Función de scikit-learn para dividir conjuntos de datos en conjuntos de entrenamiento y prueba. - `ssl`: Utilizado para manejar problemas de certificados SSL que podrían ocurrir al descargar datos para `nltk`. 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') ``` `vader_lexicon` es un léxico utilizado por `SentimentIntensityAnalyzer` para el análisis de sentimientos. 4. Define el texto para las pruebas y las etiquetas correspondientes. ```python texts = [...] labels = [0, 1, 2, 0, 1, 2] ``` Esta sección define un pequeño conjunto de datos de textos y sus etiquetas correspondientes (0 para positivo, 1 para negativo y 2 para spam). 5. Divide los datos de prueba. ```python X_train, X_test, y_train, y_test = train_test_split(texts, labels, test_size=0.2, random_state=42) ``` Esta parte divide el conjunto de datos en conjuntos de entrenamiento y de prueba, con el 20% de los datos como conjunto de prueba. Como esta aplicación utiliza un modelo preentrenado, no entrena el modelo. 6. Configura el análisis de sentimientos. ```python sia = SentimentIntensityAnalyzer() ``` Este código inicializa el `SentimentIntensityAnalyzer` para analizar el sentimiento del texto. 7. Genera predicciones y clasificaciones para los datos de prueba. ```python vader_predictions = [sia.polarity_scores(text)["compound"] for text in X_test] threshold = 0.2 vader_classifications = [0 if score > threshold else 1 for score in vader_predictions] ``` Esta parte genera puntuaciones de sentimiento para cada texto en el conjunto de prueba y los clasifica como positivos o negativos según un umbral. 8. Evalúa el modelo. ```python accuracy = accuracy_score(y_test, vader_classifications) report_vader = classification_report(y_test, vader_classifications, zero_division='warn') ``` Esta parte calcula la precisión y el informe de clasificación para las predicciones. 9. Especifica el bloque de ejecución principal. ```python if __name__ == "__main__": ``` Este modismo de Python asegura que el siguiente bloque de código se ejecute solo si este script es el programa principal. Proporciona flexibilidad, permitiendo que el script funcione tanto como un programa independiente como un módulo importado. 10. Crea un bucle infinito para la entrada continua. ```python while True: input_text = input("Enter the text for classification (type 'exit' to end): ") if input_text.lower() == 'exit': print("Exiting...") break ``` Este bucle `while` se ejecuta indefinidamente hasta que se rompe explílicamente. Permite al usuario introducir texto continuamente para el reconocimiento de entidades hasta que decida salir. 11. Analiza el texto. ```python input_text_score = sia.polarity_scores(input_text)["compound"] input_text_classification = 0 if input_text_score > threshold else 1 ``` 12. Imprime el Informe de Clasificación de VADER y el análisis de sentimientos. ```python print(f"Accuracy: {accuracy:.2f}") print("\nVADER Classification Report:") print(report_vader) print(f"\nTest Text (Positive): '{input_text}'") print(f"Predicted Sentiment: {'Positive' if input_text_classification == 0 else 'Negative'}") ``` 13. 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 ... # 03 text_classification scikit-learn==1.3.2 ... ``` Tanto el módulo `nltk` como `scikit-learn` son necesarios para la aplicación de clasificación de texto. ## 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 de 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` and `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 NLP aplicaciones 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. Para obtener más detalles, consulta la [referencia de la CLI de docker build](/reference/cli/docker/buildx/build/). 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. 2. Ejecuta la imagen como un contenedor. En una terminal, ejecuta el siguiente comando. ```console $ docker run -it basic-nlp 03_text_classification.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` or `--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`. - `03_text_classification.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 classification (type 'exit' to end): ``` 3. Prueba la aplicación. Introduce un texto para obtener la clasificación. ```console Enter the text for classification (type 'exit' to end): I love containers! Accuracy: 1.00 VADER Classification Report: precision recall f1-score support 0 1.00 1.00 1.00 1 1 1.00 1.00 1.00 1 accuracy 1.00 2 macro avg 1.00 1.00 1.00 2 weighted avg 1.00 1.00 1.00 2 Test Text (Positive): 'I love containers!' Predicted Sentiment: Positive ``` ## Resumen En esta guía, has aprendido a construir y ejecutar una aplicación de clasificación de texto. Aprendiste a construir la aplicación usando Python con scikit-learn y NLTK. Luego aprendiste 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/) - [scikit-learn](https://scikit-learn.org/) ## Pasos siguientes Explora más [guías de procesamiento del lenguaje natural](/guides/).