Modell, Vorhersage, Lösung

Jetzt können Sie Ihre Trainingsdaten trainieren, ein Modell erstellen und Vorhersagen treffen. Es gibt über 60 Algorithmen für maschinelles Lernen, mit denen Sie modellieren können.

In der Praxis müssen Sie die Art des Problems und die Anforderungen der Lösung verstehen und den richtigen Algorithmus auswählen. Die Tabelle zeigt, welche Art von Algorithmus entsprechend der Art des zu lösenden Problems und der Anzahl der Datenelemente ausgewählt werden sollte. Es ist für die Öffentlichkeit zugänglich. Lassen Sie uns diese Informationen gut nutzen.

scikit-learn argorithm cheat sheet

Vorhersageprobleme können in zwei Kategorien unterteilt werden: Klassifizierung und Regression.

1, Klassifizierung

Die Klassifizierung kann durch Aufteilen von Daten in Klassen vorhergesagt werden Mit der Regression können Sie Zahlen aus den Daten vorhersagen. Auf der linken Seite der folgenden Abbildung wird beispielsweise eine Klassifizierungslinie aus den Daten gezogen und in Klasse A und Klasse B unterteilt.

Da die neuen Daten ☆ zur Seite der Klasse A gehören, kann vorausgesagt werden, dass sie Klasse A sind. Auf der rechten Seite der folgenden Abbildung wird eine Regressionslinie aus den Daten gezogen, um den vorhergesagten Wert neuer Daten obtain zu erhalten. Diese Mechanismen werden verwendet, um zu identifizieren, ob ein Bild ein Hund oder eine Katze ist, um vorherzusagen, ob Geräte kaputt gehen oder nicht, und um Verkäufe zu prognostizieren. Es wurde angewendet und ist bei uns überfüllt.

Im Folgenden finden Sie einige typische Klassifizierungs- und Regressionsalgorithmen.

Logistische Regression
k-NN oder k-Nächste Nachbarn
Vektormaschine unterstützen
Naiver Bayes-Klassifikator
Entscheidungsbaum
Zufälliger Wald
Perceptron
neurales Netzwerk

Hier ist ein Beispiel für die Datenaufbereitung.

import pandas as pd
import matplotlib.pyplot as plt
%matplotlib inline


#Maschinelles Lernen
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC, LinearSVC
from sklearn.ensemble import RandomForestClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.linear_model import Perceptron
from sklearn.linear_model import SGDClassifier
from sklearn.tree import DecisionTreeClassifier


# 1. X_Für Zug, Zug ohne Überleben_Ersatz df.
X_train = train_df.drop("Survived", axis=1)

# 2. Y_Zug enthält nur überlebt_Ersatz df.
Y_train = train_df["Survived"]

# 3. X_Zum Testen Test ohne PassengerId_Ersatz df.
X_test  = test_df.drop("PassengerId", axis=1).copy()

# 4. X_train、Y_train、X_Gibt die Anzahl der Testzeilen und -spalten aus.
print(X_train.shape, Y_train.shape, X_test.shape)

Logistische Rückgabe

Die logistische Regression verwendet eine logistische Funktion (Sigmoid-Funktion), um Binome zu klassifizieren. Mit anderen Worten, es ist möglich zu klassifizieren, ob die Zielvariable Survived 0 oder 1 ist, und sie zur Vorhersage zu verwenden. Verwenden Sie andere erklärende Variablen wie Pclass und Age als Survived, um das Modell zu erstellen. Die Sigmoidfunktion hat im Allgemeinen die in der folgenden Abbildung gezeigte Form und nimmt einen Wert zwischen 0 und 1 an.

Logistische Regression mit Python Sklearn. passen und vorhersagen, mit Argument C regulieren

from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
X_train_lr, X_test_lr, Y_train_lr, Y_test_lr = train_test_split(X_train, Y_train, test_size=0.2)


