Erstellen Sie ein Textklassifizierungsprogramm: Ein NLP-Tutorial

Veröffentlicht: 2022-03-11

Deep Learning ist eine Technologie, die zu einem wesentlichen Bestandteil von Machine-Learning-Workflows geworden ist. Komplexe und tiefe neuronale Netze, die einst unpraktisch waren, werden jetzt durch die Nutzung der Verbesserungen der parallelen Rechenleistung und der unterstützenden Tools realisierbar.

Das Aufkommen leistungsstarker und zugänglicher Bibliotheken wie Tensorflow, Torch und Deeplearning4j hat die Entwicklung auch für Benutzer außerhalb der Hochschulen und Forschungsabteilungen großer Technologieunternehmen geöffnet. Als Beweis für seine wachsende Allgegenwart bauen Unternehmen wie Huawei und Apple jetzt dedizierte, für Deep Learning optimierte Prozessoren in ihre neuesten Geräte ein, um Deep-Learning-Anwendungen zu unterstützen.

Deep Learning hat seine Leistungsfähigkeit in vielen Bereichen bewiesen. Vor allem Googles AlphaGo war in der Lage, menschliche Spieler in einem Go-Spiel zu besiegen, einem Spiel, dessen verblüffende Komplexität einst als nahezu unüberwindbare Barriere für Computer im Wettbewerb mit menschlichen Spielern galt. Das Flow Machines-Projekt von Sony hat ein neuronales Netzwerk entwickelt, das Musik im Stil berühmter Musiker der Vergangenheit komponieren kann. FaceID, eine von Apple entwickelte Sicherheitsfunktion, verwendet Deep Learning, um das Gesicht des Benutzers zu erkennen und Änderungen am Gesicht des Benutzers im Laufe der Zeit zu verfolgen.

In diesem Artikel wenden wir Deep Learning auf zwei meiner Lieblingsthemen an: Verarbeitung natürlicher Sprache und Wein. Wir werden ein Modell erstellen, um natürlichsprachige Weinbewertungen von Experten zu verstehen und die Vielfalt des Weins abzuleiten, den sie bewerten.

Deep Learning für NLP

Deep Learning wurde ausgiebig in der Verarbeitung natürlicher Sprache (NLP) eingesetzt, da es sich gut zum Erlernen der komplexen zugrunde liegenden Struktur eines Satzes und der semantischen Nähe verschiedener Wörter eignet. Der aktuelle Stand der Technik zur Stimmungsanalyse verwendet beispielsweise Deep Learning, um schwer modellierbare sprachliche Konzepte wie Negationen und gemischte Gefühle zu erfassen.

Deep Learning hat mehrere Vorteile gegenüber anderen Algorithmen für NLP:

Flexible Modelle: Deep-Learning-Modelle sind viel flexibler als andere ML-Modelle. Wir können leicht mit verschiedenen Strukturen experimentieren und nach Bedarf Schichten hinzufügen und entfernen. Deep-Learning-Modelle ermöglichen auch das Erstellen von Modellen mit flexiblen Ausgaben. Die Flexibilität ist der Schlüssel zur Entwicklung von Modellen, die sich gut zum Verständnis komplexer sprachlicher Strukturen eignen. Es ist auch für die Entwicklung von NLP-Anwendungen wie Übersetzungen, Chatbots und Text-zu-Sprache-Anwendungen unerlässlich.
Weniger Domänenkenntnisse erforderlich: Während man sicherlich einige Domänenkenntnisse und Intuition benötigt, um ein gutes Deep-Learning-Modell zu entwickeln, bedeutet die Fähigkeit von Deep-Learning-Algorithmen, Feature-Hierarchien selbst zu lernen, dass ein Entwickler nicht so viel fundiertes Wissen darüber benötigt Problemraum zur Entwicklung von Deep-Learning-NLP-Algorithmen. Für einen so komplexen Problemraum wie die natürliche Sprache ist dies ein sehr willkommener Vorteil.
Einfacheres kontinuierliches Lernen: Deep-Learning-Algorithmen lassen sich leicht trainieren, wenn neue Daten eingehen. Einige maschinelle Lernalgorithmen erfordern, dass der gesamte Datensatz zur Aktualisierung durch das Modell gesendet wird, was bei großen Live-Datensätzen ein Problem darstellen würde.

Das Problem heute

Heute werden wir einen Deep-Learning-Algorithmus entwickeln, um die Sorte des zu bewertenden Weins basierend auf dem Bewertungstext zu bestimmen. Wir verwenden den Datensatz des Weinmagazins unter https://www.kaggle.com/zynicide/wine-reviews, der vom Kaggle-Benutzer zackthoutt bereitgestellt wird.

