[PYTHON] Ich habe versucht, die Genauigkeit von Modellen für maschinelles Lernen mit Kaggle als Thema zu vergleichen.

1. Zweck

Nachdem wir die grundlegende Python-Programmierung gelernt haben, arbeiten wir an kaggle! Zu diesem Zeitpunkt beziehen wir uns auf den Kernel! Ich denke, dass es viele Artikel und Bücher gibt, und tatsächlich denke ich, dass es ein Weg ist, wahnsinnig mächtig zu werden.

Aus der Sicht eines echten Anfängers dachte ich jedoch ** "Es ist zu schwierig, den Kernel zu lesen, und ich verstehe die Bedeutung nicht ..." ** "Nein, es ist keine so fortschrittliche Technologie, sondern vorerst grundlegendes maschinelles Lernen. Ich wollte nur ein Modell machen ... "**, und ich fand es schwierig, ich selbst zu sein.

Wie stark wird sich in diesem Artikel die Genauigkeit verschiedener Modelle des maschinellen Lernens ändern, wenn das Niveau schrittweise erhöht wird, z. B. "Super-Basic-Methode" und "leicht entwickelte Methode" **? Ich möchte ** überprüfen. Auf diese Weise ** "Ich verstehe, wie macht man ein super-grundlegendes Modell für maschinelles Lernen?" Was zu tun ist ** ist der Zweck dieses Artikels.

2. Einführung

(1) Kaggle zu verwenden (Klassifizierungsproblem)

In meinem Qiita-Artikel verwende ich den Kickstarter Projects-Datensatz von kaggle, den ich oft sehe. https://www.kaggle.com/kemical/kickstarter-projects

(2) Diesmal zu vergleichendes Modell des maschinellen Lernens

Ich habe versucht, orthodoxe Dinge zu sammeln.

・ Logistische Rendite ・ SVM · Entscheidungsbaum ・ Zufälliger Wald ・ Adaboost

(3) Überprüfungsstufe

A: Keine Anpassung (Standard) B: (Nur notwendige Modelle) Regularisierung C: (Nur erforderliche Modelle) Standardisierung D: Hyperparameter-Tuning E: Funktionsauswahl

Hier ist eine Zusammenfassung von (2) und (3) und die Genauigkeitsergebnisse aller Muster, die später überprüft werden.

◆ Lesen der Tabelle

Aus der Perspektive ist Muster 1 die Standardversion der logistischen Regression mit einer Genauigkeit von 0,52958, Muster 2 ist die Version mit nur der Regularisierung der logistischen Regression mit einer Genauigkeit von 0,59815 und Muster 3 ist die Version mit Regularisierung und Standardisierung mit logistischer Regression. Und die Genauigkeit beträgt 0,66181 ...

◆ Hinweise

Grundsätzlich wird davon ausgegangen, dass die Genauigkeit mit fortschreitendem Muster in jedem Modell zunimmt. Diesmal verwendet die Auswahl der Merkmalsmenge von E jedoch die integrierte Methode. → Bitte beachten Sie, dass die integrierte Methode auf einem linearen Modell basiert, sodass die Genauigkeit nicht unbedingt zunimmt (tatsächlich gab es Muster, bei denen es besser war, E nicht mit mehreren Mustern durchzuführen).

• Wenn es nicht linear ist, ist es besser, eine andere Methode zur Funktionsauswahl auszuprobieren. Diesmal besteht jedoch ein zeitlicher Ausgleich, sodass wir nur mit der integrierten Methode fortfahren.

◆ Für Super-Anfänger

Ich denke, es ist eine gute Idee, sich zuerst die A-Version jedes Modells anzusehen und dann das Muster für jedes Modell schrittweise weiterzuentwickeln.

• Muster 1 → 6 → 10 → 13 → 16 → 2 → 7 ...

(4) Referenz

Für jedes Modell des maschinellen Lernens werden wir es diesmal nur implementieren. Wir haben jedoch eine Reihe von Artikeln veröffentlicht, die den Hintergrund der Mathematik verstehen. Wir hoffen, dass Sie auch darauf verweisen können.

