Comment créer un modèle d'analyse des sentiments à partir de zéro

L'analyse des sentiments est une technique de traitement du langage naturel (TLN) qui identifie l'attitude derrière un texte. Il est également connu sous le nom de sondage d'opinion. Le but de l'analyse des sentiments est d'identifier si un certain texte a un sentiment positif, négatif ou neutre. Il est largement utilisé par les entreprises pour classer automatiquement le sentiment dans les avis clients. L'analyse de grands volumes d'avis permet d'obtenir des informations précieuses sur les préférences des clients.

Configuration de votre environnement

Vous devez vous familiariser avec Les bases de Python à suivre. Aller vers Colab Google ou ouvrez Jupyter Notebook. Créez ensuite un nouveau bloc-notes. Exécutez la commande suivante pour installer les bibliothèques requises dans votre environnement.

Le code source complet de ce projet est disponible dans ce Référentiel GitHub.

! pip installer tensorflow scikit-learn pandas numpy pickle5

Vous utiliserez NumPy et bibliothèque pandas pour manipuler l'ensemble de données. TensorFlow pour la création et l'entraînement du modèle d'apprentissage automatique. Scikit-learn pour diviser l'ensemble de données en ensembles d'apprentissage et de test. Enfin, vous utiliserez pickle5 pour sérialiser et enregistrer l'objet tokenizer.

Importation des bibliothèques requises

Importez les bibliothèques nécessaires que vous utiliserez pour prétraiter les données et créer le modèle.

importer numpy comme np
importer pandas comme pd
importer flux tenseur comme tf
depuis sklearn.model_selection importer train_test_split
depuis sklearn.metrics importer précision_score
depuis tensorflow.keras.preprocessing.text importer Générateur de jetons
depuis tensorflow.keras.preprocessing.séquence importer pad_séquences
depuis tensorflow.keras.models importer Séquentiel
depuis tensorflow.keras.layers importer Intégration, Conv1D, GlobalMaxPooling1D, Dense, Abandon
importer cornichon5 comme cornichon

Vous utiliserez les classes que vous importez des modules plus tard dans le code.

Chargement du jeu de données

Ici, vous utiliserez l'ensemble de données Trip Advisor Hotel Reviews de Kagglé pour construire le modèle d'analyse des sentiments.

df = pd.read_csv('/content/tripadvisor_hotel_reviews.csv')
imprimer (df.head())

Chargez le jeu de données et imprimez ses cinq premières lignes. L'impression des cinq premières lignes vous aidera à vérifier les noms de colonne de votre ensemble de données. Cela sera crucial lors du prétraitement de l'ensemble de données.

L'ensemble de données Trip Advisor Hotel Reviews comporte une colonne d'index, une colonne Review et une colonne Rating.

Prétraitement des données

Sélectionnez le Examen et Notation colonnes du jeu de données. Créez une nouvelle colonne basée sur la colonne Note et nommez-la sentiment. Si la note est supérieure à 3, étiquetez le sentiment comme positif. Si la note est inférieure à 3, étiquetez-la comme négatif. Si la note est exactement 3, étiquetez-la comme neutre.

Sélectionnez uniquement les colonnes Review et Sentiment dans l'ensemble de données. Mélangez les lignes de manière aléatoire et réinitialisez l'index de la trame de données. Le mélange et la réinitialisation garantissent que les données sont distribuées de manière aléatoire, ce qui est nécessaire pour une formation et un test appropriés du modèle.

df = df[['Examen', 'Notation']]
df['sentiment'] = df['Notation'].appliquer(lambda X: 'positif'si x> 3
autre'négatif'si x < 3
autre'neutre')
df = df[['Examen', 'sentiment']]
df = df.échantillon (frac=1).reset_index (drop=Vrai)

Convertir le Examen texte en une séquence d'entiers à l'aide du tokenizer. Cela crée un dictionnaire des mots uniques présents dans le texte Review et mappe chaque mot à une valeur entière unique. Utilisez le pad_séquences fonction de Keras pour s'assurer que toutes les séquences de révision ont la même longueur.

tokenizer = Tokenizer (num_words=5000, oov_token='')
tokenizer.fit_on_texts (df['Examen'])
word_index = tokenizer.word_index
sequences = tokenizer.texts_to_sequences (df['Examen'])
padded_sequences = pad_sequences (séquences, maxlen=100, tronquant='poste')

Convertissez les étiquettes de sentiment en codage One-hot.

sentiment_labels = pd.get_dummies (df['sentiment']).valeurs

L'encodage à chaud représente les données catégorielles dans un format plus facile à utiliser pour vos modèles.

Fractionnement de l'ensemble de données en ensembles d'apprentissage et de test

Utilisez scikit-learn pour diviser de manière aléatoire l'ensemble de données en ensembles d'apprentissage et de test. Vous utiliserez l'ensemble d'entraînement pour entraîner le modèle à classer les sentiments des avis. Et vous utiliserez l'ensemble de test pour évaluer la capacité du modèle à classer de nouvelles critiques inédites.

