From b30beaed628c3667692f20bb0a043c98880bd0c6 Mon Sep 17 00:00:00 2001
From: JulianoSL <juliano.souzaluz@hes-so.ch>
Date: Wed, 15 Nov 2023 20:57:51 +0100
Subject: [PATCH] Update print and testing
---
perceptron-tp3.py | 29 +++++++++++++++++++++--------
1 file changed, 21 insertions(+), 8 deletions(-)
diff --git a/perceptron-tp3.py b/perceptron-tp3.py
index 3623e40..ef9d6fb 100644
--- a/perceptron-tp3.py
+++ b/perceptron-tp3.py
@@ -6,25 +6,35 @@
#
##############################################
#
-# Réponse à la question :
-# Comme notre modèle d'apprentissage est assez simple, moins il y a de neurones dans la couche cachée, plus c'est
+# Après la phase d’apprentissage, pour les données « student-data-train.csv » et « student-data-test.csv »mesurer le taux de classifications correctes.
+# On essayera un nombre de neurones dans la couche cachée égal à : 10 ; 50 ; 100 ; 200.
+# A vous de décider le nombre d’itérations et la valeur du paramètre d’apprentissage.
+# "Réponse" :
+# En changeant plusieurs fois le taux d'apprentissage, on se rend compte de : (et en limitant suffisamment le n iter max pour trouver des résultats différents significativement)
+# 1: Qu'un taux presque "parfait" va rendre un changement de nombre de neurones de cachés presque "inutiles"
+# 2: Si un taux est un peu moins élevé (p.e 0.020 a la place de 0.030 (taux le plus effiface trouvé)), dans ce cas le nombre de neurones
+# varie le résultat en fonction de , + de neurones = meilleur % accuracy (grossièrement)
import numpy as np
import pandas as pd
from matplotlib import pyplot as plt
+
# Fonction pour mettre à jour les poids de la couche cachée
def upd_weights_hidden(wi_old, learning, delta, xi):
return wi_old + learning * np.outer(xi, delta)
+
# Fonction pour mettre à jour les poids de la couche de sortie
def upd_weights_output(wi_old, learning, delta, y):
return wi_old + learning * delta * y
+
# Fonction d'activation sigmoïde
def sigmoide(x):
return 1 / (1 + np.exp(-x))
+
# Fonction de prédiction
def predict(poids_input_hidden, poids_hidden_output, input_data):
hidden_input = np.dot(input_data, poids_input_hidden)
@@ -45,14 +55,17 @@ if __name__ == '__main__':
num_features = X.shape[1]
# Paramètres d'apprentissage
- learning_rate = 0.034
+ learning_rate = np.random.uniform(0, 0.5) # good one around 0.030 -> 100% accuracy
+ # learning_rate = 0.030
max_iterations = 2000
- num_hidden = 10
+ tab = [10, 50, 100, 200]
+ num_hidden = np.random.choice(tab) # prend une valeur aléatoire de nombre de neurones
+ # num_hidden = 10
# Initialiser les poids pour l'entrée dans la couche cachée et masqués dans la couche de sortie
weights_input_hidden = np.random.rand(num_features + 1, num_hidden) - 0.5
weights_hidden_output = np.random.rand(num_hidden + 1) - 0.5
- error_points = np.empty((0,2))
+ error_points = np.empty((0, 2))
print("Weights input to hidden:", weights_input_hidden)
print("Weights hidden to output:", weights_hidden_output)
@@ -78,7 +91,7 @@ if __name__ == '__main__':
total_error += (target - output) ** 2 / 2
- if (iteration % 10 == 0) or iteration == 0: # print tous les 5 iterations
+ if (iteration % 1 == 0) or iteration == 0: # print tous les 5 iterations
print(f"Iteration {iteration + 1}: Error = {total_error}")
# Calcul du taux de classification correcte
@@ -94,6 +107,8 @@ if __name__ == '__main__':
error_points = np.vstack((error_points, X[i]))
accuracy = correct_classifications / len(X)
+ print('Learning rate: ', learning_rate)
+ print("num_hidden: ", num_hidden)
print(f"Taux de classifications correctes: {accuracy * 100}%")
# Tracer la droite de séparation
@@ -106,5 +121,3 @@ if __name__ == '__main__':
plt.ylabel('Norm_Grade_2')
plt.legend()
plt.show()
-
-
--
GitLab