Maschinelles Lernen Verstehen der logistischen Regression sowohl durch Scikit-Lernen als auch durch Mathematik (https://qiita.com/Hawaii/items/ee2a0687ca451fe213be) [[Maschinelles Lernen] SVM sowohl aus Scikit-Lernen als auch aus Mathematik verstehen] (https://qiita.com/Hawaii/items/4688a50cffb2140f297d) [Maschinelles Lernen] Entscheidungsbäume sowohl aus Scikit-Learn als auch aus Mathematik verstehen [[Maschinelles Lernen] Zufällige Gesamtstruktur verstehen] (https://qiita.com/Hawaii/items/5831e667723b66b46fba)

3. Erstellen Sie abschließend ein Modell für maschinelles Lernen

(1) Vorher

Ich werde die Verarbeitung durchführen, die allen Modellen hier gemeinsam ist.

(I) Importieren

Lassen Sie uns alles auf einmal importieren. Stellen Sie sich vor, Sie führen diesen allgemeinen Vorgang am Anfang jedes Musters durch und schreiben dann den Code für jedes Muster nacheinander.

#numpy,Pandas importieren
import numpy as np
import pandas as pd

#Importieren, um Datumsdaten zu verarbeiten
import datetime

#Import für Trainingsdaten und Testdatenaufteilung
from sklearn.model_selection import train_test_split

#Import zur Standardisierung
from sklearn.preprocessing import StandardScaler

#Import zur Überprüfung der Genauigkeit
from sklearn.model_selection import cross_val_score

#Import für die Optimierung von Hyperparametern
from sklearn.model_selection import train_test_split, GridSearchCV

#Importieren zur Funktionsauswahl
from sklearn.feature_selection import SelectFromModel
from sklearn.linear_model import LassoCV

#Import für logistische Regression
from sklearn.linear_model import SGDClassifier
from sklearn.metrics import log_loss, accuracy_score, confusion_matrix

#Für SVM importieren
from sklearn.svm import SVC

#Für Entscheidungsbaum importieren
from sklearn.tree import DecisionTreeClassifier, export_graphviz

#Import für Random Forest
from sklearn.ensemble import RandomForestClassifier

#Importieren für Adaboost
from sklearn.ensemble import AdaBoostClassifier

(Ii) Daten lesen

df = pd.read_csv(r"C:~~\ks-projects-201801.csv")

(Iii) Datenerscheinung

Aus dem Folgenden können Sie ersehen, dass es sich um den Datensatz von (378661, 15) handelt. Da die Datenmenge sehr groß ist, werden Modelle, deren Verarbeitung lange dauert, anhand einiger dieser Daten trainiert.

df.shape

Schauen wir uns auch die Daten in .head kurz an.

df.head()

(Iv) Datenformung

◆ Anzahl der Rekrutierungstage

Ich werde die Details weglassen, aber da die Start- und Endzeit der Rekrutierung für die Cloud-Finanzierung in den Daten enthalten sind, werden wir dies in "Rekrutierungstage" umwandeln.

df['deadline'] = pd.to_datetime(df["deadline"])
df["launched"] = pd.to_datetime(df["launched"])
df["days"] = (df["deadline"] - df["launched"]).dt.days

◆ Informationen zur Zielvariablen

Ich werde die Details auch hier weglassen, aber es gibt andere Kategorien als Erfolg ("erfolgreich") und Misserfolg ("fehlgeschlagen") für die Zielvariable "state", aber dieses Mal werde ich nur Daten für Erfolg und Misserfolg verwenden.

df = df[(df["state"] == "successful") | (df["state"] == "failed")]

Ersetzen Sie dann Erfolg durch 1 und Misserfolg durch 0.

df["state"] = df["state"].replace("failed",0)
df["state"] = df["state"].replace("successful",1)

◆ Löschen Sie nicht benötigte Zeilen

Löschen Sie vor dem Erstellen des Modells die ID und den Namen, die Sie Ihrer Meinung nach nicht benötigen (dies sollte beibehalten werden, diesmal wird es jedoch entfernt), sowie die Variablen, die Sie erst nach der Cloud-Finanzierung kennen. ..

df = df.drop(["ID","name","deadline","launched","backers","pledged","usd pledged","usd_pledged_real","usd_goal_real"], axis=1)

◆ Verarbeitung von Kategorievariablen

Führen Sie die Verarbeitung kategorialer Variablen mit pd.get_dummies durch.

df = pd.get_dummies(df,drop_first = True)

(2) Muster 1-5 [Logistische Regression]

(I) Muster 1 ~ Standard ~

Ich möchte die logistische Regression ohne Anpassungen implementieren.

Teilen Sie es zunächst in Trainingsdaten und Testdaten auf.

y = df["state"].values
X = df.drop("state", axis=1).values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1234)

Erstellen Sie als Nächstes ein Modell für die zufällige Gesamtstruktur.

clf = SGDClassifier(loss = "log", penalty = "none",random_state=1234)
clf.fit(X_train,y_train)

clf.score(X_test, y_test)

y = df["state"].values
X = df.drop("state", axis=1).values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1234)

Lassen Sie uns abschließend die Genauigkeit anhand von Testdaten überprüfen. Dann wurde die Genauigkeit ** 0,52958 **. (Ii) Muster 2 - Nur Implementierung der Regularisierung - Was Regularisierung ist, wird hier weggelassen. Wenn jedoch nur Regularisierung durchgeführt wird, wird durch L1-Regularisierung und L2-Regularisierung überprüft, ob sich die Genauigkeit verbessert. Ich werde. Teilen Sie es zunächst in Trainingsdaten und Testdaten auf. ◆ L1-Regularisierung Setzen Sie die Strafe auf l1 und überprüfen Sie die Genauigkeit.

clf_L1 = SGDClassifier(loss = "log", penalty = "l1", random_state=1234)
clf_L1.fit(X_train,y_train)

clf_L1.score(X_test, y_test)

Dann betrug die Genauigkeit ** 0,52958 **, was dieselbe wie zuvor war.

◆ L2-Regularisierung Setzen Sie die Strafe ebenfalls auf l2 und überprüfen Sie die Genauigkeit.

clf_L2 = SGDClassifier(loss = "log", penalty = "l2", random_state=1234)
clf_L2.fit(X_train,y_train)
clf_L2.score(X_test, y_test)

