So erstellen Sie ein Stimmungsanalysemodell von Grund auf neu

Die Stimmungsanalyse ist eine Technik zur Verarbeitung natürlicher Sprache (NLP), die die Einstellung hinter einem Text identifiziert. Es wird auch als Opinion Mining bezeichnet. Das Ziel der Stimmungsanalyse ist es, festzustellen, ob ein bestimmter Text eine positive, negative oder neutrale Stimmung hat. Es wird häufig von Unternehmen verwendet, um die Stimmung in Kundenbewertungen automatisch zu klassifizieren. Die Analyse großer Mengen an Bewertungen hilft dabei, wertvolle Einblicke in die Vorlieben der Kunden zu gewinnen.

Einrichten Ihrer Umgebung

Sie müssen sich auskennen Python-Grundlagen durchzuziehen. Navigieren Sie zu Google Colab oder öffnen Sie Jupyter Notebook. Erstellen Sie dann ein neues Notizbuch. Führen Sie den folgenden Befehl aus, um die erforderlichen Bibliotheken in Ihrer Umgebung zu installieren.

Der vollständige Quellcode dieses Projekts ist in diesem verfügbar GitHub-Repository.

! pip installiere tensorflow scikit-learn pandas numpy pickle5

Sie werden NumPy und verwenden Pandas-Bibliothek zum Bearbeiten des Datensatzes. TensorFlow zum Erstellen und Trainieren des Modells für maschinelles Lernen. Scikit-learn zum Aufteilen des Datensatzes in Trainings- und Testsätze. Schließlich verwenden Sie pickle5, um das Tokenizer-Objekt zu serialisieren und zu speichern.

Importieren der erforderlichen Bibliotheken

Importieren Sie die erforderlichen Bibliotheken, die Sie verwenden, um die Daten vorzuverarbeiten und das Modell zu erstellen.

importieren taub als np
importieren Pandas als pd
importieren Tensorfluss als tf
aus sklearn.model_selection importieren train_test_split
aus sklearn.metrics importieren Genauigkeit_Ergebnis
aus tensorflow.keras.preprocessing.text importieren Tokenisierer
aus tensorflow.keras.preprocessing.sequence importieren pad_sequenzen
aus tensorflow.keras.models importieren Sequentiell
aus tensorflow.keras.layers importieren Einbettung, Conv1D, GlobalMaxPooling1D, Dichte, Dropout
importieren Gurke5 als Essiggurke

Sie werden die Klassen, die Sie aus den Modulen importieren, später im Code verwenden.

Laden des Datensatzes

Hier verwenden Sie den Trip Advisor Hotelbewertungs-Datensatz von Kaggle um das Stimmungsanalysemodell zu erstellen.

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

Laden Sie den Datensatz und drucken Sie die ersten fünf Zeilen. Das Drucken der ersten fünf Zeilen hilft Ihnen, die Spaltennamen Ihres Datensatzes zu überprüfen. Dies wird bei der Vorverarbeitung des Datensatzes entscheidend sein.

Das Trip Advisor-Hotelbewertungs-Dataset verfügt über eine Indexspalte, eine Bewertungsspalte und eine Bewertungsspalte.

Datenvorverarbeitung

Wähle aus Rezension Und Bewertung Spalten aus dem Datensatz. Erstellen Sie eine neue Spalte basierend auf der Bewertungsspalte und benennen Sie sie Gefühl. Wenn die Bewertung größer als 3 ist, kennzeichnen Sie die Stimmung als positiv. Wenn die Bewertung weniger als 3 beträgt, kennzeichnen Sie sie als Negativ. Wenn die Bewertung genau 3 ist, kennzeichnen Sie sie als neutral.

Wählen Sie nur die Spalten Review und Stimmung aus dem Dataset aus. Mischen Sie die Zeilen zufällig und setzen Sie den Index des Datenrahmens zurück. Mischen und Zurücksetzen stellen sicher, dass die Daten zufällig verteilt werden, was für ein ordnungsgemäßes Training und Testen des Modells erforderlich ist.