# 1.Trainingsdaten X._train_lr und Y._train_Erstellen Sie ein Klassifizierungsmodell durch logistische Regression mit lr.
logreg = LogisticRegression()
logreg.fit(X_train_lr, Y_train_lr)

# 2.Testdaten X._test_Wenden Sie das erstellte Modell auf lr und die Genauigkeit des Modells an.
acc_log = round(logreg.score(X_test_lr, Y_test_lr) * 100, 2)

print(acc_log)

from sklearn.linear_model import LogisticRegression

# 1.Berechnen Sie den partiellen Regressionskoeffizienten für jedes Merkmal
coeff_df = pd.DataFrame(train_df.columns.delete(0))
coeff_df.columns = ['Feature']
coeff_df["Partial regression coefficient"] = pd.Series(logreg.coef_[0])

coeff_df.sort_values(by="Partial regression coefficient", ascending=False)

Unterstützung Vektormaschine

Support Vector Machine (SVM) ist ein Algorithmus zur Klassifizierung und Regression. Das Lernen findet statt, weil die Daten mithilfe einer als Kernel-Methode bezeichneten Methode von nichtlinear in linear konvertiert werden. Die Bearbeitungszeit ist kurz.

Je breiter die Trennlinie (Rand) ist, desto weniger wahrscheinlich ist eine Überanpassung und desto einfacher lässt sich das Modell verallgemeinern. Je kleiner die Breite ist, desto wahrscheinlicher ist es jedoch, dass eine Überanpassung auftritt und das Modell nur in bestimmte Daten passt. Wenn Sie SVM verwenden, können Sie ein Modell erstellen, indem Sie mehrere Parameter einschließlich der Breite anpassen. Das Modell hat eine relativ hohe Klassifizierungsgenauigkeit.

# 1.Erstellen Sie mit der SVC-Funktion ein Klassifizierungsmodell und überprüfen Sie die Genauigkeit des Modells.
svc = SVC()
svc.fit(X_train, Y_train)

Y_pred = svc.predict(X_test)
acc_svc = round(svc.score(X_train, Y_train) * 100, 2)

print(acc_svc)

# 2.Erstellen Sie ein Klassifizierungsmodell mit der Funktion LinearSVC und überprüfen Sie die Genauigkeit des Modells
linear_svc = LinearSVC()
linear_svc.fit(X_train, Y_train)

Y_pred = linear_svc.predict(X_test)
acc_linear_svc = round(linear_svc.score(X_train, Y_train) * 100, 2)

print(acc_linear_svc)

k-Nächste Nachbarn

Die Methode k-Nearest Neighbors (oder kurz k-NN) ist ein Klassifizierungsalgorithmus.

Neue Daten werden mit der Mehrheit der bereits kategorisierten Daten kategorisiert. Wenn in der folgenden Abbildung beispielsweise 3 Daten (k = 3) mit Stimmenmehrheit vorhanden sind, werden die neuen Daten als rot eingestuft. Wenn 5 Daten (k = 5) mit Stimmenmehrheit vorliegen, werden die neuen Daten blau klassifiziert.

# 1. k-Erstellen Sie ein Klassifizierungsmodell nach der NN-Methode und überprüfen Sie die Genauigkeit des Modells.
knn = KNeighborsClassifier(n_neighbors = 3)
knn.fit(X_train, Y_train)

Y_pred = knn.predict(X_test)
acc_knn = round(knn.score(X_train, Y_train) * 100, 2)

print(acc_knn)

Naiver Bayes-Klassifikator

Naive Bayes ist ein Klassifizierungsalgorithmus. Es wird häufig hauptsächlich zur Klassifizierung von Dokumenten verwendet, und seine Anwendung auf Spamfilter ist bekannt. Naive Bayes verwendet bedingte Wahrscheinlichkeiten, genau wie "naiv" auf Japanisch "einfach" bedeutet. Es kann präzise implementiert werden. Betrachten Sie nun die Klassifizierung von Artikeln in die Kategorien A und B.