Konzeptionell stellt sich die Frage, können wir eine Weinbewertung wie…

Zu den Aromen gehören tropische Früchte, Ginster, Schwefel und getrocknete Kräuter. Der Gaumen ist nicht übermäßig ausdrucksstark und bietet unreifen Apfel, Zitrusfrüchte und getrockneten Salbei neben einer lebhaften Säure.

…und erkennen, dass es sich um eine weiße Mischung handelt? Einige Weinliebhaber erkennen vielleicht verräterische Anzeichen von Weißweinen wie Apfel, Zitrus und eine ausgeprägte Säure, aber können wir unser neuronales Netzwerk darauf trainieren, diese Signale zu erkennen? Können wir außerdem unser neuronales Netzwerk darauf trainieren, die subtilen Unterschiede zwischen einer Weißweinbewertung und einer Pinot Grigio-Bewertung zu erkennen?

Naive Bayes

Eine beliebte Implementierung von Naive Bayes für NLP beinhaltet die Vorverarbeitung des Textes mit TF-IDF und die anschließende Ausführung der multinomialen Naive Bayes auf den vorverarbeiteten Ausgaben. Dadurch kann der Algorithmus auf die prominentesten Wörter in einem Dokument ausgeführt werden. Wir können die naiven Bayes wie folgt implementieren:

 import numpy as np from sklearn.naive_bayes import MultinomialNB from sklearn.feature_extraction.text import CountVectorizer import pandas as pd from collections import Counter from sklearn.model_selection import train_test_split from sklearn.feature_extraction.text import TfidfTransformer df = pd.read_csv('data/wine_data.csv') counter = Counter(df['variety'].tolist()) top_10_varieties = {i[0]: idx for idx, i in enumerate(counter.most_common(10))} df = df[df['variety'].map(lambda x: x in top_10_varieties)] description_list = df['description'].tolist() varietal_list = [top_10_varieties[i] for i in df['variety'].tolist()] varietal_list = np.array(varietal_list) count_vect = CountVectorizer() x_train_counts = count_vect.fit_transform(description_list) tfidf_transformer = TfidfTransformer() x_train_tfidf = tfidf_transformer.fit_transform(x_train_counts) train_x, test_x, train_y, test_y = train_test_split(x_train_tfidf, varietal_list, test_size=0.3) clf = MultinomialNB().fit(train_x, train_y) y_score = clf.predict(test_x) n_right = 0 for i in range(len(y_score)): if y_score[i] == test_y[i]: n_right += 1 print("Accuracy: %.2f%%" % ((n_right/float(len(test_y)) * 100)))

Führen Sie den obigen Code aus und Sie sollten ungefähr Folgendes sehen: 73,56 %

Wenn man bedenkt, dass wir 10 Klassen betrachten, ist das ein recht gutes Ergebnis.

Wir können auch eine Support-Vektor-Maschine verwenden und sehen, wie sie funktionieren würde. Um zu sehen, wie es funktioniert, ersetzen Sie einfach die Klassifikatordefinition durch

 clf = SVC(kernel='linear').fit(train_x, train_y)

Führen Sie dies aus und Sie sollten die folgende Ausgabe sehen:

Genauigkeit: 80,66 %

Auch nicht zu schäbig.

Mal sehen, ob wir ein Deep-Learning-Modell bauen können, das diese Ergebnisse übertreffen oder zumindest erreichen kann. Wenn uns das gelingt, wäre das ein guter Hinweis darauf, dass unser Deep-Learning-Modell zumindest die Ergebnisse der populären Machine-Learning-Modelle, die auf Fachkenntnissen basieren, repliziert.

Aufbau des Modells

Heute werden wir Keras mit Tensorflow verwenden, um unser Modell zu erstellen. Keras ist eine Python-Bibliothek, die das Erstellen von Deep-Learning-Modellen im Vergleich zur relativ einfachen Schnittstelle der Tensorflow-API sehr einfach macht. Zusätzlich zu den dichten Schichten werden wir auch Einbettungs- und Faltungsschichten verwenden, um die zugrunde liegenden semantischen Informationen der Wörter und mögliche Strukturmuster innerhalb der Daten zu lernen.

Datenreinigung

Zunächst müssen wir die Daten so umstrukturieren, dass sie von unserem neuronalen Netzwerk leicht verarbeitet und verstanden werden können. Wir können dies tun, indem wir die Wörter durch eindeutig identifizierende Zahlen ersetzen. In Kombination mit einem Einbettungsvektor sind wir in der Lage, die Wörter flexibel und semantisch sensibel darzustellen.

