Japanische Verarbeitung natürlicher Sprache mit Python3 (4) Emotionsanalyse durch logistische Regression

Wie bewertet TF-IDF die Wortrelevanz?

Bis zum letzten Mal habe ich Sätze analysiert und Wörter in Merkmalsvektoren umgewandelt. Selbst wenn ein Wort in einem Satz häufig vorkommt und in einem Satz einer Kategorie häufig vorkommt, ist das Wort für die Beurteilung der Kategorie nicht sehr wichtig. Wenn Sie eine Filmkritik als "positiv" oder "negativ" klassifizieren möchten, kann das Wort "wow" häufig im Zusammenhang mit "wow" oder "wow" verwendet werden. Das ist also alles. Dann ist das Negative und Positive der Bewertung schwer zu beurteilen. Mit dieser Art von Gefühl ist, wenn ein Wort kategorisiert wird, die Methode, das Gewicht des Wortes zu erhöhen, wenn es wichtig ist, und es zu verringern, wenn es nicht wichtig ist, "TF-IDF". TF wird als Häufigkeit des Auftretens von Wörtern bezeichnet, IDF wird als Häufigkeit des umgekehrten Dokuments bezeichnet und die Definition lautet wie folgt. Angenommen, $ n_d $ repräsentiert die Gesamtzahl der Dokumente und $ df (t, d) $ repräsentiert die Anzahl der Dokumente, die das Wort t enthalten idf(t, d) = log \frac{n_d}{1 + df(t,d)}, tf-idf = tf(t,d) \times idf(t, d)

Übrigens ist es relativ einfach, dies mit der TfidfTransformer-Klasse in Pythons Scikit-Learn zu implementieren, die die Häufigkeit von Wortvorkommen vom zuletzt verwendeten CountVectorizer empfängt und konvertiert.

tf_idf.py

import numpy as np
from sklearn.feature_extraction.text import CountVectorizer 
from sklearn.feature_extraction.text import TfidfTransformer

count = CountVectorizer()
texts = np.array(["He likes to play the guitar", \
"She likes to play the piano", \
"He likes to play the guitar, and she likes to play the piano"])
bag = count.fit_transform(docs)

tfidf = TfidfTransformer(use_idf=True, norm='l2', smooth_idf=True)
np.set_printoptions(precision=2)
print(tfidf.fit_transform(count.fit_transform(docs)).toarray())

Ausgabeergebnis:
[[ 0.    0.48  0.48  0.37  0.    0.37  0.    0.37  0.37]
 [ 0.    0.    0.    0.37  0.48  0.37  0.48  0.37  0.37]
 [ 0.34  0.26  0.26  0.4   0.26  0.4   0.26  0.4   0.4 ]]

Punkte, die bei der tatsächlichen Analyse von Textdaten zu beachten sind

Textdaten bereinigen

In einem Satz wie dem obigen Beispiel enthält die Eingabe keine zusätzlichen Symbole usw. und kann so wie sie ist an countVectorizer usw. übergeben werden. Einige Textdaten enthalten jedoch HTML-Markups und Trennlinien. Diese zusätzlichen Daten müssen vor Beginn der Analyse entfernt werden (Bereinigung der Textdaten). Dies kann mit regulären Python-Ausdrücken usw. erfolgen. Operation für reguläre Ausdrücke in Python

Entfernen von Stoppwörtern

Unabhängig von der Satzkategorie sind Wörter, die häufig in einem Satz in einer bestimmten Sprache vorkommen, für die Klassifizierung von Sätzen nicht sehr wichtig. Daher ist es besser, sie zu untersuchen, bevor Sie tatsächlich maschinelles Lernen durchführen. .) Auf Englisch können Sie Stoppwörter aus der NLTK-Bibliothek von Python mitbringen, auf Japanisch gibt es jedoch keine offizielle Bibliothek slothlib. Es scheint, dass es oft die Seite liest (/Filter/StopWord/word/Japanese.txt), die Quelle analysiert und das Wort abruft. Öffnen Sie zuerst die URL mit dem folgenden Code und überprüfen Sie dann die Quelle mit einem mysteriösen Element namens Beautiful Soup.

ja_stopwords.py

import urllib.request
import bs4
from bs4 import BeautifulSoup

def get_stop_words():
    #stopwords(Häufige Wörter unabhängig von Satzattributen)Holen Sie sich die Stoppwortliste wie Japanisch in Slothlib auszuschließen.
    #Analysieren Sie die Quelle mit urllib und BeautifulSoup.
    url = 'http://svn.sourceforge.jp/svnroot/slothlib/CSharp/Version1/SlothLib/NLP/Filter/StopWord/word/Japanese.txt'
    soup = bs4.BeautifulSoup(urllib.request.urlopen(url).read(), "html.parser")
    ss = str(soup)
    return ss

