Update print and testing

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,9 +55,12 @@ 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
@@ -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()
-
-