def label(map_shape, data_shape, labelling_samples, labelling_labels, neurons):
"""labellise la carte
map_shape -- taille de la carte de la forme (lignes, colonnes)
data_shape -- taille des vecteurs de la forme (lignes, colonnes)
labelling_samples -- échantillons pour labelliser
labelling_labels -- labels associés aux échantillons
neurons -- carte des neurones
neuron_labels -- carte des labels associés aux neurones
"""
#Crée un compteur comme tableau de zéros de 100 lignes et 10 colonnes
dimension_compteur=(np.prod(map_shape), 10)
compteur=np.zeros(dimension_compteur)
#met à jour la variable compteur
for sample, label in zip(labelling_samples, labelling_labels):
#cherche la BMU et sa distance associée
(nearestVector_coor, nearestVector_dist) = nearestVector(sample, neurons)
#Met à jour le compteur: ajoute 1 au compteur pour les coordonnées BMU associés seulement
compteur[nearestVector_coor, label]+=1
#génère la carte des labels
neuron_labels=np.zeros(np.prod(map_shape))
for case in range(np.prod(map_shape)):
#attribue à la case la plus fréquente valeur du compteur
neuron_labels[case]=np.argmax(compteur[case,:])
return neuron_labels
def eval(W_labels,data,mean_bmu):
exclus = 0
Rendu = 0
fail = 0
for itt in range(testing_labels.shape[0]):
sample = testing_samples[itt]
bmu_idx, bmu_score = kohonen.nearestVector(sample, data)
label_predicted = W_labels[bmu_idx]
real_label = testing_labels[itt]
if W_labels[bmu_idx]!=-1 and bmu_score/mean_bmu < 2 : #and bmu_score<8.5: Cette condition ne marche pas
if real_label == label_predicted:
Rendu = Rendu + 1
else : fail += 1
else:
exclus = exclus + 1
#print("Le rendu de ce programme est de : ", (Rendu/testing_labels.shape[0])*100, "%")
#print("Nombre d'exclus :",(exclus/testing_labels.shape[0])*100, "%")
return (Rendu/testing_labels.shape[0])*100,(exclus/testing_labels.shape[0])*100
def test(weights, matrice_labelisee, testing_samples, testing_labels):
"""
évalue la qualité de la décision par l'algorithme de kohonen
weights -- tableau des neurones
matrice_labelisee -- tableau contenant les labels associés aux neurones
testing_samples -- échantillons utilisés pour faire l'évaluation
testing_labels -- labels réels associés aux échantillons
"""
#variables comptant le nombre de bonnes réponse (globalement et selon les nombres)
success = 0
successes = np.zeros(10)
number_tests = np.zeros(10)
for sample, label in zip(testing_samples,testing_labels):
#récupère l'indice du neurone le plus proche
nearest = nearestVector(sample, weights)[0]
number_tests[label] += 1
#si l'estimation est bonne, incrémente les variables correspondantes
if matrice_labelisee[nearest] == label:
success +=1
successes[label] += 1
#retourne les performances globale et selon les nombres
return (success / sum(number_tests), successes/number_tests)
def map(map_shape, data_shape, sigma_max_value, sigma_min_value, eta_max_value,
eta_min_value, decay_start_iter, decay_stop_iter, training_samples,
initiale):
"""
crée la carte labélisée par l'algorithme de Kohonen
map_shape -- taille de la carte de la forme (lignes, colonnes)
data_shape -- taille des vecteurs de la forme (lignes, colonnes)
iterations -- nombre d'échantillon utilisés pour entrainer la carte
sigma_max_value, sigma_min_value, eta_max_value, eta_min_value, decay_start_iter, decay_stop_iter -- arguments de la mise à jour de la carte
training_samples -- tableau des vecteurs utilisés pour entrainer la carte
"""
## dimensions des vecteurs de poids
neurons_dimension = (np.prod(map_shape), np.prod(data_shape))
## initialisation des prototypes des vecteurs de poids
neurons = np.zeros(neurons_dimension)
for i in range(np.prod(map_shape)):
neurons[i] = initiale
#===============================================================================
# Boucle d'apprentissage suivant l'algorithme de Kohonen
#===============================================================================
for curr_iter, sample in enumerate(training_samples):
## récupérer les valeurs de sigma et eta
sigma = kohonen.constrainedExponentialDecay(
curr_iter, decay_start_iter,
decay_stop_iter * len(training_samples), sigma_max_value,
sigma_min_value)
eta = kohonen.constrainedExponentialDecay(
curr_iter, decay_start_iter,
decay_stop_iter * len(training_samples), eta_max_value,
eta_min_value)
## trouver la best-matching unit (BMU) et son score (plus petite distance)
bmu_idx, bmu_score = kohonen.nearestVector(sample, neurons)
## traduire la position 1D de la BMU en position 2D dans la carte
bmu_2D_idx = np.unravel_index(bmu_idx, map_shape)
## gaussienne de taille sigma à la position 2D de la BMU
gaussian_on_bmu = kohonen.twoDimensionGaussian(map_shape, bmu_2D_idx,
sigma)
## mettre à jour les prototypes d'après l'algorithme de Kohonen (fonction à effets de bord)
kohonen.updateKohonenNeurons(sample, neurons, eta, gaussian_on_bmu)
return neurons
def eval():
'''
Evalue la qualité de la carte en comparant, pour chaque exemple, la classe associé à l'exemple et le chiffre donné par la carte.
Entrées : (sous forme de sauvegardes)
- data (numpy.ndarray) : matrices des poids de la carte créée
- mean_bmu (entier): moyenne des scores des bmu lors de la création de la carte
- W_labels (numpy.ndarray) : liste des labels correspondant aux neurones
Sortie : (sous forme de sauvegarde)
- rendu (entier) : nombre de réponses correctes données par la carte
'''
try:
W_labels = numpy.load("labels.npy")
data = numpy.load("data.npy")
mean_bmu = numpy.load("mean_bmu.npy")
#Paramètres permettant de rendre compte de l'efficacité de la CAO analysée.
exclus = 0
rendu = 0
fail = 0
for j in range(testing_labels.shape[0]):
sample = testing_samples[j]
bmu_idx, bmu_score = kohonen.nearestVector(sample, data)
label_predicted = W_labels[bmu_idx]
real_label = testing_labels[j]
if W_labels[
bmu_idx] != -1 and bmu_score / mean_bmu < 2: #Dernier critère supplémentaire : les données qui sont trop loin de tous les neurones utilisés seront rejetés.
if real_label == label_predicted:
rendu = rendu + 1
else:
fail += 1
else:
exclus = exclus + 1
numpy.save(
"results", (rendu / testing_labels.shape[0]) * 100
) #On sauvegarde pour que l'utilisateur puisse la consulter même après avoir lancé une autre CAO.
except:
affichageEval['text'] = "Veuillez d'abord faire le labelling"
def label():
'''
Associe un label à chaque neurone de la carte. Le label est choisi comme étant la classe qui correspond le mieux au neurone. Si la correspondance n'est pas assez claire, le label du neurone est mis à -1 et le neurone est dit exclus.
Entrées : (sous forme de sauvegardes)
- data (numpy.ndarray) : matrice des poids de la carte créée
- mean_bmu (entier): moyenne des scores des bmu lors de la création de la carte
Sortie : (sous forme de sauvegardes)
- W_labels (numpy.ndarray) : liste des labels correspondant aux neurones
'''
try:
data = numpy.load("data.npy")
mean_bmu = numpy.load("mean_bmu.npy")
W_associated = [
[0 for i in range(10)] for j in range(numpy.shape(data)[0])
] #Matrice qui va compter les différentes correspondances des données de labelling avec les poids de la CAO.
for j in range(labelling_labels.shape[0]):
sample = labelling_samples[j]
bmu_idx, bmu_score = kohonen.nearestVector(sample, data)
if (
bmu_score / mean_bmu
) * 100 < 200: #Test supplémentaire destiné à ne pas compter les cas qui sont trop loin des neurones de la CAO, qui viendrait polluer le labelling.
W_associated[bmu_idx][labelling_labels[j]] += 1
W_labels = [0] * numpy.shape(data)[0]
for i in range(numpy.shape(data)[0]):
if numpy.sum(W_associated[i]) != 0:
W_labels[i] = numpy.argmax(numpy.array(W_associated[i]))
else: #On ne pas mettre une étiquette sur les neuronnes qui n'ont pas été utilisés dans le labelling.
W_labels[
i] = -1 #Coefficient qui indique que l'on ne pourra pas utiliser ce neurone pour les évaluations.
numpy.save("labels", W_labels)
except:
affichageLabel['text'] = "Veuillez d'abord faire la CAO"
def label(data,mean_bmu):
exclus = 0
W_associated = [[0 for i in range(10)] for j in range(numpy.shape(data)[0])]
for itt in range(labelling_labels.shape[0]):
sample = labelling_samples[itt]
bmu_idx, bmu_score = kohonen.nearestVector(sample, data)
if (bmu_score/mean_bmu) * 100 < 200:
W_associated[bmu_idx][labelling_labels[itt]] += 1
W_labels = [0]*numpy.shape(data)[0]
for i in range(numpy.shape(data)[0]):
if numpy.sum(W_associated[i])!=0:
W_labels[i] = numpy.argmax(numpy.array(W_associated[i]))
else :
W_labels[i] = -1
exclus += 1
print("Nombre d'exclus : ", exclus)
#numpy.save("labels", W_labels)
return W_labels
W_labels = numpy.load("labels.npy")
data = numpy.load("data.npy")
Rendu = 0
Nombre_total = testing_labels.shape[0]
Nombre_exclus = 0
Raté = 0
'''
for j in range(numpy.shape(W_labels)[0]):
if W_labels[j] == -1:
data[j] = numpy.zeros((1,784))
'''
for itt in range(testing_labels.shape[0]):
sample = testing_samples[itt]
bmu_idx, bmu_score = kohonen.nearestVector(sample, data)
label_predicted = W_labels[bmu_idx]
real_label = testing_labels[itt]
print("Itération :", itt, "/", testing_labels.shape[0])
if W_labels[bmu_idx] != -1: # and bmu_score<7.5:
if real_label == label_predicted:
Rendu = Rendu + 1
else:
Raté = Raté + 1
else:
Nombre_exclus = Nombre_exclus + 1
print("Le rendu de ce programme est de : ",
(Rendu / (Nombre_total - Nombre_exclus)) * 100, "%")
## initialisation aléatoire des prototypes de la COA : distribution uniforme entre 0. et 1.
weights = numpy.random.uniform(low=0., high=10., size=weights_dimension)
#===============================================================================
# Boucle d'apprentissage suivant l'algorithme de Kohonen
#===============================================================================
eta_var = eta
sigma_var = sigma
BMU = 0
for curr_iter in range(iterations):
## choisir un indice aléatoirement
random_idx = numpy.random.randint(training_samples.shape[0])
## instancier l'exemple d'apprentissage courant
sample = data[random_idx]
## trouver la best-matching unit (BMU) et son score (plus petite distance)
bmu_idx, bmu_score = kohonen.nearestVector(sample, weights)
BMU = BMU + bmu_score
## traduire la position 1D de la BMU en position 2D dans la carte
bmu_2D_idx = (bmu_idx // map_shape[0], bmu_idx % map_shape[0])
## gaussienne de taille sigma à la position 2D de la BMU
gaussian_on_bmu = kohonen.twoDimensionGaussian(map_shape, bmu_2D_idx,
sigma)
## mettre à jour les prototypes d'après l'algorithme de Kohonen (fonction à effets de bord)
kohonen.updateKohonenWeights(sample, weights, eta, gaussian_on_bmu)
#eta = kohonen.constrainedExponentialDecay(curr_iter, 0, iterations, eta, 0.01)
#sigma = kohonen.constrainedExponentialDecay(curr_iter, 0, iterations, sigma, 0.01)
## afficher l'itération courante à l'écran
if verbose:
print('Iteration %d/%d' % (curr_iter + 1, iterations))
#===============================================================================
def allfunction():
'''
Fonction qui va effectuer tous les calculs d'un coup lors de l'appui du bouton correspondant : CAO, labelling et évaluation. Se référer aux fonctions ainsi nommées, placées plus bas, pour plus de précision.
Entrée : pas d'entrée, car fonction sur bouton, on utilise donc des sauvegardes, ici les paramètres rentrés par l'utilisateur (sauf map_shape) ou s'il n'en a pas rentré, les paramètres de base (voir plus bas)
Sortie : pas de sortie, le programme sauvegarde uniquement les données de la CAO, ainsi que le résultat de l'évaluation
'''
try: #Boucle de sécurité : si le fichier rentré dans le programme n'a pas le bon format ou les bonnes composantes, la fonction ne va rien faire et afficher un message d'erreur sur l'interface graphique.
#On charge les données :
iterations = numpy.load("iterations.npy")
iterations = int(
iterations.tolist()
) #Permet de transformer le format des données, car elles sont sauvegardées sous format numpy.
sigma = numpy.load("sigma.npy")
sigma = float(sigma.tolist())
eta = numpy.load("eta.npy")
eta = float(eta.tolist())
sigma_max = numpy.load("sigma_max.npy")
sigma_max_value = float(sigma_max.tolist())
sigma_min = numpy.load("sigma_min.npy")
sigma_min_value = float(sigma_min.tolist())
eta_max = numpy.load("eta_max.npy")
eta_max_value = float(eta_max.tolist())
eta_min = numpy.load("eta_min.npy")
eta_min_value = float(eta_min.tolist())
#===============================================================================
# Paramètres concernant les données d'apprentissage
#===============================================================================
## dimension d'un vecteur d'entrée
data_shape = (1, 784)
## nombre de classes différentes disponibles
data_number = 10
## dimensions des données
data_dimension = (data_number, numpy.prod(data_shape))
## récupération des données
data = training_samples
#===============================================================================
# Paramètres concernant la carte auto-organisatrice et l'algorithme de Kohonen
#===============================================================================
## taille de la carte auto-organisatrice (COA)
map_shape = (20, 20)
numpy.save("map_shape",
map_shape) #Sauvegardé car utilisé dans d'autres fonctions.
## dimensions des prototypes de la COA : une carte de MxM' [map_shape] vecteurs de dimension PxP' [data_dimension]
weights_dimension = (numpy.prod(map_shape), numpy.prod(data_shape))
## initialisation aléatoire des prototypes de la COA : distribution uniforme entre 0. et 1.
weights = numpy.random.uniform(low=0., high=1., size=weights_dimension)
decay_start_iter = 0.2 * iterations
decay_stop_iter = 0.6 * iterations
###Kohonen :
eta_var = eta
sigma_var = sigma
sum_bmu = 0
for curr_iter in range(iterations):
## choisir un indice aléatoirement
random_idx = numpy.random.randint(training_samples.shape[0])
## instancier l'exemple d'apprentissage courant
sample = data[random_idx]
## trouver la best-matching unit (BMU) et son score (plus petite distance)
bmu_idx, bmu_score = kohonen.nearestVector(sample, weights)
sum_bmu += bmu_score
## traduire la position 1D de la BMU en position 2D dans la carte
bmu_2D_idx = (bmu_idx // map_shape[0], bmu_idx % map_shape[0])
## gaussienne de taille sigma à la position 2D de la BMU
gaussian_on_bmu = kohonen.twoDimensionGaussian(
map_shape, bmu_2D_idx, sigma)
## mettre à jour les prototypes d'après l'algorithme de Kohonen (fonction à effets de bord)
kohonen.updateKohonenWeights(sample, weights, eta, gaussian_on_bmu)
sigma = kohonen.constrainedExponentialDecay(
curr_iter, decay_start_iter, decay_stop_iter, sigma_max_value,
sigma_min_value)
eta = kohonen.constrainedExponentialDecay(curr_iter,
decay_start_iter,
decay_stop_iter,
eta_max_value,
eta_min_value)
#===============================================================================
# Sauvegarde des données
#===============================================================================
numpy.save(
"data", weights
) # On en a besoin dans d'autres fonctions (graph par exemple).
mean_bmu = sum_bmu / iterations
numpy.save(
"mean_bmu", mean_bmu
) # De même si on veut refaire le labelling ou encore l'évaluation.
###Labelling :
data = weights #changement de nom : ici, la donnée devient invariante
W_associated = [
[0 for i in range(10)] for j in range(numpy.shape(data)[0])
] #Matrice qui va compter les différentes correspondances des données de labelling avec les poids de la CAO.
for j in range(labelling_labels.shape[0]):
sample = labelling_samples[j]
bmu_idx, bmu_score = kohonen.nearestVector(sample, data)
if (
bmu_score / mean_bmu
) * 100 < 200: #Test supplémentaire destiné à ne pas compter les cas qui sont trop loin des neurones de la CAO, qui viendrait polluer le labelling.
W_associated[bmu_idx][labelling_labels[j]] += 1
W_labels = [0] * numpy.shape(data)[0]
for i in range(numpy.shape(data)[0]):
if numpy.sum(W_associated[i]) != 0:
W_labels[i] = numpy.argmax(numpy.array(W_associated[i]))
else: #On ne pas mettre une étiquette sur les neuronnes qui n'ont pas été utilisés dans le labelling.
W_labels[
i] = -1 #Coefficient qui indique que l'on ne pourra pas utiliser ce neurone pour les évaluations.
numpy.save("labels", W_labels)
###Évaluation :
#Paramètres permettant de rendre compte de l'efficacité de la CAO analysée.
exclus = 0
rendu = 0
fail = 0
for j in range(testing_labels.shape[0]):
sample = testing_samples[j]
bmu_idx, bmu_score = kohonen.nearestVector(sample, data)
label_predicted = W_labels[bmu_idx]
real_label = testing_labels[j]
if W_labels[
bmu_idx] != -1 and bmu_score / mean_bmu < 2: #Dernier critère supplémentaire : les données qui sont trop loin de tous les neurones utilisés seront rejetés.
if real_label == label_predicted:
rendu = rendu + 1
else:
fail += 1
else:
exclus = exclus + 1
numpy.save(
"results", (rendu / testing_labels.shape[0]) * 100
) #On sauvegarde pour que l'utilisateur puisse la consulter même après avoir lancé une autre CAO.
except:
affichageAllfunction['text'] = "Erreur fichier d'entrée ou paramètres"
def coa():
'''
Fonction qui réalise une carte auto-organisatrice (CAO) à partir de l'algorithme de kohonen et de la base de donnée entrée par l'utilisateur à travers la fonction du fichier read_mnist. Voir le lien plus bas pour plus de précision.
Entrées : (sous forme de sauvegardes)
-les paramètres que l'utilisateur souhaite appliquer (iterations, sigma, eta, sigma_max, sigma_min, eta_max et eta_min
Sorties : (sous forme de sauvegardes)
-l'ensemble des poids des neurones générés par la fonction
-mean_bmu : la moyenne de la valeur des bmu(best matching unit) calculés lors de la réalisation de la CAO
Lien wikipédia : https://fr.wikipedia.org/wiki/Carte_auto_adaptative
'''
try: #Boucle de sécurité : si le fichier rentré dans le programme n'a pas le bon format ou les bonnes composantes, la fonction ne va rien faire et afficher un message d'erreur sur l'interface graphique.
#On charge les données :
iterations = numpy.load("iterations.npy")
iterations = int(
iterations.tolist()
) #Permet de transformer le format des données, car elles sont sauvegardées sous format numpy.
sigma = numpy.load("sigma.npy")
sigma = float(sigma.tolist())
eta = numpy.load("eta.npy")
eta = float(eta.tolist())
sigma_max = numpy.load("sigma_max.npy")
sigma_max_value = float(sigma_max.tolist())
sigma_min = numpy.load("sigma_min.npy")
sigma_min_value = float(sigma_min.tolist())
eta_max = numpy.load("eta_max.npy")
eta_max_value = float(eta_max.tolist())
eta_min = numpy.load("eta_min.npy")
eta_min_value = float(eta_min.tolist())
#===============================================================================
# Paramètres concernant les données d'apprentissage
#===============================================================================
## dimension d'un vecteur d'entrée
data_shape = (1, 784)
## nombre de classes différentes disponibles
data_number = 10
## dimensions des données
data_dimension = (data_number, numpy.prod(data_shape))
## récupération des données
data = training_samples
#===============================================================================
# Paramètres concernant la carte auto-organisatrice et l'algorithme de Kohonen
#===============================================================================
## taille de la carte auto-organisatrice (COA)
map_shape = (20, 20)
numpy.save("map_shape",
map_shape) #Sauvegardé car utilisé dans d'autres fonctions
## dimensions des prototypes de la COA : une carte de MxM' [map_shape] vecteurs de dimension PxP' [data_dimension]
weights_dimension = (numpy.prod(map_shape), numpy.prod(data_shape))
## initialisation aléatoire des prototypes de la COA : distribution uniforme entre 0. et 1.
weights = numpy.random.uniform(low=0., high=1., size=weights_dimension)
decay_start_iter = 0.2 * iterations
decay_stop_iter = 0.6 * iterations
###Kohonen
eta_var = eta
sigma_var = sigma
sum_bmu = 0
for curr_iter in range(iterations):
## choisir un indice aléatoirement
random_idx = numpy.random.randint(training_samples.shape[0])
## instancier l'exemple d'apprentissage courant
sample = data[random_idx]
## trouver la best-matching unit (BMU) et son score (plus petite distance)
bmu_idx, bmu_score = kohonen.nearestVector(sample, weights)
sum_bmu += bmu_score
## traduire la position 1D de la BMU en position 2D dans la carte
bmu_2D_idx = (bmu_idx // map_shape[0], bmu_idx % map_shape[0])
## gaussienne de taille sigma à la position 2D de la BMU
gaussian_on_bmu = kohonen.twoDimensionGaussian(
map_shape, bmu_2D_idx, sigma)
## mettre à jour les prototypes d'après l'algorithme de Kohonen (fonction à effets de bord)
kohonen.updateKohonenWeights(sample, weights, eta, gaussian_on_bmu)
sigma = kohonen.constrainedExponentialDecay(
curr_iter, decay_start_iter, decay_stop_iter, sigma_max_value,
sigma_min_value)
eta = kohonen.constrainedExponentialDecay(curr_iter,
decay_start_iter,
decay_stop_iter,
eta_max_value,
eta_min_value)
#===============================================================================
# Sauvegarde des données
#===============================================================================
numpy.save(
"data", weights
) # On en a besoin dans d'autres fonctions (graph par exemple).
mean_bmu = sum_bmu / iterations
numpy.save(
"mean_bmu", mean_bmu
) # De même si on veut refaire le labelling ou encore l'évaluation.
except:
affichageCAO['text'] = "Veuillez rentrer tous les paramètres"
def COA(iterations, eta, sigma,y,x):
#===============================================================================
# Paramètres généraux de la simulation
#===============================================================================
## nombre total d'itérations d'apprentissage
#iterations = 1000 #training_samples.shape[0]
## affichage console d'information ou non
verbose = False
#===============================================================================
# Paramètres concernant les données d'apprentissage
#===============================================================================
## dimension d'un vecteur d'entrée
data_shape = (1,784)
## nombre de couleurs différentes disponibles
data_number = 10
## dimensions des données : 'data_number' couleurs de taille 'data_shape' générées aléatoirement
data_dimension = (data_number, numpy.prod(data_shape))
## génération des données
data = training_samples
#===============================================================================
# Paramètres concernant la carte auto-organisatrice et l'algorithme de Kohonen
#===============================================================================
## taille de la carte auto-organisatrice (COA)
map_shape = (20,20)
## valeur constante du rayon de voisinage gaussien (sigma)
#sigma = 2
## valeur constante du taux d'apprentissage (eta)
#eta = 1. #METTRE 10^-3
## dimensions des prototypes de la COA : une carte de MxM' [map_shape] vecteurs de dimension PxP' [data_dimension]
weights_dimension = (numpy.prod(map_shape), numpy.prod(data_shape))
## initialisation aléatoire des prototypes de la COA : distribution uniforme entre 0. et 1.
weights = numpy.random.uniform(low=y, high=x, size=weights_dimension)
decay_start_iter = 0.2*iterations
decay_stop_iter = 0.6*iterations
## paramètres du rayon de voisinage gaussien (sigma)
sigma_max_value = 4.
sigma_min_value = .9
## paramètres du taux d'apprentissage (eta)
eta_max_value = .3
eta_min_value = .001
#===============================================================================
# Boucle d'apprentissage suivant l'algorithme de Kohonen
#===============================================================================
eta_var = eta
sigma_var = sigma
sum_bmu = 0
for curr_iter in range(iterations):
## choisir un indice aléatoirement
random_idx = numpy.random.randint(training_samples.shape[0])
## instancier l'exemple d'apprentissage courant
sample = data[random_idx]
## trouver la best-matching unit (BMU) et son score (plus petite distance)
bmu_idx, bmu_score = kohonen.nearestVector(sample, weights)
sum_bmu += bmu_score
## traduire la position 1D de la BMU en position 2D dans la carte
bmu_2D_idx = (bmu_idx//map_shape[0], bmu_idx%map_shape[0])
## gaussienne de taille sigma à la position 2D de la BMU
gaussian_on_bmu = kohonen.twoDimensionGaussian(map_shape, bmu_2D_idx, sigma)
## mettre à jour les prototypes d'après l'algorithme de Kohonen (fonction à effets de bord)
kohonen.updateKohonenWeights(sample, weights, eta, gaussian_on_bmu)
sigma = kohonen.constrainedExponentialDecay(curr_iter, decay_start_iter, decay_stop_iter, sigma_max_value, sigma_min_value)
eta = kohonen.constrainedExponentialDecay(curr_iter, decay_start_iter, decay_stop_iter, eta_max_value, eta_min_value)
## afficher l'itération courante à l'écran
if verbose:
print('Iteration %d/%d'%(curr_iter+1, iterations))
#===============================================================================
# Affichage graphique
#===============================================================================
weights_reshaped = weights.reshape((map_shape[0],map_shape[1],28,28))
img = numpy.zeros((map_shape[0]*28,map_shape[1]*28))
for i in range(map_shape[0]):
for j in range(map_shape[1]):
img[i*28:(i+1)*28,j*28:(j+1)*28] = weights_reshaped[i,j,:,:]
#plt.imshow(img, cmap = 'Greys')
#plt.show()
#===============================================================================
# Sauvegarde des données
#===============================================================================
return weights,sum_bmu/iterations