In der Praxis werden wir bei dieser Vorverarbeitung etwas schlauer vorgehen wollen. Es wäre sinnvoll, sich auf die häufig verwendeten Wörter zu konzentrieren und auch die am häufigsten verwendeten Wörter herauszufiltern (z. B. das, das, ein).

Wir können diese Funktionalität mit Defaultdict und NLTK implementieren. Schreiben Sie den folgenden Code in ein separates Python-Modul. Ich habe es in lib/get_top_x_words.py .

 from nltk import word_tokenize from collections import defaultdict def count_top_x_words(corpus, top_x, skip_top_n): count = defaultdict(lambda: 0) for c in corpus: for w in word_tokenize(c): count[w] += 1 count_tuples = sorted([(w, c) for w, c in count.items()], key=lambda x: x[1], reverse=True) return [i[0] for i in count_tuples[skip_top_n: skip_top_n + top_x]] def replace_top_x_words_with_vectors(corpus, top_x): topx_dict = {top_x[i]: i for i in range(len(top_x))} return [ [topx_dict[w] for w in word_tokenize(s) if w in topx_dict] for s in corpus ], topx_dict def filter_to_top_x(corpus, n_top, skip_n_top=0): top_x = count_top_x_words(corpus, n_top, skip_n_top) return replace_top_x_words_with_vectors(corpus, top_x)

Jetzt sind wir bereit, das Modell zu bauen. Wir wollen eine Einbettungsschicht, eine Faltungsschicht und eine dichte Schicht, um alle Deep-Learning-Funktionen zu nutzen, die für unsere Anwendung hilfreich sein können. Mit Keras können wir das Modell sehr einfach bauen:

 from keras.models import Sequential from keras.layers import Dense, Conv1D, Flatten from keras.layers.embeddings import Embedding from keras.preprocessing import sequence from keras.utils import to_categorical import pandas as pd from collections import Counter from sklearn.model_selection import train_test_split from lib.get_top_xwords import filter_to_top_x df = pd.read_csv('data/wine_data.csv') counter = Counter(df['variety'].tolist()) top_10_varieties = {i[0]: idx for idx, i in enumerate(counter.most_common(10))} df = df[df['variety'].map(lambda x: x in top_10_varieties)] description_list = df['description'].tolist() mapped_list, word_list = filter_to_top_x(description_list, 2500, 10) varietal_list_o = [top_10_varieties[i] for i in df['variety'].tolist()] varietal_list = to_categorical(varietal_list_o) max_review_length = 150 mapped_list = sequence.pad_sequences(mapped_list, maxlen=max_review_length) train_x, test_x, train_y, test_y = train_test_split(mapped_list, varietal_list, test_size=0.3) max_review_length = 150 embedding_vector_length = 64 model = Sequential() model.add(Embedding(2500, embedding_vector_length, input_length=max_review_length)) model.add(Conv1D(50, 5)) model.add(Flatten()) model.add(Dense(100, activation='relu')) model.add(Dense(max(varietal_list_o) + 1, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) model.fit(train_x, train_y, epochs=3, batch_size=64) y_score = model.predict(test_x) y_score = [[1 if i == max(sc) else 0 for i in sc] for sc in y_score] n_right = 0 for i in range(len(y_score)): if all(y_score[i][j] == test_y[i][j] for j in range(len(y_score[i]))): n_right += 1 print("Accuracy: %.2f%%" % ((n_right/float(len(test_y)) * 100)))

Führen Sie den Code aus und Sie sollten die folgende Ausgabe sehen.

Genauigkeit: 77,20 %

Denken Sie daran, dass die Genauigkeit für naive Bayes und SVC 73,56 % bzw. 80,66 % betrug. Unser neuronales Netzwerk kann sich also sehr gut gegen einige der gebräuchlicheren Textklassifizierungsmethoden behaupten.

Fazit

Heute haben wir den Aufbau eines Klassifikations-Deep-Learning-Modells zur Analyse von Weinbewertungen behandelt.

Wir stellten fest, dass wir in der Lage waren, ein Modell zu erstellen, das mit einigen der anderen maschinellen Lernalgorithmen konkurrieren und diese übertreffen konnte. Wir hoffen, dass Sie inspiriert sind, diese Informationen zu nutzen, um Anwendungen zu entwickeln, die komplexere Datensätze analysieren und komplexere Ergebnisse generieren!

Hinweis: Den Code, den ich für diesen Artikel verwendet habe, finden Sie auf GitHub.

Weiterführende Literatur im Toptal Engineering Blog:

Eine tiefere Bedeutung: Themenmodellierung in Python
So erstellen Sie einen E-Mail-Stimmungsanalyse-Bot: Ein NLP-Tutorial