100 traitement du langage knock-75 (en utilisant scicit-learn): poids de l'identité

Il s'agit du record du 75e "poids de la nature" de Traitement de la langue 100 coups 2015. Il produit quelles qualités sont importantes pour la classification dans le modèle formé (formé). Contrairement à l'apprentissage en profondeur, il doit être descriptif. Jusqu'à présent, je ne l'ai pas posté dans le bloc car c'était fondamentalement le même que "Traitement du langage amateur 100 coups". , "Chapter 8: Machine Learning" a été pris au sérieux et modifié dans une certaine mesure. Je posterai. J'utilise principalement scikit-learn.

Lien de référence

environnement

Dans l'environnement ci-dessus, j'utilise les packages Python supplémentaires suivants. Installez simplement avec pip ordinaire.

Tâche

Chapitre 8: Machine Learning

Dans ce chapitre, [jeu de données de polarité des phrases] de Movie Review Data publié par Bo Pang et Lillian Lee. v1.0](http://www.cs.cornell.edu/people/pabo/movie-review-data/rt-polaritydata.README.1.0.txt) est utilisé pour rendre la phrase positive ou négative. Travailler sur la tâche (analyse de polarité) pour classer comme (négative)

75. Poids de l'identité

Vérifiez les 10 principaux traits de poids élevé et les 10 principaux traits de faible poids dans le modèle de régression logistique appris en> 73.

Répondre

Programme de réponse [075. Weight of identity.ipynb](https://github.com/YoheiFukuhara/nlp100/blob/master/08.%E6%A9%9F%E6%A2%B0%E5%AD%A6%E7 % BF% 92 / 075.% E7% B4% A0% E6% 80% A7% E3% 81% AE% E9% 87% 8D% E3% 81% BF.ipynb)

Fondamentalement [précédent "Programme de réponse (analyse) 074. Forecast.ipynb"](https://github.com/YoheiFukuhara/nlp100/blob/master/08.%E6%A9%9F%E6%A2% B0% E5% AD% A6% E7% BF% 92 / 074.% E4% BA% 88% E6% B8% AC.ipynb) avec la logique d'affichage du poids de l'identité ajoutée.

import csv

import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import GridSearchCV, train_test_split
from sklearn.pipeline import Pipeline
from sklearn.base import BaseEstimator, TransformerMixin

#Classe d'utilisation de la vectorisation de mots dans GridSearchCV
class myVectorizer(BaseEstimator, TransformerMixin):
    def __init__(self, method='tfidf', min_df=0.0005, max_df=0.10):
        self.method = method
        self.min_df = min_df
        self.max_df = max_df

    def fit(self, x, y=None):
        if self.method == 'tfidf':
            self.vectorizer = TfidfVectorizer(min_df=self.min_df, max_df=self.max_df)
        else:
            self.vectorizer = CountVectorizer(min_df=self.min_df, max_df=self.max_df)
        self.vectorizer.fit(x)
        return self

    def transform(self, x, y=None):
        return self.vectorizer.transform(x)
		
#Paramètres de GridSearchCV
PARAMETERS = [
    {
        'vectorizer__method':['tfidf', 'count'], 
        'vectorizer__min_df': [0.0003, 0.0004], 
        'vectorizer__max_df': [0.07, 0.10], 
        'classifier__C': [1, 3],    #J'ai aussi essayé 10 mais le SCORE est faible juste parce qu'il est lent
        'classifier__solver': ['newton-cg', 'liblinear']},
    ]

#Lire le fichier
def read_csv_column(col):
    with open('./sentiment_stem.txt') as file:
        reader = csv.reader(file, delimiter='\t')
        header = next(reader)
        return [row[col] for row in reader]    
		
x_all = read_csv_column(1)
y_all = read_csv_column(0)
x_train, x_test, y_train, y_test = train_test_split(x_all, y_all)

def train(x_train, y_train, file):
    pipline = Pipeline([('vectorizer', myVectorizer()), ('classifier', LogisticRegression())])
    
    #clf signifie classification
    clf = GridSearchCV(
            pipline, # 
            PARAMETERS,           #Jeu de paramètres que vous souhaitez optimiser
            cv = 5)               #Nombre de tests croisés
    
    clf.fit(x_train, y_train)
    pd.DataFrame.from_dict(clf.cv_results_).to_csv(file)

    print('Grid Search Best parameters:', clf.best_params_)
    print('Grid Search Best validation score:', clf.best_score_)
    print('Grid Search Best training score:', clf.best_estimator_.score(x_train, y_train))    
    
    #Sortie de poids d'élément
    output_coef(clf.best_estimator_)
    
    return clf.best_estimator_

#Sortie de poids d'élément
def output_coef(estimator):
    vec = estimator.named_steps['vectorizer']
    clf = estimator.named_steps['classifier']

    coef_df = pd.DataFrame([clf.coef_[0]]).T.rename(columns={0: 'Coefficients'})
    coef_df.index = vec.vectorizer.get_feature_names()
    coef_sort = coef_df.sort_values('Coefficients')
    coef_sort[:10].plot.barh()
    coef_sort.tail(10).plot.barh()

def validate(estimator, x_test, y_test):
    
    for i, (x, y) in enumerate(zip(x_test, y_test)):
        y_pred = estimator.predict_proba([x])
        if y == np.argmax(y_pred).astype( str ):
            if y == '1':
                result = 'TP:La bonne réponse est positive et la prédiction est positive'
            else:
                result = 'TN:La bonne réponse est négative et la prédiction est négative'
        else:
            if y == '1':
                result = 'FN:La bonne réponse est positive et la prédiction est négative'
            else:
                result = 'FP:La bonne réponse est négative et la prédiction est positive'
        print(result, y_pred, x)
        if i == 29:
            break

estimator = train(x_train, y_train, 'gs_result.csv')
validate(estimator, x_test, y_test)

Répondre au commentaire

J'essaie de recevoir les meilleurs paramètres élevés en entraînement avec la fonction ʻoutput_coef`.

#Sortie de poids d'élément
output_coef(clf.best_estimator_)

Puisqu'il s'agit d'un pipeline, il est divisé en étapes. Récupérez chaque étape de l'attribut named_steps.

vec = estimator.named_steps['vectorizer']
clf = estimator.named_steps['classifier']

Stockez le poids dans le DataFrame de pandas et transposez-le. À ce moment-là, modifiez le nom de la colonne.

coef_df = pd.DataFrame([clf.coef_[0]]).T.rename(columns={0: 'Coefficients'})

Trier par valeur de poids, avec l'index comme fonction.

coef_df.index = vec.vectorizer.get_feature_names()
coef_sort = coef_df.sort_values('Coefficients')

Enfin, il est affiché sous forme de graphique à barres.

coef_sort[:10].plot.barh()
coef_sort.tail(10).plot.barh()

Résultat de sortie du poids d'élément

Top 10 des qualités légères

Les mots négatifs tels que mauvais et terne sont alignés. La télévision est-elle une phrase critique comme "La télévision est intéressante"?

Top 10 des poids les plus élevés

Des mots positifs tels que bearuti (beau) et rejoindre sont alignés. Est-ce qu'exécuter un mot comme «coût performance»? Je ne pense pas que le mot «défaut» soit un très bon mot, mais cette fois, je n'entrerai pas dans les détails.