Angenommen, Sie haben eine beschriftete Word-Dokumentmatrix. Aus dieser Word-Dokumentmatrix Erstellen Sie eine Wortvorkommensverteilung für Kategorie A und Kategorie B. Sie können sehen, dass die Form der Verteilung für jede Kategorie unterschiedlich ist und die Merkmale unterschiedlich sind.

Erstellen Sie eine Distribution für unbeschriftete Artikel auf die gleiche Weise, je nachdem, wie nahe sie an der zuvor erstellten Distribution (Modell) liegt. Sie können Kategorien zuweisen.

# 1.Erstellen Sie ein Klassifizierungsmodell von Naive Bayes und überprüfen Sie die Genauigkeit des Modells.
gaussian = GaussianNB()
gaussian.fit(X_train, Y_train)

Y_pred = gaussian.predict(X_test)
acc_gaussian = round(gaussian.score(X_train, Y_train) * 100, 2)

print(acc_gaussian)

Perzeptron

Perceptron ist ein Klassifizierungsalgorithmus. Es wurde durch Nachahmung der Funktion von Neuronen (Nervenzellen) im menschlichen Gehirn geschaffen. Die Eingabedaten werden gewichtet und hinzugefügt, und die Aktivierungsfunktion wird zum Konvertieren und Ausgeben angewendet.

Als Aktivierungsfunktion

Wird oft von Schrittfunktionen verwendet.

Die Schrittfunktion konvertiert den Ausgabewert in 1, wenn der Eingabewert 0 oder mehr ist, und konvertiert den Ausgabewert in 0, wenn der Eingabewert kleiner als 0 ist. Wenn der Wert des Knotens ● ist, ist der Ausgabewert ▲, dh 1, wenn er von der Schrittfunktion konvertiert wird.

Sie können ein neuronales Netzwerk erstellen, indem Sie mehrere Perceptrons kombinieren.

# 1.Erstellen Sie ein Klassifizierungsmodell von Perceptron und überprüfen Sie die Genauigkeit des Modells.
perceptron = Perceptron()
perceptron.fit(X_train, Y_train)

Y_pred = perceptron.predict(X_test)
acc_perceptron = round(perceptron.score(X_train, Y_train) * 100, 2)

print(acc_perceptron)

Probabilistische Gradientenabstiegsmethode

Während der Modellierung mit Perceptron Das Modell wird so trainiert, dass der Fehler zwischen der Ausgabe und der Zielvariablen (richtige Antwort) gering ist. Zu diesem Zeitpunkt wird das Gewicht unter Verwendung der Gradientenabstiegsmethode aktualisiert, so dass der Fehler klein ist.

Der untere Rand der Fehlerkurve ist der optimale Wert (optimale Lösung) des Gewichts, der den Fehler minimiert. Ausgehend vom Anfangswert des Gewichts × ergibt sich durch Erhöhen und Aktualisieren des Gewichtswerts der optimale Gewichtswert ●.

Der Betrag der Gewichtsaktualisierung kann durch Berechnen der Steigung erhalten werden, die von dem Quadrat in der Figur umgeben ist. Zeichnen Sie eine Linie (Tangentenlinie), die die Fehlerkurve berührt, und berechnen Sie die Steigung (Differenzkoeffizient) basierend auf dem Ausmaß der Änderung des Fehlers und des Gewichts.

Das Gewicht wird aktualisiert, sodass der Fehler kleiner als ein bestimmter Wert ist oder die angegebene Anzahl von Malen aktualisiert wird. Bei der Gradientenabstiegsmethode wird nach dem optimalen Wert gesucht, während der Abstieg zum unteren Rand der Kurve erfolgt. Insbesondere wenn die Trainingsdaten in mehrere Teile unterteilt und mehrfach berechnet werden, spricht man von der probabilistischen Gradientenabstiegsmethode.