Dann war die Genauigkeit ** 0,59815 **, was höher als die von Muster 1 war. Die L2-Regularisierung ist möglicherweise besser für diese Daten geeignet.

(Iii) Muster 3 ~ Regularisierung + Standardisierungsimplementierung ~

Lassen Sie uns überprüfen, welche Genauigkeit erzielt wird, indem der obigen Regularisierung eine Standardisierungsverarbeitung hinzugefügt wird. Nach Durchführung des Standardisierungsprozesses fügen wir die L1-Regularisierung und die L2-Regularisierung hinzu.

Teilen Sie es zunächst in Trainingsdaten und Testdaten auf.

y = df["state"].values
X = df.drop("state", axis=1).values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1234)

Als nächstes standardisieren. Da die Anzahl der Features diesmal gering ist, werden nur Ziele und Tage standardisiert, die standardisiert werden sollten, und die Spalten, die von get_dumiies mit kategorialen Variablen verarbeitet wurden, sind nicht standardisiert. Es scheint jedoch kein Problem zu geben, selbst wenn die gesamten Daten standardisiert sind (ich habe den Lehrer des von mir belegten maschinellen Lernkurses gefragt).

stdsc = StandardScaler()
df["goal"] = stdsc.fit_transform(df[["goal"]].values)
df["days"] = stdsc.fit_transform(df[["days"]].values)

Danach werden die L1-Regularisierungsverarbeitung, die L2-Regularisierungsverarbeitung und die Genauigkeitsüberprüfung durchgeführt.

#L1 Regularisierung und Genauigkeit
clf_L1 = SGDClassifier(loss = "log", penalty = "l1", random_state=1234)
clf_L1.fit(X_train,y_train)
clf_L1.score(X_test, y_test)

#L2 Regularisierung und Genauigkeit

clf_L2 = SGDClassifier(loss = "log", penalty = "l2", random_state=1234)
clf_L2.fit(X_train,y_train)
clf_L2.score(X_test, y_test)

Die Genauigkeit der L1-Regularisierung beträgt ** 0,66181 **, und die Genauigkeit der L2-Regularisierung beträgt ** 0,65750 **, wodurch die Genauigkeit sofort verbessert wird. Nach der Standardisierung scheint die L1-Regularisierung besser zu passen. Hier werde ich eine Aufzeichnung von ** 0,66181 ** der L1-Regularisierung führen, die eine gute Genauigkeit hatte.

(Iv) Muster 4 ~ Regularisierung + Standardisierung + Hyperparameter-Tuning ~

Lassen Sie uns eine weitere Optimierung der Hyperparameter für Muster 3 durchführen. Hyper-Parameter-Tuning bezieht sich auf das Erforschen und Entscheiden, welche numerischen Werte wir selbst bestimmen müssen, um ein Modell für maschinelles Lernen zu erstellen.

Hier verwenden wir Gridsearch.

Es wäre schön, wenn alle Parameter in jedem Bereich gesucht werden könnten, aber das würde zu viel Zeit in Anspruch nehmen. Diesmal werden wir also die Strafe und das Alpha einstellen, die im SGD-Klassifikator wichtig zu sein scheinen.

Das erste ist die Standardisierungsverarbeitung + Aufteilung von Trainingsdaten und Testdaten.

• Es wird nach einer Regularisierung gesucht, die besser ist, L1 oder L2, indem diesmal die Parameter eingestellt werden, sodass sie zu diesem Zeitpunkt noch nicht eingestellt ist.

#Standardisierung
stdsc = StandardScaler()
df["goal"] = stdsc.fit_transform(df[["goal"]].values)
df["days"] = stdsc.fit_transform(df[["days"]].values)

#Datenaufteilung
y = df["state"].values
X = df.drop("state", axis=1).values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1234)

parameters = {'penalty':['l1', 'l2'], 'alpha':[0.0001,0.001, 0.01, 0.1, 1, 10, 100],'loss':['log']} #Hier bearbeiten
model = SGDClassifier(random_state=1234)
clf = GridSearchCV(model, parameters, cv=3)
clf.fit(X_train, y_train)
print(clf.best_params_)

Dieses Mal wollte ich die Genauigkeit für jedes in der Tabelle zu Beginn gezeigte Muster vergleichen, daher habe ich darauf geachtet, ** GridSearch einschließlich des Standardwerts ** zu verwenden. Dies liegt daran, dass der Genauigkeitsvergleich nicht möglich ist, wenn der Standardwert nicht enthalten ist.

• Der Standardwert wird auf der Seite sklearn beschrieben. Der SGD-Klassifikator lautet diesmal beispielsweise wie folgt. https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.SGDClassifier.html

Die Strafe ist l1 oder l2, und Alpha enthält den Standardwert 0,0001, der ziemlich breit ist. Wenn Sie wie zuvor keinen Verlust im Protokoll angeben, handelt es sich in erster Linie nicht um eine logistische Regression. Geben Sie ihn daher im Protokoll an.

• Als Hinweis für Super-Anfänger, wie oben erwähnt, ** müssen Sie "welchen Parameter" und "in welchem Bereich" einstellen, um selbst zu suchen **, daher gibt es hier auch empirische Regeln und mehr Ich bin der Meinung, dass ein tiefes Verständnis erforderlich ist.

