# Construye una aplicación de resumen de texto ## Vista general En esta guía, aprenderás a construir y ejecutar una aplicación de resumen de texto. Construirás la aplicación usando Python con Bert Extractive Summarizer, y luego configurarás el entorno y ejecutarás la aplicación usando Docker. La aplicación de ejemplo de resumen de texto utiliza Bert Extractive Summarizer. Esta herramienta emplea la librería transformers de HuggingFace Pytorch para ejecutar resúmenes extractivos. Esto funciona primero incrustando (embedding) las oraciones, luego ejecutando un algoritmo de agrupamiento (clustering) y encontrando las oraciones que están más cerca de los centroides del grupo. ## 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 resumen de texto se encuentra en el archivo `Docker-NLP/04_text_summarization.py`. Abre `04_text_summarization.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 from summarizer import Summarizer ``` Esta línea de código importa la clase `Summarizer` del paquete `summarizer`, esencial para tu aplicación de resumen de texto. El módulo summarizer implementa Bert Extractive Summarizer, aprovechando la librería transformers de HuggingFace Pytorch, muy reconocida en el ámbito de NLP (Procesamiento del Lenguaje Natural). Esta librería ofrece acceso a modelos preentrenados como BERT, que revolucionaron las tareas de comprensión del lenguaje, incluido el resumen de texto. El modelo BERT, o Bidirectional Encoder Representations from Transformers, destaca en la comprensión del contexto en el lenguaje, utilizando un mecanismo conocido como "atención" para determinar la importancia de las palabras en una oración. Para el resumen, el modelo incrusta las oraciones y luego utiliza un algoritmo de agrupamiento para identificar las oraciones clave (aquellas más cercanas a los centroides de estos grupos), capturando eficazmente las ideas principales del texto. 2. 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. 3. Crea un bucle infinito para la entrada continua. ```python while True: input_text = input("Enter the text for summarization (type 'exit' to end): ") if input_text.lower() == 'exit': print("Exiting...") break ``` Un bucle infinito te solicita continuamente texto de entrada, asegurando la interactividad. El bucle se rompe cuando escribes `exit`, lo que te ayuda a controlar el flujo de la aplicación de manera efectiva. 4. Crea una instancia de Summarizer. ```python bert_model = Summarizer() ``` Aquí, creas una instancia de la clase Summarizer llamada `bert_model`. Esta instancia ya está lista para realizar la tarea de resumen utilizando el modelo BERT, simplificando los complejos procesos de incrustación de oraciones y agrupación en una interfaz accesible. 5. Genera e imprime un resumen. ```python summary = bert_model(input_text) print(summary) ``` Tu texto de entrada es procesado por la instancia `bert_model`, que luego devuelve una versión resumida. Esto demuestra el poder de las librerías de alto nivel de Python para permitir operaciones complejas con un código mínimo. 6. Crea `requirements.txt`. La aplicación de ejemplo ya contiene el archivo `requirements.txt` para especificar los módulos necesarios que importa la aplicación. Abre `requirements.txt` en un editor de código o de texto para explorar su contenido. ```text ... # 04 text_summarization bert-extractive-summarizer==0.10.1 ... torch==2.1.2 ``` Los módulos `bert-extractive-summarizer` y `torch` son necesarios para la aplicación de resumen de texto. El módulo summarizer genera un resumen del texto de entrada. Esto requiere PyTorch porque el modelo BERT subyacente, que se utiliza para generar el resumen, está implementado en PyTorch. ## 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. 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 04_text_summarization.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`. - `04_text_summarization.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 summarization (type 'exit' to end): ``` 3. Prueba la aplicación. Introduce un texto para obtener el resumen. ```console Enter the text for summarization (type 'exit' to end): Artificial intelligence (AI) is a branch of computer science that aims to create machines capable of intelligent behavior. These machines are designed to mimic human cognitive functions such as learning, problem-solving, and decision-making. AI technologies can be classified into two main types: narrow or weak AI, which is designed for a particular task, and general or strong AI, which possesses the ability to understand, learn, and apply knowledge across various domains. One of the most popular approaches in AI is machine learning, where algorithms are trained on large datasets to recognize patterns and make predictions. Artificial intelligence (AI) is a branch of computer science that aims to create machines capable of intelligent behavior. These machines are designed to mimic human cognitive functions such as learning, problem-solving, and decision-making. ``` ## Resumen En esta guía, has aprendido a construir y ejecutar una aplicación de resumen de texto. Aprendiste a construir la aplicación usando Python con Bert Extractive Summarizer, 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/) - [Bert Extractive Summarizer](https://github.com/dmmiller612/bert-extractive-summarizer) - [PyTorch](https://pytorch.org/) - [Documentación de Python](https://docs.python.org/3/) ## Pasos siguientes Explora más [guías de procesamiento del lenguaje natural](/guides/).