Résumé du flux de base de l'apprentissage automatique avec Python

J'ai récemment étudié l'apprentissage automatique, j'ai donc résumé les étapes à suivre lors de sa mise en œuvre en Python.

Prétraitement des données

Dans l'apprentissage automatique, il est d'abord nécessaire de lire les données et de connaître le type de distribution dont elles disposent. J'écrirai sur la procédure

Lire les données

Afin de lire réellement les données, lisez le fichier csv en utilisant la méthode appelée read_csv de pandas qui a été lue précédemment.

#Charger la bibliothèque
import pandas as pd
import numpy as np

#Hoge directement en dessous.Charger csv
df = pd.read_csv("./hoge.csv") 
#Extraire seulement 5 lignes du haut
df.head() 

Confirmation des données lues

En ce qui concerne l'apprentissage automatique, il existe une image selon laquelle si vous insérez les données, cela fera quelque chose, mais en réalité, vous devez regarder de près les données. Par exemple, y a-t-il des valeurs manquantes, y a-t-il trop de variations et y a-t-il des corrélations?

Statistiques de base

En entrant le code suivant, vous pouvez voir le nombre de données, la valeur moyenne, l'écart type, la valeur minimale, la valeur maximale, etc. à la fois.

#Calcul des statistiques
df.describe() 

Vous pouvez voir les statistiques de base dans une liste comme celle-ci

Confirmation de distribution

Cependant, il est difficile à comprendre simplement en regardant les nombres tels que l'écart type et la valeur moyenne, il est donc plus facile pour les humains de le comprendre dans un graphique. Par conséquent, il montre la distribution.

%matplotlib inline
#Chargement d'une bibliothèque qui affiche un graphique appelé seaborn
import seaborn as sns

#Confirmation de distribution
sns.distplot(df["x1"]) #Vérifiez d'abord les données (ici, vérifiez les données de la colonne x1)

Ce sont de bonnes données car les données semblent suivre une distribution normale

Confirmation du coefficient de corrélation

Si les données n'ont pas du tout de corrélation, il est inutile de les entraîner, alors vérifiez le coefficient de corrélation. Au fait, le coefficient de corrélation est compris entre -1 et +1 et plus il est élevé, plus il est corrélé.

#Calcul du coefficient de corrélation
df.corr()
#Vérifiez le coefficient de corrélation dans un graphique
sns.pairplot(df)

Séparation des variables d'entrée et des variables de sortie

En fait, nous allons créer quelque chose comme $ y = w0x0 + w1x1 + w2x2 + ... + $, nous devons donc diviser le contenu des données dans la variable de sortie y et la variable d'entrée x. À ce moment-là, la méthode appelée iloc des pandas est utilisée.

#df.iloc[ligne,Colonne]とすることでそのligneとColonneのデータを取り出せる
Exemple d'exemple= df.iloc[1,3]
Résultat 100
#Dernière colonne-Récupère toutes les lignes jusqu'à 1(Variable d'entrée X)
 X = df.iloc[:,:-1]
#On peut l'écrire comme ça, mais la polyvalence est faible
 X = df.iloc[:,:Numéro de la dernière colonne]

#Sortez y
 y = df.iloc[:,-1]

Apprentissage automatique à l'aide de données prétraitées

En faisant le travail ci-dessus, nous sommes prêts à effectuer un apprentissage automatique. Nous apprendrons en fait du prochain. Ici, la bibliothèque de machine learning scicit-learn est utilisée.

Diviser en données d'entraînement et données de vérification

Le but de l'apprentissage automatique était de former des données et de faire des prédictions lorsque des données inconnues étaient saisies. En d'autres termes, les données utilisées pour la formation ne sont pas utilisées. De toute évidence, si vous insérez les données utilisées pour l'apprentissage et faites une prédiction, vous obtiendrez une réponse précise parce que vous avez appris avec ces données, n'est-ce pas? Sera

Par conséquent, il est nécessaire de séparer les données d'entraînement (train) et les données de vérification (test) avant l'entraînement.

from sklearn.model_selection import train_test_split

#Séparation des données d'entraînement et des données de vérification
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.4,random_state=1)

testsize spécifie le rapport entre les données d'entraînement et les données de vérification, et ici il est défini comme apprentissage: entraînement = 6: 4. De plus, random_state est fixé pour maintenir la reproductibilité.

Construction / vérification du modèle

Avec scikit-learn, vous pouvez créer et vérifier le modèle avec juste le code suivant Le modèle utilisé pour la formation cette fois est l'analyse de régression multiple

#Importer la bibliothèque
from sklearn.linear_model import  LinearRegression

#Déclaration du modèle (la régression linéaire signifie une analyse de régression multiple)
model = LinearRegression()

#Formation du modèle (réglage des paramètres)
model.fit(X,y)

#Vérifier les paramètres
model.coef_

#Coefficient de décision(Précision de la prédiction) 0~Plus haut entre 1 est mieux
model.score(X,y)

#Calcul de la valeur prédite
x = X.iloc[0,:] #Sortez la première ligne de X
y_pred = model.predict([x])

Enregistrer / charger le modèle

Vous pouvez enregistrer le modèle avec le code suivant

#importer
from sklearn.externals import joblib

#Enregistrer le modèle (hoge.Enregistrer sous pkl
joblib.dump(model,"hoge.pkl")

Chargez le modèle avec le code suivant

#hoge.Chargement de pkl
model_new = joblib.load("hoge.pkl") 

#Afficher la valeur prévue du modèle chargé
model_new.predict([x])[0]

Ce qui précède est le flux de base de l'apprentissage automatique. Cette fois, le modèle a été réalisé par analyse de régression multiple, mais le flux de base est le même lorsque vous voulez l'exécuter avec une régression logistique ou SVM, par exemple.