df = df[['Rezension', 'Bewertung']]
df['Gefühl'] = df['Bewertung'].anwenden(Lambda X: 'positiv'Wenn x > 3
anders'Negativ'Wenn x< 3
anders'neutral')
df = df[['Rezension', 'Gefühl']]
df = df.sample (frac=1).reset_index (drop=WAHR)

Konvertieren Sie die Rezension Text mithilfe des Tokenizers in eine Folge von Ganzzahlen umwandeln. Dadurch wird ein Wörterbuch der eindeutigen Wörter erstellt, die im Überprüfungstext vorhanden sind, und jedes Wort einem eindeutigen ganzzahligen Wert zugeordnet. Verwenden Sie die pad_sequenzen Funktion von Keras, um sicherzustellen, dass alle Überprüfungssequenzen die gleiche Länge haben.

tokenizer = Tokenizer (num_words=5000, oov_token='')
tokenizer.fit_on_texts (df['Rezension'])
word_index = tokenizer.word_index
sequences = tokenizer.texts_to_sequences (df['Rezension'])
padd_sequences = pad_sequences (Sequenzen, maxlen=100, abschneiden='Post')

Konvertieren Sie die Stimmungslabels in One-Hot-Codierung.

sentiment_labels = pd.get_dummies (df['Gefühl']).Werte

One-Hot-Codierung stellt kategoriale Daten in einem Format dar, mit dem Ihre Modelle einfacher arbeiten können.

Aufteilen des Datensatzes in Trainings- und Testsätze

Verwenden Sie scikit-learn, um den Datensatz nach dem Zufallsprinzip in Trainings- und Testsätze aufzuteilen. Sie verwenden das Trainingsset, um das Modell zu trainieren, um die Meinungen der Bewertungen zu klassifizieren. Und Sie werden das Testset verwenden, um herauszufinden, wie gut das Modell darin ist, neue ungesehene Rezensionen zu klassifizieren.

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

Die Aufteilungsgröße des Datensatzes beträgt 0,2. Das bedeutet, dass 80 % der Daten das Modell trainieren. Und die restlichen 20 % testen die Leistung des Modells.

Erstellen des neuronalen Netzwerks

Ein... kreieren neurales Netzwerk mit sechs Schichten.

Modell = Sequentiell ()
model.add (Einbettung (5000, 100, Eingabe_Länge=100))
model.add (Conv1D(64, 5, Aktivierung='relu'))
model.add (GlobalMaxPooling1D())
model.add (dicht (32, Aktivierung='relu'))
model.add (Ausfall(0.5))
model.add (dicht (3, Aktivierung='softmax'))
model.compile (optimierer='Adam', Verlust='categorical_crossentropy', Metriken=['Genauigkeit'])
model.summary()

Die erste Schicht des neuronalen Netzes ist eine Embedding-Schicht. Diese Schicht lernt eine dichte Repräsentation von Wörtern im Vokabular. Die zweite Schicht ist eine Conv1D-Schicht mit 64 Filtern und einer Kernelgröße von 5. Diese Schicht führt Faltungsoperationen an den Eingabesequenzen durch, wobei ein kleines gleitendes Fenster der Größe 5 verwendet wird.

Die dritte Schicht reduziert die Folge von Merkmalskarten auf einen einzigen Vektor. Es nimmt den maximalen Wert über jede Feature-Map an. Die vierte Schicht führt eine lineare Transformation des Eingangsvektors durch. Die fünfte Schicht setzt während des Trainings zufällig einen Bruchteil der Eingabeeinheiten auf 0. Dies hilft, eine Überanpassung zu verhindern. Die letzte Schicht wandelt die Ausgabe in eine Wahrscheinlichkeitsverteilung über die drei möglichen Klassen um: positiv, neutral und negativ.

