Construire une application de reconnaissance de texte

Table des matières

Aperçu

Dans ce guide, vous apprendrez à créer et à exécuter une application de reconnaissance de texte. Vous construirez l'application en utilisant Python avec scikit-learn et le Natural Language Toolkit (NLTK). Ensuite, vous configurerez l'environnement et exécuterez l'application en utilisant Docker.

L'application analyse le sentiment du texte d'un utilisateur en utilisant le SentimentIntensityAnalyzer de NLTK. Elle permet à l'utilisateur de saisir du texte, qui est ensuite traité pour déterminer son sentiment, le classant comme positif ou négatif. De plus, elle affiche la précision et un rapport de classification détaillé de son modèle d'analyse de sentiments basé sur un jeu de données prédéfini.

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

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

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 de classification de texte se trouve dans le fichier Docker-NLP/03_text_classification.py. Ouvrez 03_text_classification.py dans un éditeur de texte ou de code pour explorer son contenu dans les étapes suivantes.

Importez les bibliothèques requises.
import nltk from nltk.sentiment import SentimentIntensityAnalyzer from sklearn.metrics import accuracy_score, classification_report from sklearn.model_selection import train_test_split import ssl
- nltk : Une bibliothèque Python populaire pour le traitement du langage naturel (NLP).
- SentimentIntensityAnalyzer : Un composant de nltk pour l'analyse de sentiments.
- accuracy_score, classification_report : Fonctions de scikit-learn pour évaluer le modèle.
- train_test_split : Fonction de scikit-learn pour diviser les jeux de données en ensembles d'entraînement et de test.
- ssl : Utilisé pour gérer les problèmes de certificat SSL qui могут survenir lors du téléchargement de données pour nltk.
Gérez la vérification du certificat SSL.
try: _create_unverified_https_context = ssl._create_unverified_context except AttributeError: pass else: ssl._create_default_https_context = _create_unverified_https_context
Ce bloc est une solution de contournement pour certains environnements où le téléchargement de données via NLTK pourrait échouer en raison de problèmes de vérification de certificat SSL. Il indique à Python d'ignorer la vérification du certificat SSL pour les requêtes HTTPS.
Téléchargez les ressources NLTK.
nltk.download('vader_lexicon')
Le vader_lexicon est un lexique utilisé par le SentimentIntensityAnalyzer pour l'analyse de sentiments.

Définissez le texte pour les tests et les étiquettes correspondantes.

texts = [
    "I love this product, it's amazing!",
    "This is the worst service I have ever received.",
    "The weather is neutral today.",
    "I am very happy with the results.",
    "I am disappointed with the quality.",
    "This is a spam message, please ignore."
]
labels = [0, 1, 2, 0, 1, 2] # 0: Positive, 1: Negative, 2: Spam

Cette section définit un petit jeu de données de textes et leurs étiquettes correspondantes (0 pour positif, 1 pour négatif et 2 pour spam).

Divisez les données de test.
X_train, X_test, y_train, y_test = train_test_split(texts, labels, test_size=0.2, random_state=42)
Cette partie divise le jeu de données en ensembles d'entraînement et de test, avec 20 % des données comme ensemble de test. Comme cette application utilise un modèle pré-entraîné, elle n'entraîne pas le modèle.
Configurez l'analyse de sentiments.
sia = SentimentIntensityAnalyzer()
Ce code initialise le SentimentIntensityAnalyzer pour analyser le sentiment du texte.
Générez des prédictions et des classifications pour les données de test.
vader_predictions = [sia.polarity_scores(text)["compound"] for text in X_test] threshold = 0.2 vader_classifications = [0 if score > threshold else 1 for score in vader_predictions]
Cette partie génère des scores de sentiment pour chaque texte de l'ensemble de test et les classe comme positifs ou négatifs en fonction d'un seuil.

Évaluez le modèle.

accuracy = accuracy_score(y_test, vader_classifications)
report_vader = classification_report(y_test, vader_classifications, zero_division='warn', labels=list(set(labels)))

Cette partie calcule la précision et le rapport de classification pour les prédictions.

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é.
Créez une boucle infinie pour une saisie continue.
while True: input_text = input("Entrez le texte pour la classification (tapez 'exit' pour terminer) : ") if input_text.lower() == 'exit': print("Sortie...") break
Cette boucle while s'exécute indéfiniment jusqu'à ce qu'elle soit explicitement interrompue. Elle permet à l'utilisateur de saisir continuellement du texte pour la reconnaissance d'entités jusqu'à ce qu'il décide de quitter.

Analysez le texte.

