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

Lien Remarques
075.Poids de l'identité.ipynb Lien GitHub du programme de réponse
100 coups de traitement du langage amateur:75 Je vous suis toujours redevable de 100 coups de traitement linguistique
Introduction à Python avec 100 coups de traitement du langage#75 -Apprentissage automatique, scikit-apprendre le coef_Propriété scikit-Résultat Knock en utilisant Learn

environnement

type version Contenu
OS Ubuntu18.04.01 LTS Il fonctionne virtuellement
pyenv 1.2.15 J'utilise pyenv car j'utilise parfois plusieurs environnements Python
Python 3.6.9 python3 sur pyenv.6.J'utilise 9
3.7 ou 3.Il n'y a aucune raison profonde de ne pas utiliser la série 8
Les packages sont gérés à l'aide de venv

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

type version
matplotlib 3.1.1
numpy 1.17.4
pandas 0.25.3
scikit-learn 0.21.3

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"? image.png

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. image.png

Recommended Posts

100 traitement du langage knock-75 (en utilisant scicit-learn): poids de l'identité
100 traitement du langage knock-76 (en utilisant scicit-learn): étiquetage
100 traitement du langage knock-73 (en utilisant scikit-learn): apprentissage
100 traitement du langage knock-74 (en utilisant scicit-learn): prédiction
100 traitements linguistiques knock-77 (en utilisant scicit-learn): mesure du taux de réponse
100 langage de traitement knock-79 (en utilisant scikit-learn): dessin de graphe avec rappel de précision
100 Language Processing Knock-32 (utilisant des pandas): Prototype de verbe
100 traitement du langage knock-36 (en utilisant des pandas): fréquence d'occurrence des mots
100 traitement du langage knock-31 (en utilisant des pandas): verbe
100 traitement du langage knock-38 (en utilisant des pandas): histogramme
100 coups de traitement linguistique (2020): 28
100 traitement de la langue frapper 00 ~ 02
100 Language Processing Knock-33 (en utilisant des pandas): nom sahen
100 traitement du langage knock-91: Préparation des données d'analogie
Traitement du langage 100 knocks-44: Visualisation des arbres dépendants
100 Language Processing Knock-26: suppression du balisage accentué
100 Language Processing Knock-39 (en utilisant des pandas): la loi de Zipf
100 traitement de langage knock-34 (utilisant des pandas): "B of A"
100 traitement de la langue knock-96 (en utilisant Gensim): Extraction du vecteur lié au nom du pays
100 traitements linguistiques Knock 2020 [00 ~ 39 réponse]
100 langues de traitement knock 2020 [00-79 réponse]
100 traitement du langage knock-90 (en utilisant Gensim): apprendre avec word2vec
100 traitements linguistiques Knock 2020 [00 ~ 69 réponse]
100 Language Processing Knock 2020 Chapitre 1
100 coups de traitement du langage amateur: 17
100 traitement du langage knock-93 (en utilisant des pandas): calcul du taux de précision de la tâche d'analogie
100 Traitement du langage Knock-52: Stemming
100 Traitement du langage Knock Chapitre 1
100 coups de langue amateur: 07
100 langage de traitement knock-20 (à l'aide de pandas): lecture de données JSON
Traitement de 100 langues knock-98 (en utilisant des pandas): Clustering par méthode Ward
100 Language Processing Knock 2020 Chapitre 3
100 Language Processing Knock 2020 Chapitre 2
Traitement du langage 100 knocks-45: Extraction de modèles de cas verbaux
Caractéristiques du langage Go
100 coups de traitement du langage amateur: 09
100 traitement du langage knock-99 (à l'aide de pandas): visualisation par t-SNE
100 coups en traitement du langage amateur: 47
Traitement 100 langues knock-53: Tokenisation
100 traitement du langage knock-95 (en utilisant des pandas): Note avec WordSimilarity-353
100 coups de traitement du langage amateur: 97
100 traitements linguistiques Knock 2020 [00 ~ 59 réponse]
100 coups de traitement du langage amateur: 67
100 traitement du langage knock-72 (en utilisant Stanford NLP): Extraction d'identité
100 langage traitement knock-92 (utilisant Gensim): application aux données d'analogie
100 Language Processing Knock: Chapitre 2 Principes de base des commandes UNIX (à l'aide de pandas)
100 Language Processing Knock-83 (en utilisant des pandas): Mesure de la fréquence des mots / contextes
100 Language Processing Knock-30 (en utilisant des pandas): lecture des résultats de l'analyse morphologique
Traitement du langage 100 knocks-49: Extraction de chemins de dépendances entre nomenclature
100 traitement de langage knock-94 (en utilisant Gensim): calcul de similarité avec WordSimilarity-353
Apprenez facilement 100 traitements linguistiques Knock 2020 avec "Google Colaboratory"
100 coups de traitement du langage avec Python 2015
100 traitement du langage Knock-51: découpage de mots
100 Language Processing Knock-57: Analyse des dépendances
100 traitement linguistique knock-50: coupure de phrase
100 Language Processing Knock Chapitre 1 (Python)
100 Language Processing Knock Chapitre 2 (Python)
Traitement parallèle avec Parallel de scikit-learn
python: principes de base de l'utilisation de scikit-learn ①
100 Language Processing Knock-25: Extraction de modèles
Traitement du langage 100 Knock-87: similitude des mots