Construire une application de traduction de langue

Aperçu

Ce guide vous guide dans la construction et l'exécution d'une application de traduction de langue. Vous construirez l'application en utilisant Python avec Googletrans, puis vous configurerez l'environnement et exécuterez l'application en utilisant Docker.

L'application démontre une utilisation simple mais pratique de la bibliothèque Googletrans pour la traduction de langue, mettant en valeur les concepts de base de Python et Docker. Googletrans est une bibliothèque Python gratuite et illimitée qui implémente l'API Google Translate. Elle utilise l'API Ajax de Google Translate pour effectuer des appels à des méthodes telles que la détection et la traduction.

Prérequis

• Vous avez installé la dernière version de Docker Desktop. Docker ajoute régulièrement de nouvelles fonctionnalités et certaines parties de ce guide peuvent ne fonctionner qu'avec la dernière version de Docker Desktop.
• Vous avez un client Git. Les exemples de cette section utilisent un client Git en ligne de commande, mais vous pouvez utiliser n'importe quel client.

Obtenir l'application d'exemple

1. Ouvrez un terminal et clonez le dépôt de l'application d'exemple en utilisant la commande suivante.

   $ git clone https://github.com/harsh4870/Docker-NLP.git
   

2. Vérifiez que vous avez cloné le dépôt.

   Vous devriez voir les fichiers suivants dans votre répertoire 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

Explorer le code de l'application

Le code source de l'application se trouve dans le fichier Docker-NLP/05_language_translation.py. Ouvrez 05_language_translation.py dans un éditeur de texte ou de code pour explorer son contenu dans les étapes suivantes.

1. Importez les bibliothèques requises.

   from googletrans import Translator

   Cette ligne importe la classe Translator de googletrans. Googletrans est une bibliothèque Python qui fournit une interface à l'API AJAX de Google Translate.

2. Spécifiez le bloc d'exécution principal.

   if __name__ == "__main__":

   Cette expression idiomatique Python garantit que le bloc de code suivant ne s'exécute que si ce script est le programme principal. Elle offre une flexibilité, permettant au script de fonctionner à la fois comme un programme autonome et comme un module importé.

3. Créez une boucle infinie pour une saisie continue.

      while True:
         input_text = input("Entrez le texte pour la traduction (tapez 'exit' pour terminer) : ")
   
         if input_text.lower() == 'exit':
            print("Sortie...")
            break

   Une boucle infinie est établie ici pour vous inviter continuellement à saisir du texte, garantissant l'interactivité. La boucle se termine lorsque vous tapez exit, vous permettant de contrôler efficacement le flux de l'application.

4. Créez une instance de Translator.

         translator = Translator()

   Ceci crée une instance de la classe Translator, qui effectue la traduction.

5. Traduisez le texte.

         translated_text = translator.translate(input_text, dest='fr').text

   Ici, la méthode translator.translate est appelée avec l'entrée de l'utilisateur. L'argument dest='fr' spécifie que la langue de destination pour la traduction est le français. L'attribut .text obtient la chaîne traduite. Pour plus de détails sur les codes de langue disponibles, consultez la documentation de Googletrans.

6. Imprimez le texte original et le texte traduit.

         print(f"Texte original : {input_text}")
         print(f"Texte traduit : {translated_text}")

   Ces deux lignes impriment le texte original saisi par l'utilisateur et le texte traduit.

7. Créez requirements.txt. L'application d'exemple contient déjà le fichier requirements.txt pour spécifier les modules nécessaires que l'application importe. Ouvrez requirements.txt dans un éditeur de code ou de texte pour explorer son contenu.

   ...
   
   # 05 traduction_de_langue
   googletrans==4.0.0-rc1

   Seul googletrans est requis pour l'application de traduction de langue.

Explorer l'environnement de l'application

Vous utiliserez Docker pour exécuter l'application dans un conteneur. Docker vous permet de conteneuriser l'application, fournissant un environnement cohérent et isolé pour son exécution. Cela signifie que l'application fonctionnera comme prévu dans son conteneur Docker, quelles que soient les différences du système sous-jacent.