Dann wurde {'alpha': 0,0001, 'Verlust': 'log', 'Strafe': 'l1'} angezeigt und er suchte nach dem besten Parameter.

Beachten Sie, dass das Alpha dieses besten Parameters genau den gleichen Wert wie der Standardwert hat, wenn Sie sich die Site von sklearn ansehen **. Zusätzlich wird bei der L1-Regularisierung von Muster 3 der Verlust auf log und die Strafe auf l1 gesetzt, so dass theoretisch, selbst wenn eine Hyperparametersuche durchgeführt wird, ** dieselben Parameter wie bei der L1-Regularisierung von Muster 3 verwendet werden. **.

Mit anderen Worten, lassen Sie uns fortfahren und denken, dass die Genauigkeit 0,66181 betragen sollte, was der L1-Regularisierung von Muster 3 entspricht.

Lassen Sie uns nun das Modell mit diesem besten Parameter erneut erstellen. Das Folgende bedeutet, dass Sie "** clf.best_paramas_" verwenden, um den SGD-Klassifikator mit den besten Parametern zu trainieren, die ich zuvor erwähnt habe.

clf_2 = SGDClassifier(**clf.best_params_,random_state=1234)
clf_2.fit(X_train,y_train)

• Wenn Sie die Zufallszahl hier nicht als random_state = 1234 festlegen, können Sie sie nicht mit der L1-Regularisierung von Muster 3 vergleichen. Korrigieren Sie sie daher fest.

Überprüfen Sie abschließend die Genauigkeit anhand der Testdaten.

clf_2.score(X_test, y_test)

Es wurde ** 0,66181 ** und es wurde das gleiche System wie Muster 3, wie angenommen.

(V) Muster 5 ~ Regularisierung + Standardisierung + Hyperparameter-Tuning + Funktionsauswahl ~

Bis zu Muster 4 habe ich ein Modell mit der von mir willkürlich ausgewählten Feature-Menge erstellt. Hier werde ich jedoch die Feature-Menge mithilfe der als integrierte Methode bezeichneten Methode auswählen.

• Für die Einbettungsmethode haben wir etwas ausführlicheren Inhalt mit genau demselben Material wie dieses Mal veröffentlicht. Eine ausführliche Erläuterung und Erläuterung der Einbettungsmethode finden Sie hier. [[Maschinelles Lernen] Funktionsauswahl - Versuchen Sie, die integrierte Methode mit scikitlearn- zu implementieren.] (https://qiita.com/Hawaii/items/1490587aad33b08d3936)

Standardisieren und teilen Sie zunächst die Daten.

#Standardisierung
stdsc = StandardScaler()
df["goal"] = stdsc.fit_transform(df[["goal"]].values)
df["days"] = stdsc.fit_transform(df[["days"]].values)

#Datenaufteilung
y = df["state"].values
X = df.drop("state", axis=1).values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1234)

Als Nächstes wählen wir die Feature-Menge nach der integrierten Methode aus.

estimator = LassoCV(normalize = True, cv = 10, random_state = 1234)
sfm = SelectFromModel(estimator, threshold = 1e-5)
sfm.fit(X_train,y_train)

Die ausgewählten Funktionen werden überschrieben und mit den Trainingsdaten und Testdaten aktualisiert.

X_train_selected = sfm.transform(X_train)
X_test_selected = sfm.transform(X_test)

Überprüfen Sie die Genauigkeit des SGD-Klassifikators anhand der überschriebenen Trainingsdaten (zu diesem Zeitpunkt wurde noch keine Hyperparameter-Abstimmung durchgeführt).

classifier = SGDClassifier(random_state=1234)
classifier.fit(X_train_selected, y_train)

Führen Sie von hier aus eine Hyperparameter-Optimierung durch. Die Methode ist im Grunde die gleiche wie zuvor, es werden jedoch die Trainingsdaten (X_train_selected) verwendet, die den Inhalt von .fit überschreiben.

parameters = {'penalty':['l1', 'l2'], 'alpha':[0.0001,0.001, 0.01, 0.1, 1, 10, 100],'loss':['log']} 
model = SGDClassifier(random_state=1234)
clf = GridSearchCV(model, parameters, cv=3)
clf.fit(X_train_selected, y_train)
print(clf.best_params_)

Trainieren Sie den SGD-Klassifikator erneut mit den besten Parametern, die Sie angegeben haben.

• Entschuldigen Sie mich oft, aber da es sich um die Feature-Daten handelt, die von der hier trainierten integrierten Methode ausgewählt wurden, verwenden Sie X_train_selected anstelle von X_train.

clf_2 = SGDClassifier(**clf.best_params_,random_state=1234)
clf_2.fit(X_train_selected,y_train)

Überprüfen Sie abschließend die Genauigkeit.

clf_2.score(X_test_selected, y_test)

Mit ** 0,66185 ** konnten wir die beste Genauigkeit aller Zeiten erzielen.

Dies ist das Ende der logistischen Regression. Fassen wir die Genauigkeit einmal zusammen.

Fahren wir nun mit SVM fort.

(3) Muster 6-9 [SVM]

