google übersetzte http://scikit-learn.org/0.18/tutorial/text_analytics/working_with_text_data.html scikit-learn 0.18 Tutorial Inhaltsverzeichnis / Vorheriges Tutorial
Der Zweck dieses Handbuchs besteht darin, einige der wichtigsten "Scikit-Learn" -Werkzeuge für eine praktische Aufgabe zu untersuchen: die Analyse von Textdokumenten (Newsgroup-Posts) zu 20 verschiedenen Themen. In diesem Abschnitt wird beschrieben, wie Sie:
--Laden Sie Dateiinhalte und -kategorien
Um dieses Tutorial zu starten, müssen Sie zuerst scicit-learn und alle erforderlichen Abhängigkeiten installieren. Weitere Informationen und systemspezifische Anweisungen finden Sie auf der Seite Installationsanweisungen (http://scikit-learn.org/0.18/install.html#installation-instructions). Die Quelle für dieses Tutorial befindet sich im Ordner scikit-learn:
scikit-learn/doc/tutorial/text_analytics/
Der Tutorial-Ordner sollte die folgenden Ordner enthalten:
-- * .rst file - Quelle des in Sphinx geschriebenen Tutorial-Dokuments
--data - Ordner zum Speichern des im Lernprogramm verwendeten Datensatzes
--skeletons - Unvollständiges Beispielskript für Übungen
--solutions --Praktische Lösungen
Kopieren Sie skeltons in einen neuen Ordner namens sklearn_tut_workspace irgendwo auf Ihrer Festplatte. Behalten Sie das ursprüngliche Skelett bei und bearbeiten Sie die kopierte Datei in dieser Übung:
% cp -r skeletons work_directory/sklearn_tut_workspace
Daten werden für maschinelles Lernen benötigt. Gehen Sie zu jedem Unterordner "$ STRUCT_HOME / data" und führen Sie von dort aus das Skript "fetch_data.py" aus (nach dem ersten Laden). Zum Beispiel:
% cd $TUTORIAL_HOME/data/languages
% less fetch_data.py
% python fetch_data.py
Der Datensatz heißt "20 Newsgroups". Hier ist die offizielle Beschreibung der Website (http://people.csail.mit.edu/jrennie/20Newsgroups/):
Ein 20-Newsgroup-Datensatz ist eine Sammlung von ungefähr 20.000 Newsgroup-Dokumenten, die (fast) gleichmäßig auf 20 Newsgroups verteilt sind. Soweit wir wissen, wurde es ursprünglich von Ken Lang für seine Arbeit "Newsweeder: Lernen, Net News zu filtern" gesammelt, aber es wird in dieser Sammlung nicht explizit erwähnt. Die Sammlung von 20 Newsgroups ist ein beliebter Datensatz zum Experimentieren mit Textanwendungen in maschinellen Lerntechniken wie Textklassifizierung und Textclustering.
Im Folgenden wird der integrierte Dataset Loader für die 20 Newsgroups von scikit-learn verwendet. Sie können den Datensatz auch manuell von der Website und von [sklearn.datasets.load_files] herunterladen (http://scikit-learn.org/0.18/modules/generated/sklearn.datasets.load_files.html#sklearn.datasets.load_files] Sie können auch die Funktion) verwenden, um den Unterordner "20news-bydate-train" des unkomprimierten Archivordners anzugeben. Um die Ausführungszeit dieses ersten Beispiels zu verkürzen, erstellen Sie ein Teildatensatz mit nur 4 der 20 im Datensatz verfügbaren Kategorien.
>>> categories = ['alt.atheism', 'soc.religion.christian',
... 'comp.graphics', 'sci.med']
Sie können eine Liste von Dateien laden, die diesen Kategorien wie folgt entsprechen:
>>> from sklearn.datasets import fetch_20newsgroups
>>> twenty_train = fetch_20newsgroups(subset='train',
... categories=categories, shuffle=True, random_state=42)
Der zurückgegebene Datensatz ist ein Scicit-Learn-Haufen. Ein einfaches Halterobjekt mit Feldern, auf die der Einfachheit halber als Attribut von Pythons "dict" -Schlüssel oder "object" zugegriffen werden kann. Beispielsweise enthält target_names eine Liste der angeforderten Kategorienamen.
>>> twenty_train.target_names
['alt.atheism', 'comp.graphics', 'sci.med', 'soc.religion.christian']
Die Datei selbst wird in den Speicher des Datenattributs geladen. Dateinamen stehen auch als Referenz zur Verfügung:
>>> len(twenty_train.data)
2257
>>> len(twenty_train.filenames)
2257
Drucken wir nun die erste Zeile der geladenen Datei:
>>> print("\n".join(twenty_train.data[0].split("\n")[:3]))
From: [email protected] (Michael Collier)
Subject: Converting images to HP LaserJet III?
Nntp-Posting-Host: hampton
>>> print(twenty_train.target_names[twenty_train.target[0]])
comp.graphics
Der überwachte Lernalgorithmus erfordert eine Kategoriebeschriftung für jedes Dokument im Trainingssatz. In diesem Fall ist die Kategorie der Name der Newsgroup und auch der Name des Ordners, in dem sich die einzelnen Dokumente befinden. Aus Gründen der Geschwindigkeit und der Raumeffizienz lädt scikit-learn das Attribut "target" als Array von Ganzzahlen, die dem Index des Kategorienamens in der Liste "target_names" entsprechen. Die Kategorie-Ganzzahl-ID für jede Stichprobe wird im Attribut "Ziel" gespeichert.
>>> twenty_train.target[:10]
array([1, 1, 3, 3, 3, 3, 3, 2, 2, 2])
Sie können den Kategorienamen wie folgt erhalten:
>>> for t in twenty_train.target[:10]:
... print(twenty_train.target_names[t])
...
comp.graphics
comp.graphics
soc.religion.christian
soc.religion.christian
soc.religion.christian
soc.religion.christian
soc.religion.christian
sci.med
sci.med
sci.med
Sie werden feststellen, dass die Proben zufällig gemischt werden (mit festen zufälligen Samen). Es ist nützlich, das Modell schnell nur mit der ersten Stichprobe zu trainieren und die Ergebnisse der ersten Idee zu testen, bevor Sie den gesamten Datensatz trainieren.
Um ein Textdokument maschinell zu lernen, muss zunächst der Textinhalt in einen numerischen Merkmalsvektor konvertiert werden.
Bag of Words
Der intuitivste Weg, dies zu tun, ist mit der Bag of Words-Darstellung:
Der Ausdruck "Taschen voller Wörter" bedeutet, dass "n_features" die Anzahl der verschiedenen Wörter im Korpus ist. Diese Zahl überschreitet normalerweise 100.000.
Für "n_samples == 10000" erfordert das Speichern von "X" als Gleitkomma-Array von "numpy" 10000 x 100000 x 4 Byte = ** 4 GB RAM **, was auf heutigen Computern schwierig ist.
Glücklicherweise sind die meisten Werte für ** X 0 **. Dies liegt daran, dass das angegebene Dokument Tausende verschiedener Wörter verwendet. Aus diesem Grund ist der Wortbeutel ein ** hochdimensionaler, spärlicher Datensatz **. Es kann viel Speicherplatz gespart werden, indem nur der Nicht-Null-Teil des Merkmalsvektors im Speicher gespeichert wird.
Die scipy.sparse Matrix ist genau die Datenstruktur, die dies tut, und scikit-learn hat eine integrierte Unterstützung für diese Strukturen.
Die Vorverarbeitung, Tokenisierung und Filterung von Stoppworttext ist in übergeordneten Komponenten enthalten, mit denen ein Wörterbuch mit Features erstellt und Dokumente in Feature-Vektoren konvertiert werden können.
>>> from sklearn.feature_extraction.text import CountVectorizer
>>> count_vect = CountVectorizer()
>>> X_train_counts = count_vect.fit_transform(twenty_train.data)
>>> X_train_counts.shape
(2257, 35788)
CountVectorizer steht für N-Gramm-Wörter oder aufeinanderfolgende Zeichen. Unterstützt das Zählen. Nach dem Anpassen erstellt der Vektorisierer ein Wörterbuch mit Funktionsindikatoren:
>>> count_vect.vocabulary_.get(u'algorithm')
4690
Die Indexwerte der Wörter im Vokabular sind an die Häufigkeit des gesamten Trainingskorpus gebunden.
Das Zählen von Wörtern ist ein guter Anfang, aber je länger das Dokument ist, desto höher ist die durchschnittliche Anzahl, selbst wenn Sie über dasselbe Thema sprechen. Um diese möglichen Abweichungen zu vermeiden, ist es ausreichend, die Anzahl der Vorkommen jedes Wortes im Dokument durch die Gesamtzahl der Wörter im Dokument zu teilen. Diese neuen Funktionen werden in Termfrequenzen als "tf" bezeichnet. Eine weitere Verbesserung von tf besteht darin, das Gewicht von Wörtern zu reduzieren, die in vielen Korpusdokumenten vorkommen. Es ist weniger nützlich als die Wörter, die selten im Korpus vorkommen. Diese Verkleinerung wird als "Termfrequenz mal Inverse Dokumentfrequenz" tf-idf bezeichnet. ** tf ** und ** tf-idf ** können wie folgt berechnet werden:
>> from sklearn.feature_extraction.text import TfidfTransformer
>>> tf_transformer = TfidfTransformer(use_idf=False).fit(X_train_counts)
>>> X_train_tf = tf_transformer.transform(X_train_counts)
>>> X_train_tf.shape
(2257, 35788)
Der Code im obigen Beispiel verwendet zuerst die Methode fit (...), um die Schätzung an die Daten anzupassen, und transformiert dann die Zählmatrix in eine tf-idf-Darstellung transform (... ) Verwenden Sie die Methode. Durch die Kombination dieser beiden Schritte und das Überspringen der redundanten Verarbeitung können Sie das gleiche Endergebnis schneller erzielen. Dies erfolgt mit der Methode fit_transform (..), wie in den Anmerkungen im vorherigen Abschnitt beschrieben, wie unten gezeigt.
>>> tfidf_transformer = TfidfTransformer()
>>> X_train_tfidf = tfidf_transformer.fit_transform(X_train_counts)
>>> X_train_tfidf.shape
(2257, 35788)
Nachdem Sie über die Funktionen verfügen, können Sie Ihren Klassifikator trainieren, um die Kategorien Ihrer Beiträge vorherzusagen. Naive Bayes Beginnen wir mit dem Klassifikator. Dies bietet eine hervorragende Basis für diese Aufgabe. scikit-learn enthält mehrere Varianten dieses Klassifikators. Für die Anzahl der Wörter am besten geeignet ist eine Variante des Polymorphismus:
>>> from sklearn.naive_bayes import MultinomialNB
>>> clf = MultinomialNB().fit(X_train_tfidf, twenty_train.target)
Um das Ergebnis eines neuen Dokuments vorherzusagen, müssen Sie Features mit fast derselben Feature-Extraktionskette wie zuvor extrahieren. Der Unterschied besteht darin, dass Sie bereits in das Trainingsset passen und im Konverter "transform" anstelle von "fit_transform" aufrufen.
>>> docs_new = ['God is love', 'OpenGL on the GPU is fast']
>>> X_new_counts = count_vect.transform(docs_new)
>>> X_new_tfidf = tfidf_transformer.transform(X_new_counts)
>>> predicted = clf.predict(X_new_tfidf)
>>> for doc, category in zip(docs_new, predicted):
... print('%r => %s' % (doc, twenty_train.target_names[category]))
...
'God is love' => soc.religion.christian
'OpenGL on the GPU is fast' => comp.graphics
Um die Verwendung einer Reihe von Operationen wie "vectorizer => converter => classifier" zu vereinfachen, bietet scikit-learn eine "Pipeline" -Klasse, die sich wie ein zusammengesetzter Klassifikator verhält.
>>> from sklearn.pipeline import Pipeline
>>> text_clf = Pipeline([('vect', CountVectorizer()),
... ('tfidf', TfidfTransformer()),
... ('clf', MultinomialNB()),
... ])
Die Namen "vect", "tfidf" und "clf" (kurz für Klassifikator) sind beliebig. Im Folgenden erfahren Sie, wie Sie es im Abschnitt "Rastersuche" verwenden. Sie können Ihr Modell mit den folgenden Befehlen trainieren:
>>> text_clf = text_clf.fit(twenty_train.data, twenty_train.target)
Ebenso einfach ist die Bewertung der Vorhersagegenauigkeit eines Modells.
>>> twenty_test = fetch_20newsgroups(subset='test',
... categories=categories, shuffle=True, random_state=42)
>>> docs_test = twenty_test.data
>>> predicted = text_clf.predict(docs_test)
>>> np.mean(predicted == twenty_test.target)
0.834...
Wir haben eine Genauigkeit von 83,4% erreicht. Weithin als einer der besten Textklassifizierungsalgorithmen anerkannt (obwohl etwas langsamer als Naive Bayes) Linear Support Vector Machine (SVM) Mal sehen, ob es mit #svm funktioniert). Sie können den Lernenden ändern, indem Sie einfach ein anderes Klassifikatorobjekt in die Pipeline einfügen:
>>> from sklearn.linear_model import SGDClassifier
>>> text_clf = Pipeline([('vect', CountVectorizer()),
... ('tfidf', TfidfTransformer()),
... ('clf', SGDClassifier(loss='hinge', penalty='l2',
... alpha=1e-3, n_iter=5, random_state=42)),
... ])
>>> _ = text_clf.fit(twenty_train.data, twenty_train.target)
>>> predicted = text_clf.predict(docs_test)
>>> np.mean(predicted == twenty_test.target)
0.912...
scikit-learn bietet auch ein Dienstprogramm für eine detailliertere Leistungsanalyse der Ergebnisse:
>>> from sklearn import metrics
>>> print(metrics.classification_report(twenty_test.target, predicted,
... target_names=twenty_test.target_names))
...
precision recall f1-score support
alt.atheism 0.95 0.81 0.87 319
comp.graphics 0.88 0.97 0.92 389
sci.med 0.94 0.90 0.92 396
soc.religion.christian 0.90 0.95 0.93 398
avg / total 0.92 0.91 0.91 1502
>>> metrics.confusion_matrix(twenty_test.target, predicted)
array([[258, 11, 15, 35],
[ 4, 379, 3, 3],
[ 5, 33, 355, 3],
[ 5, 10, 4, 379]])
Wie erwartet zeigt die Chaosmatrix, dass Beiträge von Nachrichtengruppen zu Atheismus und Christen oft eher miteinander verwechselt werden als mit Computergrafiken.
Parameter wie use_idf sind bereits in TfidfTransformer aufgetreten. Klassifikatoren neigen auch dazu, viele Parameter zu haben. MultinomialNB enthält den Glättungsparameter alpha und SGDClassifier hat einen Strafparameter alpha und einen Verlust- und Strafbegriff, der innerhalb der Zielfunktion eingestellt werden kann (siehe Modulhandbuch oder Siehe diese Anweisungen mit der Python-Hilfefunktion.
Anstatt die Parameter der verschiedenen Komponenten der Kette zu optimieren, können Sie in einem Raster möglicher Werte umfassend nach den besten Parametern suchen. Probieren Sie das Vorhandensein oder Fehlen von idf, den Strafparameter (alpha) 0,01 oder 0,001 für lineare SVM und die Vektorisierer-Aufteilungsmethode, entweder Wort oder Bigram, aus.
>>> from sklearn.model_selection import GridSearchCV
>>> parameters = {'vect__ngram_range': [(1, 1), (1, 2)],
... 'tfidf__use_idf': (True, False),
... 'clf__alpha': (1e-2, 1e-3),
... }
Offensichtlich kann eine solch gründliche Suche teuer sein. Wenn Sie mehrere CPU-Kerne haben, können Sie den Parameter n_jobs an den Grid-Sucher übergeben, um ihn anzuweisen, eine Kombination von acht Parametern parallel zu versuchen. Wenn Sie für diesen Parameter den Wert "-1" angeben, wird die Anzahl der installierten Kerne erkannt und alle werden verwendet.
>>> gs_clf = GridSearchCV(text_clf, parameters, n_jobs=-1)
Die Rastersuchinstanz verhält sich wie ein reguläres Scikit-Lernmodell. Führen Sie Suchen in kleineren Teilmengen von Trainingsdaten durch, um die Berechnungen zu beschleunigen:
>>> gs_clf = gs_clf.fit(twenty_train.data[:400], twenty_train.target[:400])
Das Ergebnis der Anpassung eines GitSearchCV-Objekts ist ein Klassifizierer, den die Vorhersage verwenden kann.
>>> twenty_train.target_names[gs_clf.predict(['God is love'])[0]]
'soc.religion.christian'
Die Attribute best_score_ und best_params_ des Objekts speichern die besten Durchschnittswerte und Parametereinstellungen für diesen Wert.
>>> gs_clf.best_score_
0.900...
>>> for param_name in sorted(parameters.keys()):
... print("%s: %r" % (param_name, gs_clf.best_params_[param_name]))
...
clf__alpha: 0.001
tfidf__use_idf: True
vect__ngram_range: (1, 1)
Weitere Informationen zur Suche finden Sie unter gs_clf.cv_results_.
Der Parameter "cv_results_" kann zur späteren Überprüfung einfach als "DataFrame" in Pandas importiert werden.
Kopieren Sie zum Üben den Inhalt des Ordners "Skelette" in einen neuen Ordner mit dem Namen "Arbeitsbereich".
% cp -r skeletons workspace
Sie können dann den Inhalt des Arbeitsbereichs bearbeiten, ohne die ursprünglichen Übungsanweisungen zu verlieren. Starten Sie dann die Ipython-Shell und führen Sie das Work-in-Progress-Skript aus.
[1] %run workspace/exercise_XX_script.py arg1 arg2 arg3
Wenn eine Ausnahme ausgelöst wird, verwenden Sie "% debug", um eine Autopsie-Debug-Sitzung zu starten. Verbessern Sie Ihre Implementierung und wiederholen Sie den Vorgang, bis die Übung abgeschlossen ist. Jede Übung enthält alle Importanweisungen, die für eine Skelettdatei erforderlich sind, Boilerplate-Code zum Lesen der Daten und Beispielcode zur Bewertung der Vorhersagegenauigkeit des Modells.
ipython Befehlszeile:
%run workspace/exercise_01_language_train_model.py data/languages/paragraphs/
--Erstellen Sie eine Textklassifizierungspipeline, um Filmkritiken positiv oder negativ zu klassifizieren. --Verwenden Sie eine Rastersuche, um den entsprechenden Parametersatz zu finden.
ipython Befehlszeile:
%run workspace/exercise_02_sentiment.py data/movie_reviews/txt_sentoken/
--Verwenden Sie die Ergebnisse der vorherigen Übung und das Modul "cPickle" der Standardbibliothek, um die Sprache des von stdin gelieferten Textes zu ermitteln und die Polarität (positiv oder negativ) zu schätzen, wenn der Text in Englisch verfasst ist. Beschreibt das zu verwendende Befehlszeilenprogramm.
Nach Abschluss dieses Tutorials gibt es einige Vorschläge, die Ihnen helfen, Scikit intuitiv zu verstehen:
-analyzer und Token Normalization von CountVectorizer Bitte versuche
Inhaltsverzeichnis des Lernprogramms / Nächstes Lernprogramm
© 2010 - 2016, Entwickler von Scikit-Learn (BSD-Lizenz).
Recommended Posts