def learn_plot_perceptron2D(perceptron,
trainx,
trainy,
testx,
testy,
gradient_descent,
title="Batch gradient descent"):
"""FIXME! briefly describe function
:param perceptron: Perceptron utilisé pour afficher les données
:param trainx: Données d'apprentissage
:param trainy: Labels des données d'apprentissage
:param testx: Données de test
:param testy: Labels des données de test
:param gradient_descent: type de gradient descent utilisé
:param title: titre du graphique
:returns: affiche un graphique
:rtype: void
"""
perceptron.fit(trainx, trainy, gradient_descent=gradient_descent)
print("Erreur : train %f, test %f\n" %
(perceptron.score(trainx, trainy), perceptron.score(testx, testy)))
plot_frontiere(testx, perceptron.predict, 20)
plot_data(testx, testy, title=title)
# plt.savefig("ktg23100h.png")
plt.show()
def main():
# Création des données selon deux distributions gaussiennes
plt.ion()
trainx,trainy = gen_arti(nbex=1000, data_type=0, epsilon=1)
testx,testy = gen_arti(nbex=1000, data_type=0, epsilon=1)
# Base pour projection en distance gaussienne :
base = trainx[np.random.randint(trainx.shape[0], size=100),:]
# Tracé de l'isocontour de l'erreur pour MSE et HINGE
plot_error(trainx,trainy,mse)
plot_error(trainx,trainy,hinge)
# Modèle standard avec MSE
perceptron = Lineaire(mse,mse_g,max_iter=1000,eps=0.01)
perceptron.fit(trainx,trainy)
print("\nErreur mse : train %f, test %f"% (perceptron.score(trainx,trainy),perceptron.score(testx,testy)))
plt.figure()
plot_frontiere(trainx,perceptron.predict,200)
plot_data(trainx,trainy)
plot_trajectory(trainx,trainy,perceptron)
plt.show()
# Modèle standard Hinge
perceptron = Lineaire(hinge,hinge_g,max_iter=1000,eps=0.1)
perceptron.fit(trainx,trainy)
print("\nErreur hinge : train %f, test %f"% (perceptron.score(trainx,trainy),perceptron.score(testx,testy)))
plt.figure()
plot_frontiere(trainx,perceptron.predict,200)
plot_data(trainx,trainy)
plot_trajectory(trainx,trainy,perceptron)
plt.show()
# Modèle MSE avec biais
perceptron = Lineaire(mse,mse_g,max_iter=1000,eps=0.01, bias=True)
perceptron.fit(trainx,trainy)
print("\nErreur mse biais : train %f, test %f"\
% (perceptron.score(trainx,trainy),perceptron.score(testx,testy)))
plt.figure()
plot_frontiere(trainx,perceptron.predict,200)
plot_data(trainx,trainy)
plot_trajectory(trainx,trainy,perceptron)
plt.show()
# Modèle hinge avec biais
perceptron = Lineaire(hinge, hinge_g, max_iter=1000, eps=0.1, bias=True)
perceptron.bias = True
perceptron.fit(trainx,trainy)
print("\nErreur hinge biais : train %f, test %f"\
% (perceptron.score(trainx,trainy),perceptron.score(testx,testy)))
plt.figure()
plot_frontiere(trainx,perceptron.predict,200)
plot_data(trainx,trainy)
plot_trajectory(trainx,trainy,perceptron)
plt.show()
# Attention : l'affichage de la frontières avec projections sont très longues à générer
"""
# Modèle hinge avec projection gaussienne
perceptron = Lineaire(hinge, hinge_g, max_iter=1000, eps=0.5, bias=False, project="gauss")
perceptron.base = base
perceptron.fit(trainx,trainy)
print("\nErreur hinge gauss : train %f, test %f"\
%(perceptron.score(trainx,trainy),perceptron.score(testx,testy)))
plt.figure()
plot_frontiere(trainx,perceptron.predict,200)
plot_data(trainx,trainy)
plot_trajectory(trainx,trainy,perceptron)
plt.show()
# Modèle hinge avec projection polynomiale
perceptron = Lineaire(hinge, hinge_g, max_iter=100, eps=0.1, bias=False, project="polynomial")
perceptron.fit(trainx,trainy)
print("\nErreur hinge polynomial : train %f, test %f"\
%(perceptron.score(trainx,trainy),perceptron.score(testx,testy)))
plt.figure()
plot_frontiere(trainx,perceptron.predict,200)
plot_data(trainx,trainy)
plot_trajectory(trainx,trainy,perceptron)
plt.show()
"""
# Données USPS
datax_train, datay_train = load_usps("USPS_test.txt")
datax_test, datay_test = load_usps("USPS_train.txt")
#6 vs 9
trainx = datax_train[np.where(np.logical_or(datay_train == 6,datay_train == 9))]
trainy = datay_train[np.where(np.logical_or(datay_train == 6,datay_train == 9))]
labely_train = np.sign(trainy - 7)
testx = datax_test[np.where(np.logical_or(datay_test == 6,datay_test == 9))]
testy = datay_test[np.where(np.logical_or(datay_test == 6,datay_test == 9))]
labely_test = np.sign(testy - 7)
perceptron = Lineaire(hinge, hinge_g, max_iter=1000, eps=0.1)
perceptron.fit(trainx, labely_train)
print("Erreur 2 classes 6/9: train %f, test %f"% (perceptron.score(trainx,labely_train),\
perceptron.score(testx,labely_test)))
plot_vector(perceptron.w.reshape(16,16))
plot_learning_curve(trainx, labely_train, testx, labely_test, start=0, stop=501, step=10)
#6 vs all
labely_train = 2 * (datay_train == 6) - 1
labely_test = 2 * (datay_test == 6) - 1
perceptron = Lineaire(hinge, hinge_g, max_iter=1000, eps=0.1)
perceptron.fit(datax_train, labely_train)
print("Erreur one vs all: train %f, test %f"% (perceptron.score(datax_train,labely_train),\
perceptron.score(datax_test,labely_test)))
# Attention : la courbe d'apprentissage est très longue à générer
"""
plt.ion()
trainx, trainy = a.gen_arti(nbex=1000, data_type=0, epsilon=1)
testx, testy = a.gen_arti(nbex=1000, data_type=0, epsilon=1)
plt.figure()
plot_error(trainx, trainy, mse)
plt.figure()
plot_error(trainx, trainy, hinge)
#hinge (Perceptron)
perceptron = Lineaire(hinge, hinge_g, max_iter=10, eps=0.1)
perceptron.fit(trainx, trainy)
print("Erreur hinge: train %f, test %f" %
(perceptron.score(trainx, trainy), perceptron.score(testx, testy)))
plt.figure()
a.plot_frontiere(testx, perceptron.predict, 200)
a.plot_data(testx, testy)
#mse (Descente de gradient)
"""
perceptron = Lineaire(mse,mse_g,max_iter=3,eps=0.1)
perceptron.fit(trainx,trainy)
print("Erreur mse: train %f, test %f"% (perceptron.score(trainx,trainy),perceptron.score(testx,testy)))
plt.figure()
a.plot_frontiere(trainx,perceptron.predict,200)
a.plot_data(trainx,trainy)
"""
#Hinge avec Biais
"""
perceptron = Lineaire(hinge,hinge_g_bias,max_iter=1000,eps=0.1,b=True)
if __name__ == "__main__":
plt.close("all")
""" Tracer des isocourbes de l'erreur """
plt.ion()
trainx, trainy = gen_arti(nbex=1000, data_type=1, epsilon=1)
testx, testy = gen_arti(nbex=1000, data_type=1, epsilon=1)
#Pour tester si le biais fonctionne
#testx += 1
#trainx += 1
perceptron = Lineaire(hinge, hinge_g, max_iter=1000, eps=0.05, hist=True)
perceptron.fit(trainx, trainy)
plt.figure()
plot_error(trainx, trainy, mse)
plt.figure()
plot_error(trainx, trainy, hinge)
color = np.empty((perceptron.w_hist.shape[0], 3))
color[:, 0] = 1
color[:, 1] = np.linspace(0, 1, color.shape[0])
color[:, 2] = np.linspace(0, 1, color.shape[0])
plt.scatter(perceptron.w_hist[:, 0], perceptron.w_hist[:, 1], c=color)
print("Erreur : train %f, test %f" %
(perceptron.score(trainx, trainy), perceptron.score(testx, testy)))
plt.figure()
plot_frontiere(trainx, perceptron.predict, 200)
plot_data(trainx, trainy)
# plot_frontiere(trainx, lambda x: perceptron.predict(projection_polynomiale(x)), 200)
# plot_data(trainx,trainy)
# =============================================================================
#projection gaussienne
plt.close("all")
trainx, trainy = gen_arti(nbex=4000, data_type=2)
testx, testy = gen_arti(nbex=4000, data_type=2)
x1min = trainx[:, 0].min()
x2min = trainx[:, 1].min()
x1max = trainx[:, 0].max()
x2max = trainx[:, 1].max()
n1 = 40
n2 = 40
ntrainx = projection_gaussienne(trainx, x1min, x1max, x2min, x2max, n1, n2)
ntestx = projection_gaussienne(testx, x1min, x1max, x2min, x2max, n1, n2)
perceptron = Lineaire(hinge, hinge_g, max_iter=1000, eps=0.05)
perceptron.fit(ntrainx, trainy)
print("Erreur : train %f, test %f" %
(perceptron.score(ntrainx, trainy), perceptron.score(ntestx, testy)))
plt.figure()
plot_frontiere(
trainx, lambda x: perceptron.predict(
projection_gaussienne(x, x1min, x1max, x2min, x2max, n1, n2)), 200)
plot_data(trainx, trainy)
def main():
# Affichage de f et df en fonction du nombre d'itérations
plot_nb_iter(f1, df1, 5, 0.1, 30)
plot_nb_iter(f2, df2, 5, 0.1, 30)
plot_nb_iter(f3, df3, np.array([-1, -1]).reshape(1, 2), 0.001, 20)
# Affichage 2D de f1, f2 et 3D de f3
plot_2d(f1, df1, 5, 0.1, 30)
plot_2d(f2, df2, 5, 0.1, 30)
plot_3d(f3, df3, np.array([-1, -1]).reshape(1, 2), 0.001, 20)
# Affichage des distances à l'optimum de l'historique
plot_distance(f1, df1, 5, 0.1, 30)
plot_distance(f2, df2, 5, 0.1, 30)
plot_distance(f3, df3, np.array([-1, -1]).reshape(1, 2), 0.001, 50)
# Regression logistique avec données USPS
datax_train, datay_train = load_usps("USPS_test.txt")
datax_test, datay_test = load_usps("USPS_train.txt")
## On test la reconnaissance 6 vs 9 (on isole puis transforme les données en -1 et 1)
datax_train_2 = datax_train[np.where(
np.logical_or(datay_train == 1, datay_train == 8))]
datay_train_2 = datay_train[np.where(
np.logical_or(datay_train == 1, datay_train == 8))]
labely_train = np.sign(datay_train_2 - 2)
datax_test_2 = datax_test[np.where(
np.logical_or(datay_test == 1, datay_test == 8))]
datay_test_2 = datay_test[np.where(
np.logical_or(datay_test == 1, datay_test == 8))]
labely_test = np.sign(datay_test_2 - 2)
model = Learner(max_iter=1000, eps=0.05)
model.fit(datax_train_2, labely_train)
print("Erreur de classification 6/9: train %f, test %f"\
% (model.score(datax_train_2,labely_train),model.score(datax_test_2,labely_test)))
## Affichage des poids
weights = model.w
plot_vector(weights.reshape(16, 16))
## Classification 1 versus toutes les autres
model2 = Learner(max_iter=1000, eps=0.05)
labely_train = 2 * (datay_train == 6) - 1
labely_test = 2 * (datay_test == 6) - 1
model2.fit(datax_train, labely_train)
print("Erreur one vs all: train %f, test %f"\
% (model2.score(datax_train,labely_train),model2.score(datax_test,labely_test)))
## Essai sur gen_arti pour tester les performances
trainx, trainy = gen_arti(nbex=1000, data_type=0, epsilon=1)
testx, testy = gen_arti(nbex=1000, data_type=0, epsilon=1)
model1 = Learner(max_iter=100, eps=0.01)
model1.fit(trainx, trainy)
print("Erreur de classification gen_arti: train %f, test %f"\
% (model1.score(trainx,trainy),model1.score(testx,testy)))
plt.figure()
plot_frontiere(trainx, model1.predict, 200)
plot_data(trainx, trainy)