// Fonctions radiales de base (FRB) appliquées aux données Iris
//	 Version implémentée :
//		- FRB gaussiennes
//		- centres sélectionnés par kppv
//		- gaussiennes isotropes
//		- poids de sortie appris par règle d'apprentissage supervisé

// Affichage des paramètres (s'assurer qu'ils sont préalablement initialisés)
nom_fich_don
nb_classes
nb_vec
nb_car
for i=1:nb_classes
	nb_vec_cl(i);
nb_noyaux

// chargement des données
fid=mopen(nom_fich_don, 'rt');
for i=1:nb_vec
	for j=1:nb_car
		vec(i,j)=mfscanf(fid, '%f');
	end
	nom(i)=mfscanf(fid, '%s');
end
//vec;		// retirer le ';' pour afficher la matrice
nom;
mclose(fid);

// Séparation des données en 2 sous-ensembles : un pour l'apprentissage et l'autre pour la reconnaissance
// pour chaque classe : la moitié pour l'apprentissage et l'autre pour le test
// dans le cas où l'effectif est impair, on en met un de plus pour l'apprentissage
dec=0;
dec_a=0;
dec_t=0;
for k=1:nb_classes
	for j=1:nb_vec_cl(k)/2
		for i=1:nb_car
			vec_a(j+dec_a,i)=vec(j+dec,i);
		end
	end
	dec_a=dec_a+int(nb_vec_cl(k)/2);
	dec=dec+int(nb_vec_cl(k)/2);
	for j=1:nb_vec_cl(k)/2
		for i=1:nb_car
			vec_t(j+dec_t,i)=vec(j+dec,i);
		end
	end
	dec_t=dec_t+int(nb_vec_cl(k)/2);
	dec=dec+int(nb_vec_cl(k)/2);
	if modulo(nb_vec_cl(k),2)==1 then			// si effectif de cette classe impair, ajouter le (2n+1)e vecteur
		dec_t=dec_t+1;
		dec=dec+1;
		for i=1:nb_car
			vec_t(dec_t,i)=vec(dec,i);
		end
	end
end
nb_vec_a=dec_a
nb_vec_t=dec_t
dec
vec_a;

// Tableau des sorties désirées du réseau pour le calcul de l'erreur de sortie
// nécessaire pour les données d'apprentissage (pour la modification des poids)
// et pour les données de test (pour le calcul des taux de reconnaissance)
for j=1:nb_vec
	for i=1:nb_classes
		sortie_desiree(i, j)=0;
	end
end
for j=1:nb_vec
	sortie_desiree(num_cl(j), j)=1;
end
sortie_desiree;

// Chargement des noyaux à partir d'un fichier de type .cod (compatible avec le programme 'eveninit' du LVQ_PAQ, par exemple)
// Le fichier utilisé dans cet exemple est constitué par le premier vecteur de la liste des vecteurs de données du fichier 'iris.don', 
// pour chacune des classes
fid=mopen(nom_fich_cod, 'rt');
nb_car=mfscanf(fid, '%d');
texte=mfscanf(fid, '%s');
for i=1:nb_noyaux
	for j=1:nb_car
		centre(i,j)=mfscanf(fid, '%f');
	end
	nom=mfscanf(fid, '%s');				// nom de la classe (non mémorisé)
end
mclose(fid);

//normalisation des données (caractéristique par caractéristique, séparemment)
for j=1:nb_car
	maxim=0;
	for i=1:nb_vec_a
		if(vec_a(i,j)>maxim)
			maxim=vec_a(i,j);
		end;
	end;
	for i=1:nb_vec_a
		vec_a(i,j)=vec_a(i,j)/maxim;
	end;
end;
//normalisation des données (caractéristique par caractéristique, séparemment)
for j=1:nb_car
	maxim=0;
	for i=1:nb_vec_t
		if(vec_t(i,j)>maxim)
			maxim=vec_t(i,j);
		end;
	end;
	for i=1:nb_vec_t
		vec_t(i,j)=vec_t(i,j)/maxim;
	end;