x_train, x_test, y_train, y_test = train_test_split (padded_sequences, sentiment_labels, test_size=0.2)

La taille de fractionnement de l'ensemble de données est de 0,2. Cela signifie que 80 % des données formeront le modèle. Et les 20% restants testeront les performances du modèle.

Création du réseau de neurones

Créer un réseau neuronal avec six couches.

modèle = Séquentiel()
model.add (Incorporation(5000, 100, longueur_entrée=100))
model.add (Conv1D(64, 5, activation='relu'))
model.add (GlobalMaxPooling1D())
model.add (Dense(32, activation='relu'))
model.add (Décrochage(0.5))
model.add (Dense(3, activation='softmax'))
model.compile (optimiseur='Adam', perte='categorical_crossentropy', mesures=['précision'])
modèle. résumé ()

La première couche du réseau de neurones est une couche d'intégration. Cette couche apprend une représentation dense des mots du vocabulaire. La deuxième couche est une couche Conv1D avec 64 filtres et une taille de noyau de 5. Cette couche effectue des opérations de convolution sur les séquences d'entrée, en utilisant une petite fenêtre glissante de taille 5.

La troisième couche réduit la séquence de cartes d'entités à un seul vecteur. Il prend la valeur maximale sur chaque carte de caractéristiques. La quatrième couche effectue une transformation linéaire sur le vecteur d'entrée. La cinquième couche définit de manière aléatoire une fraction des unités d'entrée sur 0 pendant l'apprentissage. Cela permet d'éviter le surajustement. La couche finale convertit la sortie en une distribution de probabilité sur les trois classes possibles: positive, neutre et négative.

Formation du réseau de neurones

Ajustez les ensembles d'entraînement et de test au modèle. Entraînez le modèle pendant dix époques. Vous pouvez modifier le nombre d'époques à votre guise.

model.fit (x_train, y_train, epochs=10, taille_lot=32, validation_data=(test_x, test_y))

Après chaque époque, les performances du modèle sur l'ensemble de test sont évaluées.

Évaluation des performances du modèle formé

Utilisez le modèle.prédire() méthode pour prédire les étiquettes de sentiment pour l'ensemble de test. Calculer le score de précision à l'aide de la précision_score() fonction de scikit-learn.

y_pred = np.argmax (model.predict (x_test), axe=-1)
imprimer("Précision:", score_précision (np.argmax (test_y, axe=-1), y_pred))

La précision de ce modèle est d'environ 84 %.

Enregistrement du modèle

Enregistrez le modèle à l'aide de modèle.save() méthode. Utilisez pickle pour sérialiser et enregistrer l'objet tokenizer.

modèle.save('sentiment_analysis_model.h5')
avec ouvrir('tokenizer.pickle', 'wb') comme gérer:
 pickle.dump (tokenizer, handle, protocol=pickle. HIGHEST_PROTOCOL)

L'objet tokenizer marquera votre propre texte d'entrée et le préparera pour alimenter le modèle formé.

Utilisation du modèle pour classer le sentiment de votre propre texte

Après avoir créé et enregistré le modèle, vous pouvez l'utiliser pour classer le sentiment de votre propre texte. Tout d'abord, chargez le modèle et le tokenizer enregistrés.

# Charger le modèle enregistré et le tokenizer
importer keras
modèle = keras.models.load_model('sentiment_analysis_model.h5')
avec ouvrir('tokenizer.pickle', 'rb') comme gérer:
 tokenizer = pickle.load (handle)

Définissez une fonction pour prédire le sentiment du texte d'entrée.

définitivementprédire_sentiment(texte):
# Tokeniser et remplir le texte d'entrée
 text_sequence = tokenizer.texts_to_sequences([texte])
 text_sequence = pad_sequences (text_sequence, maxlen=100)
# Faire une prédiction en utilisant le modèle entraîné
 predicted_rating = model.predict (text_sequence)[0]
si np.argmax (predicted_rating) == 0:
retour'Négatif'
elif np.argmax (predicted_rating) == 1:
retour'Neutre'
autre:
retour'Positif'

Enfin, prédisez votre propre texte.

text_input = "J'ai vraiment adoré mon séjour dans cet hôtel. Le personnel était incroyable et la chambre était fantastique !"
prédit_sentiment = prédire_sentiment (text_input)
imprimer (predicted_sentiment)

Le sentiment prédit de l'examen ci-dessus est le suivant :

Le modèle est capable de classer correctement les sentiments des trois avis.

Prédire les sentiments à l'aide de modèles pré-entraînés

Parfois, dans l'apprentissage automatique, vous pouvez avoir le défi de trouver le bon ensemble de données. Il se peut également que vous manquiez de ressources pour créer votre propre jeu de données. C'est là qu'interviennent les modèles pré-formés. Il faut savoir utiliser leur API et les laisser s'occuper du reste.