Ich habe auch SVM ausprobiert und festgestellt, dass es ein Durcheinander ist, aber die Verarbeitung nimmt viel Zeit in Anspruch. Wenn ich also wie bei der logistischen Regression ein Modell erstellen und Hyperparameter unter Verwendung aller Trainingsdaten optimieren würde, hätte ich nicht genug Zeit, also habe ich darauf geachtet, die Daten kleiner zu machen.

* Ergänzung - Geschätzt, wie lange es dauern wird, Daten zu verarbeiten- *

Ich habe alle Daten vom ersten Schuss an trainiert und viele Male festgestellt, dass sie nicht endeten, selbst wenn es Stunden dauerte. Deshalb habe ich es zuerst mit einer sehr kleinen Anzahl von Daten (und Parametern) und der dafür benötigten Zeit versucht Notieren. Ich denke, es ist besser, den Prozess zu starten, nachdem Sie eine Richtlinie festgelegt haben, wie lange es dauern wird, da dieser Betrag ungefähr ein Vielfaches beträgt.

(I) Muster 6 ~ Standard ~

Ich werde SVM ohne Anpassungen implementieren. Teilen Sie es zunächst in Trainingsdaten und Testdaten auf.

y = df["state"].values
X = df.drop("state", axis=1).values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1234)

Die wichtigsten Änderungen, die ich bei der Verarbeitung von SVMs mit anderen Modellen vorgenommen habe, sind folgende, aber es dauert sehr lange, SVMs mit allen Trainingsdaten wie der logistischen Regression zu trainieren.

Behandeln wir daher die Trainingsdaten, die einmal in 70% der Gesamtzahl aufgeteilt wurden, und behandeln dann 1,5% (= 10,5% aller Daten) als Trainingsdaten.

• 1,5% sind nicht eindeutig entschieden, und es ist ein sinnvoller Wert, dass ich dies als Trainingsdaten möchte. Ursprünglich wollte ich, dass es etwas mehr Trainingsdaten sind, aber als ich es bei 30% ausprobierte, blieb es 3 Stunden und die Verarbeitung wurde nicht abgeschlossen, also habe ich es diesmal unter Berücksichtigung der Zeit auf 1,5% gesetzt.

Selbst mit 1,5% dauerte es mehr als 3 Stunden, um den Prozess abzuschließen. ..

#1 aus den Trainingsdaten.Probe 50%
X_train_sample = pd.DataFrame(X_train).sample(frac = 0.15, random_state=1234)
y_train_sample = pd.DataFrame(y_train).sample(frac = 0.15, random_state=1234)

#Modellbau
clf = SVC(random_state=1234)
clf.fit(X_train_sample, y_train_sample) 

Nachdem wir nun ein Modell haben, überprüfen wir die Genauigkeit anhand der Testdaten. Es ist wichtig zu beachten, dass die Testdaten nicht von 30% der Gesamtmenge reduziert werden, sondern die Genauigkeit anhand aller Testdaten bestätigt wird. Dies liegt daran, dass ich dachte, wenn die Anzahl der Testdaten nur für SVM reduziert würde, wäre es nicht möglich, die Genauigkeit mit anderen Modellen zu vergleichen.

clf.score(X_test,y_test)

Die Genauigkeit betrug ** 0,61935 **.

(Ii) Muster 7 - Nur Implementierung der Standardisierung

Da SVM selbst keine Regularisierung erfordert, beginnt es mit der Implementierung der Standardisierung.

• Durch das Anpassen von Hyperparametern spielt beispielsweise das Anpassen der Tiefe eines Baums in gewissem Sinne eine Rolle wie die Regularisierung.

Lassen Sie uns zunächst die Daten standardisieren und teilen. Danach ist es dasselbe wie in Muster 6.

#Standardisierung
stdsc = StandardScaler()
df["goal"] = stdsc.fit_transform(df[["goal"]].values)
df["days"] = stdsc.fit_transform(df[["days"]].values)

#Datenaufteilung
y = df["state"].values
X = df.drop("state", axis=1).values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1234)

#1 aus den Trainingsdaten.Probe 50%
X_train_sample = pd.DataFrame(X_train).sample(frac = 0.15, random_state=1234)
y_train_sample = pd.DataFrame(y_train).sample(frac = 0.15, random_state=1234)

#Modellbau
clf = SVC(random_state=1234)
clf.fit(X_train_sample, y_train_sample)

#Genauigkeitsbewertung
clf.score(X_test, y_test)

Die Genauigkeit beträgt ** 0,64871 **, was besser ist als bei Muster 6.

(Iii) Muster 8 ~ Standardisierung + Hyperparameter-Tuning ~

Als nächstes implementieren wir Standardisierung + Hyperparameter-Tuning.

Erstens ist Standardisierung und Datenteilung.

stdsc = StandardScaler()
df["goal"] = stdsc.fit_transform(df[["goal"]].values)
df["days"] = stdsc.fit_transform(df[["days"]].values)

y = df["state"].values
X = df.drop("state", axis=1).values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1234)

Führen Sie als Nächstes eine Hyperparameter-Optimierung durch. Auch hier nimmt die Suche mit allen Trainingsdaten viel Zeit in Anspruch, sodass 3% (= 2,1% der Gesamtzahl) der 70% der Trainingsdaten für die Optimierung von Hyperparametern verwendet werden.

Ursprünglich möchte ich mehr Daten zum Anpassen der Parameter verwenden, aber da die Verarbeitung noch nicht wirklich abgeschlossen ist, habe ich diesen Wert gewählt.

