def apprentissage(nlmap, ncmap,it,Tmax,Tmin) :
'''
% Code pour l'apprentissage en 2 phases de la Carte
En sortie :
sMap : La structure de la carte
Xapp : L'ensemble d'apprentissage
'''
from triedpy import triedsompy as SOM
# Positionnement du rand pour avoir ou pas le meme alea a chaque fois
seed = 0;
np.random.seed(seed);
# Creation d'une structure de carte initialisee (référents non initialisés)
initmethod='random'; # 'random', 'pca'
sMap = SOM.SOM('sMap', Xapp, mapsize=[nlmap, ncmap], norm_method='data', \
initmethod=initmethod)
# APPRENTISSAGE
#------------------------------------------------------------------
tracking = 'on'; # niveau de suivi de l'apprentissage
#____________
# paramètres 1ere étape :-> Variation rapide de la temperature
epochs1 = it; radius_ini1 =Tmax; radius_fin1 = 1.25;
etape1=[epochs1,radius_ini1,radius_fin1];
#
# paramètres 2ème étape :-> Variation fine de la temperature
epochs2 = it; radius_ini2 =1.25; radius_fin2 = Tmin;
etape2=[epochs2,radius_ini2,radius_fin2];
sMap.train(etape1=etape1,etape2=etape2, verbose=tracking);
print('Map[%dx%d](%d,%2.2f,%2.2f)(%d,%2.2f,%2.2f) '
%(nlmap,ncmap,epochs1,radius_ini1,radius_fin1,
epochs2,radius_ini2,radius_fin2),end='');
return sMap
def app_donnees(donnee, classname):
'''
% Code pour l'apprentissage en 2 phases de la Carte
% Topologique
En sortie :
sMap : La structure de la carte
Xapp, Xapplabels : L'ensemble d'apprentissage et le labels (classes) associés
classnames : Nom des classes (qui on servis à la labelisation)
'''
from triedpy import triedsompy as SOM
# if 0 : # Affichage des seules données
# plt.figure();
# plt.plot(donnee);
#==================================================================
# la CARTE TOPOLOGIQUE
#------------------------------------------------------------------
# Choix des dimensions de la CT : remplacer les 0 par les valeurs
# souhaitees des nombres de lignes (nlmap) et de colonne (ncmap)
nlmap = 7
ncmap = 7
# Nombre de lignes et nombre de colones
if nlmap <= 0 or ncmap <= 0:
print("app_lettre : mauvais choix de dimension pour la carte")
sys.exit(0)
#
# Creation d'une structure de carte initialisee (référents non initialisés)
initmethod = 'random'
# 'random', 'pca'
sMap = SOM.SOM('sMap', donnee, mapsize=[nlmap, ncmap], norm_method='data', \
initmethod=initmethod, varname=classnames)
#==================================================================
# APPRENTISSAGE
#------------------------------------------------------------------
tracking = 'on'
# niveau de suivi de l'apprentissage
#____________
# paramètres 1ere étape :-> Variation rapide de la temperature
epochs1 = 20
radius_ini1 = 5.00
radius_fin1 = 1.25
etape1 = [epochs1, radius_ini1, radius_fin1]
#
# paramètres 2ème étape :-> Variation fine de la temperature
epochs2 = 50
radius_ini2 = 1.25
radius_fin2 = 0.10
etape2 = [epochs2, radius_ini2, radius_fin2]
#
# Avec Sompy, les paramètres des 2 étapes sont passés en même temps pour l'
# apprentissage de la carte.
sMap.train(etape1=etape1, etape2=etape2, verbose=tracking)
#
print('Map[%dx%d](%d,%2.2f,%2.2f)(%d,%2.2f,%2.2f) ' %
(nlmap, ncmap, epochs1, radius_ini1, radius_fin1, epochs2,
radius_ini2, radius_fin2),
end='')
ctk.showmapping(sMap,
donnee,
bmus=[],
seecellid=1,
subp=True,
override=False)
plt.title("Etat Final")
#tmp = ctk.classifperf(sMap, Xapp, Xapplabels)
return sMap, donnee, classnames
])
Data = np.loadtxt("sst_mmoyB.txt")
Dapp = tls.centred(Data)
# Centrage et réduction
#======================================================================
# Carte Topologique
tseed = 0
print(tseed)
np.random.seed(tseed)
#----------------------------------------------------------------------
# Création de la structure de la carte
#--------------------------------------
nbl = 3
nbc = 5
# Taille de la carte
sm = SOM.SOM('sm', Dapp, mapsize=[nbl, nbc], norm_method='data', \
initmethod='random', varname=varname)
# Apprentissage de la carte QE TE
Parm_app = (3, 3., 1., 12, 1., 1.0)
# 3.193289 0.896840 0.440515 0.331517 0.6019
epoch1, radini1, radfin1, epoch2, radini2, radfin2 = Parm_app
etape1 = [epoch1, radini1, radfin1]
etape2 = [epoch2, radini2, radfin2]
sm.train(etape1=etape1, etape2=etape2, verbose='on')
#
bmus2 = mbmus(sm, Data=None, narg=2)
et = errtopo(sm, bmus2)
# dans le cas 'rect' uniquement
print("erreur topologique = %.4f" % et)
#
x = 0
A = SOM.grid_dist(sm, x)
print("----------------------------------------------------------------------")
for iloop in np.arange(n_tests):
#----------------------------------------------------------------------
if iloop < n_tests / 2 :
tseed = iloop
else:
tseed = np.long(time());
np.random.seed(tseed);
#tseed = 0; #tseed = 9;
#print("tseed=",tseed);
#----------------------------------------------------------------------
# Création de la structure de la carte_______________
norm_method = 'data'; # je n'utilise pas 'var' mais je fais centred à
# la place (ou pas) qui est équivalent, mais qui
# me permet de garder la maitrise du codage
sMapO = SOM.SOM('sMapObs', Dobs, mapsize=[nbl, nbc], norm_method=norm_method, \
initmethod='random', varname=varnames)
#print("NDobs(sm.dlen)=%d, dim(Dapp)=%d\nCT : %dx%d=%dunits" \
# %(sMapO.dlen,sMapO.dim,nbl,nbc,sMapO.nnodes));
#
# Apprentissage de la carte _________________________
etape1=[epoch1,radini1,radfin1]; etape2=[epoch2,radini2,radfin2];
qerr = sMapO.train(etape1=etape1,etape2=etape2, verbose='off',retqerrflg=True);
# + err topo maison
bmus2O = ctk.mbmus (sMapO, Data=None, narg=2);
etO = ctk.errtopo(sMapO, bmus2O); # dans le cas 'rect' uniquement
if np.sum(np.isnan(sMapO.codebook)) == 0 :
print("Obs, cas: {} .. {:3d} ... tseed: {} ... qerr: {:8.6f} ... terr: {:.4f}".format(
'',iloop,tseed,qerr,etO))
#
# Visualisation______________________________________
if 0 : #==>> la U_matrix
def do_ct_map_process(Dobs,
name=None,
mapsize=None,
tseed=SEED,
norm_method=None,
initmethod=None,
neigh=None,
varname=None,
step1=[5, 5, 2],
step2=[5, 2, 0.1],
verbose=VERBOSE,
retqerrflg=False):
"""
Training of a SOM on temperature data
:param Dobs: train data
:param name: SOM name
:param mapsize: size of the SOM [W, H] = W * H
:param tseed: default seed (from config.py)
:param norm_method: data normalization
:param initmethod: initialization method for SOM weights ('random' or 'pca')
:param neigh:
:param varname: name of variables
:param step1: parameters for the 1st training pass : [number of epochs, initialization radius, end of training radius]
:param step2: parameters for the 2nt training pass : [number of epochs, initialization radius, end of training radius]
:param verbose: verbosity (from config.py)
:param retqerrflg:
:return: the SOM model, quantification error, topological error
"""
if verbose:
print("Initializing random generator with seed={}".format(tseed))
print("tseed=", tseed)
np.random.seed(tseed)
# Création de la structure de la carte
if verbose:
smap_verbose = 'on'
else:
smap_verbose = 'off'
if name is None:
name = 'sMapObs'
if norm_method is None:
norm_method = 'data' # je n'utilise pas 'var' mais je fais centred Ã
# la place (ou pas) qui est équivalent, mais qui
# me permetde garder la maitrise du codage
if initmethod is None:
initmethod = 'random' # peut etre ['random', 'pca']
if neigh is None:
neigh = 'Guassian' # peut etre ['Bubble', 'Guassian'] (sic !!!)
# Initialisation de la SOM ________________________________________________
sMapO = SOM.SOM(name,
Dobs,
mapsize=mapsize,
norm_method=norm_method,
initmethod='random',
varname=varname)
# Apprentissage de la carte _______________________________________________
ttrain0 = time()
# Entrainenemt de la SOM __________________________________________________
eqO = sMapO.train(etape1=step1,
etape2=step2,
verbose=smap_verbose,
retqerrflg=retqerrflg)
if verbose:
print("Training elapsed time {:.4f}s".format(time() - ttrain0))
# + err topologique
bmus2O = ctk.mbmus(sMapO, Data=None, narg=2)
etO = ctk.errtopo(sMapO, bmus2O) # dans le cas 'rect' uniquement
if verbose:
print("Two phases training executed:")
print(
" - Phase 1: {0[0]} epochs for radius varying from {0[1]} to {0[2]}"
.format(step1))
print(
" - Phase 2: {0[0]} epochs for radius varying from {0[1]} to {0[2]}"
.format(step2))
return sMapO, eqO, etO