Construire une application d'analyse de sentiments

Table des matières

Aperçu

Dans ce guide, vous apprendrez à construire et à exécuter une application d'analyse de sentiments. Vous construirez l'application en utilisant Python avec le Natural Language Toolkit (NLTK), puis vous configurerez l'environnement et exécuterez l'application en utilisant Docker.

L'application analyse le texte d'entrée de l'utilisateur pour le sentiment en utilisant le SentimentIntensityAnalyzer de NLTK et indique si le sentiment est positif, négatif ou neutre.

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 d'analyse de sentiments se trouve dans le fichier Docker-NLP/01_sentiment_analysis.py. Ouvrez 01_sentiment_analysis.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 import ssl
- nltk : Il s'agit de la bibliothèque Natural Language Toolkit utilisée pour travailler avec les données du langage humain en Python.
- SentimentIntensityAnalyzer : Il s'agit d'un outil spécifique de NLTK utilisé pour déterminer le sentiment d'un morceau de texte.
- ssl : Ce module donne accès aux fonctions de Transport Layer Security (cryptage) utilisées pour les connexions web sécurisées.
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') nltk.download('punkt')
- vader_lexicon : Il s'agit d'un lexique utilisé par le SentimentIntensityAnalyzer pour l'analyse des sentiments.
- punkt : Il est utilisé par NLTK pour la tokenisation des phrases. Il est nécessaire au bon fonctionnement du SentimentIntensityAnalyzer.

Créez une fonction d'analyse de sentiments.

def perform_semantic_analysis(text):
    sid = SentimentIntensityAnalyzer()
    sentiment_score = sid.polarity_scores(text)

    if sentiment_score['compound'] >= 0.05:
        return "Positive"
    elif sentiment_score['compound'] <= -0.05:
        return "Negative"
    else:
        return "Neutral"

SentimentIntensityAnalyzer() crée une instance de l'analyseur.
polarity_scores(text) génère un score de sentiment pour le texte d'entrée.

La fonction renvoie Positif, Négatif ou Neutre en fonction du score composé.

Créez la boucle principale.

if __name__ == "__main__":
    while True:
        input_text = input("Entrez le texte pour l'analyse sémantique (tapez 'exit' pour terminer) : ")

        if input_text.lower() == 'exit':
            print("Sortie...")
            break

        result = perform_semantic_analysis(input_text)
        print(f"Sentiment : {result}")

Cette partie du script exécute une boucle infinie pour accepter l'entrée de l'utilisateur pour analyse. Si l'utilisateur tape exit, le programme se termine. Sinon, il imprime le sentiment du texte fourni.

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.
# 01 analyse_des_sentiments nltk==3.6.5 ...
Seul le paquet nltk est requis pour l'application d'analyse de sentiments.

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 vers l'image Docker. Ce fichier liste tous les dépendances Python nécessaires par l'application. Le copier dans le conteneur permet à la commande suivante (RUN pip install) d'installer ces dépendances à l'intérieur de 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 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.
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. Il télécharge le modèle en_core_web_sm, qui est un petit modèle linguistique anglais 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.
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 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'é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 :

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

Pour plus de détails, consultez la référence de la CLI docker build.
Exécuter l'image en tant que conteneur.

Dans un terminal, exécutez la commande suivante.
$ docker run -it basic-nlp 01_sentiment_analysis.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) ouvert même si non attaché. Cela permet au conteneur de rester en cours d'exécution en arrière-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.
- 01_sentiment_analysis.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 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 des 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 l'analyse sémantique (tapez 'exit' pour terminer) :

Tester l'application.

Entrez un commentaire pour obtenir l'analyse de sentiment.

Entrez le texte pour l'analyse sémantique (tapez 'exit' pour terminer) : J'aime les conteneurs !
Sentiment : Positive
Entrez le texte pour l'analyse sémantique (tapez 'exit' pour terminer) : Je suis encore en train d'apprendre à propos des conteneurs.
Sentiment : Neutre

Résumé

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

Informations connexes :

Étapes suivantes

Explorez plus guides d'analyse du langage naturel.