#Trainingsdaten 3%Probenahme
X_train_grid = pd.DataFrame(X_train).sample(frac = 0.03,random_state=1234)
y_train_grid = pd.DataFrame(y_train).sample(frac = 0.03,random_state=1234)

Führen Sie dann eine Hyperparameter-Optimierung durch.

parameters = {'kernel':['linear', 'rbf'], 'C':[0.001, 0.01,0.1,1,10]} #Hier bearbeiten
model = SVC(random_state=1234)
clf = GridSearchCV(model, parameters, cv=2,return_train_score=False)
clf.fit(X_train_grid, y_train_grid)
print(clf.best_params_, clf.best_score_)

Der Punkt, der sich von der logistischen Regression unterscheidet, ist, dass der Lebenslauf des GridSearch-Arguments auf 2 + + return_train_score auf False gesetzt ist. Ursprünglich war cv auf 3 gesetzt und return_train_score wurde nicht speziell gesetzt, aber da die Verarbeitung nicht für immer endet, habe ich es auf der Site überprüft und gesetzt.

• Es scheint, dass cv die Anzahl der Gegenprüfungen ist (dies scheint zur Effizienz beizutragen), und return_train_score = False muss sich nicht die Mühe machen, die Genauigkeit der Trainingsdaten zu messen.

Bisher haben wir nach den "optimalen Parametern" gesucht! Wir werden mit Trainingsdaten mit diesem optimalen Parameter trainieren und die Genauigkeit mit Testdaten überprüfen.

• Die obigen 3% sind die Daten, die für die optimale Parametersuche verwendet werden. Die gleiche Anzahl von Daten wie die logistische Regression wird verwendet, um den Modelllerner zu schulen.

#1 aus den Trainingsdaten.Probe 50%
X_train_sample = pd.DataFrame(X_train).sample(frac = 0.15, random_state=1234)
y_train_sample = pd.DataFrame(y_train).sample(frac = 0.15, random_state=1234)

#Modelltraining
clf = SVC(**clf.best_params_,random_state=1234)
clf.fit(X_train_sample, y_train_sample) 

#Bestätigen Sie die Genauigkeit mit den Testdaten
clf.score(X_test, y_test)

Die Genauigkeit betrug ** 0,65393 **.

(Iv) Muster 9-Standardisierung + Hyper-Parameter-Tuning + Funktionsauswahl-

Fügen Sie abschließend eine Funktionsauswahl hinzu.

Auch hier sind die Trainingsdaten für die Merkmalsauswahl weiter in Muster 8 unterteilt. Achten Sie also darauf, nicht zu verwechseln, welche Trainingsdaten Sie für was verwenden.

#Standardisierung
stdsc = StandardScaler()
df["goal"] = stdsc.fit_transform(df[["goal"]].values)
df["days"] = stdsc.fit_transform(df[["days"]].values)

#Datenaufteilung
y = df["state"].values
X = df.drop("state", axis=1).values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1234)

#Merkmalsauswahl
estimator = LassoCV(normalize = True, cv = 10, random_state = 1234)
sfm = SelectFromModel(estimator, threshold = 1e-5)
sfm.fit(X_train,y_train)

#Trainingsdaten mit ausgewählten Funktionen überschreiben
X_train_selected = sfm.transform(X_train)
X_test_selected = sfm.transform(X_test)

Dies ist die Funktionsauswahl. Als nächstes wird die Optimierung der Hyperparameter basierend auf der ausgewählten Merkmalsmenge durchgeführt.

#3 von Trainingsdaten, die mit ausgewählten Funktionen für die Hyperparameter-Abstimmung überschrieben wurden%Probenahme
X_train_grid = pd.DataFrame(X_train_selected).sample(frac = 0.03,random_state=1234)
y_train_grid = pd.DataFrame(y_train).sample(frac = 0.03,random_state=1234)

#Hyper-Parameter-Tuning
parameters = {'kernel':['linear', 'rbf'], 'C':[0.001, 0.01,0.1,1,10]} #Hier bearbeiten
model = SVC(random_state=1234)
clf = GridSearchCV(model, parameters, cv=2,return_train_score=False)
clf.fit(X_train_grid, y_train_grid)
print(clf.best_params_, clf.best_score_)

Zu diesem Zeitpunkt wurde die Optimierung der Hyperparameter unter Verwendung der durch die integrierte Methode ausgewählten Funktionen abgeschlossen und die besten Parameter ermittelt.

Trainieren wir das SVM-Modell mit den Trainingsdaten (X_train_selected), die mit dieser ausgewählten Feature-Menge überschrieben wurden, und den besten Parametern mit 1,5% der Trainingsdaten von 70% der Gesamtzahl.

#Stichprobe 30% aus den überschriebenen Trainingsdaten
X_train_sample = pd.DataFrame(X_train_selected).sample(frac = 0.15, random_state=1234)
y_train_sample = pd.DataFrame(y_train).sample(frac = 0.15, random_state=1234)

#Modellbau mit zusätzlichen 30% der Probendaten aus 70% der Trainingsdaten
clf = SVC(**clf.best_params_,random_state=1234)
clf.fit(X_train_sample, y_train_sample) 

