Construire une application de reconnaissance d'entités nommées

Table des matières

Aperçu

Ce guide vous guide dans la construction et l'exécution d'une application de reconnaissance d'entités nommées (NER). Vous construirez l'application en utilisant Python avec spaCy, puis vous configurerez l'environnement et exécuterez l'application en utilisant Docker.

L'application traite le texte d'entrée pour identifier et imprimer les entités nommées, comme les personnes, les organisations ou les lieux.

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

Importez les bibliothèques requises.
import spacy
Cette ligne importe la bibliothèque spaCy. spaCy est une bibliothèque populaire en Python utilisée pour le traitement du langage naturel (NLP).
Chargez le modèle de langue.
nlp = spacy.load("en_core_web_sm")
Ici, la fonction spacy.load charge un modèle de langue. Le modèle en_core_web_sm est un petit modèle de langue anglaise. Vous pouvez utiliser ce modèle pour diverses tâches de NLP, y compris la tokenisation, l'étiquetage des parties du discours et la reconnaissance d'entités nommées.
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:
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.
Obtenez l'entrée de l'utilisateur.
input_text = input("Entrez le texte pour la reconnaissance d'entités (tapez 'exit' pour terminer) : ")
Cette ligne invite l'utilisateur à saisir du texte. Le programme effectuera ensuite une reconnaissance d'entités sur ce texte.
Définissez une condition de sortie.
if input_text.lower() == 'exit': print("Sortie...") break
Si l'utilisateur tape quelque chose, le programme convertit l'entrée en minuscules et la compare à exit. S'ils correspondent, le programme imprime Sortie... et sort de la boucle while, mettant ainsi fin au programme.
Effectuez la reconnaissance d'entités nommées.
doc = nlp(input_text) for ent in doc.ents: print(f"Entité : {ent.text}, Type : {ent.label_}")
- doc = nlp(input_text) : Ici, le modèle nlp traite le texte saisi par l'utilisateur. Cela crée un objet Doc qui contient divers attributs NLP, y compris les entités identifiées.
- for ent in doc.ents: : Cette boucle itère sur les entités trouvées dans le texte.
- print(f"Entité : {ent.text}, Type : {ent.label_}") : Pour chaque entité, elle imprime le texte de l'entité et son type (comme PERSONNE, ORG ou GPE).
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.
# 02 reconnaissance_entite_nommee spacy==3.7.2 ...
Seul le paquet spacy est requis pour l'application de reconnaissance de noms.

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 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.
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 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 exécuter 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 taguer l'image. La marque -t signifie tag. Elle attribue un nom à l'image, ce qui est basic-nlp dans ce cas. Les balises sont une manière pratique de faire référence aux images plus tard, surtout lors de leur envoi vers un registre ou lors de la création 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 fonctionnalité de mise en cache, donc les constructions ultérieures peuvent être plus rapides. La console retourne à l'invite de commande lorsqu'elle est terminée.
Exécuter l'image en tant que conteneur.

Dans un terminal, exécutez la commande suivante.
$ docker run -it basic-nlp 02_name_entity_recognition.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 : Cela 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 en avant-plan et d'être interactif.
  - -t ou --tty : Cela 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.
- 02_name_entity_recognition.py : C'est le script que vous souhaitez exécuter à l'intérieur du conteneur Docker. 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 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 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 le suivant dans votre console après le démarrage du conteneur.
Entrez le texte pour la reconnaissance d'entités (tapez 'exit' pour terminer) :

Tester l'application.

Entrez quelques informations pour obtenir la reconnaissance d'entités nommées.

Entrez le texte pour la reconnaissance d'entités (tapez 'exit' pour terminer) : Apple Inc. est en train d'ouvrir une nouvelle boutique à San Francisco. Tim Cook est le PDG d'Apple.

Entité : Apple Inc., Type : ORG
Entité : San Francisco, Type : GPE
Entité : Tim Cook, Type : PERSON
Entité : Apple, Type : ORG

Résumé

Ce guide a montré comment construire et exécuter une application de reconnaissance d'entités nommées. Vous avez appris à construire l'application en utilisant Python avec spaCy, puis à configurer l'environnement et exécuter l'application en utilisant Docker.

Informations connexes :

Étapes suivantes

Explorez plus guides de traitement du langage naturel.