[PYTHON] Es ist okay, über die Titanic zu stolpern! Einführung in die Kaggle-Strategie für Super-Anfänger

Ich habe Kaggle gestartet, bin mir aber zur Zeit der Titanic nicht sicher!

Einige von Ihnen haben sich vielleicht bei Kaggle registriert und das Tutorial zur Titanic angesehen, aber Sie sind sich nicht sicher, was Sie tun.

Auch wenn die Titanic in gewissem Umfang durchgeführt werden kann, ist es schwierig zu verstehen, wie sie in anderen Analysen verwendet werden kann.

Dieses Mal werde ich erklären, welche Schritte Sie mit Kaggle unternehmen sollten, auch wenn Sie gerade mit Kaggle an der Titanic arbeiten.

In diesem Artikel verwenden wir den Ayame-Datensatz, der anstelle von Titanic in der Python-Bibliothek enthalten ist, um die Sorten zu klassifizieren.

Beginnen wir mit dem Importieren der erforderlichen Bibliotheken und Daten.

Importieren Sie die erforderlichen Bibliotheken und Daten

Egal, ob Sie Titanic mit Kaggle machen oder darüber hinaus Probleme angehen, Sie müssen zuerst die Werkzeuge haben, die Sie benötigen.

Wenn Sie dies nicht tun, wird eine Fehlermeldung angezeigt, auch wenn Sie den Code schreiben. Seien Sie also vorsichtig.

import numpy as np
import pandas as pd
from pandas import DataFrame, Series
#numpy wird zur Berechnung verwendet und pandas wird zur Datenverarbeitung verwendet.

from sklearn.datasets import load_iris
#Leihen Sie die Originaldaten aus
from sklearn import datasets
#Daten in Pandas verfügbar machen
from sklearn.model_selection import train_test_split
#Wird zum Teilen von Daten verwendet
from sklearn.linear_model import LogisticRegression
#Verwenden Sie diese Zeit für maschinelles Lernen

import matplotlib.pyplot as plt
import seaborn as sns
#Beide werden verwendet, um ein Diagramm zu erstellen

Hier werden wir darauf eingehen, wie jede Bibliothek verwendet wird.

numpy wird für die Datenberechnung verwendet und pandas wird für die Verarbeitung gelesener Daten verwendet.

sklearn enthält frei verwendbare Datensätze und verfügt über Methoden des maschinellen Lernens.

Hier werden die Daten gelesen, die die Merkmale und den Sortennamen von Ayame beschreiben.

Es wird auch geladen, was die Daten in Pandas verwendbar macht und was zum Aufteilen der Daten erforderlich ist.

Wir werden später erklären, wie die Daten aufgeteilt werden.

matplotlib und seaborn werden verwendet, um gegebene Daten aufzuzeichnen und zu visualisieren.

Manchmal kann schon das Betrachten der Daten ein Hinweis darauf sein, was Sie nicht verstehen oder über Ihre nächste Strategie nachdenken können.

Sehen Sie sich das Gesamtbild der Daten an, um festzustellen, ob Werte fehlen

Nachdem wir die Bibliothek geladen haben, werfen wir einen Blick auf die Daten der diesmal verwendeten Iris.

iris = load_iris()#Irisdaten lesen
df = pd.DataFrame(iris.data, columns=iris.feature_names)#Machen Sie Daten in Datenrahmen sichtbar

df.head()#Sehen Sie nur den Anfang der Daten
df.describe()#Sehen Sie das Gesamtbild der Daten

Der Anfang der Daten

Gesamtbild der Daten

Ich habe die Daten gelesen und versucht, einen Überblick und den Anfangsteil zu geben.

Die hier angegebene Sepallänge ist die Länge des Stücks, die Sepalbreite ist die Breite des Stücks, die Blütenblattlänge ist die Länge der Blütenblätter und die Blütenblattbreite ist die Breite der Blütenblätter.

Die Informationen hier charakterisieren die Sorten von Ayame und werden als "Merkmalsmenge" bezeichnet.

Diese Daten haben insgesamt 150 Daten und es gibt drei Arten.

Der Einfachheit halber werden wir uns jedoch auf zwei Typen konzentrieren.

df = df[:100]

Lassen Sie uns von hier aus sehen, ob in den Daten "fehlender Wert" etwas fehlt.

Stellen wir uns hier ein Nachschlagewerk für Studien vor.

Wenn wir uns das Nachschlagewerk ansehen, können wir es in unseren Gedanken irgendwie wieder gut machen, wenn es Fehler oder unsichtbare Teile gibt.

Das Programm "erkennt" die eingegebenen Informationen jedoch so, wie sie sind, sodass ein Fehler angezeigt wird.

Sie müssen also sicherstellen, dass es überhaupt nicht vorhanden ist.

df.isnull().sum()

sepal length (cm)    0
sepal width (cm)     0
petal length (cm)    0
petal width (cm)     0
dtype: int64

Zum Glück fehlten hier keine Werte.

In dem unwahrscheinlichen Fall, dass etwas passiert, müssen Sie beispielsweise die Zahlen wie den Durchschnittswert eingeben oder die fehlenden Teile ausschließen. Denken Sie also daran.

