[PYTHON] [Traitement du langage 100 coups 2020] Chapitre 6: Machine learning
introduction
Version 2020 de 100 coups de traitement du langage, qui est célèbre comme une collection de problèmes de traitement du langage naturel, a été publié. Cet article résume les résultats de la résolution Chapitre 6: Apprentissage automatique des chapitres 1 à 10 suivants. ..
- Chapitre 1: Mouvement préparatoire
- Chapitre 2: Commandes UNIX
- Chapitre 3: Expressions régulières
- Chapitre 4: Analyse morphologique
- Chapitre 5: Analyse des dépendances --Chapitre 6: Apprentissage automatique
- Chapitre 7: Vecteur de mot --Chapitre 8: Réseau neuronal
- Chapitre 9: RNN, CNN --Chapitre 10: Traduction automatique
Préparation préalable
Nous utilisons Google Colaboratory pour obtenir des réponses. Pour plus d'informations sur la configuration et l'utilisation de Google Colaboratory, consultez cet article. Le cahier contenant les résultats d'exécution des réponses suivantes est disponible sur github.
Chapitre 6: Apprentissage automatique
Dans ce chapitre, nous utiliserons le jeu de données News Aggregator publié par Fabio Gasparetti pour travailler sur la tâche (classification par catégorie) de classer les titres des articles de presse dans les catégories «business», «science et technologie», «divertissement» et «santé».
50. Obtention et mise en forme des données
Téléchargez l'ensemble de données News Aggregator et créez les données d'entraînement (train.txt), les données de vérification (valid.txt) et les données d'évaluation (test.txt) comme suit.
- Décompressez le fichier zip téléchargé et lisez l'explication de readme.txt.
- N'extrayez que les cas (articles) dont les sources d'information (éditeurs) sont «Reuters», «Huffington Post», «Businessweek», «Contactmusic.com» et «Daily Mail».
- Triez au hasard les cas extraits.
- Divisez 80% des observations extraites en données d'entraînement et les 10% restants en données de vérification et en données d'évaluation, et enregistrez-les sous les noms de fichier train.txt, valid.txt et test.txt, respectivement. Écrivez un cas par ligne dans le fichier et utilisez le format délimité par des tabulations du nom de la catégorie et de l'en-tête de l'article (ce fichier sera réutilisé plus tard dans le problème 70).
Après avoir créé les données d'entraînement et les données d'évaluation, vérifiez le nombre de cas dans chaque catégorie.
Tout d'abord, téléchargez les données spécifiées.
!wget https://archive.ics.uci.edu/ml/machine-learning-databases/00359/NewsAggregatorDataset.zip
!unzip NewsAggregatorDataset.zip
#Vérifiez le nombre de lignes
!wc -l ./newsCorpora.csv
production
422937 ./newsCorpora.csv
#Vérifiez les 10 premières lignes
!head -10 ./newsCorpora.csv
production
1 Fed official says weak data caused by weather, should not slow taper http://www.latimes.com/business/money/la-fi-mo-federal-reserve-plosser-stimulus-economy-20140310,0,1312750.story\?track=rss Los Angeles Times b ddUyU0VZz0BRneMioxUPQVP6sIxvM www.latimes.com 1394470370698
2 Fed's Charles Plosser sees high bar for change in pace of tapering http://www.livemint.com/Politics/H2EvwJSK2VE6OF7iK1g3PP/Feds-Charles-Plosser-sees-high-bar-for-change-in-pace-of-ta.html Livemint b ddUyU0VZz0BRneMioxUPQVP6sIxvM www.livemint.com 1394470371207
3 US open: Stocks fall after Fed official hints at accelerated tapering http://www.ifamagazine.com/news/us-open-stocks-fall-after-fed-official-hints-at-accelerated-tapering-294436 IFA Magazine b ddUyU0VZz0BRneMioxUPQVP6sIxvM www.ifamagazine.com 1394470371550
4 Fed risks falling 'behind the curve', Charles Plosser says http://www.ifamagazine.com/news/fed-risks-falling-behind-the-curve-charles-plosser-says-294430 IFA Magazine b ddUyU0VZz0BRneMioxUPQVP6sIxvM www.ifamagazine.com 1394470371793
5 Fed's Plosser: Nasty Weather Has Curbed Job Growth http://www.moneynews.com/Economy/federal-reserve-charles-plosser-weather-job-growth/2014/03/10/id/557011 Moneynews b ddUyU0VZz0BRneMioxUPQVP6sIxvM www.moneynews.com 1394470372027
6 Plosser: Fed May Have to Accelerate Tapering Pace http://www.nasdaq.com/article/plosser-fed-may-have-to-accelerate-tapering-pace-20140310-00371 NASDAQ b ddUyU0VZz0BRneMioxUPQVP6sIxvM www.nasdaq.com 1394470372212
7 Fed's Plosser: Taper pace may be too slow http://www.marketwatch.com/story/feds-plosser-taper-pace-may-be-too-slow-2014-03-10\?reflink=MW_news_stmp MarketWatch b ddUyU0VZz0BRneMioxUPQVP6sIxvM www.marketwatch.com 1394470372405
8 Fed's Plosser expects US unemployment to fall to 6.2% by the end of 2014 http://www.fxstreet.com/news/forex-news/article.aspx\?storyid=23285020-b1b5-47ed-a8c4-96124bb91a39 FXstreet.com b ddUyU0VZz0BRneMioxUPQVP6sIxvM www.fxstreet.com 1394470372615
9 US jobs growth last month hit by weather:Fed President Charles Plosser http://economictimes.indiatimes.com/news/international/business/us-jobs-growth-last-month-hit-by-weatherfed-president-charles-plosser/articleshow/31788000.cms Economic Times b ddUyU0VZz0BRneMioxUPQVP6sIxvM economictimes.indiatimes.com 1394470372792
10 ECB unlikely to end sterilisation of SMP purchases - traders http://www.iii.co.uk/news-opinion/reuters/news/152615 Interactive Investor b dPhGU51DcrolUIMxbRm0InaHGA2XM www.iii.co.uk 1394470501265
#Remplacement des guillemets doubles par des guillemets simples pour éviter les erreurs lors de la lecture
!sed -e 's/"/'\''/g' ./newsCorpora.csv > ./newsCorpora_re.csv
Ensuite, lisez le cadre de données pandas et créez les données selon les instructions de l'énoncé du problème.
Le train_test_split '' de Scikit-learn est utilisé pour diviser les données. À ce moment-là, si vous utilisez l'option stratifier '', le rapport de composition de la colonne spécifiée sera divisé afin qu'il soit le même pour chaque donnée après la division. Ici, la variable objective de classification, `` CATÉGORIE '', est spécifiée afin qu'il n'y ait pas de biais pour chaque donnée.
import pandas as pd
from sklearn.model_selection import train_test_split
#Lire les données
df = pd.read_csv('./newsCorpora_re.csv', header=None, sep='\t', names=['ID', 'TITLE', 'URL', 'PUBLISHER', 'CATEGORY', 'STORY', 'HOSTNAME', 'TIMESTAMP'])
#Extraction de données
df = df.loc[df['PUBLISHER'].isin(['Reuters', 'Huffington Post', 'Businessweek', 'Contactmusic.com', 'Daily Mail']), ['TITLE', 'CATEGORY']]
#Répartition des données
train, valid_test = train_test_split(df, test_size=0.2, shuffle=True, random_state=123, stratify=df['CATEGORY'])
valid, test = train_test_split(valid_test, test_size=0.5, shuffle=True, random_state=123, stratify=valid_test['CATEGORY'])
#Stockage de données
train.to_csv('./train.txt', sep='\t', index=False)
valid.to_csv('./valid.txt', sep='\t', index=False)
test.to_csv('./test.txt', sep='\t', index=False)
#Confirmation du nombre de cas
print('[Données d'apprentissage]')
print(train['CATEGORY'].value_counts())
print('[Données de vérification]')
print(valid['CATEGORY'].value_counts())
print('[Données d'évaluation]')
print(test['CATEGORY'].value_counts())
production
[Données d'apprentissage]
b 4501
e 4235
t 1220
m 728
Name: CATEGORY, dtype: int64
[Données de vérification]
b 563
e 529
t 153
m 91
Name: CATEGORY, dtype: int64
[Données d'évaluation]
b 563
e 530
t 152
m 91
Name: CATEGORY, dtype: int64
51. Extraction d'entités
Extrayez les fonctionnalités des données d'entraînement, des données de vérification et des données d'évaluation, et enregistrez-les respectivement sous les noms de fichier train.feature.txt, valid.feature.txt et test.feature.txt. N'hésitez pas à concevoir les fonctionnalités susceptibles d'être utiles pour la catégorisation. La ligne de base minimale serait un titre d'article converti en une chaîne de mots.
Cette fois, nous allons calculer TF-IDF pour un groupe de mots dans lequel l'en-tête d'un article est divisé par des espaces, et utiliser cette valeur comme quantité de caractéristiques. Il calcule également TF-IDF non seulement pour un mot (uni-gramme) mais aussi pour deux mots consécutifs (bi-gramme). Lors du calcul de ce qui précède, trois traitements sont effectués comme prétraitement de texte: (1) remplacer le symbole par un espace, (2) abaisser l'alphabet et (3) remplacer la chaîne numérique par 0.
import string
import re
def preprocessing(text):
table = str.maketrans(string.punctuation, ' '*len(string.punctuation))
text = text.translate(table) #Remplacer le symbole par un espace
text = text.lower() #Abaissement
text = re.sub('[0-9]+', '0', text) #Remplacez la chaîne numérique par 0
return text
#Recombinaison de données
df = pd.concat([train, valid, test], axis=0)
df.reset_index(drop=True, inplace=True) #Réaffecter l'index
#Mise en place du prétraitement
df['TITLE'] = df['TITLE'].map(lambda x: preprocessing(x))
print(df.head())
production
TITLE CATEGORY
0 refile update 0 european car sales up for sixt... b
1 amazon plans to fight ftc over mobile app purc... t
2 kids still get codeine in emergency rooms desp... m
3 what on earth happened between solange and jay... e
4 nato missile defense is flight tested over hawaii b
from sklearn.feature_extraction.text import TfidfVectorizer
#Répartition des données
train_valid = df[:len(train) + len(valid)]
test = df[len(train) + len(valid):]
# TfidfVectorizer
vec_tfidf = TfidfVectorizer(min_df=10, ngram_range=(1, 2)) # ngram_TF à portée-Spécifiez la longueur du mot pour lequel IDF est calculé
#Vectorisation
X_train_valid = vec_tfidf.fit_transform(train_valid['TITLE']) #N'utilisez pas les informations de test
X_test = vec_tfidf.transform(test['TITLE'])
#Convertir le vecteur en bloc de données
X_train_valid = pd.DataFrame(X_train_valid.toarray(), columns=vec_tfidf.get_feature_names())
X_test = pd.DataFrame(X_test.toarray(), columns=vec_tfidf.get_feature_names())
#Répartition des données
X_train = X_train_valid[:len(train)]
X_valid = X_train_valid[len(train):]
#Stockage de données
X_train.to_csv('./X_train.txt', sep='\t', index=False)
X_valid.to_csv('./X_valid.txt', sep='\t', index=False)
X_test.to_csv('./X_test.txt', sep='\t', index=False)
print(X_train.head())
production
0m 0million 0nd 0s 0st ... yuan zac zac efron zendaya zone
0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0
1 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0
2 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0
3 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0
4 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0
[5 rows x 2815 columns]
52. Apprentissage
Apprenez le modèle de régression logistique à l'aide des données d'entraînement construites en> 51.
Nous continuerons d'utiliser scikit-learn pour apprendre le modèle de régression logistique.
from sklearn.linear_model import LogisticRegression
#Apprentissage de modèle
lg = LogisticRegression(random_state=123, max_iter=10000)
lg.fit(X_train, train['CATEGORY'])
production
LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,
intercept_scaling=1, l1_ratio=None, max_iter=10000,
multi_class='auto', n_jobs=None, penalty='l2',
random_state=123, solver='lbfgs', tol=0.0001, verbose=0,
warm_start=False)
53. Prévisions
Implémentez un programme qui calcule la catégorie et sa probabilité de prédiction à partir de l'en-tête d'article donné en utilisant le modèle de régression logistique appris en> 52.
Définit une fonction qui prend un ensemble de données ayant subi un prétraitement de texte 51 pour la vectorisation par TF-IDF.
import numpy as np
def score_lg(lg, X):
return [np.max(lg.predict_proba(X), axis=1), lg.predict(X)]
train_pred = score_lg(lg, X_train)
test_pred = score_lg(lg, X_test)
print(train_pred)
production
[array([0.8402725 , 0.67906432, 0.55642575, ..., 0.86051523, 0.61362406,
0.90827641]), array(['b', 't', 'm', ..., 'b', 'm', 'e'], dtype=object)]
54. Mesure du taux de réponse correcte
Mesurer le taux de réponse correct du modèle de régression logistique appris en> 52 sur les données d'entraînement et les données d'évaluation.
Utilisez accuracy_score de scicit-learn pour calculer le taux de précision.
from sklearn.metrics import accuracy_score
train_accuracy = accuracy_score(train['CATEGORY'], train_pred[1])
test_accuracy = accuracy_score(test['CATEGORY'], test_pred[1])
print(f'Taux de réponse correct (données d'apprentissage):{train_accuracy:.3f}')
print(f'Taux de réponse correct (données d'évaluation):{test_accuracy:.3f}')
production
Taux de réponse correct (données d'apprentissage): 0.927
Taux de réponse correct (données d'évaluation): 0.885
55. Création d'une matrice de confusion
Créer une matrice de confusion du modèle de régression logistique appris en> 52 sur les données de formation et les données d'évaluation.
La matrice de confusion est également calculée à l'aide de scicit-learn. De plus, la matrice de confusion calculée est visualisée à l'aide de seaborn.
from sklearn.metrics import confusion_matrix
import seaborn as sns
import matplotlib.pyplot as plt
#Données d'entraînement
train_cm = confusion_matrix(train['CATEGORY'], train_pred[1])
print(train_cm)
sns.heatmap(train_cm, annot=True, cmap='Blues')
plt.show()
production
[[4344 93 8 56]
[ 52 4173 2 8]
[ 96 125 494 13]
[ 192 133 7 888]]
#Données d'évaluation
test_cm = confusion_matrix(test['CATEGORY'], test_pred[1])
print(test_cm)
sns.heatmap(test_cm, annot=True, cmap='Blues')
plt.show()
production
[[528 20 2 13]
[ 12 516 1 1]
[ 11 26 52 2]
[ 38 26 1 87]]
56. Mesure de la précision, du rappel et du score F1
Mesurer la précision, le rappel et le score F1 du modèle de régression logistique appris en> 52 sur les données d'évaluation. Obtenez le taux de précision, le taux de rappel et le score F1 pour chaque catégorie, et intégrez les performances de chaque catégorie avec une micro-moyenne et une macro-moyenne.
from sklearn.metrics import precision_score, recall_score, f1_score
def calculate_scores(y_true, y_pred):
#Taux de conformité
precision = precision_score(test['CATEGORY'], test_pred[1], average=None, labels=['b', 'e', 't', 'm']) #Si None est spécifié, la précision de chaque classe est renvoyée dans ndarray.
precision = np.append(precision, precision_score(y_true, y_pred, average='micro')) #Ajouter une micro moyenne à la fin
precision = np.append(precision, precision_score(y_true, y_pred, average='macro')) #Ajouter une moyenne macro à la fin
#Rappel
recall = recall_score(test['CATEGORY'], test_pred[1], average=None, labels=['b', 'e', 't', 'm'])
recall = np.append(recall, recall_score(y_true, y_pred, average='micro'))
recall = np.append(recall, recall_score(y_true, y_pred, average='macro'))
#Score F1
f1 = f1_score(test['CATEGORY'], test_pred[1], average=None, labels=['b', 'e', 't', 'm'])
f1 = np.append(f1, f1_score(y_true, y_pred, average='micro'))
f1 = np.append(f1, f1_score(y_true, y_pred, average='macro'))
#Combinez les résultats dans un dataframe
scores = pd.DataFrame({'Taux de conformité': precision, 'Rappel': recall, 'Score F1': f1},
index=['b', 'e', 't', 'm', 'Micro moyenne', 'Moyenne macro'])
return scores
print(calculate_scores(test['CATEGORY'], test_pred[1]))
production
Taux de rappel du taux de correspondance Score F1
b 0.896 0.938 0.917
e 0.878 0.974 0.923
t 0.845 0.572 0.682
m 0.929 0.571 0.707
Micro moyenne 0.885 0.885 0.885
Moyenne macro 0.887 0.764 0.807
57. Confirmation du poids caractéristique
Vérifiez les 10 principales fonctionnalités avec des poids élevés et les 10 principales caractéristiques avec des poids faibles dans le modèle de régression logistique appris en> 52.
Le poids de chaque fonction apprise est stocké dans `` coef_``` pour chaque classe.
features = X_train.columns.values
index = [i for i in range(1, 11)]
for c, coef in zip(lg.classes_, lg.coef_):
print(f'【Catégorie】{c}')
best10 = pd.DataFrame(features[np.argsort(coef)[::-1][:10]], columns=['Importance plus élevée'], index=index).T
worst10 = pd.DataFrame(features[np.argsort(coef)[:10]], columns=['Importance moindre'], index=index).T
display(pd.concat([best10, worst10], axis=0))
print('\n')
production
[Catégorie] b
1 2 3 4 5 6 7 8 9 \
Importance plus élevée de la banque nourrie en Chine et de la BCE Actions Euro Obamacare Oil Yellen
Vidéo de moindre importance Ebola The Her and She Apple Google Star
10
Dollar d'importance plus élevée
Moins d'importance Microsoft
[Catégorie] e
1 2 3 4 5 6 7 8 \
Top importance kardashian chris son film star de cinéma paul he
Importance moindre mise à jour des États-Unis Google Study China GM CEO Facebook
9 10
Mariage de la plus haute importance, elle
Pomme de moindre importance dit
[Catégorie] m
1 2 3 4 5 6 7 8 9 \
Étude de première importance sur l'Ebola, un médicament contre le cancer, des cas de FDA
Moins d'importance Facebook GM PDG Accord Apple Bank Climat de vente Google
10
Cigarettes de première importance
Twitter d'importance moindre
[Catégorie] t
1 2 3 4 5 6 7 8 \
Top importance google facebook apple Microsoft climat gm nasa tesla
Des actions de moindre importance ont nourri son pourcentage de drogue American Cancer Ukraine
9 10
Comcast Heartbleed de première importance
Une moindre importance est toujours partagée
58. Modifier les paramètres de régularisation
Lors de l'entraînement d'un modèle de régression logistique, le degré de surajustement pendant l'entraînement peut être contrôlé en ajustant les paramètres de régularisation. Apprenez le modèle de régression logistique avec différents paramètres de régularisation et trouvez le taux de réponse correct sur les données d'entraînement, les données de validation et les données d'évaluation. Résumez les résultats de l'expérience dans un graphique avec les paramètres de régularisation sur l'axe horizontal et le taux de précision sur l'axe vertical.
Si la régularisation est trop forte (C est petit), l'apprentissage ne se poursuivra pas et la précision sera faible, et si la régularisation est trop faible (C est grand), un surapprentissage se produira et la différence de précision entre l'apprentissage et l'évaluation sera élargie. À partir de ce résultat, nous pouvons confirmer qu'il est important de choisir le C.
from tqdm import tqdm
result = []
for C in tqdm(np.logspace(-5, 4, 10, base=10)):
#Apprentissage de modèle
lg = LogisticRegression(random_state=123, max_iter=10000, C=C)
lg.fit(X_train, train['CATEGORY'])
#Obtenez la valeur prévue
train_pred = score_lg(lg, X_train)
valid_pred = score_lg(lg, X_valid)
test_pred = score_lg(lg, X_test)
#Calcul du taux de réponse correcte
train_accuracy = accuracy_score(train['CATEGORY'], train_pred[1])
valid_accuracy = accuracy_score(valid['CATEGORY'], valid_pred[1])
test_accuracy = accuracy_score(test['CATEGORY'], test_pred[1])
#Stockage des résultats
result.append([C, train_accuracy, valid_accuracy, test_accuracy])
production
100%|██████████| 10/10 [07:26<00:00, 44.69s/it] #Afficher la progression à l'aide de tqdm
#Visualisation
result = np.array(result).T
plt.plot(result[0], result[1], label='train')
plt.plot(result[0], result[2], label='valid')
plt.plot(result[0], result[3], label='test')
plt.ylim(0, 1.1)
plt.ylabel('Accuracy')
plt.xscale ('log')
plt.xlabel('C')
plt.legend()
plt.show()
59. Recherche d'hyper paramètres
Apprenez le modèle de catégorisation tout en modifiant l'algorithme d'apprentissage et les paramètres d'apprentissage. Trouvez le paramètre d'algorithme d'apprentissage qui donne le taux de précision le plus élevé sur les données de vérification. Trouvez également le taux de réponse correct sur les données d'évaluation lorsque l'algorithme d'apprentissage et les paramètres sont utilisés.
Ici, la recherche de paramètres est effectuée pour C '' qui spécifie la force de la régularisation et l1_ratio '' qui spécifie l'équilibre entre la régularisation L1 et la régularisation L2.
De plus, optuna est utilisé pour l'optimisation.
!pip install optuna
import optuna
#Spécifiez la cible d'optimisation avec une fonction
def objective_lg(trial):
#Ensemble de paramètres à régler
l1_ratio = trial.suggest_uniform('l1_ratio', 0, 1)
C = trial.suggest_loguniform('C', 1e-4, 1e4)
#Apprentissage de modèle
lg = LogisticRegression(random_state=123,
max_iter=10000,
penalty='elasticnet',
solver='saga',
l1_ratio=l1_ratio,
C=C)
lg.fit(X_train, train['CATEGORY'])
#Obtenez la valeur prévue
valid_pred = score_lg(lg, X_valid)
#Calcul du taux de réponse correcte
valid_accuracy = accuracy_score(valid['CATEGORY'], valid_pred[1])
return valid_accuracy
#optimisation
study = optuna.create_study(direction='maximize')
study.optimize(objective_lg, timeout=3600)
#Voir les résultats
print('Best trial:')
trial = study.best_trial
print(' Value: {:.3f}'.format(trial.value))
print(' Params: ')
for key, value in trial.params.items():
print(' {}: {}'.format(key, value))
production
Best trial:
Value: 0.892
Params:
l1_ratio: 0.23568685768996045
C: 4.92280374981671
Réglage automatique des hyper paramètres avec Optuna -Pytorch Lightning edition-
Entraînez à nouveau le modèle avec les paramètres recherchés et vérifiez le taux de précision.
#Paramétrage
l1_ratio = trial.params['l1_ratio']
C = trial.params['C']
#Apprentissage de modèle
lg = LogisticRegression(random_state=123,
max_iter=10000,
penalty='elasticnet',
solver='saga',
l1_ratio=l1_ratio,
C=C)
lg.fit(X_train, train['CATEGORY'])
#Obtenez la valeur prévue
train_pred = score_lg(lg, X_train)
valid_pred = score_lg(lg, X_valid)
test_pred = score_lg(lg, X_test)
#Calcul du taux de réponse correcte
train_accuracy = accuracy_score(train['CATEGORY'], train_pred[1])
valid_accuracy = accuracy_score(valid['CATEGORY'], valid_pred[1])
test_accuracy = accuracy_score(test['CATEGORY'], test_pred[1])
print(f'Taux de réponse correct (données d'apprentissage):{train_accuracy:.3f}')
print(f'Taux de réponse correct (données de vérification):{valid_accuracy:.3f}')
print(f'Taux de réponse correct (données d'évaluation):{test_accuracy:.3f}')
production
Taux de réponse correct (données d'apprentissage): 0.966
Taux de réponse correct (données de vérification): 0.892
Taux de réponse correct (données d'évaluation): 0.895
Étant donné que le taux de réponse correcte des données d'évaluation lors de l'entraînement avec les paramètres par défaut était de 0,885, on peut voir que la précision a été améliorée en adoptant les paramètres appropriés.
Cette fois, je vais également essayer XGBoost. De plus, cela n'effectue pas de recherche de paramètres, mais entraîne le modèle avec des paramètres fixes.
!pip install xgboost
import xgboost as xgb
params={'objective': 'multi:softmax',
'num_class': 4,
'eval_metric': 'mlogloss',
'colsample_bytree': 1.0,
'colsample_bylevel': 0.5,
'min_child_weight': 1,
'subsample': 0.9,
'eta': 0.1,
'max_depth': 5,
'gamma': 0.0,
'alpha': 0.0,
'lambda': 1.0,
'num_round': 1000,
'early_stopping_rounds': 50,
'verbosity': 0
}
#Conversion de format pour XGBoost
category_dict = {'b': 0, 'e': 1, 't':2, 'm':3}
y_train = train['CATEGORY'].map(lambda x: category_dict[x])
y_valid = valid['CATEGORY'].map(lambda x: category_dict[x])
y_test = test['CATEGORY'].map(lambda x: category_dict[x])
dtrain = xgb.DMatrix(X_train, label=y_train)
dvalid = xgb.DMatrix(X_valid, label=y_valid)
dtest = xgb.DMatrix(X_test, label=y_test)
#Apprentissage de modèle
num_round = params.pop('num_round')
early_stopping_rounds = params.pop('early_stopping_rounds')
watchlist = [(dtrain, 'train'), (dvalid, 'eval')]
model = xgb.train(params, dtrain, num_round, evals=watchlist, early_stopping_rounds=early_stopping_rounds)
#Obtenez la valeur prévue
train_pred = model.predict(dtrain, ntree_limit=model.best_ntree_limit)
valid_pred = model.predict(dvalid, ntree_limit=model.best_ntree_limit)
test_pred = model.predict(dtest, ntree_limit=model.best_ntree_limit)
#Calcul du taux de réponse correcte
train_accuracy = accuracy_score(y_train, train_pred)
valid_accuracy = accuracy_score(y_valid, valid_pred)
test_accuracy = accuracy_score(y_test, test_pred)
print(f'Taux de réponse correct (données d'apprentissage):{train_accuracy:.3f}')
print(f'Taux de réponse correct (données de vérification):{valid_accuracy:.3f}')
print(f'Taux de réponse correct (données d'évaluation):{test_accuracy:.3f}')
production
Taux de réponse correct (données d'apprentissage): 0.963
Taux de réponse correct (données de vérification): 0.873
Taux de réponse correct (données d'évaluation): 0.873
en conclusion
Traitement du langage 100 coups sont conçus pour que vous puissiez apprendre non seulement le traitement du langage naturel lui-même, mais également le traitement des données de base et l'apprentissage automatique général. Même ceux qui étudient l'apprentissage automatique dans des cours en ligne pourront pratiquer de très bons résultats, alors essayez-le.
Recommended Posts