[PYTHON] [Sprachverarbeitung 100 Schläge 2020] Kapitel 6: Maschinelles Lernen
Einführung
Die Version 2020 von 100 Klopfen der Sprachverarbeitung, die als Sammlung von Problemen der Verarbeitung natürlicher Sprache bekannt ist, wurde veröffentlicht. Dieser Artikel fasst die Ergebnisse der Lösung von Kapitel 6: Maschinelles Lernen aus den folgenden Kapiteln 1 bis 10 zusammen. ..
- Kapitel 1: Vorbereitungsbewegung
- Kapitel 2: UNIX-Befehle
- Kapitel 3: Reguläre Ausdrücke
- Kapitel 4: Morphologische Analyse
- Kapitel 5: Abhängigkeitsanalyse --Kapitel 6: Maschinelles Lernen --Kapitel 7: Word-Vektor
- Kapitel 8: Neuronales Netz
- Kapitel 9: RNN, CNN --Kapitel 10: Maschinelle Übersetzung
Vorbereitungen
Wir verwenden Google Colaboratory für Antworten. Ausführliche Informationen zum Einrichten und Verwenden von Google Colaboratory finden Sie in diesem Artikel. Das Notizbuch mit den Ausführungsergebnissen der folgenden Antworten ist unter [github] verfügbar (https://github.com/hana-mame/nlp100/blob/master/chapter06.ipynb).
Kapitel 6: Maschinelles Lernen
In diesem Kapitel verwenden wir den von Fabio Gasparetti veröffentlichten News Aggregator-Datensatz, um die Aufgabe (Kategorieklassifizierung) der Klassifizierung von Nachrichtenartikelüberschriften in die Kategorien "Business", "Wissenschaft und Technologie", "Unterhaltung" und "Gesundheit" zu bearbeiten.
50. Daten erhalten und gestalten
Laden Sie den News Aggregator-Datensatz herunter und erstellen Sie die folgenden Trainingsdaten (train.txt), Verifizierungsdaten (valid.txt) und Bewertungsdaten (test.txt).
- Entpacken Sie die heruntergeladene Zip-Datei und lesen Sie die Erklärung zu readme.txt.
- Extrahieren Sie nur Fälle (Artikel), deren Informationsquellen (Herausgeber) "Reuters", "Huffington Post", "Businessweek", "Contactmusic.com" und "Daily Mail" sind.
- Sortieren Sie die extrahierten Fälle nach dem Zufallsprinzip.
- Teilen Sie 80% der extrahierten Fälle in Trainingsdaten und die restlichen 10% in Verifizierungsdaten und Bewertungsdaten auf und speichern Sie sie unter den Dateinamen train.txt, valid.txt bzw. test.txt. Schreiben Sie einen Fall pro Zeile in die Datei und verwenden Sie das durch Tabulatoren getrennte Format des Kategorienamens und der Artikelüberschrift (diese Datei wird später in Problem 70 wiederverwendet).
Überprüfen Sie nach dem Erstellen der Trainingsdaten und Bewertungsdaten die Anzahl der Fälle in jeder Kategorie.
Laden Sie zunächst die angegebenen Daten herunter.
!wget https://archive.ics.uci.edu/ml/machine-learning-databases/00359/NewsAggregatorDataset.zip
!unzip NewsAggregatorDataset.zip
#Überprüfen Sie die Anzahl der Zeilen
!wc -l ./newsCorpora.csv
Ausgabe
422937 ./newsCorpora.csv
#Überprüfen Sie die ersten 10 Zeilen
!head -10 ./newsCorpora.csv
Ausgabe
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
#Doppelte Anführungszeichen durch einfache Anführungszeichen ersetzt, um Fehler beim Lesen zu vermeiden
!sed -e 's/"/'\''/g' ./newsCorpora.csv > ./newsCorpora_re.csv
Lesen Sie als Nächstes den Pandas-Datenrahmen ein und erstellen Sie die Daten gemäß den Anweisungen in der Problembeschreibung.
Scikit-learns `train_test_split``` wird verwendet, um die Daten zu teilen. Wenn Sie zu diesem Zeitpunkt die Option `stratify``` verwenden, wird das Zusammensetzungsverhältnis der angegebenen Spalte so aufgeteilt, dass es für alle Daten nach der Teilung gleich ist. Hier wird die objektive Klassifizierungsvariable "KATEGORIE" angegeben, so dass für jede Daten keine Verzerrung vorliegt.
import pandas as pd
from sklearn.model_selection import train_test_split
#Daten lesen
df = pd.read_csv('./newsCorpora_re.csv', header=None, sep='\t', names=['ID', 'TITLE', 'URL', 'PUBLISHER', 'CATEGORY', 'STORY', 'HOSTNAME', 'TIMESTAMP'])
#Datenextraktion
df = df.loc[df['PUBLISHER'].isin(['Reuters', 'Huffington Post', 'Businessweek', 'Contactmusic.com', 'Daily Mail']), ['TITLE', 'CATEGORY']]
#Datenaufteilung
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'])
#Datenspeicher
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)
#Bestätigung der Anzahl der Fälle
print('[Lerndaten]')
print(train['CATEGORY'].value_counts())
print('[Verifizierungsdaten]')
print(valid['CATEGORY'].value_counts())
print('[Bewertungsdaten]')
print(test['CATEGORY'].value_counts())
Ausgabe
[Lerndaten]
b 4501
e 4235
t 1220
m 728
Name: CATEGORY, dtype: int64
[Verifizierungsdaten]
b 563
e 529
t 153
m 91
Name: CATEGORY, dtype: int64
[Bewertungsdaten]
b 563
e 530
t 152
m 91
Name: CATEGORY, dtype: int64
51. Merkmalsextraktion
Extrahieren Sie die Funktionen aus den Trainingsdaten, Verifizierungsdaten und Bewertungsdaten und speichern Sie sie unter den Dateinamen train.feature.txt, valid.feature.txt bzw. test.feature.txt. Entwerfen Sie die Funktionen, die für die Kategorisierung wahrscheinlich nützlich sind. Die minimale Grundlinie wäre eine Artikelüberschrift, die in eine Wortfolge konvertiert wird.
Dieses Mal berechnen wir TF-IDF für eine Gruppe von Wörtern, in denen die Überschrift eines Artikels durch Leerzeichen geteilt ist, und verwenden diesen Wert als Merkmalsmenge. Es berechnet auch TF-IDF nicht nur für ein Wort (Unigramm), sondern auch für zwei aufeinanderfolgende Wörter (Bi-Gramm). Bei der Berechnung des Obigen werden drei Verarbeitungen als Textvorverarbeitung ausgeführt: (1) Ersetzen des Symbols durch ein Leerzeichen, (2) Verringern des Alphabets und (3) Ersetzen der Zahlenfolge durch 0.
import string
import re
def preprocessing(text):
table = str.maketrans(string.punctuation, ' '*len(string.punctuation))
text = text.translate(table) #Ersetzen Sie das Symbol durch ein Leerzeichen
text = text.lower() #Senkung
text = re.sub('[0-9]+', '0', text) #Ersetzen Sie die Zahlenfolge durch 0
return text
#Datenrekombination
df = pd.concat([train, valid, test], axis=0)
df.reset_index(drop=True, inplace=True) #Ordnen Sie den Index neu zu
#Durchführung der Vorbehandlung
df['TITLE'] = df['TITLE'].map(lambda x: preprocessing(x))
print(df.head())
Ausgabe
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
#Datenaufteilung
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 in Reichweite-Geben Sie die Länge des Wortes an, für das IDF berechnet wird
#Vektorisierung
X_train_valid = vec_tfidf.fit_transform(train_valid['TITLE']) #Verwenden Sie keine Testinformationen
X_test = vec_tfidf.transform(test['TITLE'])
#Vektor in Datenrahmen konvertieren
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())
#Datenaufteilung
X_train = X_train_valid[:len(train)]
X_valid = X_train_valid[len(train):]
#Datenspeicher
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())
Ausgabe
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. Lernen
Lernen Sie das logistische Regressionsmodell anhand der in> 51 erstellten Trainingsdaten.
from sklearn.linear_model import LogisticRegression
#
lg = LogisticRegression(random_state=123, max_iter=10000)
lg.fit(X_train, train['CATEGORY'])
``
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)
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)
Modelltrainingsausgabe 53. Implementieren Sie unter Verwendung des in Vorhersage> 52 erlernten logistischen Regressionsmodells ein Programm, das die Kategorie und ihre Vorhersagewahrscheinlichkeit aus der angegebenen Artikelüberschrift berechnet. Definiert eine Funktion, die einen Datensatz, der 51 Textvorverarbeitungen unterzogen hat, zur Vektorisierung durch TF-IDF verwendet. Ausgabe
[array([0.8402725 , 0.67906432, 0.55642575, ..., 0.86051523, 0.61362406,
0.90827641]), array(['b', 't', 'm', ..., 'b', 'm', 'e'], dtype=object)]
54. Messung der richtigen Antwortrate
Messen Sie die korrekte Antwortrate des in> 52 erlernten logistischen Regressionsmodells anhand der Trainingsdaten und Bewertungsdaten.
Verwenden Sie `` `Genauigkeit_Wert``` von scicit-learn, um die Genauigkeitsrate zu berechnen.
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'Richtige Antwortrate (Lerndaten):{train_accuracy:.3f}')
print(f'Richtige Antwortrate (Bewertungsdaten):{test_accuracy:.3f}')
Ausgabe
Richtige Antwortrate (Lerndaten): 0.927
Richtige Antwortrate (Bewertungsdaten): 0.885
55. Erstellen einer Verwirrungsmatrix
Erstellen Sie eine Verwirrungsmatrix des in> 52 erlernten logistischen Regressionsmodells für die Trainingsdaten und Bewertungsdaten.
Die Verwirrungsmatrix wird auch unter Verwendung von Scicit-Learn berechnet. Zusätzlich wird die berechnete Verwirrungsmatrix mit Seaborn visualisiert.
from sklearn.metrics import confusion_matrix
import seaborn as sns
import matplotlib.pyplot as plt
#Trainingsdaten
train_cm = confusion_matrix(train['CATEGORY'], train_pred[1])
print(train_cm)
sns.heatmap(train_cm, annot=True, cmap='Blues')
plt.show()
Ausgabe
[[4344 93 8 56]
[ 52 4173 2 8]
[ 96 125 494 13]
[ 192 133 7 888]]
#Bewertungsdaten
test_cm = confusion_matrix(test['CATEGORY'], test_pred[1])
print(test_cm)
sns.heatmap(test_cm, annot=True, cmap='Blues')
plt.show()
Ausgabe
[[528 20 2 13]
[ 12 516 1 1]
[ 11 26 52 2]
[ 38 26 1 87]]
56. Messung von Präzision, Rückruf und F1-Punktzahl
Messen Sie die Genauigkeit, den Rückruf und die F1-Bewertung des logistischen Regressionsmodells, das in> 52 anhand der Bewertungsdaten gelernt wurde. Ermitteln Sie die Genauigkeitsrate, die Rückrufrate und die F1-Bewertung für jede Kategorie und integrieren Sie die Leistung für jede Kategorie in den Mikro- und Makro-Durchschnitt.
from sklearn.metrics import precision_score, recall_score, f1_score
def calculate_scores(y_true, y_pred):
#Compliance-Rate
precision = precision_score(test['CATEGORY'], test_pred[1], average=None, labels=['b', 'e', 't', 'm']) #Wenn Keine angegeben ist, wird die Genauigkeit für jede Klasse in ndarray zurückgegeben.
precision = np.append(precision, precision_score(y_true, y_pred, average='micro')) #Fügen Sie am Ende den Mikrodurchschnitt hinzu
precision = np.append(precision, precision_score(y_true, y_pred, average='macro')) #Fügen Sie am Ende den Makro-Durchschnitt hinzu
#Erinnern
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'))
#F1-Punktzahl
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'))
#Kombinieren Sie die Ergebnisse zu einem Datenrahmen
scores = pd.DataFrame({'Compliance-Rate': precision, 'Erinnern': recall, 'F1-Punktzahl': f1},
index=['b', 'e', 't', 'm', 'Mikrodurchschnitt', 'Makro-Durchschnitt'])
return scores
print(calculate_scores(test['CATEGORY'], test_pred[1]))
Ausgabe
Match Rate Rückrufrate F1 Score
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
Mikrodurchschnitt 0.885 0.885 0.885
Makro-Durchschnitt 0.887 0.764 0.807
57. Bestätigung des Merkmalsgewichts
Überprüfen Sie die Top-10-Features mit hohen Gewichten und die Top-10-Features mit niedrigen Gewichten im logistischen Regressionsmodell, das in> 52 gelernt wurde.
Das Gewicht jedes gelernten Merkmals wird für jede Klasse in `` `coef_``` gespeichert.
features = X_train.columns.values
index = [i for i in range(1, 11)]
for c, coef in zip(lg.classes_, lg.coef_):
print(f'【Kategorie】{c}')
best10 = pd.DataFrame(features[np.argsort(coef)[::-1][:10]], columns=['Höhere Bedeutung'], index=index).T
worst10 = pd.DataFrame(features[np.argsort(coef)[:10]], columns=['Geringere Bedeutung'], index=index).T
display(pd.concat([best10, worst10], axis=0))
print('\n')
Ausgabe
[Kategorie] b
1 2 3 4 5 6 7 8 9 \
Höhere Bedeutung Bank Fed China Ecb Aktien Euro Obamacare Öl Yellen
Niedrigere Bedeutung Video Ebola die sie und sie Apple Google Star
10
Dollar mit höherer Bedeutung
Microsoft mit geringerer Bedeutung
[Kategorie] e
1 2 3 4 5 6 7 8 \
Höchste Bedeutung Kardashian Chris ihr Filmstar Film Paul er
Geringere Bedeutung uns Update Google Studie China GM CEO Facebook
9 10
Höchste Hochzeit
Ältere Bedeutung sagt Apfel
[Kategorie] m
1 2 3 4 5 6 7 8 9 \
Höchste Bedeutung Ebola-Studie Krebsmedikamente mers FDA-Fälle cdc könnte
Geringere Bedeutung Facebook GM CEO Apple Bank Deal Google Verkaufsklima
10
Zigaretten von höchster Wichtigkeit
Twitter mit geringerer Bedeutung
[Kategorie] t
1 2 3 4 5 6 7 8 \
Höchste Bedeutung Google Facebook Apple Microsoft Klima gm NASA Tesla
Aktien von geringerer Bedeutung fütterten ihren Prozentsatz an Drogenkrebs in der Ukraine
9 10
Comcast Heartbleed von höchster Wichtigkeit
Geringere Bedeutung teilt immer noch
58. Ändern Sie die Regularisierungsparameter
Beim Training eines logistischen Regressionsmodells kann der Grad der Überanpassung während des Trainings durch Anpassen der Regularisierungsparameter gesteuert werden. Lernen Sie das logistische Regressionsmodell mit verschiedenen Regularisierungsparametern und finden Sie die richtige Antwortrate für die Trainingsdaten, Validierungsdaten und Bewertungsdaten. Fassen Sie die Ergebnisse des Experiments in einem Diagramm mit den Regularisierungsparametern auf der horizontalen Achse und der Genauigkeitsrate auf der vertikalen Achse zusammen.
Wenn die Regularisierung zu stark ist (C ist klein), wird das Lernen nicht fortgesetzt und die Genauigkeit ist gering. Wenn die Regularisierung zu schwach ist (C ist groß), tritt Überlernen auf und der Unterschied in der Genauigkeit zwischen Lernen und Bewertung wird größer. Aus diesem Ergebnis können wir bestätigen, dass es wichtig ist, das geeignete C auszuwählen.
from tqdm import tqdm
result = []
for C in tqdm(np.logspace(-5, 4, 10, base=10)):
#Modelllernen
lg = LogisticRegression(random_state=123, max_iter=10000, C=C)
lg.fit(X_train, train['CATEGORY'])
#Erhalten Sie den vorhergesagten Wert
train_pred = score_lg(lg, X_train)
valid_pred = score_lg(lg, X_valid)
test_pred = score_lg(lg, X_test)
#Berechnung der richtigen Antwortrate
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])
#Speicherung der Ergebnisse
result.append([C, train_accuracy, valid_accuracy, test_accuracy])
Ausgabe
100%|██████████| 10/10 [07:26<00:00, 44.69s/it] #Zeigen Sie den Fortschritt mit tqdm an
#Visualisierung
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. Suche nach Hyperparametern
Lernen Sie das Kategorisierungsmodell, während Sie den Lernalgorithmus und die Lernparameter ändern. Suchen Sie den Lernalgorithmusparameter, der die höchste Genauigkeitsrate für die Verifizierungsdaten ergibt. Finden Sie auch die richtige Antwortrate in den Bewertungsdaten, wenn der Lernalgorithmus und die Parameter verwendet werden.
Hier wird eine Parametersuche für `C``` durchgeführt, das die Stärke der Regularisierung angibt, und für` l1_ratio```, das das Gleichgewicht zwischen L1-Regularisierung und L2-Regularisierung angibt.
Zusätzlich wird Optuna zur Optimierung verwendet.
!pip install optuna
import optuna
#Geben Sie das Optimierungsziel mit einer Funktion an
def objective_lg(trial):
#Parametersatz, der eingestellt werden soll
l1_ratio = trial.suggest_uniform('l1_ratio', 0, 1)
C = trial.suggest_loguniform('C', 1e-4, 1e4)
#Modelllernen
lg = LogisticRegression(random_state=123,
max_iter=10000,
penalty='elasticnet',
solver='saga',
l1_ratio=l1_ratio,
C=C)
lg.fit(X_train, train['CATEGORY'])
#Erhalten Sie den vorhergesagten Wert
valid_pred = score_lg(lg, X_valid)
#Berechnung der richtigen Antwortrate
valid_accuracy = accuracy_score(valid['CATEGORY'], valid_pred[1])
return valid_accuracy
#Optimierung
study = optuna.create_study(direction='maximize')
study.optimize(objective_lg, timeout=3600)
#Ergebnisse anzeigen
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))
Ausgabe
Best trial:
Value: 0.892
Params:
l1_ratio: 0.23568685768996045
C: 4.92280374981671
Automatische Anpassung von Hyperparametern mit Optuna -Pytorch Lightning Edition-
Trainieren Sie das Modell erneut mit den gesuchten Parametern und überprüfen Sie die Genauigkeitsrate.
#Parametereinstellungen
l1_ratio = trial.params['l1_ratio']
C = trial.params['C']
#Modelllernen
lg = LogisticRegression(random_state=123,
max_iter=10000,
penalty='elasticnet',
solver='saga',
l1_ratio=l1_ratio,
C=C)
lg.fit(X_train, train['CATEGORY'])
#Erhalten Sie den vorhergesagten Wert
train_pred = score_lg(lg, X_train)
valid_pred = score_lg(lg, X_valid)
test_pred = score_lg(lg, X_test)
#Berechnung der richtigen Antwortrate
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'Richtige Antwortrate (Lerndaten):{train_accuracy:.3f}')
print(f'Richtige Antwortrate (Verifizierungsdaten):{valid_accuracy:.3f}')
print(f'Richtige Antwortrate (Bewertungsdaten):{test_accuracy:.3f}')
Ausgabe
Richtige Antwortrate (Lerndaten): 0.966
Richtige Antwortrate (Verifizierungsdaten): 0.892
Richtige Antwortrate (Bewertungsdaten): 0.895
Da die korrekte Antwortrate der Bewertungsdaten beim Training mit den Standardparametern 0,885 betrug, ist ersichtlich, dass die Genauigkeit durch Übernahme der entsprechenden Parameter verbessert wurde.
Dieses Mal werde ich auch XGBoost ausprobieren. Außerdem führt dies keine Parametersuche durch, sondern trainiert das Modell mit festen Parametern.
!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
}
#Formatkonvertierung für 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)
#Modelllernen
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)
#Erhalten Sie den vorhergesagten Wert
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)
#Berechnung der richtigen Antwortrate
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'Richtige Antwortrate (Lerndaten):{train_accuracy:.3f}')
print(f'Richtige Antwortrate (Verifizierungsdaten):{valid_accuracy:.3f}')
print(f'Richtige Antwortrate (Bewertungsdaten):{test_accuracy:.3f}')
Ausgabe
Richtige Antwortrate (Lerndaten): 0.963
Richtige Antwortrate (Verifizierungsdaten): 0.873
Richtige Antwortrate (Bewertungsdaten): 0.873
abschließend
Sprachverarbeitung 100 Klopfen sind so konzipiert, dass Sie nicht nur die Verarbeitung natürlicher Sprache selbst lernen können, sondern auch die grundlegende Datenverarbeitung und das allgemeine maschinelle Lernen. Sogar diejenigen, die maschinelles Lernen in Online-Kursen studieren, können sehr gute Ergebnisse erzielen. Probieren Sie es also bitte aus.
Recommended Posts