Teilen Sie die Daten und bereiten Sie sie für das Lernen vor

Da wir die Daten gelesen und bestätigt haben, dass keine Werte fehlen, werden wir zunächst mit der Aufteilung der Daten beginnen.

y = pd.Series(data=iris.target)
y = y[:100]
#Da y der Name der Iris-Sorte ist, konvertieren Sie ihn in eine Zahl.
x = df.loc[:,["sepal length (cm)","sepal width (cm)","petal length (cm)","petal width (cm)"]]

x_train, x_test, y_train, y_test =train_test_split(x, y, test_size = 0.1, train_size = 0.9, shuffle = True)

Dieses Mal wurden 10% zufällig aufgeteilt und zum Testen aus den gelesenen Daten herausgenommen.

Wenn es sich um einen regulären Wettbewerb handelt, wird das gesamte Nachschlagewerk als Trainingsdaten übergeben und die Prüfungsfragen als Testdaten verteilt.

Diesmal gibt es so etwas jedoch nicht, sodass 10%, die zufällig aus den Daten extrahiert wurden, als Prüfungsfragen verwendet werden.

x_Train, x_valid, y_Train, y_valid =train_test_split(x_train, y_train, test_size = 0.2, train_size = 0.8, shuffle = True)

Dann werden 20% zufällig aus den verbleibenden Daten extrahiert und als Übung verwendet.

Lassen Sie AI hier lernen, aber verwenden Sie nur die Daten, die bis zum Ende nicht abgerufen wurden.

Sie fragen sich vielleicht, warum die Trainingsdaten weiter unterteilt sind.

Dies soll sicherstellen, dass es keinen Unterschied zwischen dem verbleibenden Teil und den Übungen gibt.

Als wir in der Schule für einen Test lernten, haben wir alle Nachschlagewerke auswendig gelernt, aber manchmal führte das nicht zu einem Punkt.

Dies kann auch programmgesteuert geschehen und wird als "Überlernen" bezeichnet.

Um festzustellen, ob dies geschieht, studieren Sie die bis zum Ende verbleibenden Seiten und überprüfen Sie anhand der Übungen, ob Sie nur für die verbleibenden Seiten lernen.

In diesem Fall müssen Sie überprüfen, wie Sie lernen.

Überprüfen Sie das gelernte Ergebnis

lg = LogisticRegression()
lg.fit(x_Train, y_Train)

LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,
                   intercept_scaling=1, l1_ratio=None, max_iter=100,
                   multi_class='warn', n_jobs=None, penalty='l2',
                   random_state=None, solver='warn', tol=0.0001, verbose=0,
                   warm_start=False)

Nur der Teil, der bis zum Ende übrig bleibt, wird zum Lernen mit einer der für die KI verwendeten Methoden (künstliche Intelligenz) verwendet.

Vergleichen Sie die richtige Antwortrate anhand der Daten, die erneut für das Training verwendet wurden, und der Daten, die für die Übung extrahiert wurden.

print('Train Score: {}'.format(round(lg.score(x_Train, y_Train), 3)))
print(' Test Score: {}'.format(round(lg.score(x_valid, y_valid), 3)))

Train Score: 1.0
 Test Score: 1.0

Als ich es verifizierte, schien es fast kein Problem zu geben.

Dann gehen wir mit dem, was wir gelernt haben, zur Testproduktion. Ich mache hier eine Antwort.

y_pred = lg.predict(x_test)

y_pred
array([1, 1, 0, 0, 1, 0, 0, 0, 1, 0])

y_test
68    1
88    1
35    0
20    0
95    1
7     0
12    0
0     0
76    1
44    0
dtype: int64

Dann überprüfen wir die richtige Antwortrate.

np.mean(y_pred==y_test)

1.0

Als ich gebeten wurde, automatisch zu punkten, gab es fast kein Problem.

Im üblichen Wettbewerb hat die Managementseite die Antwort. Bitte beachten Sie auch, dass nur einige Daten ausgewertet werden.

Wenn wir mit Kaggle an der Titanic arbeiten, machen wir das auch!

sns.heatmap(df.corr(),annot=True,cmap='bwr',linewidths=0.2) 
fig=plt.gcf()
fig.set_size_inches(5,4)
plt.show()

Hier wird angezeigt, inwieweit die Merkmalsmengen miteinander in Beziehung stehen.

Diesmal habe ich es nicht gemacht, aber es besteht die Möglichkeit, mehrere Dinge zu kombinieren, um ein neues zu erstellen.

Darüber hinaus gibt es verschiedene Methoden für die KI (künstliche Intelligenz).

from sklearn.neural_network import MLPClassifier

mlpc = MLPClassifier(hidden_layer_sizes=(100, 100, 10), random_state=0)
mlpc.fit(x_Train, y_Train)

print('Train Score: {}'.format(round(mlpc.score(x_Train, y_Train), 3)))
print(' Test Score: {}'.format(round(mlpc.score(x_valid, y_valid), 3)))

Train Score: 1.0
 Test Score: 1.0

lg_pred = lg.predict_proba(x_test)
mlpc_pred = mlpc.predict_proba(x_test)

