Construye una aplicación de traducción de idiomas

Tabla de contenidos

Descripción general

Esta guía te acompaña en el proceso de construir y ejecutar una aplicación de traducción de idiomas. Construirás la aplicación usando Python con Googletrans, y luego configurarás el entorno y la ejecutarás usando Docker.

La aplicación demuestra un uso sencillo pero práctico de la biblioteca Googletrans para la traducción de idiomas, mostrando conceptos básicos de Python y Docker. Googletrans es una biblioteca de Python gratuita e ilimitada que implementa la API de Google Translate. Utiliza la API Ajax de Google Translate para realizar llamadas a métodos como detect y translate.

Requisitos previos

Has instalado la última versión de Docker Desktop. Docker añade nuevas 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. 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

Abre una terminal y clona el repositorio de la aplicación de ejemplo usando el siguiente comando.
$ git clone https://github.com/harsh4870/Docker-NLP.git

Verifica que hayas 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 está en el archivo Docker-NLP/05_language_translation.py. Abre 05_language_translation.py en un editor de texto o de código para explorar su contenido con los siguientes pasos.

Importa las bibliotecas requeridas.
from googletrans import Translator
Esta línea importa la clase Translator de googletrans. Googletrans es una biblioteca de Python que proporciona una interfaz para la API AJAX de Google Translate.
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. Ofrece flexibilidad, lo que permite que el script funcione tanto como un programa independiente como un módulo importado.
Crea un bucle infinito para la entrada continua de datos.
while True: input_text = input("Enter the text for translation (type 'exit' to end): ") if input_text.lower() == 'exit': print("Exiting...") break
Aquí se establece un bucle infinito para pedirte continuamente que ingreses texto, asegurando la interactividad. El bucle finaliza cuando escribes exit, lo que te permite controlar el flujo de la aplicación de manera efectiva.
Crea una instancia de Translator.
translator = Translator()
Esto crea una instancia de la clase Translator, que realiza la traducción.
Traduce el texto.
translated_text = translator.translate(input_text, dest='fr').text
Aquí se llama al método translator.translate con la entrada del usuario. El argumento dest='fr' especifica que el idioma de destino para la traducción es el francés. El atributo .text obtiene la cadena traducida. Para obtener más detalles sobre los códigos de idioma disponibles, consulta la documentación de Googletrans.
Muestra el texto original y el traducido.
print(f"Original Text: {input_text}") print(f"Translated Text: {translated_text}")
Estas dos líneas imprimen el texto original ingresado por el usuario y el texto traducido.
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.
... # 05 traducción de idiomas googletrans==4.0.0-rc1
Solo se requiere googletrans para la aplicación de traducción de idiomas.

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.

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 útil para una aplicación basada en Python donde podrías no necesitar la imagen estándar completa de Python.
Establece el directorio de trabajo.
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 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.
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.
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 desactiva la caché, lo que reduce el tamaño de la imagen de Docker al no almacenar datos de caché innecesarios.
Ejecuta comandos adicionales.
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. Aunque no es necesario para esta aplicación, se incluye para mantener la compatibilidad con otras aplicaciones de NLP que podrían usar este Dockerfile.
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.
Configura 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 asegurar que el contenedor Docker pueda ejecutar este script para iniciar la aplicación.
Establece el punto de entrada (entry point).
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:

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 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.
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.
Ejecuta la imagen como un contenedor.
En una terminal, ejecuta el siguiente comando.
$ docker run -it basic-nlp 05_language_translation.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.
- 05_language_translation.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.
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.
Verás lo siguiente en tu consola después de que se inicie el contenedor.
Enter the text for translation (type 'exit' to end):

Test la aplicación.

Ingresa algo de texto para obtener la traducción.

Enter the text for translation (type 'exit' to end): Hello, how are you doing?
Original Text: Hello, how are you doing?
Translated Text: Bonjour comment allez-vous?

Resumen

En esta guía, aprendiste a construir y ejecutar una aplicación de traducción de idiomas. Aprendiste a construir la aplicación usando Python con Googletrans, y luego a configurar el entorno y ejecutar la aplicación usando Docker.

Información relacionada:

Siguientes pasos

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

¿En qué te puedo ayudar?

Construye una aplicación de traducción de idiomas