Pour exécuter l'application dans un conteneur, un Dockerfile est requis. Un Dockerfile est un document texte qui contient toutes les commandes que vous appelleriez sur la ligne de commande pour assembler une image. Une image est un modèle en lecture seule avec des instructions pour créer un conteneur Docker.

L'application d'exemple contient déjà un Dockerfile. Ouvrez le Dockerfile dans un éditeur de code ou de texte pour explorer son contenu.

Les étapes suivantes expliquent chaque partie du Dockerfile. Pour plus de détails, consultez la référence du Dockerfile.

1. Spécifiez l'image de base.

   FROM python:3.8-slim

   Cette commande définit la base de la construction. python:3.8-slim est une version légère de l'image Python 3.8, optimisée pour la taille et la vitesse. L'utilisation de cette image légère réduit la taille globale de votre image Docker, ce qui entraîne des téléchargements plus rapides et moins de surface pour les vulnérabilités de sécurité. Ceci est particulièrement utile pour une application basée sur Python où vous n'avez peut-être pas besoin de l'image Python standard complète.

2. Définissez le répertoire de travail.

   WORKDIR /app

   WORKDIR définit le répertoire de travail actuel dans l'image Docker. En le définissant sur /app, vous vous assurez que toutes les commandes suivantes dans le Dockerfile (comme COPY et RUN) sont exécutées dans ce répertoire. Cela aide également à organiser votre image Docker, car tous les fichiers liés à l'application sont contenus dans un répertoire spécifique.

3. Copiez le fichier des exigences dans l'image.

   COPY requirements.txt /app

   La commande COPY transfère le fichier requirements.txt de votre machine locale dans l'image Docker. Ce fichier répertorie toutes les dépendances Python requises par l'application. Le copier dans le conteneur permet à la commande suivante (RUN pip install) d'installer ces dépendances dans l'environnement de l'image.

4. Installez les dépendances Python dans l'image.

   RUN pip install --no-cache-dir -r requirements.txt

   Cette ligne utilise pip, l'installateur de package Python, pour installer les packages listés dans requirements.txt. L'option --no-cache-dir désactive le cache, ce qui réduit la taille de l'image Docker en ne stockant pas les données de cache inutiles.

5. Exécutez des commandes supplémentaires.

   RUN python -m spacy download en_core_web_sm

   Cette étape est spécifique aux applications NLP qui requièrent la bibliothèque spaCy. Il télécharge le modèle en_core_web_sm, qui est un petit modèle de langue anglaise pour spaCy. Bien que ce n'est pas nécessaire pour cette application, il est inclus pour la compatibilité avec d'autres applications NLP qui pourraient utiliser ce Dockerfile.

6. Copiez le code de l'application dans l'image.

   COPY *.py /app
   COPY entrypoint.sh /app

   Ces commandes copient vos scripts Python et le script entrypoint.sh dans le répertoire /app de l'image. C'est crucial car le conteneur a besoin de ces scripts pour exécuter l'application. Le script entrypoint.sh est particulièrement important car il indique comment l'application se démarque à l'intérieur du conteneur.

7. Définissez les autorisations pour le script entrypoint.sh.

   RUN chmod +x /app/entrypoint.sh

   Cette commande modifie les autorisations du fichier entrypoint.sh, le rendant exécutable. Cette étape est nécessaire pour s'assurer que le conteneur Docker peut exécuter ce script pour démarrer l'application.

8. Définissez le point d'entrée.

   ENTRYPOINT ["/app/entrypoint.sh"]

   L'instruction ENTRYPOINT configure le conteneur pour exécuter entrypoint.sh comme son executable par défaut. Cela signifie que lorsque le conteneur démarre, il exécute automatiquement le script.

   Vous pouvez explorer le script entrypoint.sh en l'ouvrant dans un éditeur de code ou de texte. Comme l'échantillon contient plusieurs applications, le script vous permet de spécifier quelle application doit être exécutée lorsque le conteneur démarre.

Exécuter l'application

Pour exécuter l'application en utilisant Docker :