pred_proba = (lg_pred + mlpc_pred) / 2
pred = pred_proba.argmax(axis=1)

Jede Lernmethode hat ihre Vor- und Nachteile.

Daher wird das Kombinieren mehrerer Lernvorgänge zur Verbesserung der Genauigkeit als "Ensemble-Lernen" bezeichnet.

np.mean(pred==y_test)

1.0

Dieses Mal habe ich die Verwendung des Ayame-Datensatzes anstelle der Titanic erklärt, damit auch Personen, die Kaggle noch nicht kennen und an der Analyse der Titanic arbeiten, die minimal erforderlichen Einstellungen für Kaggle verstehen können.

Die Mindestanforderung besteht darin, die erforderlichen Bibliotheken und Daten zu lesen, das Gesamtbild der Daten auf fehlende Werte zu überprüfen, die Daten so zu teilen, dass sie gelernt werden können, und schließlich die Genauigkeit zu trainieren und zu überprüfen. Sichergehen.

Wenn Sie eine umfassende Analyse wie Titanic mit Kaggle eingeben, müssen Sie beispielsweise die Beziehung zwischen den Merkmalsmengen erkennen und mehrere Lernmethoden verwenden.

Neben der Titanic verfügt Kaggle auch über eine Umgebung, in der Dinge besprochen werden können, die Sie nicht verstehen, oder über Datensätze für Anfänger.

Die Titanic soll Kaggles Hallo-Welt sein, aber lassen Sie uns daran arbeiten, damit wir verschiedene Daten analysieren können, während wir ohne Eile stetig vorgehen.

Abschließend werde ich den diesmal verwendeten Code zusammenfassen.

Dieser Code

import numpy as np
import pandas as pd
from pandas import DataFrame, Series
#numpy wird zur Berechnung verwendet und pandas wird zur Datenverarbeitung verwendet.

from sklearn.datasets import load_iris
#Leihen Sie die Originaldaten aus
from sklearn import datasets
#Daten in Pandas verfügbar machen
from sklearn.model_selection import train_test_split
#Wird zum Teilen von Daten verwendet
from sklearn.linear_model import LogisticRegression
#Verwenden Sie diese Zeit für maschinelles Lernen

import matplotlib.pyplot as plt
import seaborn as sns
#Beide werden verwendet, um ein Diagramm zu erstellen

iris = load_iris()#Irisdaten lesen
df = pd.DataFrame(iris.data, columns=iris.feature_names)#Machen Sie Daten in Datenrahmen sichtbar
df.head()#Sehen Sie nur den Anfang der Daten
df.describe()#Sehen Sie das Gesamtbild der Daten
df = df[:100]#Grenzen Sie die Arten von Iris auf nur zwei Arten ein
df.isnull().sum()#Visualisieren Sie nach fehlenden Werten

y = pd.Series(data=iris.target)
y = y[:100]
#Da y der Name der Iris-Sorte ist, konvertieren Sie ihn in eine Zahl.
x = df.loc[:,["sepal length (cm)","sepal width (cm)","petal length (cm)","petal width (cm)"]]
x_train, x_test, y_train, y_test =train_test_split(x, y, test_size = 0.1, train_size = 0.9, shuffle = True)
x_Train, x_valid, y_Train, y_valid =train_test_split(x_train, y_train, test_size = 0.2, train_size = 0.8, shuffle = True)
#Teilen Sie die Daten in Trainings- und Testdaten auf und teilen Sie die Trainingsdaten weiter in Training und Training

lg = LogisticRegression()
lg.fit(x_Train, y_Train)

print('Train Score: {}'.format(round(lg.score(x_Train, y_Train), 3)))
print(' Test Score: {}'.format(round(lg.score(x_valid, y_valid), 3)))
#AI(Künstliche Intelligenz)Überprüfen Sie mit einer der in verwendeten Methoden, ob Sie zu viel gelernt haben

y_pred = lg.predict(x_test)
y_pred
y_test
np.mean(y_pred==y_test)
#Überprüfen Sie die richtige Antwortrate, indem Sie die Testdaten mit dem Gelernten überprüfen

sns.heatmap(df.corr(),annot=True,cmap='bwr',linewidths=0.2) 
fig=plt.gcf()
fig.set_size_inches(5,4)
plt.show()
#Visualisieren Sie die Beziehung zwischen den einzelnen Features

from sklearn.neural_network import MLPClassifier

mlpc = MLPClassifier(hidden_layer_sizes=(100, 100, 10), random_state=0)
mlpc.fit(x_Train, y_Train)

print('Train Score: {}'.format(round(mlpc.score(x_Train, y_Train), 3)))
print(' Test Score: {}'.format(round(mlpc.score(x_valid, y_valid), 3)))

lg_pred = lg.predict_proba(x_test)
mlpc_pred = mlpc.predict_proba(x_test)

pred_proba = (lg_pred + mlpc_pred) / 2
pred = pred_proba.argmax(axis=1)
np.mean(pred==y_test)
#Ensemble lernen und gute KI(Künstliche Intelligenz)Kombinieren Sie einige der in verwendeten Techniken