# Construye una aplicación de reconocimiento de entidades nombradas ## Descripción general Esta guía te acompaña en el proceso de construir y ejecutar una aplicación de reconocimiento de entidades nombradas (NER). Construirás la aplicación usando Python con spaCy, y luego configurarás el entorno y la ejecutarás usando Docker. La aplicación procesa el texto de entrada para identificar e imprimir entidades nombradas, como personas, organizaciones o ubicaciones. ## Requisitos previos - Has instalado la última versión de [Docker Desktop](/get-started/get-docker/). Docker añade funciones regularmente y algunas partes de esta guía pueden funcionar solo con la versión más reciente 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 línea de comandos, pero puedes usar cualquier cliente. ## Obtener la aplicación de ejemplo 1. Abre una terminal y clona el repositorio de la aplicación de ejemplo usando el siguiente comando. ```console $ git clone https://github.com/harsh4870/Docker-NLP.git ``` 2. Verifica que hayas 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 reconocimiento de nombres está en el archivo `Docker-NLP/02_name_entity_recognition.py`. Abre `02_name_entity_recognition.py` en un editor de texto o de código para explorar su contenido con los siguientes pasos. 1. Importa las bibliotecas requeridas. ```python import spacy ``` Esta línea importa la biblioteca `spaCy`. `spaCy` es una biblioteca popular en Python utilizada para el procesamiento de lenguaje natural (NLP). 2. Load el modelo de idioma. ```python nlp = spacy.load("en_core_web_sm") ``` Aquí, la función `spacy.load` carga un modelo de idioma. El modelo `en_core_web_sm` es un modelo pequeño de idioma inglés. Puedes usar este modelo para diversas tareas de NLP, incluyendo la tokenización, el etiquetado de partes del discurso y el reconocimiento de entidades nombradas. 3. 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. Ofrece flexibilidad, lo que permite que el script funcione tanto como un programa independiente como un módulo importado. 4. Crea un bucle infinito para la entrada continua de datos. ```python while True: ``` Este bucle while se ejecuta indefinidamente hasta que se rompe explícitamente. Permite al usuario ingresar texto continuamente para el reconocimiento de entidades hasta que decida salir. 5. Obtén la entrada del usuario. ```python input_text = input("Enter the text for entity recognition (type 'exit' to end): ") ``` Esta línea le pide al usuario que ingrese texto. El programa luego realizará el reconocimiento de entidades en este texto. 6. Define una condición de salida. ```python if input_text.lower() == 'exit': print("Exiting...") break ``` Si el usuario escribe algo, el programa convierte la entrada a minúsculas y la compara con `exit`. Si coinciden, el programa imprime **Exiting...** y sale del bucle while, finalizando efectivamente el programa. 7. Realiza el reconocimiento de entidades nombradas. ```python doc = nlp(input_text) for ent in doc.ents: print(f"Entity: {ent.text}, Type: {ent.label_}") ``` - `doc = nlp(input_text)`: Aquí, el modelo nlp procesa el texto ingresado por el usuario. Esto crea un objeto Doc que contiene varios atributos de NLP, incluidas las entidades identificadas. - `for ent in doc.ents:`: Este bucle itera sobre las entidades encontradas en el texto. - `print(f"Entity: {ent.text}, Type: {ent.label_}")`: Para cada entidad, imprime el texto de la entidad y su tipo (como PERSON, ORG o GPE). 8. 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 de texto para explorar su contenido. ```text # 02 reconocimiento de entidades nombradas spacy==3.7.2 ... ``` Solo se requiere el paquete `spacy` para la aplicación de reconocimiento de nombres. ## Explorar el entorno de la aplicación Utilizarás Docker para ejecutar la aplicación en un contenedor. Docker te permite contenedorizar la aplicación, proporcionando un entorno coherente 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 ú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 configurarlo en `/app`, aseguras 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` desactiva 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 biblioteca spaCy. Descarga el modelo `en_core_web_sm`, que es un modelo pequeño de idioma inglés para spaCy. 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. Configura 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 asegurar que el contenedor Docker pueda ejecutar este script para iniciar la aplicación. 8. Establece el punto de entrada (entry point). ```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 de texto. Dado que el ejemplo contiene varias aplicaciones, el script te permite 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 muestra un 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 especificada, 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 tarde, especialmente al subirlas a un registro o al 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 registros 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 tomar varios minutos. Docker cuenta con una función de caché, por lo que las construcciones posteriores pueden ser más rápidas. La consola volverá al prompt cuando termine. 2. Ejecuta la imagen como un contenedor. En una terminal, ejecuta el siguiente comando. ```console $ docker run -it basic-nlp 02_name_entity_recognition.py ``` A continuación se muestra un 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á conectado. 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 de comandos o un shell. Esto 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 usará para crear el contenedor. En este caso, es la imagen llamada `basic-nlp` que creaste con el comando `docker build`. - `02_name_entity_recognition.py`: Este es el script que deseas ejecutar dentro del contenedor Docker. Se pasa al script `entrypoint.sh`, que lo ejecuta cuando el contenedor se inicia. 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 entity recognition (type 'exit' to end): ``` 3. Prueba la aplicación. Ingresa alguna información para obtener el reconocimiento de entidades nombradas. ```console Enter the text for entity recognition (type 'exit' to end): Apple Inc. is planning to open a new store in San Francisco. Tim Cook is the CEO of Apple. Entity: Apple Inc., Type: ORG Entity: San Francisco, Type: GPE Entity: Tim Cook, Type: PERSON Entity: Apple, Type: ORG ``` ## Resumen Esta guía demostró cómo construir y ejecutar una aplicación de reconocimiento de entidades nombradas. Aprendiste a construir la aplicación usando Python con spaCy, 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/) - [spaCy](https://spacy.io/) - [Documentación de Python](https://docs.python.org/3/) ## Siguientes pasos Explora más [guías de procesamiento de lenguaje natural](/guides/).