Traitement du langage naturel que l'on trouve presque toujours dans l'apprentissage automatique.
Les mots semblent difficiles, il est donc difficile de les identifier.
Cependant, il est en fait très indispensable pour nous de passer notre vie quotidienne.
De plus, même les débutants peuvent le façonner complètement s'ils préparent l'ensemble de données nécessaire et savent comment le concevoir.
Par conséquent, cette fois, nous allons créer un programme à partir de Python en utilisant le traitement du langage naturel.
Le défi ici est l'analyse émotionnelle. Sur la base d'un ensemble de données collectant des évaluations de vêtements pour femmes, nous prédirons à quelle évaluation correspond le nouveau texte saisi.
Cela dit, commençons par le codage proprement dit en vous disant ce qu'est le traitement du langage naturel et ce qu'est l'analyse des émotions.
Pour expliquer ce qu'est le traitement du langage naturel, il est nécessaire de clarifier la différence entre les deux langues.
Les deux langages sont le langage naturel et le langage de programmation. La différence entre les deux réside dans les nombreuses significations et interprétations possibles de la phrase.
Un exemple de langage naturel est «une fille aux grands yeux noirs». Avec cela seul, au moins deux interprétations peuvent être faites.
L'un est «noir», «grands yeux» et «fille», c'est-à-dire une fille aux grands yeux et à la peau blanche. L'autre est «yeux noirs» et «grande fille», c'est-à-dire une grande fille aux yeux noirs.
Comme vous pouvez le voir, il y a des parties vagues dans les mots en langage naturel.
Un exemple de langage de programmation est "4 * 6 + 1".
Dans ce cas, il peut être interprété comme multipliant 4 par 6 et ajoutant 1, il n'y a donc pas de place pour penser à d'autres modèles.
De cette manière, le langage de programmation est un langage sans ambiguïté car il permet à l'ordinateur de toujours interpréter et utiliser les mêmes phrases de la même manière.
Le traitement du langage naturel est une technologie permettant de traiter pratiquement une énorme quantité de données textuelles basée sur l'ambiguïté du langage naturel.
Parmi eux, l'analyse des émotions consiste à quantifier en fonction des éléments émotionnels du texte. On peut s'attendre à ce qu'il soit utilisé pour divers feedback tels que l'analyse de l'évaluation des produits sur le net.
Cette fois, sur la base d'un ensemble de données "Womens Clothing E-Commerce Reviews.csv" qui résume les critiques de Kaggle aux vêtements pour femmes. Nous effectuerons le traitement du langage naturel.
Ce qui est utilisé comme analyse émotionnelle, c'est la valeur numérique de l'évaluation des vêtements qu'il contient.
Ici, les nombres sont en 5 étapes de 1 à 5, et nous analyserons quels mots sont utilisés dans chaque évaluation afin de pouvoir enfin prédire à quelle évaluation correspond la phrase que vous avez saisie. ..
Depuis que j'ai abordé l'ensemble de données utilisé pour le traitement du langage naturel et ce qu'il faut cibler pour l'analyse des émotions, je vais expliquer le processus de création étape par étape.
Commencez par charger les bibliothèques et les données nécessaires.
import numpy as np
import pandas as pd
from nltk.classify import NaiveBayesClassifier
from nltk.classify.util import accuracy as nltk_accuracy
review = pd.read_csv("Womens Clothing E-Commerce Reviews.csv")
#Le répertoire doit être ajusté en conséquence
review = pd.DataFrame(review)
Jetons un coup d'œil à chaque rôle.
numpy
numpy est une bibliothèque incluse dans Python qui effectue efficacement des calculs numériques. Lorsqu'il s'agit d'apprentissage automatique, le modèle est appris en répétant des opérations sur des tableaux multidimensionnels tels que des vecteurs et des matrices. À ce moment-là, si vous utilisez numpy, vous pouvez calculer efficacement. L'existence de cette bibliothèque est donc indispensable.
pandas
les pandas effectuent efficacement le travail nécessaire à l'analyse des données. Dans le processus d'analyse des données, le prétraitement jusqu'à l'apprentissage automatique représente 80% à 90% du total. Plus précisément, organisez les données proprement afin que l'apprentissage automatique puisse être effectué correctement, comme la lecture de données et le remplissage des valeurs manquantes. Puisque pandas a toutes les fonctions nécessaires, vous pouvez travailler efficacement.
nltk
nltk est une plate-forme pour créer des programmes qui traitent des données en langage humain en Python. Il est organisé de manière à ce que divers processus tels que l'analyse et la classification des phrases puissent être exécutés.
Jetons un coup d'œil à la vue d'ensemble des données et des valeurs manquantes en examinant chaque rôle.
review.columns
Index(['Unnamed: 0', 'Clothing ID', 'Age', 'Title', 'Review Text', 'Rating',
'Recommended IND', 'Positive Feedback Count', 'Division Name',
'Department Name', 'Class Name'],
dtype='object')
review = review.rename(columns={"Unnamed: 0":"ID",'Review Text': 'Text'})
#"Unnamed: 0"À"ID"、'Review Text'À'Text'という風に呼称À変更する。
review = review[["ID","Text","Rating"]]
#Seuls l'identifiant, le texte et les chiffres sont utilisés ici.
#isnull().sum()Voir le nombre de valeurs manquantes avec.
review.isnull().sum()
ID 0
Text 845
Rating 0
dtype: int64
#On peut voir qu'il y a 845 cas dans lesquels les phrases ne sont pas écrites simplement en ajoutant des numéros d'évaluation.
#Ici dropna()Supprimez ces données en utilisant.
review = review.dropna()
review.isnull().sum()
ID 0
Text 0
Rating 0
dtype: int64
#Vous pouvez maintenant le supprimer.
review.head()#Affichez le début des données. tête()utilisation.
| ID | Text | Rating |
|---|---|---|
| 0 | Absolutely wonderful - silky and sexy and comf... | 4 |
| 1 | Love this dress! it's sooo pretty. i happene... | 5 |
| 2 | I had such high hopes for this dress and reall... | 3 |
| 3 | I love, love, love this jumpsuit. it's fun, fl... | 5 |
| 4 | This shirt is very flattering to all due to th... | 5 |
review.describe()#Affichez l'apparence des données. décrire décrire()utilisation.
#Le nombre de données est de 22,Il s'avère que 461 avis, soit près de la moitié des avis, sont 5.
|ID|Rating|
|:-----------|------------:|:------------:| |count |22641.000000 |22641.000000| |mean |11740.849035 |4.183561| |std |6781.957509 |1.115762| |min |0.000000 |1.000000| |25% |5872.000000 |4.000000| |50% |11733.000000 |5.000000| |75% |17621.000000 |5.000000| |max |23485.000000 |5.000000|
review.dtypes#Utilisez des dtypes. S'il y a des inconvénients dans le traitement ou le fonctionnement des données, il peut être nécessaire de changer le type.
ID int64
Text object
Rating int64
dtype: object
Maintenant que nous avons confirmé les données et supprimé les valeurs manquantes, commençons immédiatement à apprendre.
Commencez par diviser les phrases de toutes les données en une liste pour chaque nombre de taux, divisez-les en mots et stockez-les.
rate_id_one = []
rate_id_two = []
rate_id_three = []
rate_id_four = []
rate_id_five =[]
for text, rating in zip(review['Text'], review['Rating']):
line = text.split(" ")
dic = {}
if rating == 1:
for word in line:
dic[word] = True
ireru = (dic, 1)
rate_id_one.append(ireru)
elif rating == 2:
for word in line:
dic[word] = True
ireru = (dic, 2)
rate_id_two.append(ireru)
elif rating == 3:
for word in line:
dic[word] = True
ireru = (dic, 3)
rate_id_three.append(ireru)
elif rating == 4:
for word in line:
dic[word] = True
ireru = (dic, 4)
rate_id_four.append(ireru)
else:
for word in line:
dic[word] = True
ireru = (dic, 5)
rate_id_five.append(ireru)
Maintenant que nous avons trié par nombre, nous allons le diviser en 8: 2 avec des données d'entraînement et des données de test.
Le total est la somme de chaque nombre pour le test d'apprentissage.
threshold = 0.8
num_one = int(threshold * len(rate_id_one))
num_two = int(threshold * len(rate_id_two))
num_three = int(threshold * len(rate_id_three))
num_four = int(threshold * len(rate_id_four))
num_five = int(threshold * len(rate_id_five))
features_train = rate_id_one[:num_one] + rate_id_two[:num_two] + rate_id_three[:num_three] + rate_id_four[:num_four] + rate_id_five[:num_five]
features_test = rate_id_one[num_one:] + rate_id_two[num_two:] + rate_id_three[num_three:] + rate_id_four[num_four:] + rate_id_five[num_five:]
print("Number of training datapoints:", len(features_train))
print("Number of test datapoints:", len(features_test))
Number of training datapoints: 18111
Number of test datapoints: 4530
Je l'ai divisé en deux parties, l'une pour l'apprentissage et l'autre pour les tests, je vais donc commencer à apprendre.
Et j'ai fait en sorte que les données du test jugent le nombre avec ce que j'ai appris, mais le taux de réponse correcte semble être inférieur à la moitié.
classifier = NaiveBayesClassifier.train(features_train)
print('Accuracy of the classifier:', nltk_accuracy(classifier, features_test))
Accuracy of the classifier: 0.4640176600441501
La cause peut être qu'il existe un large éventail de choix allant de 1 à 5 et que le nombre absolu de données sur les phrases mal notées est insuffisant. Par exemple, si vous choisissez entre 1 et 5 taux, cela peut s'améliorer.
Sinon, si d'autres méthodes sont utilisées, la précision peut être encore améliorée, ce sera donc un problème pour l'avenir.
Voyons quels mots ont influencé les nombres prédits pendant la formation.
N = 15
print('Top ' + str(N) + ' most informative words:')
for i, item in enumerate(classifier.most_informative_features()[:N]):
print(str(i+1) + '. ' + item[0])
Top 15 most informative words:
1. worst
2. shame
3. poorly
4. horrible
5. disappointment.
6. cheap.
7. strange.
8. sad.
9. dull
10. terrible.
11. returned.
12. terrible
13. awkward.
14. concept
15. awful.
Les mots négatifs tels que le pire, la honte et la déception ressortent.
Une expression directe de la négativité sera le facteur décisif qui influence le nombre.
Certains mots ont un point, mais cette fois, je vais voir cela comme l'un des mots.
Maintenant écrivons nos propres phrases et prédisons le taux.
def extract_features(words):
return dict([(word, True) for word in words])
#Divisez en mots comme la grande quantité de texte de révision précédemment
input_review = input()
print("Clothes review predictions:")
print("\nReview:",input_review)
features = extract_features(input_review.split())
probabilities = classifier.prob_classify(features)
predicted_sentiment = probabilities.max()
print("Predicted sentiment:", predicted_sentiment)
print("Probability:", round(probabilities.prob(predicted_sentiment), 2))
#Calculer et afficher à quel nombre le texte saisi correspond le plus probablement
Par exemple, entrez "Je ne peux pas croire à quel point c'est terrible!" Ici. En japonais, cela signifie "Je ne peux pas croire cela terrible!"
I cannnot believe how terrible is it!
Clothes review predictions:
Review: I cannnot believe how terrible is it!
Predicted sentiment: 1
Probability: 0.61
Il s'avère que c'est probablement la note la plus basse.
Cette fois, après avoir abordé ce que sont le traitement du langage naturel et l'analyse des émotions, nous avons en fait mis en œuvre le traitement du langage naturel en utilisant l'ensemble de données de Kaggle.
Même si vous êtes un débutant en programmation, il est tout à fait possible de l'implémenter si vous obtenez les données nécessaires et prenez les mesures appropriées. Et les mesures réellement prises sont les suivantes.
Chargez la bibliothèque et les données
Vérifiez les données, traitez-les et préparez-les pour l'apprentissage.
Apprenez et vérifiez les performances
Si vous comprenez la configuration générale et pouvez réellement l'écrire et la déplacer, vous pouvez l'appliquer à d'autres ensembles de données. C'est donc une bonne idée de maintenir cela et de l'utiliser dans votre propre ensemble de données.
Enfin, je publierai ce code, alors veuillez vous y référer.
import numpy as np
import pandas as pd
from nltk.classify import NaiveBayesClassifier
from nltk.classify.util import accuracy as nltk_accuracy
review = pd.read_csv("Womens Clothing E-Commerce Reviews.csv")
#Le répertoire doit être ajusté en conséquence
review = pd.DataFrame(review)
review.columns
Index(['Unnamed: 0', 'Clothing ID', 'Age', 'Title', 'Review Text', 'Rating',
'Recommended IND', 'Positive Feedback Count', 'Division Name',
'Department Name', 'Class Name'],
dtype='object')
review = review.rename(columns={"Unnamed: 0":"ID",'Review Text': 'Text'})
review = review[["ID","Text","Rating"]]#Seuls l'identifiant, le texte et les chiffres sont utilisés ici.
review.isnull().sum()
ID 0
Text 845
Rating 0
dtype: int64
review = review.dropna()
review.isnull().sum()
ID 0
Text 0
Rating 0
dtype: int64
review.head()#Afficher le début des données
review.describe()#Afficher l'apparence des données
review.dtypes
ID int64
Text object
Rating int64
dtype: object
rate_id_one = []
rate_id_two = []
rate_id_three = []
rate_id_four = []
rate_id_five =[]
for text, rating in zip(review['Text'], review['Rating']):
line = text.split(" ")
dic = {}
if rating == 1:
for word in line:
dic[word] = True
ireru = (dic, 1)
rate_id_one.append(ireru)
elif rating == 2:
for word in line:
dic[word] = True
ireru = (dic, 2)
rate_id_two.append(ireru)
elif rating == 3:
for word in line:
dic[word] = True
ireru = (dic, 3)
rate_id_three.append(ireru)
elif rating == 4:
for word in line:
dic[word] = True
ireru = (dic, 4)
rate_id_four.append(ireru)
else:
for word in line:
dic[word] = True
ireru = (dic, 5)
rate_id_five.append(ireru)
rate_id_one[0]#Afficher les mots de la liste
len(rate_id_one)
821
threshold = 0.8
num_one = int(threshold * len(rate_id_one))
num_two = int(threshold * len(rate_id_two))
num_three = int(threshold * len(rate_id_three))
num_four = int(threshold * len(rate_id_four))
num_five = int(threshold * len(rate_id_five))
features_train = rate_id_one[:num_one] + rate_id_two[:num_two] + rate_id_three[:num_three] + rate_id_four[:num_four] + rate_id_five[:num_five]
features_test = rate_id_one[num_one:] + rate_id_two[num_two:] + rate_id_three[num_three:] + rate_id_four[num_four:] + rate_id_five[num_five:]
print("Number of training datapoints:", len(features_train))
print("Number of test datapoints:", len(features_test))
Number of training datapoints: 18111
Number of test datapoints: 4530
classifier = NaiveBayesClassifier.train(features_train)
print('Accuracy of the classifier:', nltk_accuracy(classifier, features_test))
Accuracy of the classifier: 0.4640176600441501
N = 15
print('Top ' + str(N) + ' most informative words:')
for i, item in enumerate(classifier.most_informative_features()[:N]):
print(str(i+1) + '. ' + item[0])
Top 15 most informative words:
1. worst
2. shame
3. poorly
4. horrible
5. disappointment.
6. cheap.
7. strange.
8. sad.
9. dull
10. terrible.
11. returned.
12. terrible
13. awkward.
14. concept
15. awful.
def extract_features(words):
return dict([(word, True) for word in words])
#Voyez ce que vous avez tapé sur place
input_review = input()
print("Clothes review predictions:")
print("\nReview:",input_review)
features = extract_features(input_review.split())
probabilities = classifier.prob_classify(features)
predicted_sentiment = probabilities.max()
print("Predicted sentiment:", predicted_sentiment)
print("Probability:", round(probabilities.prob(predicted_sentiment), 2))
I cannnot believe how terrible is it!
Clothes review predictions:
Review: I cannnot believe how terrible is it!
Predicted sentiment: 1
Probability: 0.61
Recommended Posts