Introduction à Python scikit-learn, matplotlib, algorithme monocouche (~ vers B3 ~ part3)

Dans la troisième partie, nous ferons un apprentissage automatique simple.

L'apprentissage automatique est classé en trois types.

Flux d'apprentissage automatique

Même si vous faites de l'apprentissage automatique, il est rare que vous puissiez obtenir de bons résultats simplement en créant un modèle d'apprentissage et en saisissant des données. Le flux de travail spécifique est le suivant.

1. Préparation des données
   Déterminez le contenu des données que vous souhaitez que le modèle entraîne et collectez-le.
2. Sélection du modèle
   Sélectionnez un modèle approprié à partir du format et des caractéristiques des données.
   Il n'y a pas de modèle optimal pour toutes les données
   (No Free Ranch Theorem), alors trouvez un modèle adapté à vos données.
   S'il s'agit d'un modèle de prédiction, l'indice d'évaluation est le taux de réponse correct.
3. Prétraitement
   Comme la plupart des données brutes ne fonctionnent pas bien, nous formaterons les données.
   Achèvement des données manquantes
   -Extraction de quantités de caractéristiques
   -Même échelle des caractéristiques contenues dans les données
   -Réduction de la dimension pour compresser les éléments non pertinents (bruit)
   -Données fractionnées pour l'apprentissage et l'évaluation
4. Formation sur modèle
   Nous nous entraînerons avec le modèle sélectionné.
   Cependant, il y a des paramètres (hyper paramètres) qui doivent être ajustés manuellement dans le modèle, donc ajustez-les également.
5. Évaluation du modèle
   Évaluez le modèle (évaluez les performances de généralisation) en utilisant les données laissées pour l'évaluation.

En répétant ce processus, nous générerons un modèle d'apprentissage approprié.

Dans ce séminaire, nous ferons 3-5. Cependant, puisque 3 a été principalement fait dans la partie 2, nous nous concentrerons sur 4 et 5 pour les modèles à introduire à partir de maintenant.

Neurone

Qu'est-ce que l'apprentissage automatique? Warren McCulloch et Walter Pitts se sont demandé s'ils pouvaient imiter le cerveau humain pour concevoir l'intelligence artificielle. Par conséquent, nous avons annoncé le neurone McCulloch-Pitts, qui est une version simplifiée du neurone, qui est la plus petite unité du cerveau humain.

Les neurones reçoivent des signaux chimiques et électriques dans le cerveau et génèrent des signaux de sortie lorsque les signaux accumulés dépassent un certain seuil. Ils l'ont considéré comme une porte logique pour la sortie binaire et ont conçu des neurones MCP.

Quelques années plus tard, Frank Rosenblatt a conçu un algorithme qui apprenait automatiquement le facteur de pondération optimal, puis le multipliait par le signal d'entrée pour déterminer si le neurone se déclencherait (dépassait le seuil). C'est le début du «problème de classification» de «l'apprentissage supervisé».

La définition des neurones artificiels est la suivante. Soit le vecteur de poids pour plusieurs signaux d'entrée $ \ boldsymbol {x} $ $ \ boldsymbol {w} $. Mettez la combinaison linéaire de chaque entrée $ x_i $ et son poids $ w_i $ comme entrée totale $ z $.

z = \Sigma_i^Nw_i x_i=\boldsymbol{w}^T\boldsymbol{x} 

Divisez la valeur de sortie de la classification binaire en «1 (classe positive)» et «-1 (classe négative)». Définissez une fonction $ \ phi $ (fonction de détermination) qui classe l'entrée totale $ z $ dans une classe positive si elle est supérieure au seuil $ \ theta $, sinon elle est classée comme une classe négative.

