Traitement du langage naturel japonais utilisant Python3 (4) Analyse des émotions par régression logistique

Quelle est l'évaluation par TF-IDF de la pertinence des mots?

Jusqu'à la dernière fois, j'ai analysé des phrases et converti des mots en vecteurs de caractéristiques. Cependant, même si un mot existe beaucoup dans une phrase, s'il apparaît beaucoup dans une phrase de n'importe quelle catégorie, le mot n'est pas très important pour juger de la catégorie. Lorsque vous souhaitez classer une critique de film comme "positive" ou "négative", le mot "wow" peut être fréquemment utilisé dans le contexte de "wow" ou "wow", c'est tout. Ensuite, le négatif et le positif de la critique sont difficiles à juger. Avec ce genre de sentiment, lorsqu'un mot est catégorisé, la méthode pour augmenter le poids du mot s'il est important et le diminuer s'il n'est pas important est "TF-IDF". TF est appelée fréquence d'occurrence de mot, IDF est appelée fréquence inverse du document et la définition est la suivante. En supposant que $ n_d $ représente le nombre total de documents et $ df (t, d) $ représente le nombre de documents contenant le mot t idf(t, d) = log \frac{n_d}{1 + df(t,d)}, tf-idf = tf(t,d) \times idf(t, d)

À propos, il est relativement facile de l'implémenter avec la classe TfidfTransformer dans scikit-learn de Python, qui reçoit la fréquence des occurrences de mots du CountVectorizer utilisé la dernière fois et la convertit.

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())

Résultat de sortie:
[[ 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 ]]

Points à garder à l'esprit lors de l'analyse des données textuelles

Nettoyage des données textuelles

Dans une phrase comme l'exemple ci-dessus, l'entrée n'inclut pas de symboles supplémentaires, etc. et peut être transmise à countVectorizer etc. telle quelle. Cependant, certaines données texte incluent des balises HTML et des lignes de séparation, et il est nécessaire de supprimer ces données supplémentaires avant de commencer l'analyse (nettoyage des données texte). Cela peut être fait avec des expressions régulières Python, etc. Opération d'expression régulière en Python

Suppression des mots vides

Quelle que soit la catégorie de phrase, les mots qui apparaissent souvent dans une phrase dans une certaine langue ne sont pas très importants pour classer les phrases, il est donc préférable de les examiner avant d'effectuer réellement l'apprentissage automatique. .) En anglais, vous pouvez importer des mots vides de la bibliothèque NLTK de Python, mais en japonais, il n'y a pas de bibliothèque officielle, slothlib Il semble qu'il lit souvent la page (/Filter/StopWord/word/Japanese.txt), analyse la source et récupère le mot. Tout d'abord, ouvrez l'URL avec un code comme celui-ci, puis vérifiez la source en utilisant une chose mystérieuse appelée Beautiful Soup.

ja_stopwords.py

import urllib.request
import bs4
from bs4 import BeautifulSoup

def get_stop_words():
    #stopwords(Mots fréquents quels que soient les attributs de la phrase)Obtenez la liste des mots vides comme le japonais dans slothlib à exclure.
    #Analysez la source avec urllib et 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())

Résultat de sortie:
là bas
Autour
Là
Là bas
après
trou
tu
cette
Combien
Quand
Maintenant
je
...

Formation de modèles de régression logistique pour classer les documents

Ensuite, comme cela, nous trouverons la quantité de caractéristiques, etc., et effectuerons une analyse de régression logistique sur les phrases prétraitées, et classerons si les phrases d'apprentissage automatique sont positives ou négatives. Il n'y avait pas de source abordable en japonais (il semble qu'il existe de nombreuses collections de Twitter, mais il est difficile de jouer avec AWS pour cela) Essayez en vous basant sur des données annotées comme négatives ou positives pour les critiques de films en anglais. Ce programme s'appelle [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-gear / dp / 4844380605 / ref = sr_1_cc_2? S = aps & ie = UTF8 & qid = 1487516026 & sr = 1-2-catcorr & keywords = python +% E6% A9% Je me suis référé au chapitre sur le traitement du langage naturel dans le livre 9F% E6% A2% B0% E5% AD% A6% E7% BF% 92).

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_)

Commencez par diviser df en données d'entraînement et données de test. Cela peut être plus facile à comprendre si vous imaginez que df ressemble à une table dans le bloc de données de la bibliothèque pandas.

['Review'] ['sentiment'] dans ceci est le texte de l'avis (c'est x) et le libellé de l'avis (0,1 indique positif ou négatif), et c'est y. (J'omettrai comment df lit réellement les données originales et nettoie les données ...) Après cela, j'utilise GridSearchCV, une classe de sklearn, pour régler les paramètres optimaux pour la rotation logistique. J'ai créé une instance de GridSearchCV appelée gs_lr_tfidf et l'ai formée avec gs_lr_tfidf.fit () en utilisant X_train et y_train.

(Réglage des hyperparamètres avec sklearn)

Cependant, il faut énormément de temps pour appliquer cette méthode ... Par conséquent, lorsque les données sont volumineuses, il semble qu'il soit courant de faire ce que l'on appelle l'apprentissage hors du cœur.