Verarbeitung natürlicher Sprache, die fast immer im maschinellen Lernen zu finden ist.
Die Wörter scheinen schwierig zu sein, daher ist es schwer zu bestimmen.
Tatsächlich ist es für uns jedoch sehr wichtig, unser tägliches Leben zu verbringen.
Darüber hinaus können auch Anfänger es vollständig gestalten, wenn sie den erforderlichen Datensatz vorbereiten und wissen, wie er zu entwerfen ist.
Daher werden wir dieses Mal tatsächlich ein Programm aus Python erstellen, das die Verarbeitung natürlicher Sprache verwendet.
Die Herausforderung hierbei ist die emotionale Analyse. Basierend auf einem Datensatz, der Bewertungen von Frauenkleidern sammelt, werden wir vorhersagen, welcher Bewertung der neu eingegebene Text entspricht.
Beginnen wir jedoch mit der eigentlichen Codierung, indem wir Ihnen sagen, was die Verarbeitung natürlicher Sprache ist und was die Emotionsanalyse ist.
Bei der Erklärung der Verarbeitung natürlicher Sprache muss der Unterschied zwischen den beiden Sprachen geklärt werden.
Die beiden Sprachen sind natürliche Sprache und Programmiersprache. Der Unterschied zwischen den beiden liegt in den vielen möglichen Bedeutungen und Interpretationen des Satzes.
Als Beispiel für natürliche Sprache "ein Mädchen mit großen schwarzen Augen". Allein damit können mindestens zwei Interpretationen vorgenommen werden.
Eines ist "schwarz", "große Augen" und "Mädchen", dh ein Mädchen mit großen Augen und weißer Haut. Das andere sind "schwarze Augen" und "großes Mädchen", dh ein großes Mädchen mit schwarzen Augen.
Wie Sie sehen können, gibt es einige vage Teile in Wörtern in natürlicher Sprache.
Ein Beispiel für eine Programmiersprache ist "4 * 6 + 1".
In diesem Fall kann dies so interpretiert werden, dass 4 mit 6 multipliziert und 1 addiert wird, sodass kein Raum zum Nachdenken über andere Muster besteht.
Auf diese Weise ist die Programmiersprache eine eindeutige Sprache, da der Computer immer dieselben Sätze auf dieselbe Weise interpretieren und bedienen kann.
Die Verarbeitung natürlicher Sprache ist eine Technologie zum praktischen Umgang mit einer großen Menge von Textdaten, die auf der Mehrdeutigkeit natürlicher Sprache basiert.
Unter anderem soll die Emotionsanalyse anhand der emotionalen Elemente im Text quantifiziert werden. Es ist zu erwarten, dass es für verschiedene Rückmeldungen verwendet wird, beispielsweise für die Analyse der Bewertung von Produkten im Internet.
Diesmal basierend auf einem Datensatz "Womens Clothing E-Commerce Reviews.csv", der die Bewertungen von Kaggle zu Damenbekleidung zusammenfasst. Wir werden die Verarbeitung natürlicher Sprache durchführen.
Was als emotionale Analyse verwendet wird, ist der numerische Wert der Bewertung der Kleidung darin.
Hier sind die Zahlen in 5 Stufen von 1 bis 5 und wir werden analysieren, welche Wörter in jeder Bewertung verwendet werden, damit wir schließlich vorhersagen können, welcher Bewertung der von Ihnen eingegebene Satz entspricht. ..
Da ich den Datensatz für die Verarbeitung natürlicher Sprache und das Ziel für die Emotionsanalyse angesprochen habe, werde ich den Erstellungsprozess Schritt für Schritt erläutern.
Laden Sie zunächst die erforderlichen Bibliotheken und Daten.
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")
#Das Verzeichnis muss entsprechend angepasst werden
review = pd.DataFrame(review)
Werfen wir einen Blick auf jede Rolle.
numpy
numpy ist eine in Python enthaltene Bibliothek, die numerische Berechnungen effizient durchführt. Wenn es um maschinelles Lernen geht, wird das Modell gelernt, während Operationen an mehrdimensionalen Arrays wie Vektoren und Matrizen wiederholt werden. Wenn Sie zu diesem Zeitpunkt numpy verwenden, können Sie effizient berechnen. Die Existenz dieser Bibliothek ist daher unverzichtbar.
pandas
Pandas führen die für die Datenanalyse erforderlichen Arbeiten effizient aus. Bei der Datenanalyse macht die Vorverarbeitung bis zum maschinellen Lernen 80% bis 90% der Gesamtmenge aus. Ordnen Sie die Daten besonders ordentlich an, damit maschinelles Lernen ordnungsgemäß durchgeführt werden kann, z. B. Lesen von Daten und Ausfüllen fehlender Werte. Da Pandas alle notwendigen Funktionen hat, können Sie effizient arbeiten.
nltk
nltk ist eine Plattform zum Erstellen von Programmen, die menschliche Sprachdaten in Python verarbeiten. Es ist so angeordnet, dass verschiedene Prozesse wie Satzanalyse und Klassifizierung durchgeführt werden können.
Werfen wir einen Blick auf die Übersicht der Daten und die fehlenden Werte, indem wir uns die einzelnen Rollen ansehen.
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"Zu"ID"、'Review Text'Zu'Text'という風に呼称Zu変更する。
review = review[["ID","Text","Rating"]]
#Hier werden nur ID, Text und Nummern verwendet.
#isnull().sum()Sehen Sie die Anzahl der fehlenden Werte mit.
review.isnull().sum()
ID 0
Text 845
Rating 0
dtype: int64
#Es ist ersichtlich, dass es 845 Fälle gibt, in denen Sätze nicht nur durch Hinzufügen von Bewertungsnummern geschrieben werden.
#Hier Dropna()Löschen Sie solche Daten mit.
review = review.dropna()
review.isnull().sum()
ID 0
Text 0
Rating 0
dtype: int64
#Sie können es jetzt löschen.
review.head()#Zeigen Sie den Anfang der Daten an. Kopf()verwenden.
| 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()#Zeigen Sie das Erscheinungsbild der Daten an. beschreiben beschreiben()verwenden.
#Die Anzahl der Daten beträgt 22,Es stellt sich heraus, dass 461 Bewertungen, fast die Hälfte der Bewertungen, 5 sind.
|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#Verwenden Sie dtypes. Wenn die Datenverarbeitung oder der Datenbetrieb unangenehm sind, muss möglicherweise der Typ geändert werden.
ID int64
Text object
Rating int64
dtype: object
Nachdem wir die Daten bestätigt und die fehlenden Werte gelöscht haben, beginnen wir sofort mit dem Lernen.
Teilen Sie zunächst die Sätze aller Daten in eine Liste für jede Tarifnummer, teilen Sie sie in Wörter und speichern Sie sie.
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)
Nachdem wir nach Zahlen sortiert haben, teilen wir sie mit Trainingsdaten und Testdaten in 8: 2 auf.
Die Summe ist die Summe jeder Zahl für den Lerntest.
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
Ich habe es in zwei Teile geteilt, einen zum Lernen und einen zum Testen, also werde ich anfangen zu lernen.
Und ich habe die Testdaten dazu gebracht, die Anzahl mit dem zu beurteilen, was ich gelernt habe, aber die richtige Antwortrate scheint weniger als die Hälfte zu sein.
classifier = NaiveBayesClassifier.train(features_train)
print('Accuracy of the classifier:', nltk_accuracy(classifier, features_test))
Accuracy of the classifier: 0.4640176600441501
Die Ursache kann sein, dass es eine große Auswahl von 1 bis 5 gibt und dass die absolute Anzahl von Satzdaten mit niedriger Bewertung nicht ausreicht. Wenn Sie beispielsweise zwischen 1 und 5 Raten wählen, kann sich dies verbessern.
Wenn andere Methoden verwendet werden, kann alternativ die Genauigkeit weiter verbessert werden, sodass dies ein Problem für die Zukunft sein wird.
Mal sehen, welche Wörter die vorhergesagten Zahlen während des Trainings beeinflusst haben.
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.
Negative Wörter wie das Schlimmste, Scham und Enttäuschung fallen auf.
Ein direkter Ausdruck von Negativität wird der entscheidende Faktor sein, der die Zahl beeinflusst.
Einige Wörter haben einen Punkt, aber dieses Mal werde ich dies als eines der Wörter sehen.
Schreiben wir nun unsere eigenen Sätze und sagen die Rate voraus.
def extract_features(words):
return dict([(word, True) for word in words])
#Teilen Sie in Wörter wie die große Menge an Rezensionstext früher
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))
#Berechnen Sie und geben Sie aus, welcher Nummer der eingegebene Text am wahrscheinlichsten entspricht
Geben Sie hier beispielsweise "Ich kann nicht glauben, wie schrecklich es ist!" Ein. Auf Japanisch bedeutet es "Ich kann das schrecklich nicht glauben!"
I cannnot believe how terrible is it!
Clothes review predictions:
Review: I cannnot believe how terrible is it!
Predicted sentiment: 1
Probability: 0.61
Es stellt sich heraus, dass es wahrscheinlich die niedrigste Bewertung ist.
Dieses Mal haben wir, nachdem wir uns mit der Verarbeitung natürlicher Sprache und der Emotionsanalyse befasst haben, die Verarbeitung natürlicher Sprache mithilfe des Datensatzes in Kaggle implementiert.
Selbst wenn Sie ein Anfänger in der Programmierung sind, ist es durchaus möglich, sie zu implementieren, wenn Sie die erforderlichen Daten erhalten und geeignete Schritte unternehmen. Und die tatsächlich unternommenen Schritte sind wie folgt.
Laden Sie die Bibliothek und die Daten
Überprüfen Sie die Daten, verarbeiten Sie sie und bereiten Sie sie für das Lernen vor.
Lernen und überprüfen Sie die Leistung
Wenn Sie das allgemeine Setup verstehen und es tatsächlich schreiben und verschieben können, können Sie es auf andere Datensätze anwenden. Es ist daher eine gute Idee, dies gedrückt zu halten und in Ihrem eigenen Datensatz zu verwenden.
Zum Schluss werde ich diesen Code veröffentlichen. Bitte beziehen Sie sich darauf.
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")
#Das Verzeichnis muss entsprechend angepasst werden
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"]]#Hier werden nur ID, Text und Nummern verwendet.
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()#Zeigen Sie den Anfang der Daten an
review.describe()#Zeigen Sie das Erscheinungsbild der Daten an
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]#Zeigen Sie die Wörter in der 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])
#Sehen Sie, was Sie vor Ort eingegeben haben
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