[PYTHON] C'est normal de tomber sur Titanic! Présentation de la stratégie Kaggle pour les super débutants

J'ai commencé Kaggle, mais je ne suis pas sûr à l'époque du Titanic!

Certaines personnes se sont inscrites auprès de Kaggle et ont regardé le tutoriel sur Titanic, mais ne sont pas certaines de ce qu'elles font.

De plus, même si Titanic peut être réalisé dans une certaine mesure, il est difficile de comprendre comment l'utiliser dans d'autres analyses.

Donc cette fois, je vais vous expliquer les étapes à suivre avec Kaggle même si vous êtes au niveau de travailler sur Titanic avec Kaggle.

Dans cet article, nous utiliserons l'ensemble de données Ayame, qui est inclus dans la bibliothèque Python au lieu de Titanic, pour classer les variétés.

Commençons par importer les bibliothèques et les données nécessaires.

Importez les bibliothèques et les données requises

Que vous fassiez du Titanic avec Kaggle ou que vous résolviez des problèmes au-delà de cela, vous devez d'abord disposer des outils dont vous avez besoin.

Si vous ne le faites pas, vous obtiendrez une erreur même si vous écrivez le code, alors soyez prudent.

import numpy as np
import pandas as pd
from pandas import DataFrame, Series
#numpy est utilisé pour le calcul et pandas est utilisé pour le traitement des données.

from sklearn.datasets import load_iris
#Emprunter les données d'origine
from sklearn import datasets
#Rendre les données disponibles dans les pandas
from sklearn.model_selection import train_test_split
#Utilisé pour diviser les données
from sklearn.linear_model import LogisticRegression
#Utilisez ceci cette fois pour l'apprentissage automatique

import matplotlib.pyplot as plt
import seaborn as sns
#Les deux sont utilisés pour faire un diagramme

Nous aborderons ici la manière dont chaque bibliothèque est utilisée.

numpy est utilisé pour le calcul des données et pandas est utilisé pour le traitement des données lues.

sklearn contient des ensembles de données et des méthodes d'apprentissage automatique librement utilisables.

Ici, les données décrivant les caractéristiques et le nom de la variété d'Ayame sont lues.

Il charge également ce qui rend les données utilisables dans les pandas et ce qui est nécessaire pour diviser les données.

Nous vous expliquerons comment diviser les données plus tard.

matplotlib et seaborn sont utilisés pour tracer et visualiser des données données.

Parfois, le simple fait de regarder les données peut être un indice de ce que vous ne pouvez pas comprendre ou de penser à votre prochaine stratégie.

Regardez la vue d'ensemble des données pour voir s'il y a des valeurs manquantes

Maintenant que nous avons chargé la bibliothèque, jetons un œil aux données de l'iris utilisé cette fois.

iris = load_iris()#Lire les données d'iris
df = pd.DataFrame(iris.data, columns=iris.feature_names)#Rendre les données visibles dans les blocs de données

df.head()#Voir uniquement le début des données
df.describe()#Voir une vue d'ensemble des données

Le début des données

Vue d'ensemble des données

J'ai lu les données et essayé de donner un aperçu et la partie de début.

La longueur du sépale écrite ici est la longueur de la pièce, la largeur du sépale est la largeur de la pièce, la longueur des pétales est la longueur des pétales et la largeur des pétales est la largeur des pétales.

Les informations ici caractérisent les variétés d'Ayame et sont appelées «quantité de caractéristiques».

Ces données ont un total de 150 données, et il existe trois types.

Cependant, par souci de simplicité, nous nous concentrerons sur deux types.

df = df[:100]

À partir de là, voyons s'il manque quelque chose dans les données appelé «valeur manquante».

Imaginons un livre de référence d'étude ici.

Lorsque nous regardons le livre de référence, nous pouvons en quelque sorte le rattraper dans notre esprit et comprendre les erreurs ou les parties invisibles.

Cependant, le programme "reconnaît" les informations saisies telles quelles, donc une erreur est affichée.

Par conséquent, il est nécessaire de le vérifier à la première étape.

df.isnull().sum()

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

Heureusement, il n'y avait aucune valeur manquante ici.

Dans le cas peu probable où quelque chose se produirait, vous devrez faire quelque chose comme remplir les nombres tels que la valeur moyenne ou exclure les parties manquantes, alors gardez à l'esprit.

Divisez les données et préparez-les pour l'apprentissage

Puisque nous avons lu les données et confirmé qu'il n'y a aucune valeur manquante, nous commencerons par diviser les données.

y = pd.Series(data=iris.target)
y = y[:100]
#Puisque y est le nom de la variété d'iris, convertissez-le en nombre.
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)

Cette fois, 10% ont été répartis au hasard et prélevés pour être testés à partir des données lues.

S'il s'agit d'un concours régulier, le livre de référence sera remis sous forme de données de formation et les questions d'examen seront distribuées sous forme de données de test.

Cependant, cette fois-ci, une telle chose n'existe pas, donc 10% extraits au hasard des données seront utilisés comme questions d'examen.

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)

Ensuite, 20% sont extraits au hasard des données restantes et utilisés comme exercice.

Ici, laissez AI apprendre, mais n'utilisez que les données qui n'ont été récupérées qu'à la fin.

