[PYTHON] Vous serez ingénieur dans 100 jours ――Jour 82 ――Programmation ――À propos de l'apprentissage automatique 7

Cliquez ici jusqu'à hier

Cette fois, c'est la suite de l'histoire de l'apprentissage automatique.

À propos du modèle de classification

Je vais vous expliquer ce que vous pouvez faire avec l'apprentissage automatique pour la première fois, mais ce que vous pouvez faire avec l'apprentissage automatique Il y en a essentiellement trois.

· Revenir · Classification ・ Regroupement

En gros, cela devient «prédiction», mais la partie de ce qu'il faut «prédire» change.

・ Retour: prédire les valeurs numériques ・ Classification: Catégories de prédiction ・ Clustering: faites-vous sentir bien

Le «modèle de classification» permet de prédire la valeur de la catégorie.

Les données utilisées cette fois sont les données de ʻiris(Ayame) attachées àscikit-learn`.

sepal length (cm)	La longueur de la pièce
sepal width (cm)	Largeur de la pièce
petal length (cm)	Longueur des pétales
petal width (cm)	Largeur des pétales

Il existe trois types d'iris: «setosa», «versicolor» et «virginica».

Visualisation de données

Lisons les données et regardons les données.

from sklearn.datasets import load_iris
import pandas as pd
import numpy as np

#Lecture des données d'iris
iris = load_iris()
#Convertir en bloc de données
df = pd.DataFrame(np.concatenate((iris.data, iris.target.reshape(-1,1)), axis=1),columns=iris.feature_names + ['type'])
df.head()

	sepal length (cm)	sepal width (cm)	petal length (cm)	petal width (cm)
0	5.1	3.5	1.4	0.2
1	4.9	3	1.4	0.2
2	4.7	3.2	1.3	0.2
3	4.6	3.1	1.5	0.2
4	5	3.6	1.4	0.2

Il s'agit de 3 types de données Ayame (non rigides) et de 150 lignes de données numériques pour 4 colonnes. La dernière colonne «type» est la variété Ayame.

Puisqu'il existe trois types de données utilisées cette fois, les nombres sont «0», «1» et «2».

Visualisons quel type de fonctionnalités il apparaît.

import matplotlib.pyplot as plt
%matplotlib inline

#Stocker les données de visualisation dans des variables
x1 = df['petal length (cm)']
x2 = df['petal width (cm)']
y  = df['type']
x  = df[['petal length (cm)','petal width (cm)']]

#Dessiner des données
for i in range(3):
    plt.scatter(x1[y==i],x2[y==i],marker="x",label=i)
plt.legend()
plt.grid()
plt.show()

Il semble que les trois types d'Ayame soient assez bien séparés et assemblés.

Essayons maintenant la normalisation et la standardisation, qui sont l'une des méthodes de traitement des données d'apprentissage automatique.

Normalisation (normalisation min-max)

La normalisation est une méthode de conversion de la valeur minimale à l'échelle de 0 et de la valeur maximale à l'échelle de 1. Cependant, on dit que la méthode utilisant les valeurs minimum et maximum est fortement affectée par les valeurs maximum et minimum.

Valeur normalisée = (valeur-valeur minimale) / (valeur maximale-valeur minimale)

Standardisation (normalisation du score z)

La normalisation modifie la plage de données numériques de sorte que la moyenne soit de 0 et la distribution de 1. En faisant cela, on dit qu'il est plus résistant aux valeurs aberrantes que la normalisation.

Valeur standardisée = (valeur-moyenne) / écart-type

La normalisation peut réduire l'échelle des données et accélérer l'apprentissage.

Lorsque l'échelle entre chaque variable explicative est significativement différente (taille, poids, etc.) Des variables à plus grande échelle affectent l'apprentissage et peuvent être corrigées par la normalisation.

Méthode de normalisation

La normalisation et la standardisation peuvent être effectuées avec le code suivant.

Utilisez «MinMaxScaler» et «StandardScaler» comme bibliothèques.

** Répartition des données **

Commencez par diviser les données pour la formation et les tests. Cette fois, nous nous séparerons à 7: 3.

#Diviser les données
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3, random_state=3)

** Effectuer la normalisation **

#Effectuer la normalisation
from sklearn.preprocessing import MinMaxScaler
mms = MinMaxScaler()

#Normaliser les données d'entraînement
x_train_norm = mms.fit_transform(x_train)

#Normaliser les données de test en fonction des données d'entraînement
x_test_norm = mms.transform(x_test)

print('Données d'entraînement maximales: ' , x_train_norm.max())
print('Valeur minimale des données d'entraînement: ' , x_train_norm.min())
#La version de test est basée sur les données d'entraînement, elle peut donc être un peu différente.
print('Valeur maximale des données de test: ' , x_test_norm.max())
print('Valeur minimale des données de test: ' , x_test_norm.min())

Données d'entraînement maximales: 1.0 Données d'entraînement minimum: 0,0 Valeur maximale des données de test: 1.0357142857142858 Données de test minimum: -0.017857142857142877

** Normaliser **

#Standardiser
from sklearn.preprocessing import StandardScaler
ss = StandardScaler()

x_train_std = ss.fit_transform(x_train)
x_test_std  = ss.transform(x_test)

print('Valeur moyenne des données d'entraînement: ' , x_train_std.mean())
print('Écart type des données d'entraînement: ' , x_train_std.std())
#La version de test est basée sur les données d'entraînement, elle peut donc être un peu différente.
print('Valeur moyenne des données de test: ' , x_test_std.mean())
print('Écart type des données de test: ' , x_test_std.std())

Données d'entraînement moyennes: 3.425831047414769e-16 Écart type des données d'entraînement: 1.0000000000000002 Valeur moyenne des données de test: -0,1110109621182351 Écart type des données de test: 1.040586519459273

Lorsqu'elle est normalisée, la moyenne est proche de 0.

Voyons la différence entre le résultat de la normalisation et de la standardisation et les données d'origine.

#Visualisez les données d'origine après normalisation et standardisation
x_norm = mms.transform(x)
x_std  = ss.transform(x)
plt.axis('equal')
plt.scatter(x.iloc[:,0],x.iloc[:,1], marker="x", label="org" ,c='blue')
plt.scatter(x_std[:,0] ,x_std[:,1] , marker="x", label="std" ,c='red')
plt.scatter(x_norm[:,0],x_norm[:,1], marker="x", label="norm",c='green')
plt.legend()
plt.grid()
plt.show()

Le bleu est la valeur d'origine, le rouge les données normalisées et le vert les données normalisées. Vous pouvez voir que les distributions possibles ont considérablement changé.

Créer un modèle prédictif

Voyons la différence entre les résultats d'entraînement machine de la normalisation, les données standardisées et les données d'origine. Ce qui suit produit le résultat de la classification à l'aide de «Régression logistique». Plus la valeur du score est élevée, meilleure est la précision.

#Charger un modèle de régression logistique
from sklearn.linear_model import LogisticRegression
lr      = LogisticRegression(solver='liblinear', multi_class='auto')
lr_norm = LogisticRegression(solver='liblinear', multi_class='auto')
lr_std  = LogisticRegression(solver='liblinear', multi_class='auto')

lr.fit(x_train,y_train)
print('Partition des données d'origine:',lr.score(x_train,y_train))

lr_norm.fit(x_train_norm,y_train)
print('Score des données normalisées:',lr_norm.score(x_train_norm,y_train))

lr_std.fit(x_train_std,y_train)
print('Score de données standardisé:',lr_std.score(x_train_std,y_train))

Partition des données d'origine: 0.8666666666666667 Score de données normalisé: 0.8095238095238095 Score des données normalisées: 0,9523809523809523

La précision des données normalisées est beaucoup plus élevée.

Le modèle discriminant délivre finalement la valeur prédite de la variable objective. Dans ce cas, affichez l'une des valeurs «0», «1», «2» comme valeur de catégorie et vérifiez si le résultat correspond aux données de test. Je mesure la précision.

La méthode de vérification de l'exactitude est la même que celle utilisée dans la conférence de la veille «À propos de Machine Learning 5».

Type de modèle de classification

Voici quelques autres modèles de classification.

** Arbre de décision **

Référence: wikipedia

En parlant de classification, c'est une méthode qui est souvent utilisée comme s'il s'agissait de celle-ci. En cours d'apprentissage, il se ramifie en fonction de la valeur de la variable, et enfin c'est un modèle qui peut être visualisé sous la forme d'un arbre.

** Forêt aléatoire **

C'est un algorithme «d'apprentissage d'ensemble» qui utilise un arbre de décision comme un apprenant faible. À l'origine, il s'agit d'un arbre de décision, mais plusieurs arbres de décision sont créés au hasard et disposés en parallèle pour prendre une décision à la majorité sur les résultats.

** Arbre de décision d'amélioration du dégradé **

Il est abrégé en GBDT (Gradient Boosting Decision Tree). Ceci est également appris sur la base de l'arbre de décision, et l'apprentissage est répété afin de réduire l'erreur du résultat. C'est une technique pour tirer la conclusion finale en faisant cela. Plus vous en apprenez, meilleure est la précision.

La méthode courante actuelle est appelée «boosting».

Les deux sont inclus dans la bibliothèque scikit-learn, vous pouvez donc les expérimenter.

Résumé

Aujourd'hui, j'ai expliqué le fonctionnement du modèle de classification. Il existe de nombreux autres modèles de classification.

Tout d'abord, commençons par ce qu'est la classification et supprimons comment créer un modèle et comment le vérifier.

18 jours jusqu'à ce que vous deveniez ingénieur

Informations sur l'auteur

HP d'Otsu py: http://www.otupy.net/

Youtube： https://www.youtube.com/channel/UCaT7xpeq8n1G_HcJKKSOXMw

Twitter： https://twitter.com/otupython

	sepal length (cm)	sepal width (cm)	petal length (cm)	petal width (cm)
0	5.1	3.5	1.4	0.2
1	4.9	3	1.4	0.2
2	4.7	3.2	1.3	0.2
3	4.6	3.1	1.5	0.2
4	5	3.6	1.4	0.2

	sepal length (cm)	sepal width (cm)	petal length (cm)	petal width (cm)
0	5.1	3.5	1.4	0.2
1	4.9	3	1.4	0.2
2	4.7	3.2	1.3	0.2
3	4.6	3.1	1.5	0.2
4	5	3.6	1.4	0.2

	sepal length (cm)	sepal width (cm)	petal length (cm)	petal width (cm)
0	5.1	3.5	1.4	0.2
1	4.9	3	1.4	0.2
2	4.7	3.2	1.3	0.2
3	4.6	3.1	1.5	0.2
4	5	3.6	1.4	0.2