\phi(z) = \Biggl\{\begin{array}{l} 1  　(z \geq\Lorsque thêta) \\-1　(z < \Lorsque thêta)\end{array} 

Ici, par souci de simplicité, nous déplaçons le seuil $ \ theta $ vers la gauche et le définissons comme $ w_0 = - \ theta $, $ x_0 = 1 $. Le seuil négatif de $ - \ theta $ à ce moment est appelé une unité de biais.

\phi(z) = \Biggl\{\begin{array}{l} 1  　(z \Lorsque geq0) \\-1　(z <Quand 0)\end{array} 

Mise à jour du poids (apprentissage)

L'apprentissage automatique fait référence à la mise à jour des pondérations. La procédure d'apprentissage est résumée ci-dessous.

1. Initialisez le poids avec 0 ou un petit nombre aléatoire.
2. Exécutez la procédure suivante pour chaque échantillon d'apprentissage. -① Calculer la valeur de sortie $ \ hat {y} $ -② Mettre à jour le poids

Mettez à jour le poids $ w_j $ pour une entrée donnée $ x_j $ comme suit:

w_j = w_j + \Delta w_j 

\Delta w_j = \eta(y^{(i)}-\hat{y}^{(i)})x_j

Cependant, $ \ eta $ est le taux d'apprentissage, et plus cette valeur est élevée, plus Chaque échantillon d'entraînement a un impact plus important sur les mises à jour de poids. La différence entre la classe correcte et l'étiquette de sortie $ (y ^ {(i)} - \ hat {y} ^ {(i)}) $ est appelée l'erreur.

Maintenant, implémentons Perceptron.

class Perceptron(object):
    def __init__(self,eta=0.01,n_iter=50,random_state=1):
        #Définition du taux d'apprentissage
        self.eta=eta
        #Définition de la fréquence d'entraînement
        self.n_iter=n_iter
        #Graine aléatoire utilisée pour initialiser les poids
        self.random_state=random_state
    def fit(self,X,y):
        #Génération aléatoire
        rgen=np.random.RandomState(self.random_state)
        #step1 Initialisation du poids
        self.w_=rgen.normal(loc = 0.0,scale=0.01,size=1+X.shape[1])
        #Déclaration d'erreur
        self.errors_=[]
        #Performer pour le nombre de formations
        for _ in range(self.n_iter):
            #Erreur d'initialisation
            errors=0
            #step2 Exécuter pour chaque échantillon d'apprentissage
            for xi, target in zip(X,y):
                #Calcul de la valeur de sortie et delta_Calcul de w
                udelta_w = self.eta * (target - self.predict(xi))
                #Mise à jour du poids
                self.w_[1:] += delta_w * xi
                self.w_[0] += delta_w
                errors += int(delta_w != 0.0)
            self.errors_.append(errors)
        return self
    
    #Définition de l'apport total
    def net_input(self,X):
        return np.dot(X, self.w_[1:]) + self.w_[0]
    #Définition de la fonction déterminante
    def predict(self,X):
        return np.where(self.net_input(X) >= 0.0,1,-1)

Utilisons ce Perceptron pour prédire les données Iris utilisées dans la partie 2.

import pandas as pd
df = pd.read_csv('https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data',header=None)
y = df.iloc[0:100,4].values
y = np.where(y == 'Iris-setosa',-1,1)
X = df.iloc[0:100,[0,2]].values
ppn = Perceptron(eta=0.01,n_iter=10)
ppn.fit(X,y)
plt.plot(range(1,len(ppn.errors_)+1), ppn.errors_,marker='o')
plt.xlabel('Epochs')
plt.ylabel('Number of errors')
plt.show()

Après 10 séances d'entraînement comme celle-ci, l'erreur de classification a finalement disparu. Le modèle a appris l'ensemble de données en mettant à jour les pondérations.

** Supplément ** Si cela est illustré, ce sera une telle zone de décision.

from matplotlib.colors import  ListedColormap

def plot_decision_regions(X,y,classifier,resolution=0.02):
    markers = ('s','x','o','^','v')
    colors    = ('red','blue','lightgreen','gray','cyan')
    cmap     = ListedColormap(colors[:len(np.unique(y))])

    
    x1_min, x1_max = X[:,0].min() -1,X[:,0].max()+1
    x2_min, x2_max = X[:,1].min() -1,X[:,1].max()+1
    xx1,xx2 = np.meshgrid(np.arange(x1_min,x1_max,resolution),np.arange(x2_min,x2_max,resolution))
    Z = classifier.predict(np.array([xx1.ravel(),xx2.ravel()]).T)
    Z = Z.reshape(xx1.shape)
    plt.contourf(xx1,xx2,Z,alpha=0.3,cmap = cmap)
    plt.xlim(xx1.min(),xx1.max())
    plt.ylim(xx2.min(),xx2.max())

    for idx, cl in enumerate(np.unique(y)):
        plt.scatter(x = X[y == cl,0],y = X[y == cl,1],alpha = 0.8, c = colors[idx],marker=markers[idx],label=cl,edgecolor='black')


plot_decision_regions(X,y,classifier=ppn)
plt.xlabel('sepal length[cm]')
plt.ylabel('petal lemgth[cm]')
plt.legend(loc='upper left')

plt.show()

Défis

Voyons comment l'apprentissage du modèle change en modifiant le taux d'apprentissage $ \ eta $ et le nombre de formations

Scikit-learn Scikit-learn est un module qui contient de nombreux algorithmes de classification simples. Il contient également le Perceptron que j'ai implémenté plus tôt. Essayons-le.

from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.linear_model import Perceptron
import numpy as np
#Acquisition des données d'iris, sélection des données à utiliser
iris = datasets.load_iris()
X = iris.data[:,[2,3]]
y = iris.target
#Divisé en données de test et données de train
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.3,random_state=1,stratify=y)
#Appeler Perceptron
ppn = Perceptron(n_iter_no_change=500,eta0=0.1,random_state=1)
#Entraînez le modèle pour entraîner les données
ppn.fit(X_train,y_train)
#Valider le modèle entraîné
y_predict = ppn.predict(X_test)
#Affichage du nombre d'erreurs de classification
print('Misclassified samples: %d' %(y_test != y_predict).sum())
#Affichage du taux de réponse correct
print('Accuracy: %.2f' %ppn.score(X_test,y_test))

Misclassified samples: 7
Accuracy: 0.84

Défis

Illustrons cette fois les régions de décision en utilisant la fonction plot_decision_regions utilisée dans le supplément ci-dessus.

image.png

Retour logistique

Quel genre de zone de décision est-il devenu? Perceptron est un modèle qui effectue une séparation linéaire, donc une séparation linéaire n'est pas possible Ne convient pas aux ensembles de données. Regardons donc un algorithme appelé régression logistique. La régression logistique utilise un rapport de cotes.

\frac{p}{(1-p)}

L'odds ratio est le ratio qui indique la probabilité d'un événement. $ p $ indique la probabilité de l'événement que vous souhaitez prédire. Le rapport de cotes multiplié par le logarithme naturel est appelé la fonction logit.

logit(p)=log{\frac{p}{1-p}}

En utilisant cette fonction, une telle relation est établie entre la quantité de caractéristiques et le rapport de cotes logarithmique.

logit(p(y=1|x))=\boldsymbol{w}^T \boldsymbol{x}

p (y = 1 | x) est la probabilité conditionnelle que l'échantillon appartienne à la classe 1 (y = 1) étant donné la caractéristique $ x $. Cette fois, je veux prédire la probabilité que l'échantillon appartienne à une classe spécifique, donc

p(y=1|x) = \phi(z) = logit^{-1}(\boldsymbol{w}^T \boldsymbol{x})=\frac{1}{1+e^{-z}}

Cela peut être exprimé ainsi. En d'autres termes, la fonction sigmoïde logistique (communément appelée fonction sigmoïde) est mordue avant la fonction de décision. Pour mettre à jour le poids, la valeur de sortie après application du sigmoïde logistique sera utilisée comme données de prédiction pour la mise à jour. La fonction qui entre ainsi entre l'entrée totale et la fonction de décision est appelée la ** fonction d'activation **. Puisque Perceptron met à jour le poids en comparant la sortie de la fonction déterminante avec la valeur vraie, La différence utilisée lors de la mise à jour du poids était une valeur discrète. En insérant la fonction d'activation, la valeur prédite $ \ hat {y} $ utilisée pour mettre à jour le poids devient une valeur continue.

Utilisons en fait la régression logistique.

from sklearn.linear_model import LogisticRegression
lr = LogisticRegression(C=100.0,random_state=1)

Défis

Exécutez le code ci-dessus, puis apprenez les données Iris avec régression logistique Illustrons également le domaine de décision post-apprentissage

image.png

Machine à vecteurs de soutien (SVM)

Chez Perceptron, l'objectif était de minimiser le taux d'erreurs de classification. D'autre part, dans Support Vector Machine (SVM) Le but est de maximiser la ** marge **. La marge est la limite de décision de la classification et la plus proche de la limite de décision Il fait référence à la distance par rapport à l'échantillon d'apprentissage. L'exemple de formation ci-dessus s'appelle ** Support Vector **. En ajustant les limites de décision pour maximiser la marge Une frontière de décision forte est générée en tant que classificateur.

Soit $ y = f (\ boldsymbol {x}) $ la fonction de classification qui classe l'entrée $ \ boldsymbol {x} $ en deux classes. Supposons que vous ayez $ n $ échantillons d'entraînement $ (\ boldsymbol {x_1}, y_1), (\ boldsymbol {x_2}, y_2), ..., (\ boldsymbol {x_m}, y_m) $. Ici, nous définissons le classificateur linéaire $ f (\ boldsymbol {x}) = sgn [\ boldsymbol {w} \ bullet \ boldsymbol {x} + b] $. Cela renvoie 1 lorsque $ \ boldsymbol {w} \ bullet \ boldsymbol {x} + b \ geq0 $, et -1 lorsque $ \ boldsymbol {w} \ bullet \ boldsymbol {x} + b <0 $ Retour. À ce stade, $ \ boldsymbol {w} \ bullet \ boldsymbol {x} + b = 0 $ est appelé une surface super courbe. La distance entre la surface super courbe et l'échantillon le plus proche (vecteur de support) est

\frac{|\boldsymbol{w}\bullet\boldsymbol{x_i}+b|}{||\boldsymbol{w}||}

Ce sera. La formule pour maximiser la marge est la suivante.

\max_{\boldsymbol{w},b}\min_{i}\{\frac{|\boldsymbol{w}\bullet\boldsymbol{x_i}|+b}{||\boldsymbol{w}||}\}

Puisque la surface super-courbe est invariante même si elle est multipliée par une constante, pour tous les échantillons

y_i(\boldsymbol{a}\bullet\boldsymbol{x_i}+b) \geq 1

Peut être supposé. À ce stade, la marge est

\min_{i}\{\frac{|\boldsymbol{w}\bullet\boldsymbol{x_i}|+b}{||\boldsymbol{w}||}\}=\frac{1}{||\boldsymbol{w}||}

En d'autres termes\frac{1}{||\boldsymbol{w}||}Doit être maximisé. c'est||\boldsymbol{w}||^2Est synonyme de minimisation. Cela peut être résolu par la méthode de programmation secondaire.

Cette classification de la marge maximale n'est valable que lorsque la séparation linéaire est possible. Dans d'autres cas, nous introduirons une variable de marge.

Formule de convention linéaire

y_i(\boldsymbol{w}\bullet\boldsymbol{x_i}+b) \geq 1

Introduisez la variable slack $ \ xi $ for. Cela permet d'obtenir des échantillons acceptables mais coûteux qui ne répondent pas aux contraintes et aborde également des problèmes non linéaires.

y_i(\boldsymbol{w}\bullet\boldsymbol{x_i}+b) \geq 1-\xi

En introduisant la variable d'écart, la classification de la marge maximale peut être décrite comme suit.

\frac{1}{2}||\boldsymbol{w}||^2+C(\Sigma_{i}{\xi^{(i)})}

Nous utiliserons cette variable $ C $ pour contrôler la pénalité en cas d'erreur de classification. Plus $ C $ est élevé, plus la pénalité est grande et plus la largeur de la marge est étroite. Une telle classification de marge maximale est appelée une classification de marge souple. La classification de la marge maximale avant l'introduction de $ \ xi $ est appelée classification de la marge ferme.

Cette fois, nous utiliserons la classification à marge souple (SVC).

from sklearn.svm import SVC
svm = SVC(kernel='linear',C = 1.0,random_state=1)
svm.fit(X_train,y_train)

Défis

Exécutez le code ci-dessus, puis apprenez les données Iris avec SVC Illustrons également le domaine de décision post-apprentissage

image.png

Il existe une méthode efficace pour le problème de classification non linéaire appelée ** kernelization **. Les SVM sont plus faciles à noyau que les autres algorithmes de classification. C'est pourquoi SVM est une méthode de classification populaire. Regardons un exemple de données non linéaires pour lesquelles le noyau est activé.

import matplotlib.pyplot as plt
import numpy as np

np.random.seed(1)
X_xor = np.random.randn(200, 2)
y_xor = np.logical_xor(X_xor[:, 0] > 0,
                       X_xor[:, 1] > 0)
y_xor = np.where(y_xor, 1, -1)

plt.scatter(X_xor[y_xor == 1, 0],
            X_xor[y_xor == 1, 1],
            c='c', marker='x',
            label='1')
plt.scatter(X_xor[y_xor == -1, 0],
            X_xor[y_xor == -1, 1],
            c='m',
            marker='*',
            label='-1')

plt.xlim([-3, 3])
plt.ylim([-3, 3])
plt.legend(loc='best')
plt.tight_layout()

plt.show()

Dans un tel cas, il est impossible de les séparer par une seule ligne droite. Cependant, en projetant ces données dans une dimension supérieure, l'apparence des données changera.

Fonction de projection $ \ phi (x_1, x_2) = (z_1, z_2, z_3) = (x_1, x_2, x_1 * x_2) $

Défis

Tracons les données en 3D comme $ z = \ phi (x, y) $.

Vidéo tracée

np.random.seed(1)
X_xor = np.random.randn(200, 2)
y_xor = np.logical_xor(X_xor[:, 0] > 0,
                       X_xor[:, 1] > 0)
y_xor = np.where(y_xor, 1, -1)
svm = SVC(kernel='rbf', random_state=1, gamma=0.10, C=10.0)
svm.fit(X_xor, y_xor)
plot_decision_regions(X_xor, y_xor,
                      classifier=svm)

plt.legend(loc='upper left')
plt.tight_layout()

plt.show()

svm = SVC(kernel='rbf',random_state=1,gamma=0.20,C = 10.0)
svm.fit(X_train,y_train)
plot_decision_regions(X_combined,y_combined,classifier=svm)

plt.xlabel('petal length')
plt.ylabel('sepal length')
plt.legend(loc = 'upper left')
plt.tight_layout()
plt.show()

Défis

Vérifions comment la zone de décision change en changeant la valeur de gamma

Apprentissage de l'arbre de décision

Le classificateur d'arbre de décision est un modèle qui peut être efficace lorsque l'on considère l'interprétabilité du sens. Ce classificateur prend des décisions basées sur une série de questions et classe les données. En expliquant le classifieur d'arbre de décision, nous allons d'abord expliquer l'indice ** gain d'information **. Le gain d'information fait référence à la réduction de la variation des éléments de chaque ensemble lorsqu'un ensemble est divisé. L'arbre décisif forme un arbre à nombreuses feuilles par ramification conditionnelle jusqu'à ce que le gain d'information disparaisse. Si un arbre est entièrement créé pour les données de train, il est facile de tomber dans le surentraînement (un modèle qui s'adapte trop uniquement pour entraîner les données). C'est ce qu'on appelle ** l'élagage **.

La fonction objective de l'algorithme d'apprentissage d'arbre de décision est la suivante.

IG(D_p,f)=\boldsymbol{I}(D_p)-\Sigma^{m}_{j=1}\frac{N_j}{N_p}\boldsymbol{I}(D_j)

Ici, $ f $ est la quantité d'entités à diviser, $ D_p $ est le jeu de données parent, $ N_p $ est le nombre total d'échantillons du nœud parent, $ D_j $ est le jième ensemble de données enfant, $ N_j $ est le nombre total de jièmes nœuds enfants et $ \ boldsymbol {I} $ est impur. En d'autres termes, le gain d'information est la différence entre la pureté du nœud parent et la pureté du nœud enfant, et est un indice pour quantifier la proportion d'échantillons de différentes classes mélangées dans le nœud. .. Les indicateurs de pureté les plus couramment utilisés

--Gini impur --Entropie

• Erreur de classification

Il ya trois. Parmi eux, Gini Impureness indique le rapport des échantillons dans lesquels $ p (i | t) $ appartient à la classe $ i $ au nœud spécial $ t $. Par conséquent, Gini impur est une condition qui minimise la probabilité d'erreur de classification.

I_G(t)=\Sigma^c_{i=1}p(i|t)(1-p(i|t)) = 1-\Sigma^c_{i=1}p(i|t)^2

L'arbre de décision apprend par quelle valeur diviser les données d'échantillon pour créer une branche conditionnelle avec moins d'erreurs de classification.

Classifions les données Iris avec un classificateur d'arbre de décision avec une profondeur d'arbre de décision de 4.

from sklearn.tree import DecisionTreeClassifier
tree  = DecisionTreeClassifier(criterion='gini',max_depth=4,random_state=1)

Défis

Exécutez le code ci-dessus puis apprenez les données Iris avec l'arbre de décision Illustrons également le domaine de décision post-apprentissage Essayez de changer la profondeur de l'arbre de décision (max_depth) et voyez comment la zone de décision change.

image.png

Forêt aléatoire

L'algorithme de forêt aléatoire est l'idée de créer un modèle avec des performances de généralisation plus élevées (qui peut gérer toutes les données) en faisant la moyenne de plusieurs arbres de décision profonds. La combinaison de plusieurs algorithmes de cette manière s'appelle ** apprentissage d'ensemble **. Il est courant de combiner différents modèles.

La forêt aléatoire est effectuée par la procédure suivante.

1. Sélectionnez au hasard cet échantillon à partir des données d'entraînement.
2. Développez un arbre de décision en fonction de l'échantillon de données sélectionné. 3.2 Répéter 2
3. Collectez les étiquettes de prédiction pour chaque arbre décisionnel et attribuez des étiquettes de classe en fonction de la ** décision majoritaire **.

Maintenant, classons les données Iris dans une forêt aléatoire.

from sklearn.ensemble import RandomForestClassifier
forest  = RandomForestClassifier(n_estimators=25,criterion='gini',random_state=1,n_jobs=2)

Défis

Exécutez le code ci-dessus, puis apprenez les données Iris dans une forêt aléatoire Illustrons également le domaine de décision post-apprentissage

image.png

méthode de voisinage k

La méthode k-voisinage, également connue sous le nom d'apprentissage paresseux, mémorise et classe les ensembles de données sans apprendre d'eux. L'algorithme k-voisinage suit les étapes suivantes:

1. Sélectionnez la valeur de k et l'indice de distance
2. Trouvez les k voisins les plus proches de l'échantillon que vous souhaitez classer.
3. Attribuez des étiquettes de classe à la majorité à partir des étiquettes de classe des données voisines.

L'avantage de cette méthode est qu'elle ne nécessite pas d'apprentissage et est immédiatement mise en phase de classification. Cependant, il convient de noter que si la quantité de données d'apprentissage est trop grande, la quantité de calcul sera énorme.

Classifions en fait en utilisant la méthode k-Neighborhood

from sklearn.neighbors import KNeighborsClassifier
knn =  KNeighborsClassifier(n_neighbors=5,p=2,metric='minkowski')

Défis

Exécutez le code ci-dessus, puis apprenez les données Iris en utilisant la méthode k-near Illustrons également le domaine de décision post-apprentissage

image.png

Résumé

Défis

Utilisons des données titanesques pour prédire la survie! La colonne à utiliser cette fois 'Passenderld','Age','Pclass','Sex','FamilySize' ça ira.