1. Construire l'image.

   Dans un terminal, exécutez la commande suivante à l'intérieur du répertoire où se trouve le Dockerfile.

   $ docker build -t basic-nlp .
   

   La commande suivante est une décomposition de la commande :

   • docker build : C'est la commande principale utilisée pour construire une image Docker à partir d'un Dockerfile et d'un contexte. Le contexte est généralement un ensemble de fichiers à un emplacement spécifié, souvent le répertoire contenant le Dockerfile.
   • -t basic-nlp : C'est une option pour étiqueter l'image. La marque -t signifie tag. Il attribue un nom à l'image, ce qui dans ce cas est basic-nlp. Les étiquettes sont une manière pratique de faire référence aux images plus tard, surtout lors de leur envoi à un registre ou de leur exécution de conteneurs.
   • . : C'est la dernière partie de la commande et spécifie le contexte de construction. Le point (.) désigne le répertoire actuel. Docker va chercher un Dockerfile dans ce répertoire. Le contexte de construction (le répertoire actuel, dans ce cas) est envoyé au daemon Docker pour permettre la construction. Il inclut tous les fichiers et sous-répertoires dans le répertoire spécifié.

   Pour plus de détails, consultez la référence de la CLI docker build.

   Docker affiche plusieurs journaux à votre console lors de la construction de l'image. Vous verrez qu'il télécharge et installe les dépendances. En fonction de votre connexion réseau, cela peut prendre plusieurs minutes. Docker a une fonction de mise en cache, donc les constructions suivantes peuvent être plus rapides. La console retourne à l'invite de commande lorsqu'elle est terminée.

2. Exécuter l'image en tant que conteneur.

   Dans un terminal, exécutez la commande suivante.

   $ docker run -it basic-nlp 05_language_translation.py
   

   La commande suivante est une décomposition de la commande :

   • docker run : C'est la commande principale utilisée pour exécuter un nouveau conteneur à partir d'une image Docker.
   • -it : C'est une combinaison de deux options :
     • -i ou --interactive : Ceci maintient l'entrée standard (STDIN) ouvert même si non attaché. Il permet au conteneur de rester en cours d'exécution en premier plan et d'être interactif.
     • -t ou --tty : Ceci alloue un pseudo TTY, essentiellement simulant un terminal, comme une invite de commande ou un shell. C'est ce qui vous permet d'interagir avec l'application à l'intérieur du conteneur.
   • basic-nlp : Cela spécifie le nom de l'image Docker à utiliser pour créer le conteneur. Dans ce cas, il s'agit de l'image nommée basic-nlp que vous avez créée avec la commande docker build.
   • 05_language_translation.py : C'est le script que vous souhaitez exécuter à l'intérieur du Docker container. Il est transmis au script entrypoint.sh, qui l'exécute lorsque le conteneur démarre.

   Pour plus de détails, consultez la référence de la CLI docker run.

   Note

   Pour les utilisateurs Windows, vous pouvez obtenir une erreur lors de l'exécution du conteneur. Vérifiez que les fins de ligne dans le entrypoint.sh sont LF (\n) et non CRLF (\r\n), puis reconstruisez l'image. Pour plus de détails, consultez [Éviter les erreurs de syntaxe inattendues, utiliser les fins de ligne Unix pour les fichiers dans les conteneurs](/desktop/troubleshoot-and-support/troubleshoot/topics/#Unexpected-syntax-errors-use-Unix-style-line endings-for-files-in-containers).

   Vous verrez la suivante dans votre console après le démarrage du conteneur.

   Entrez le texte pour la traduction (tapez 'exit' pour terminer) :
   

3. Tester l'application.

   Entrez du texte pour obtenir le résumé de texte.

   Entrez le texte pour la traduction (tapez 'exit' pour terminer) : Bonjour comment allez-vous?
   Texte original : Bonjour comment allez-vous?
   Texte traduit : Hello, how are you doing?
   

Résumé

Dans ce guide, vous avez appris à construire et à exécuter une application de traduction de langue. Vous avez appris à construire l'application en utilisant Python avec Googletrans, puis à configurer l'environnement et à exécuter l'application en utilisant Docker.

Informations connexes :

• Référence de la CLI docker
• Référence du Dockerfile
• Googletrans
• Documentation Python

Étapes suivantes

Explorez plus guides de traitement du langage naturel.