Vous vous demandez peut-être pourquoi les données d'entraînement sont davantage divisées.

C'est pour s'assurer qu'il n'y a pas de différence entre la partie restante et les exercices.

Lorsque nous étudions pour un test à l'école, nous mémorisons tous les livres de référence, mais parfois cela ne mène à rien.

Cela peut également se produire par programmation et s'appelle «surapprentissage».

Pour voir si cela se produit, étudiez les pages qui restent jusqu'à la fin et consultez les exercices pour voir si vous étudiez uniquement les pages qui restent.

Si cela se produit, vous devez revoir comment vous apprenez.

Vérifiez le résultat appris

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)

Seule la partie qui reste jusqu'à la fin est utilisée pour l'apprentissage en utilisant l'une des méthodes utilisées pour l'IA (intelligence artificielle).

Comparez le taux de réponse correct en utilisant les données qui ont été utilisées à nouveau pour l'entraînement et les données extraites pour l'exercice.

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

Lorsque je l'ai vérifié, il ne semblait y avoir pratiquement aucun problème.

Ensuite, passons au test de production avec ce que nous avons appris. Je fais une réponse ici.

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

Ensuite, nous vérifierons le taux de réponse correct.

np.mean(y_pred==y_test)

1.0

Quand on m'a demandé de marquer automatiquement, il n'y avait presque aucun problème.

Dans la compétition habituelle, la direction a la réponse. Veuillez également noter que seules certaines données seront notées.

Lorsque nous travaillons sur Titanic avec Kaggle, nous le faisons aussi!

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

Ici, la relation entre les quantités de caractéristiques est affichée.

Je ne l'ai pas fait cette fois, mais il est possible de combiner plusieurs choses pour en créer une nouvelle.

En outre, il existe différentes méthodes utilisées pour l'IA (intelligence artificielle).

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)

Chaque méthode d'apprentissage a ses avantages et ses inconvénients.

Par conséquent, combiner plusieurs apprentissages pour améliorer la précision est appelé «apprentissage d'ensemble».

np.mean(pred==y_test)

1.0

Cette fois, j'ai expliqué l'utilisation de l'ensemble de données d'Ayame au lieu de Titanic afin que même les personnes qui ne connaissent pas Kaggle et qui travaillent sur l'analyse de Titanic puissent comprendre la configuration minimale nécessaire avec Kaggle.

L'exigence minimale est de lire les bibliothèques et les données nécessaires, de vérifier l'image globale des données pour les valeurs manquantes, de diviser les données pour qu'elles puissent être apprises, et enfin de s'entraîner et de vérifier l'exactitude. Assurer.

Lors de la saisie d'une analyse à grande échelle telle que Titanic avec Kaggle, il est nécessaire de concevoir comme voir la relation entre les quantités de caractéristiques et utiliser plusieurs méthodes d'apprentissage.

En plus de Titanic, Kaggle dispose également d'un environnement pour discuter de choses que vous ne comprenez pas ou que vous avez des ensembles de données pour les débutants.

On dit que le Titanic est le bonjour du monde de Kaggle, mais travaillons dessus afin que nous puissions analyser diverses données tout en procédant régulièrement sans nous précipiter.

Enfin, je vais résumer le code utilisé cette fois.

Ce code

import numpy as np
import pandas as pd
from pandas import DataFrame, Series
#numpy est utilisé pour le calcul et pandas est utilisé pour le traitement des données.

from sklearn.datasets import load_iris
#Emprunter les données d'origine
from sklearn import datasets
#Rendre les données disponibles dans les pandas
from sklearn.model_selection import train_test_split
#Utilisé pour diviser les données
from sklearn.linear_model import LogisticRegression
#Utilisez ceci cette fois pour l'apprentissage automatique

import matplotlib.pyplot as plt
import seaborn as sns
#Les deux sont utilisés pour faire un diagramme

iris = load_iris()#Lire les données d'iris
df = pd.DataFrame(iris.data, columns=iris.feature_names)#Rendre les données visibles dans les blocs de données
df.head()#Voir uniquement le début des données
df.describe()#Voir une vue d'ensemble des données
df = df[:100]#Limitez les types d'iris à seulement deux types
df.isnull().sum()#Visualisez les valeurs manquantes

y = pd.Series(data=iris.target)
y = y[:100]
#Puisque y est le nom de la variété d'iris, convertissez-le en nombre.
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)
#Divisez les données en données d'entraînement et de test, puis divisez davantage les données d'entraînement en entraînement et exercice

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(Intelligence artificielle)Vérifiez le surapprentissage en utilisant l'une des méthodes utilisées dans

y_pred = lg.predict(x_test)
y_pred
y_test
np.mean(y_pred==y_test)
#Vérifiez le taux de réponse correct en vérifiant les données du test avec ce que vous avez appris

sns.heatmap(df.corr(),annot=True,cmap='bwr',linewidths=0.2) 
fig=plt.gcf()
fig.set_size_inches(5,4)
plt.show()
#Visualisez la relation entre chaque fonctionnalité

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)
#Apprentissage d'ensemble et bonne IA(Intelligence artificielle)Combinez certaines des techniques utilisées dans