input_text_score = sia.polarity_scores(input_text)["compound"]
input_text_classification = 0 if input_text_score > threshold else 1

Imprimez le rapport de classification VADER et l'analyse de sentiments.

print(f"Précision : {accuracy:.2f}")
print("\nRapport de classification VADER :")
print(report_vader)

print(f"\nTexte de test (positif) : '{input_text}'")
print(f"Sentiment prédit : {'Positif' if input_text_classification == 0 else 'Négatif'}")

Créez requirements.txt. L'application d'exemple contient déjà le fichier requirements.txt pour spécifier les paquets nécessaires que l'application importe. Ouvrez requirements.txt dans un éditeur de code ou de texte pour explorer son contenu.
# 03 classification_de_texte scikit-learn==1.3.2 nltk==3.6.5 ...
Les paquets scikit-learn et nltk sont requis pour l'application de classification de texte.

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.

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.
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.
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.
Installez les dépendances Python dans l'image.
RUN pip install --no-cache-dir -r requirements.txt
Cette ligne utilise pip, l'installateur de paquets Python, pour installer les paquets 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.
Exécutez des commandes supplémentaires.
RUN python -m spacy download en_core_web_sm
Cette étape est spécifique aux applications NLP qui nécessitent la bibliothèque spaCy. Elle télécharge le modèle en_core_web_sm, qui est un petit modèle de langue anglaise pour spaCy. Bien que non nécessaire pour cette application, elle est incluse pour la compatibilité avec d'autres applications NLP qui pourraient utiliser ce Dockerfile.
Copiez le code de l'application dans l'image.
COPY 03_text_classification.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. Ceci 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 dicte comment l'application démarre à l'intérieur du conteneur.
Définissez les permissions pour le script entrypoint.sh.
RUN chmod +x /app/entrypoint.sh
Cette commande modifie les permissions 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.
Définissez le point d'entrée.
ENTRYPOINT ["/app/entrypoint.sh"]
L'instruction ENTRYPOINT configure le conteneur pour qu'il exécute entrypoint.sh comme son exécutable 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'exemple contient plusieurs applications, le script vous permet de spécifier quelle application exécuter lorsque le conteneur démarre.

Exécuter l'application

Pour exécuter l'application en utilisant Docker :

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. L'option -t signifie tag. Elle attribue un nom à l'image, qui dans ce cas est basic-nlp. Les étiquettes sont un moyen pratique de faire référence aux images plus tard, en particulier lors de leur envoi à un registre ou de l'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 cherchera un Dockerfile dans ce répertoire. Le contexte de construction (le répertoire actuel, dans ce cas) est envoyé au démon 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 dans votre console lors de la construction de l'image. Vous le verrez télécharger et installer les dépendances. En fonction de votre connexion réseau, cela peut prendre plusieurs minutes. Docker dispose d'une fonction de mise en cache, de sorte que les constructions ultérieures peuvent être plus rapides. La console reviendra à l'invite lorsque ce sera terminé.
Exécutez l'image en tant que conteneur.

Dans un terminal, exécutez la commande suivante.
$ docker run -it basic-nlp 03_text_classification.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) ouverte même si elle n'est pas attachée. Cela permet au conteneur de rester en cours d'exécution au premier plan et d'être interactif.
  - -t ou --tty : Ceci alloue un pseudo-TTY, simulant essentiellement 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 : Ceci spécifie le nom de l'image Docker à utiliser pour créer le conteneur. Dans ce cas, c'est l'image nommée basic-nlp que vous avez créée avec la commande docker build.
- 03_text_classification.py : C'est le script que vous voulez exécuter à l'intérieur du conteneur Docker. Il est passé 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 de 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 de style 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 ce qui suit dans votre console après le démarrage du conteneur.
Entrez le texte pour la classification (tapez 'exit' pour terminer) :

Testez l'application.

Entrez un commentaire pour obtenir la classification de texte.

Entrez le texte pour la classification (tapez 'exit' pour terminer) : Les conteneurs sont géniaux
Précision : 0.50

Rapport de classification VADER :
              precision    recall  f1-score   support

           0       1.00      0.50      0.67         2
           1       0.00      0.00      0.00         0

avg / total       1.00      0.50      0.67         2


Texte de test (positif) : 'Les conteneurs sont géniaux'
Sentiment prédit : Positif

Résumé

Ce guide a montré comment construire et exécuter une application de classification de texte. Vous avez appris à construire l'application en utilisant Python avec scikit-learn et NLTK, puis à configurer l'environnement et à exécuter l'application en utilisant Docker.

Informations connexes :

Étapes suivantes

Explorez d'autres guides de traitement du langage naturel.