end;
//normalisation des centres(caractéristique par caractéristique, séparemment)
for j=1:nb_car
	maxim=0;
	for i=1:nb_noyaux
		if(centre(i,j)>maxim)
			maxim=centre(i,j);
		end;
	end;
	for i=1:nb_noyaux
		centre(i,j)=centre(i,j)/maxim;
	end;
end;

// Initialisation des poids de sortie à des valeurs aléatoires
for j=1:nb_classes
	for i=1:nb_noyaux
		w(i,j)=rand();
	end
end
w;

// Classification : présentation des entrées et calcul des sorties du réseau
sigma=0.4;			// 98,22% avec Iris
sigma=0.3;			// 94,8 % avec Wine
alpha=0.03;
erreur=0.;
nb_cycles_app=30;
for k=1:nb_cycles_app		// cycles d'apprentissage (présentation de la bas d'apprentissage)
	erreur_cum=0;
	for h=1:nb_vec_a			// pour chaque vecteur d'apprentissage
   		// calcul des sorties de la couche des gaussiennes
		for i=1:nb_noyaux
			sortie_noyaux(i)=exp(-(vec_a(h,:)-centre(i,:))*(vec_a(h,:)-centre(i,:))'/(2*sigma*sigma));
		end
		// calcul des sorties du réseau
		for j=1:nb_classes
			sortie_reseau(j,h)=0;
			for i=1:nb_noyaux
				sortie_reseau(j,h)=sortie_reseau(j,h)+sortie_noyaux(i)*w(i,j);
			end
			erreur(j)=(sortie_desiree(j,h)-sortie_reseau(j,h));
			erreur_cum=erreur_cum+erreur(j);
		end
 		// modification des poids pour la correction des erreurs
 		for j=1:nb_classes
			for i=1:nb_noyaux
				w(i,j)=w(i,j)+alpha*erreur(j)*sortie_noyaux(i);
			end
		end
	end		// fin boucle sur les vecteurs

	// nouveau calcul de l'erreur avec les données de test 
   	for h=1:nb_vec_t			// pour chaque vecteur d'apprentissage 
   		// calcul des sorties de la couche des gaussiennes 
		for i=1:nb_noyaux
      			sortie_noyaux(i)=exp(-(vec_t(h,:)-centre(i,:))*(vec_t(h,:)-centre(i,:))'/(2*sigma*sigma)); 
   		end
   		// calcul des sorties du réseau
   		for j=1:nb_classes 
      			sortie_reseau(j,h)=0; 
      			for i=1:nb_noyaux
      	 			sortie_reseau(j,h)=sortie_reseau(j,h)+sortie_noyaux(i)*w(i,j); 
         		end
        		erreur(j)=(sortie_desiree(j,h)-sortie_reseau(j,h)); 
      		end
   	end
	// mise en évidence de la réponse maximale : remplacement par 1 ; les autres par 0
	maxim=0;
	for j=1:nb_vec_t
		for i=1:nb_classes,
			if maxim<sortie_reseau(i,j) then
				indice=i;
				maxim=sortie_reseau(i,j);
			end,
	   	end
		maxim=0;
		for i=1:nb_classes,
			if indice==i then
				sortie_reseau(i,j)=1;
			else
				sortie_reseau(i,j)=0;
			end,
		end
	end
	sortie_reseau;

	// pourcentage d'erreur pour chaque classe
	for i=1:nb_classes									// initialisation
		identique(i)=0;
		different(i)=0;
	end
	for j=1:nb_vec_t
		for i=1:nb_classes
			if sortie_reseau(i,j)==sortie_desiree(i,j) then
				identique(i)=identique(i)+1;
			else
				different(i)=different(i)+1;
			end
		end
	end
	for i=1:nb_classes
		taux_reco(i)=identique(i)/(identique(i)+different(i))*100
	end
	taux_global=sum(taux_reco)/nb_classes

end		// fin des cycles d'apprentissage