# 1.Erstellen Sie ein Klassifizierungsmodell mit der Methode des probabilistischen Gradientenabfalls und überprüfen Sie die Genauigkeit des Modells.
sgd = SGDClassifier()
sgd.fit(X_train, Y_train)

Y_pred = sgd.predict(X_test)
acc_sgd = round(sgd.score(X_train, Y_train) * 100, 2)

print(acc_sgd)

Entscheidungsbaum

Der Entscheidungsbaum ist ein Algorithmus zur Klassifizierung und Regression. Wenn Sie einen Entscheidungsbaum verwenden, werden die aus den Daten extrahierten Regeln in einer Baumstruktur dargestellt. Es ist als benutzerfreundlicher Algorithmus bekannt, da er intuitiv und für Menschen leicht zu erklären ist.

Die Zielvariable in der Abbildung ist label, und die erklärenden Variablen sind a1 bis a4. Der Entscheidungsbaum besteht aus Knoten.

Der oberste Knoten wird als "Baumwurzelknoten" und der Endknoten als "Blattknoten" bezeichnet. Die Verzweigung des Entscheidungsbaums ist eine Bedingung der Regel. Wenn beispielsweise der Wert des Knotens a3 2,45 und der Wert des Knotens a4 1,75 überschreitet, Ayame-Blüten werden als "Iris-virginica" klassifiziert.

Außerdem sind die Variablen, die die Klassifizierung beeinflussen, in der Reihenfolge vom Wurzelknoten zum Blattknoten angeordnet. Je monochromatischer der Blattknoten ist, desto höher ist die Reinheit. Der Versuch, die Reinheit zu erhöhen, verkompliziert die Regeln und verbessert die Genauigkeit des Modells, kann jedoch zu einer Überanpassung führen.

# 1.Erstellen Sie ein Klassifizierungsmodell basierend auf dem Entscheidungsbaum und überprüfen Sie die Genauigkeit des Modells.
decision_tree = DecisionTreeClassifier()
decision_tree.fit(X_train, Y_train)

Y_pred = decision_tree.predict(X_test)
acc_decision_tree = round(decision_tree.score(X_train, Y_train) * 100, 2)

print(acc_decision_tree)

Zufälliger Wald

Random Forest ist ein Algorithmus zur Klassifizierung und Regression. Eine der Lernmethoden des Ensembles (Klassifikatoren, die aus dem Sammeln mehrerer Klassifikatoren bestehen) Bäume werden zusammengetragen und als Wald bezeichnet, da sie eine große Anzahl von Entscheidungsbäumen bilden (n_estimators = 100).

# 1.Erstellen Sie ein Klassifizierungsmodell mit einer zufälligen Gesamtstruktur und überprüfen Sie die Genauigkeit des Modells.
random_forest = RandomForestClassifier(n_estimators=100)
random_forest.fit(X_train, Y_train)

Y_pred = random_forest.predict(X_test)
random_forest.score(X_train, Y_train)
acc_random_forest = round(random_forest.score(X_train, Y_train) * 100, 2)

print(acc_random_forest)

Modellbewertung

Ordnen Sie die Genauigkeit aller Modelle und wählen Sie das beste Modell für die Problemlösung aus.

#Listen Sie die Genauigkeit jedes Modells auf
models = pd.DataFrame({
    'Model': ['Support Vector Machines', 'KNN', 'Logistic Regression', 
              'Random Forest',  
              'Linear SVC', 
              'Decision Tree'],
    'Score': [acc_svc, acc_knn, acc_log, 
              acc_random_forest,  
              acc_linear_svc, acc_decision_tree]})

models.sort_values(by='Score', ascending=False)

#Speichern Sie das zufällige Gesamtstrukturmodell in einer CSV-Datei.
submission = pd.DataFrame({
        "PassengerId": test_df["PassengerId"],
        "Survived": Y_pred
    })

submission.to_csv('./8010_titanic_data/submission.csv', index=False)

Python: Schiffsüberlebensvorhersage Teil 3