Défis d'apprentissage automatique de Coursera en Python: ex2 (retour logistique)

Une série qui implémente des tâches de programmation Coursera Machine Learning en Python. (2015/10/23) Ajouté ex2_reg et ajouté. (2015/12/25) Ajout d'une version qui peut être facilement écrite en utilisant les fonctionnalités polynomiales avec ex2_reg

ex2 (régression logistique sans régularisation)

introduction

Dans cet exemple, les scores des deux tests sont donnés comme données d'entrée, et les résultats des tests (réussite ou échec) sont donnés comme données de sortie, et un classificateur par régression logistique est créé.

Code Python

ex2.py

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn import linear_model

data = pd.read_csv("ex2data1.txt", header=None)
# read 1st, 2nd column as feature matrix (100x2)
X = np.array([data[0],data[1]]).T
# read 3rd column as label vector (100)
y = np.array(data[2])

# plot
pos = (y==1) # numpy bool index
neg = (y==0) # numpy bool index
plt.scatter(X[pos,0], X[pos,1], marker='+', c='b')
plt.scatter(X[neg,0], X[neg,1], marker='o', c='y')
plt.legend(['Admitted', 'Not admitted'], scatterpoints=1)
plt.xlabel("Exam 1 Score")
plt.ylabel("Exam 2 Score")

# Logistic regression model with no regularization
model = linear_model.LogisticRegression(C=1000000.0)
model.fit(X, y)

# Extract model parameter (theta0, theta1, theta2)
[theta0] = model.intercept_
[[theta1, theta2]] = model.coef_
# Plot decision boundary
plot_x = np.array([min(X[:,0])-2, max(X[:,0])+2])   # lowest and highest x1
plot_y = - (theta0 + theta1*plot_x) / theta2   # calculate x2
plt.plot(plot_x, plot_y, 'b')

plt.show()

L'intrigue résultante ressemble à ceci.

Points d'apprentissage automatique

Pour faire une régression logistique, utilisez la classe sklearn.linear_model.LogisticRegression () et apprenez avec le familier model.fit (X, y).

Dans la classe LogisticRegression, la force de la régularisation est spécifiée par le paramètre C. En classe, cela a été spécifié par le paramètre $ \ lambda $, mais C est l'inverse de $ \ lambda $ (apparaîtra dans une session SVM ultérieure). Plus le «C» est petit, plus la régularisation est forte, et plus le «C» est grand, plus la régularisation est faible. Dans cet exemple, nous ne voulons pas de régularisation, nous mettons donc une valeur élevée (1 000 000) dans «C».

Après avoir entraîné le modèle, dessinez une frontière de décision. La limite de décision de la régression logistique est une ligne droite définie par $ \ theta ^ {T} X = 0 $. Dans le cas de l'exemple, si vous l'écrivez en termes de composants, $ \ theta_0 + \ theta_1 x_1 + \ theta_2 x_2 = 0 $, et résolvez ceci à la formule $ x_2 = - \ frac {\ theta_0 + \ theta_1 x_1} {\ theta_2} $ Calculez les coordonnées des points sur la frontière de décision avec et transmettez-les à la fonction de tracé.

Point semblable à Python

• L'indice booléen de Numpy (index par valeur logique) est utilisé lors du traçage de y = 1 avec + et y = 0 avec ○ sur le diagramme de dispersion.
• Lors du tracé de la frontière de décision (ligne droite), un vecteur bidimensionnel ayant des points aux deux extrémités de la ligne droite en tant que composants est placé dans «plot_x», et le «plot_y» correspondant est à commande vectorielle. Notez que lors de la création de ce plot_x, si vous ne le créez pas en tant que tableau Numpy (si vous le créez en tant que liste standard Python), vous ne pourrez pas effectuer d'opérations vectorielles.

ex2_reg (Régression logistique avec régularisation)

introduction

Dans cet exemple, les deux résultats de test de la micropuce sont donnés comme données d'entrée, et l'indicateur de réussite ou d'échec est donné comme données de résultat. Créez un classificateur qui classe les succès et les échecs à l'aide d'un modèle de régression logistique. Comme la séparation linéaire n'est pas possible avec une ligne droite, un ajustement polymorphe est utilisé. De plus, créez un modèle avec différents paramètres de régularisation $ \ lambda $ et voyez l'effet de la régularisation.

code

ex2_reg.py

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn import linear_model

# mapFeature(x1, x2)
#Faire une cartographie des fonctionnalités
#Argument: vecteur de caractéristiques x1,x2 (doit avoir la même dimension n)
#Valeur de retour: matrice de caractéristiques X(matrice nx28)
#Jusqu'au 6ème ordre 1, x1, x2, x1^2, x1*x2, x2, x1^3, .... x1*x2^5, x2^28 rangées comme 6
def mapFeature(x1, x2):
    degree = 6
    out = np.ones(x1.shape) #La première colonne est 1
    for i in range(1, degree+1):  #Boucle de 1 à degré
        for j in range(0, i+1):   #Boucle de 0 à i
            out = np.c_[out, (x1**(i-j) * x2**j)] #Augmenter le nombre de colonnes
    return out

#Texte d'ici
data = pd.read_csv("ex2data2.txt", header=None)

x1 = np.array(data[0])
x2 = np.array(data[1])
y = np.array(data[2])

