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. 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 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.

   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.

   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.

      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.

         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.

   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.

   ...
   
   # 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.

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.

   Para obtener más detalles, consulta la referencia de la CLI de docker 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.

   $ 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.

   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 summarization (type 'exit' to end):
   

3. Prueba la aplicación.

   Introduce un texto para obtener el resumen.

   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
• Referencia de Dockerfile
• Bert Extractive Summarizer
• PyTorch
• Documentación de Python

Pasos siguientes

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