#Genauigkeitsbewertung mit Testdaten
clf.score(X_test_selected, y_test)

Die Genauigkeit beträgt ** 0,65066 **.

Lassen Sie uns hier die Genauigkeit noch einmal zusammenfassen.

(4) Muster 10-12 [Entscheidungsbaum]

Als nächstes kommt der Entscheidungsbaum.

(I) Muster 10 ~ Standard ~

Teilen Sie die Daten.

y = df["state"].values
X = df.drop("state", axis=1).values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1234)

Erstellen Sie ein Modell des Entscheidungsbaums und überprüfen Sie die Genauigkeit.

clf = DecisionTreeClassifier(random_state=1234)
clf = clf.fit(X_train, y_train)

clf.score(X_test, y_test)

Die Genauigkeit beträgt jetzt ** 0,63727 **.

(Ii) Muster 11 ~ Hyper Parameter Tuning ~

Der Entscheidungsbaum erfordert keine Regularisierung oder Standardisierung, daher beginnen wir mit der Optimierung der Hyperparameter.

Erstens ist die Datenteilung.

y = df["state"].values
X = df.drop("state", axis=1).values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1234)

Führen Sie als Nächstes eine Rastersuche für die Optimierung von Hyperparametern durch. Danach erstellen wir das Modell mit den besten Parametern und überprüfen die Genauigkeit der Testdaten.

#GridSearch
parameters = {'criterion':['gini', 'entropy'], 'max_depth':[i for i in range(1, 11)],'max_features':['auto','sqrt','log2'], 'min_samples_leaf':[i for i in range(1, 11)],'random_state':[1234]} #Hier bearbeiten
model = DecisionTreeClassifier(random_state=1234)
clf = GridSearchCV(model, parameters, cv=3)
clf.fit(X_train, y_train)
print(clf.best_params_, clf.best_score_)

#Erstellen Sie ein Modell mit den besten Parametern
clf = DecisionTreeClassifier(**clf.best_params_,random_state=1234)
clf.fit(X_train, y_train)

#Genauigkeitsüberprüfung
clf.score(X_test,y_test)

Die Genauigkeit betrug ** 0,66376 **.

(Iii) Muster 12-Hyper-Parameter-Tuning + Funktionsauswahl-

Beginnen Sie wie immer mit der Datenpartitionierung.

#Datenaufteilung
y = df["state"].values
X = df.drop("state", axis=1).values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1234)

#Merkmalsauswahl
estimator = LassoCV(normalize = True, cv = 10, random_state = 1234)
sfm = SelectFromModel(estimator, threshold = 1e-5)
sfm.fit(X_train,y_train)

#Trainingsdaten mit ausgewählten Funktionen überschreiben
X_train_selected = sfm.transform(X_train)
X_test_selected = sfm.transform(X_test)

#Hyper-Parameter-Tuning
parameters = {'criterion':['gini', 'entropy'], 'max_depth':[i for i in range(1, 11)],'max_features':['auto','sqrt','log2'], 'min_samples_leaf':[i for i in range(1, 11)],'random_state':[1234]}
model = DecisionTreeClassifier(random_state=1234)
clf = GridSearchCV(model, parameters, cv=3)
clf.fit(X_train_selected, y_train)
print(clf.best_params_, clf.best_score_)

#Trainieren Sie die Lernenden mit optimalen Parametern
clf_2 = DecisionTreeClassifier(**clf.best_params_,random_state=1234)
clf_2.fit(X_train_selected,y_train)

#Bestätigen Sie die Genauigkeit mit den Testdaten
clf_2.score(X_test_selected, y_test)

Die Genauigkeit beträgt ** 0,65732 **.

(5) Muster 13 bis 15 [Random Forest]

(I) Muster 13 ~ Standard ~

Teilen Sie die Daten.

y = df["state"].values
X = df.drop("state", axis=1).values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1234)

Es wird eine zufällige Waldmodellkonstruktion durchgeführt und eine Genauigkeitsüberprüfung durchgeführt.

clf = RandomForestClassifier(random_state=1234)
clf.fit(X_train, y_train)

clf.score(X_test, y_test)

Die Genauigkeit beträgt jetzt ** 0,64522 **.

(Ii) Muster 14 ~ Hyper Parameter Tuning ~

Zufällige Gesamtstrukturen erfordern wie der Entscheidungsbaum keine Regularisierung und Standardisierung.

Nach wie vor erfolgt die Optimierung der Hyperparameter nach der Datenteilung. Der Unterschied zum Vorgängermodell besteht darin, dass der Suchbereich etwas eingeschränkt wird (jeder Index wird im Bereich von 1 bis 5 durchsucht). Dies allein dauerte ungefähr 35 Minuten, daher hatte ich das Gefühl, dass es schwierig sein würde, den Prozess unter Berücksichtigung meiner eigenen Zeit zu unterteilen, wenn ich den Bereich weiter ausbaute, sodass ich den Bereich einschränkte.

#Datenaufteilung
y = df["state"].values
X = df.drop("state", axis=1).values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1234)

#Hyper-Parameter-Tuning
parameters = {'max_depth':[2,4,6,None],  'min_samples_leaf':[1,3,5],'min_samples_split':[2,4,6]}
model = RandomForestClassifier(random_state=1234)
clf = GridSearchCV(model, parameters, cv=3,)
clf.fit(X_train, y_train)
print(clf.best_params_, clf.best_score_)