print(get_stop_words())

Ausgabeergebnis:
da drüben
Pro
Dort
Da drüben
nach
Loch
Sie
Das
Wie viele
Wann
Jetzt
ich
...

Schulung logistischer Regressionsmodelle zur Klassifizierung von Dokumenten

Dann finden wir auf diese Weise die Merkmalsmenge usw. und führen tatsächlich eine logistische Regressionsanalyse für die vorverarbeiteten Sätze durch, um zu klassifizieren, ob die Sätze, die maschinelles Lernen sind, positiv oder negativ sind. Es gab keine erschwingliche Quelle auf Japanisch (es scheint, dass es viele Sammlungen von Twitter gibt, aber es ist mühsam, sich dafür mit AWS anzulegen) Versuchen Sie es mit Daten, die für englische Filmkritiken negativ oder positiv sind. Dieses Programm ist [Python Machine Learning](https://www.amazon.co.jp/Python%E6%A9%9F%E6%A2%B0%E5%AD%A6%E7%BF%92%E3%83 % 97% E3% 83% AD% E3% 82% B0% E3% 83% A9% E3% 83% 9F% E3% 83% B3% E3% 82% B0-% E9% 81% 94% E4% BA% BA% E3% 83% 87% E3% 83% BC% E3% 82% BF% E3% 82% B5% E3% 82% A4% E3% 82% A8% E3% 83% B3% E3% 83% 86% E3% 82% A3% E3% 82% B9% E3% 83% 88% E3% 81% AB% E3% 82% 88% E3% 82% 8B% E7% 90% 86% E8% AB% 96% E3% 81% A8% E5% AE% 9F% E8% B7% B5-Impress-Top-Gang / dp / 4844380605 / ref = sr_1_cc_2? S = aps & dh = UTF8 & qid = 1487516026 & sr = 1-2-catcorr & keywords = Python +% E6% A9% Ich habe auf das Kapitel über die Verarbeitung natürlicher Sprache im Buch 9F% E6% A2% B0% E5% AD% A6% E7% BF% 92) verwiesen.

reviews.py

from sklearn.pipeline import Pipeline 
from sklearn.linear_model import LogisticRegression
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.model_selection import GridSearchCV

X_train = df.loc[:25000, 'review'].values
y_train = df.loc[:25000, 'sentiment'].values
X_test = df.loc[25000:, 'review'].values
y_test = df.loc[25000:, 'sentiment'].values

tfidf = TfidfVectorizer(strip_accents=None, lowercase=False, preprocessor=None)

param_grid = [{'vect__ngram_range': [(1, 1)],
               'vect__stop_words': [stop, None],
               'vect__tokenizer': [tokenizer, tokenizer_porter],
               'clf__penalty': ['l1', 'l2'],
               'clf__C': [1.0, 10.0, 100.0]},
              {'vect__ngram_range': [(1, 1)],
               'vect__stop_words': [stop, None],
               'vect__tokenizer': [tokenizer, tokenizer_porter],
               'vect__use_idf':[False],
               'vect__norm':[None],
               'clf__penalty': ['l1', 'l2'],
               'clf__C': [1.0, 10.0, 100.0]},
              ]

                     ('clf', LogisticRegression(random_state=0))])

gs_lr_tfidf = GridSearchCV(lr_tfidf, param_grid,
                           scoring='accuracy',
                           cv=5,
                           verbose=1,
                           n_jobs=-1)
gs_lr_tfidf.fit(X_train, y_train)
print('Accuracy: %.3f' % gs_lr_tfidf.best_score_)

Teilen Sie df zunächst in Trainingsdaten und Testdaten auf. Es ist möglicherweise einfacher zu verstehen, wenn Sie sich vorstellen, dass df wie eine Tabelle im Datenrahmen der Pandas-Bibliothek aussieht.

['Bewertung'] ['Stimmung'] in diesem ist der Text der Bewertung (dies ist x) und das Etikett für die Bewertung (0,1 bedeutet positiv oder negativ), und dies ist y. (Ich werde weglassen, wie df tatsächlich die Originaldaten liest und die Daten bereinigt ...) Danach verwende ich GridSearchCV, eine Klasse von sklearn, um die optimalen Parameter für die logistische Rotation zu optimieren. Ich habe eine Instanz von GridSearchCV mit dem Namen gs_lr_tfidf erstellt und sie mit gs_lr_tfidf.fit () unter Verwendung von X_train und y_train trainiert.

(Hyperparameter-Tuning mit sklearn)

Es dauert jedoch enorm viel Zeit, um diese Methode tatsächlich durchzuführen ... Wenn die Daten groß sind, scheint es daher üblich zu sein, das zu tun, was als Out-of-Core-Lernen bezeichnet wird.