#Tracer des échantillons de données
pos = (y==1) # numpy bool index
neg = (y==0) # numpy bool index
plt.scatter(x1[pos], x2[pos], marker='+', c='b') #Le bon exemple est'+'
plt.scatter(x1[neg], x2[neg], marker='o', c='y') #Exemple négatif'o'
plt.legend(['y = 0', 'y = 1'], scatterpoints=1)
plt.xlabel("Microchip Test 1")
plt.ylabel("Microchip Test 2")

#X est une matrice nx28 pour le mappage de caractéristiques
X = mapFeature(x1, x2)

#Modèle de régression logistique avec régularisation
model = linear_model.LogisticRegression(penalty='l2', C=1.0)
model.fit(X, y)

# Decision Boundary(Limite de décision)Comploter
px = np.arange(-1.0, 1.5, 0.1)
py = np.arange(-1.0, 1.5, 0.1)
PX, PY = np.meshgrid(px, py) # PX,Chaque PY est une matrice 25x25
XX = mapFeature(PX.ravel(), PY.ravel()) #Cartographie des fonctionnalités. L'argument est ravel()Convertissez en un vecteur à 625 dimensions et transmettez-le. XX est une matrice 625x28
Z = model.predict_proba(XX)[:,1] #Prédiction avec un modèle de régression logistique. y=La probabilité de 1 est dans la deuxième colonne du résultat, alors supprimez-la. Z est un vecteur à 625 dimensions
Z = Z.reshape(PX.shape) #Convertir la matrice Z en matrice 25x25
plt.contour(PX, PY, Z, levels=[0.5], linewidths=3) # Z=0.La ligne de contour de 5 devient la limite de décision
plt.show()

Points d'apprentissage automatique

La partie qui utilise la classe LogisticRegression est la même que dans l'exemple précédent. Puisque la régularisation apparue dans Coursera est la régularisation L2 (régression de crête), ajoutez l'option «pénalité = 'l2». Je vais dessiner une frontière de décision avec un modèle entraîné en changeant la force de la régularisation, mais dans Coursera il y avait 3 types de $ \ lambda = 0, 1, 100 $, mais dans l'exemple Python C = 1000000.0 , «C = 1,0», «C = 0,01».

Dans le cas de C = 1000000.0 (pas de régularisation, overfit)

Lorsque C = 1.0

Lorsque C = 0,01 (trop régulier, sous-ajusté)

Point semblable à Python

• Convertissez une matrice en vecteur avec la méthode ravel (). Matlab / Octave prend en charge ʻA (:) . Ceci est dû au fait que la matrice de coordonnées créée par meshgrid doit être un vecteur lors de la transmission à mapFeature et LogisticRegression.predict_proba () `. Inversement, le vecteur de retour «Z» est renvoyé à la matrice avec la méthode «reshape ()».
• La valeur de retour de LogisticRegression.predict_proba () est une matrice avec le nombre d'échantillons (625 lignes) verticalement et le nombre de classes (2 colonnes) horizontalement, et contient la probabilité que chaque échantillon soit classé dans chaque classe. Dans cet exemple, nous voulons la probabilité que y == 1, donc nous ne prenons que la deuxième colonne comme vecteur comme Z [:, 1]. La ligne de contour avec probabilité = 0,5 est la limite de décision.

Addendum: Simplifié en utilisant une bibliothèque pour générer des caractéristiques de polynômes

Dans le code ci-dessus, j'ai créé ma propre fonction appelée mapFeature () pour générer des caractéristiques de polynômes, mais scikit-learn a une classe appelée sklearn.preprocessing.PolynomialFeatures qui fait la même chose. Il y en a, alors remplacez-le ici. Cliquez-ici pour le code.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import sklearn

data = pd.read_csv("ex2data2.txt", header=None)

x1 = np.array(data[0])
x2 = np.array(data[1])
y = np.array(data[2])

#Tracer des échantillons de données
pos = (y==1) # numpy bool index
neg = (y==0) # numpy bool index
plt.scatter(x1[pos], x2[pos], marker='+', c='b') #Le bon exemple est'+'
plt.scatter(x1[neg], x2[neg], marker='o', c='y') #Exemple négatif'o'
plt.legend(['y = 0', 'y = 1'], scatterpoints=1)
plt.xlabel("Microchip Test 1")
plt.ylabel("Microchip Test 2")

#X est une matrice nx28 pour le mappage de caractéristiques
poly = sklearn.preprocessing.PolynomialFeatures(6)
X = poly.fit_transform(np.c_[x1,x2])

#Modèle de régression logistique avec régularisation
model = linear_model.LogisticRegression(penalty='l2', C=1.0)
model.fit(X, y)

# Decision Boundary(Limite de décision)Comploter
px = np.arange(-1.0, 1.5, 0.1)
py = np.arange(-1.0, 1.5, 0.1)
PX, PY = np.meshgrid(px, py) # PX,Chaque PY est une matrice 25x25
XX = poly.fit_transform(np.c_[PX.ravel(), PY.ravel()]) #L'argument de mappage de fonctionnalités est Ravel()Convertit en un vecteur de 625 dimensions et passe XX est une matrice de 625x28
Z = model.predict_proba(XX)[:,1] #Prédite par le modèle de régression logistique y=Puisque la probabilité de 1 est dans la deuxième colonne du résultat, le Z à extraire est un vecteur à 625 dimensions.
Z = Z.reshape(PX.shape) #Convertir la matrice Z en matrice 25x25
plt.contour(PX, PY, Z, levels=[0.5], linewidths=3) # Z=0.La ligne de contour de 5 devient la limite de décision
plt.show()

en conclusion

J'étudie à la fois Python et l'apprentissage automatique, donc je vous serais reconnaissant si vous pouviez signaler des points étranges (^^)