#Trainieren Sie die Lernenden mit optimalen Parametern
clf = RandomForestClassifier(**clf.best_params_,random_state=1234)
clf.fit(X_train, y_train)

#Bestätigen Sie die Genauigkeit mit den Testdaten
clf.score(X_test, y_test)

Da es lange gedauert hat, die numerischen Werte in der Hyperparametersuche einzugrenzen, haben wir auf die Suche nach geraden oder nur ungeraden Zahlen umgestellt, unter der Annahme, dass die Standardwerte enthalten sind. Die Genauigkeit betrug ** 0,67762 **.

(Iii) Muster 15-Hyper-Parameter-Tuning + Funktionsauswahl-

#Datenaufteilung
y = df["state"].values
X = df.drop("state", axis=1).values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1234)

#Merkmalsauswahl
estimator = LassoCV(normalize = True, cv = 10, random_state = 1234)
sfm = SelectFromModel(estimator, threshold = 1e-5)
sfm.fit(X_train,y_train)

#Trainingsdaten mit ausgewählten Funktionen überschreiben
X_train_selected = sfm.transform(X_train)
X_test_selected = sfm.transform(X_test)

#Hyper-Parameter-Tuning
parameters = {'max_depth':[2,4,6,None],  'min_samples_leaf':[1,3,5],'min_samples_split':[2,4,6]}
model = RandomForestClassifier(random_state=1234)
clf = GridSearchCV(model, parameters, cv=3,)
clf.fit(X_train_selected, y_train)
print(clf.best_params_, clf.best_score_)

#Trainieren Sie die Lernenden mit optimalen Parametern
clf = RandomForestClassifier(**clf.best_params_,random_state=1234)
clf.fit(X_train_selected, y_train)

#Bestätigen Sie die Genauigkeit mit den Testdaten
clf.score(X_test_selected, y_test)

Die Genauigkeit beträgt jetzt ** 0,66308 **.

Lassen Sie uns die Genauigkeit noch einmal überprüfen.

(6) Muster 16-18 [Adaboost]

(I) Muster 16 ~ Standard ~

Teilen Sie die Daten.

#Datenaufteilung
y = df["state"].values
X = df.drop("state", axis=1).values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1234)

Wir erstellen ein Modell von Adaboost und überprüfen dessen Richtigkeit.

clf = AdaBoostClassifier(DecisionTreeClassifier(random_state=1234))
clf.fit(X_train, y_train)

clf.score(X_test, y_test)

Die Genauigkeit beträgt jetzt ** 0,63947 **.

(Ii) Muster 17 ~ Hyper Parameter Tuning ~

#Datenaufteilung
y = df["state"].values
X = df.drop("state", axis=1).values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1234)

#Hyper-Parameter-Tuning
parameters = {'learning_rate':[0.1,0.5,1.0]}
model = AdaBoostClassifier(random_state=1234)
clf = GridSearchCV(model, parameters, cv=3,)
clf.fit(X_train, y_train)
print(clf.best_params_, clf.best_score_)

#Trainieren Sie die Lernenden mit optimalen Parametern
clf = AdaBoostClassifier(**clf.best_params_,random_state=1234)
clf.fit(X_train, y_train)

#Bestätigen Sie die Genauigkeit mit den Testdaten
clf.score(X_test, y_test)

Die Genauigkeit betrug ** 0,67426 **.

(Iii) Muster 18-Hyper-Parameter-Tuning + Funktionsauswahl-

#Datenaufteilung
y = df["state"].values
X = df.drop("state", axis=1).values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1234)

#Merkmalsauswahl
estimator = LassoCV(normalize = True, cv = 10, random_state = 1234)
sfm = SelectFromModel(estimator, threshold = 1e-5)
sfm.fit(X_train,y_train)

#Trainingsdaten mit ausgewählten Funktionen überschreiben
X_train_selected = sfm.transform(X_train)
X_test_selected = sfm.transform(X_test)

#Hyper-Parameter-Tuning
parameters = {'learning_rate':[0.1,0.5,1.0]}
model = AdaBoostClassifier(random_state=1234)
clf = GridSearchCV(model, parameters, cv=3)
clf.fit(X_train_selected, y_train)
print(clf.best_params_, clf.best_score_)

#Trainieren Sie die Lernenden mit optimalen Parametern
clf = AdaBoostClassifier(**clf.best_params_,random_state=1234)
clf.fit(X_train_selected, y_train)

#Bestätigen Sie die Genauigkeit mit den Testdaten
clf.score(X_test_selected, y_test)

Die Genauigkeit betrug ** 0,659367 **.

4. Fazit

Was haben Sie gedacht.

Überraschenderweise denke ich, dass es nur wenige Websites gibt, auf denen grundlegende Methoden zur Modellbildung eingeführt werden, und ich denke immer: "Ich möchte nicht so fortgeschrittene Dinge wissen, ich möchte nur einmal ein Modell erstellen!" Ich tat.

Dieser Artikel konzentriert sich auf meine eigenen Probleme, daher hoffe ich, dass er dazu beiträgt, mein Verständnis zu vertiefen.