Training des neuronalen Netzes

Passen Sie die Trainings- und Testsätze an das Modell an. Trainieren Sie das Modell für zehn Epochen. Sie können die Anzahl der Epochen nach Belieben ändern.

model.fit (x_Zug, y_Zug, Epochen=10, batch_size=32, Validierungsdaten=(x_test, y_test))

Nach jeder Epoche wird die Leistung des Modells auf dem Testsatz bewertet.

Bewerten der Leistung des trainierten Modells

Verwenden Sie die model.predict() -Methode, um die Stimmungsbezeichnungen für die Testreihe vorherzusagen. Berechnen Sie die Genauigkeitspunktzahl mit der Genauigkeit_Ergebnis() Funktion von scikit-learn.

y_pred = np.argmax (model.predict (x_test), Achse=-1)
drucken("Genauigkeit:", precision_score (np.argmax (y_test, axis=-1), y_pred))

Die Genauigkeit dieses Modells liegt bei etwa 84 %.

Speichern des Modells

Speichern Sie das Modell mit der model.save() Methode. Verwenden Sie pickle, um das Tokenizer-Objekt zu serialisieren und zu speichern.

model.save('sentiment_analysis_model.h5')
mit offen('tokenizer.pickle', 'wb') als handhaben:
 pickle.dump (Tokenizer, Handle, Protokoll=pickle. HIGHEST_PROTOCOL)

Das Tokenizer-Objekt tokenisiert Ihren eigenen Eingabetext und bereitet ihn für die Zuführung zum trainierten Modell vor.

Verwenden des Modells, um die Stimmung Ihres eigenen Textes zu klassifizieren

Nachdem Sie das Modell erstellt und gespeichert haben, können Sie es verwenden, um die Stimmung Ihres eigenen Textes zu klassifizieren. Laden Sie zuerst das gespeicherte Modell und den Tokenizer.

# Laden Sie das gespeicherte Modell und den Tokenizer
importieren Keras
model = keras.models.load_model('sentiment_analysis_model.h5')
mit offen('tokenizer.pickle', 'rb') als handhaben:
 Tokenizer = pickle.load (Handle)

Definieren Sie eine Funktion, um die Stimmung von Eingabetext vorherzusagen.

defVorhersage_Gefühl(Text):
# Tokenisieren und füllen Sie den Eingabetext auf
 text_sequence = tokenizer.texts_to_sequences([text])
 text_sequence = pad_sequences (text_sequence, maxlen=100)
# Mit dem trainierten Modell eine Vorhersage treffen
 vorhergesagte_bewertung = modell.vorhersage (text_sequenz)[0]
Wenn np.argmax (vorhergesagte_Bewertung) == 0:
zurückkehren'Negativ'
elf np.argmax (vorhergesagte_Bewertung) == 1:
zurückkehren'Neutral'
anders:
zurückkehren'Positiv'

Sagen Sie schließlich Ihren eigenen Text voraus.

Texteingabe = „Ich habe meinen Aufenthalt in diesem Hotel absolut geliebt. Das Personal war fantastisch und das Zimmer war fantastisch!"
vorhergesagte_stimmung = vorhergesagte_stimmung (text_eingabe)
drucken (predicted_sentiment)

Die vorhergesagte Stimmung der obigen Überprüfung ist wie folgt:

Das Modell ist in der Lage, die Stimmungen aller drei Bewertungen richtig einzuordnen.

Vorhersage von Stimmungen mit vortrainierten Modellen

Manchmal stehen Sie beim maschinellen Lernen vor der Herausforderung, den richtigen Datensatz zu finden. Möglicherweise fehlen Ihnen auch die Ressourcen, um Ihr eigenes Dataset zu erstellen. Hier kommen vortrainierte Modelle ins Spiel. Sie müssen wissen, wie man ihre API verwendet, und sie den Rest erledigen lassen.