Estimation des précipitations par télédétection spatiale active et

Maîtrise d'Ingénierie Mathématique,
2003-2004
Estimation des précipitations
par télédétection spatiale
active et passive
Stagiaire : Sophie Demure
Responsables du stage : Nicolas Viltard et Cécile Mallet
Remerciements
Je tiens tout d’abord à exprimer mes sincères remerciements à Nicolas Viltard et Cécile
Mallet, mes tuteurs de stage, qui par leur aide, leurs conseils et leur disponibilité m’ont permis de
réaliser ce stage dans les meilleures conditions.
Je remercie aussi vivement toutes les personnes du CETP pour leur gentillesse, et en
particulier, les personnes d’ABM pour leur accueil très chaleureux.
Sommaire
1
1. Introduction ......................................................................................................... 3
1.1 Le CETP ............................................................................................................................... 3
1.2 Motivation ............................................................................................................................ 3
2. Restitution des taux précipitants radar à partir des mesures
radiométriques spatialesTMI.................................................................................. 3
2.1 Le radiomètre TMI et le radar PR ......................................................................................... 4
2.2 Généralités sur la théorie du transfert radiatif......................................................................... 4
2.3 Inversion des données radiométriques .................................................................................... 5
3. Introduction aux cartes de Kohonen ................................................................. 6
3.1 Généralités sur les réseaux de neurones .................................................................................. 6
3.1.1 Processeur élémentaire : le neurone ................................................................................. 6
3.1.2 Étapes de conception d'un réseau de neurones................................................................ 8
3.2. Cartes de Kohonen ou cartes auto-organisatrices (réseau de neurones non supervisé)............ 9
3.2.1 L'algorithme de Kohonen................................................................................................. 9
3.2.2 Utilisation pour la classification.................................................................................... 12
3.3 Exemples de cartes à partir de données simulées .................................................................. 12
3.3.1 Application en deux dimensions.................................................................................... 13
3.3.2 Application en trois dimensions.................................................................................... 16
4. Application aux températures de brillance TMI............................................. 23
4.1 Représentation des données................................................................................................. 23
4.2 Classification des données ................................................................................................... 27
5. Inversion des données radiométriques ........................................................... 36
6. Conclusion ......................................................................................................... 40
7. Bibliographie ...................................................................................................... 41
8. Annexes.............................................................................................................. 42
Annexe 1 : fonctions utilisées dans les programmes ................................................................... 42
Annexe 2 : programmes ............................................................................................................. 45
2
1. Introduction
1.1 Le CETP
Le Centre d'études des Environnements Terrestres et Planétaires est situé d'une part à Vélizy
dans l'enceinte de l'IUT, et d'autre part à St Maur-des-fossés. Le CETP est un laboratoire CNRS
rattaché à l'Université de Versailles St Quentin-en-Yvelines (UVSQ). Il est l'une des composantes de
l'Institut Pierre-Simon Laplace (IPSL) qui regroupe des laboratoires d’Ile-de-France qui étudient
l’environnement. Il est composé de plusieurs départements de recherche : les activités scientifiques
des départements EMI (Electrodynamique des Milieux Ionisés) et OPN (Ondes dans les Plasmas
Naturels) concernent pour l'essentiel l'étude des interactions du vent solaire avec les objets du
système solaire, les études amonts concernant la propagation des ondes électromagnétiques et les
méthodes statistiques sont assurées par le département EMA (Electromagnétisme et Méthodes
d'Analyse), l'étude des interactions entre la surface de la Terre ou de la mer et l'atmosphère par le
département IOTA (Interfaces Océan-Terre-Atmosphère), et l'étude des processus physiques
multi-échelles et rétroactions à l'oeuvre dans les phénomènes météorologiques par ABM
(Atmosphère Basse et Moyenne).
Mon sujet de stage consiste à mettre en œuvre une méthode statistique pour la mesure du
taux précipitant par télédétection spatiale. Il se situe dans le cadre d’une collaboration entre les
départements ABM et EMA.
1.2 Motivation
La mesure des taux de précipitation est un élément important pour l'étude du cycle de l'eau
dans l'atmosphère et pour améliorer les modèles de climat. La forte variabilité à la fois spatiale et
temporelle des précipitations les rend extrêmement difficiles à déterminer. Le premier instrument
pour mesurer la pluie, encore utilisé aujourd'hui, est le pluviomètre : il est constitué d'un récipient
permettant de mesurer l'eau liquide tombée en un temps donné.
Cependant, cet instrument ne permet pas d'estimer les taux de précipitation au-dessus des
océans qui représentent plus de 70% de la surface du globe. Seule une étude depuis l'espace peut
permettre une estimation globale. Les données du radiomètre TMI (TRMM Microwave Imager),
instrument embarqué sur le satellite TRMM (Tropical Rainfall Measuring Mission), sont utilisées
au CETP. Ce satellite, lancé fin 1997, est dédié à l'étude des précipitations en zone tropicale. En
effet, les précipitations dans les zones tropicales (-30N, +30N) représentent les deux tiers des
précipitations globales. Plusieurs autres capteurs ont été embarqués sur ce satellite et en particulier,
le premier radar spatial pour l'étude de la pluie : le radar PR (Precipitation Radar).
2. Restitution des taux précipitants radar à partir des
mesures radiométriques spatialesTMI
3
2.1 Le radiomètre TMI et le radar PR
La mesure radiométrique est appelée température de brillance. Les fréquences d'observations
se situent entre 1 GHz et 100 GHz correspondant à des longueurs d'onde de 30 cm à 3 mm. On
utilise des radiomètres multicanaux pour isoler les différents signaux atmosphériques :
-la glace aux hautes fréquences
-la vapeur d'eau aux fréquences proches de 22 GHz
-l'eau liquide aux basses fréquences.
Le radiomètre TMI, capteur passif, possède 9 canaux qui vont donc chacun être plus
spécifiquement sensibles à différents paramètres de l'atmosphère et de la surface.
-Tableau des fréquences et sensibilités du TMIFréquences
(GHz)
10.65
19.35
Polarisation
H-V
H-V
Sensibilité
Surf. / Liq
Liq.
21.3
37.0
85.5
V
H-V
H-V
Vap.
Liq. / Glace
Glace
Le balayage du TMI assure une fauchée de 760 km. Par une combinaison des différentes fréquences
radiométriques, les mesures du TMI sont ensuite interprétées en termes de contenus en
hydrométéores de la colonne atmosphérique (précipitation liquide, glace...).
Le PR, capteur actif, permet une mesure tridimensionnelle de la distribution du taux
précipitant au-dessus des terres et des océans. Il donne un taux de réflectivité qui peut être ensuite
converti en taux de pluie de surface (R ou Rain rates en mm.h-¹) ou en contenu en eau (W ou Water
contents en g.m-³). Le PR fonctionne à une fréquence de 13.8 GHz et effectue une fauchée de 215
km.
Il existe donc une zone commune entre la fauchée du radiomètre TMI et celle du radar PR.
Le but est de trouver une «relation» entre les températures de brillance et les taux de pluie à l'aide
des mesures réalisées dans cette zone commune, afin de pouvoir déterminer les taux de pluie dans les
zones où nous disposons que des mesures de températures de brillance.
2.2 Généralités sur la théorie du transfert radiatif
La fonction du TMI consiste à détecter le rayonnement électromagnétique émis par
l'atmosphère, la Terre et le fond cosmique, et à le convertir en une grandeur qui puisse être
interprétée.
Ce rayonnement thermique provenant d'un milieu naturel est modifié lors de sa propagation
dans les milieux adjacents, suite aux processus d'absorption, de diffusion et de réflexion.
Dans la configuration de mesure spatiale, le TMI, situé au-dessus de l'atmosphère, mesure le
rayonnement montant émergeant de l'atmosphère. Ce rayonnement est constitué de rayonnement
naturel de la surface et en partie atténué par l'atmosphère, du rayonnement émis vers le haut par
l'ensemble des couches atmosphériques et en partie atténué par les couches supérieures, et enfin du
rayonnement descendant provenant du fond cosmique réfléchi par la surface et en partie atténué par
4
l'atmosphère.
Schéma conceptuel de la mesure radiométrique au-dessus de l'océan
La relation directe entre les grandes géophysiques recherchées (dans notre cas le taux de
pluie) et les grandeurs radiométriques mesurées est connue sus le nom d’équation de transfert
radiatif. L'équation générale de transfert radiatif décrit l'évolution d'une onde électromagnétique à la
traversée d'un milieu. Elle résulte de l’intégration le long du trajet de l’onde de l’équation suivante
qui exprime la modification associée à un parcours infinitésimal ds :
d
I(r, s, í ) = - Ê e (r, s, í )I(r, s, í ) + Ê a (r, s, í )B(T, í ) + ?ç
P ( r , s , s ' , í ) I ( r , s ' , í ) dÙ '
ds
4!
où
I est le vecteur de Stokes modifié du rayonnement électromagnétique [4x1] qui se propage dans la
direction r , en provenance de la direction s à la fréquence ν
Ê e la matrice d'extinction [4x4]
Ê a le vecteur d'absorption [4x1]
P la matrice de phase [4x4]
ν la fréquence d'onde
I est relié aux températures de brillance et les termes d’extinction et d’absorption sont reliés au taux
de pluie. On ne peut pas résoudre cette équation à moins d’en faire une approximation.
2.3 Inversion des données radiométriques
Il existe différentes méthodes d'inversion des données radiométriques (températures de
brillance : TBs) pour la restitution de paramètres microphysiques tels que le taux de pluie de surface
(R). Elles peuvent être classées en 5 grandes catégories :
-la première, la plus utilisée, est basée par exemple, sur une régression linéaire (Alishouse et al.
5
1990) ou «log-linéaire» (Grody and Ferraro 1992) des TBs observées aux différentes fréquences
-la seconde approche utilise des algorithmes «itératifs», dont le principe repose sur l'ajustement
itératif des TBs simulées et observées en modifiant à chaque pas le profil de précipitations
(Kummerow et al. 1989; Obligis 1996; Kummerow and Giglio 1994).Ces méthodes posent un
problème de temps de calcul.
Dans tous les cas, le problème de la restitution de la pluie par radiométrie hyperfréquence est
très sous déterminée. Pour réduire l'espace des solutions aux solutions ayant un sens physique, les
deux autres familles reposent sur la construction préalable d'une base de données afin de réaliser
l'inversion :
-la troisième méthode est une méthode neuronale qui a été développée au CETP [Moreau 2002] en
réalisant une base de données constituée de TBs simulées par l’équation de transfert radiatif et
appliquée à un grand nombre de paramètres atmosphériques.
Un autre type d’approche consiste à essayer d’estimer à partir des TBs le taux précipitant fourni
par le radar PR en supposant ce dernier exact :
-la quatrième méthode s'appuie ainsi sur une approche bayésienne consistant à rechercher le taux de
pluie le plus probable à partir d'un ensemble d'exemples issus d'une base de données (Kumerrow et
al. 1996; Bauer et al. 2000; Viltard et al. 2000)
-la cinquième méthode, que je dois utiliser dans le cadre de ce stage, est une méthode de classification
non supervisée de type neuronale (cartes de Kohonen) afin d’étudier la topologie des TBs mesurées
indépendamment de tout modèle de transfert radiatif et de toute autre information. Dans un second
temps, j’utiliserai les données du radar PR pour étiqueter les classes obtenues. Le classifieur ainsi
réalisé pourra être utilisé pour inverser les données ; c’est-à-dire attribuer un taux précipitant à
chaque vecteur de TBs mesuré.
3. Introduction aux cartes de Kohonen
Les cartes de Kohonen ou cartes auto-organisatrices sont des réseaux de neurones
particuliers, qui permettent une classification non supervisée. Afin d’expliquer leur fonctionnement,
je présente dans un premier temps des généralités relatives aux réseaux de neurones.
3.1 Généralités sur les réseaux de neurones
Un réseau de neurones est constitué de processeurs élémentaires appelés neurones.
3.1.1 Processeur élémentaire : le neurone
Le neurone est caractérisé par :
- des signaux d'entrées s1, ..., sn
- une fonction de transition d'état ou d'activation f
- un signal de sortie sj
s1
si
f
sj = f(s1, ..., sn)
sn
6
- Le neurone produit scalaire :
s1
w1j
Σ
sn
Aj
sj = g(Aj) = g(wjt . s)
g
wnj
Produit scalaire : Aj = Σ wij si = wjt . s, pour i allant de 1 à n
i
et où wij : poids de la connexion de i vers j
le neurone produit scalaire est donc constitué de deux modules successifs : une transformation
linéaire (le produit scalaire) suivi d'une transformation g.
Fonctions d'activation g :
sj
sj
sj = tanh( kAj )
1
Aj
Aj
Aj
-1
fonction identité
fonction signe
fonction sigmoïde
k : pente à l'origine
- Le neurone distance :
s1
w1j
dist
sn
g
wnj
Distance : Aj = Σ (wij -si ) 2 = ||wj - s|| 2 pour i allant de 1 à n.
7
sj = g(Aj) = g(||wj - s||2)
i
Le neurone distance est donc constitué de deux modules successifs : un module de calcul de distance
suivi d'une transformation g. Les neurones distances comparent un prototype (leur vecteur de
poids) au signal d'entrée.
Fonctions d'activation g :
sj
sj
Aj
Aj
fonction identité
fonction noyau
Un réseau de neurones est un ensemble de neurones interconnectés, il est entièrement
caractérisé par :
- son architecture : nombre de neurones, schéma d'interconnexion
- les fonctions d'activation et les poids de connexion.
Les neurones scalaires sont utilisés dans les réseaux destinés à l’approximation de fonction
non linéaire. Les cartes de Kohonen sont constituées de neurones distance. Une fois l’architecture et
les fonctions d’activation choisis en fonction de l’application, les poids de connexion du réseau sont
obtenus par apprentissage à partir des données.
3.1.2 Étapes de conception d'un réseau de neurones
Voici chronologiquement les quatre grandes étapes qui doivent guider la création d'un réseau
de neurones.
Choix des échantillons : le processus d'élaboration d'un réseau de neurones commence
toujours par le choix des échantillons. Cette étape est cruciale et va aider le concepteur à déterminer
le type de réseau approprié pour résoudre son problème. La façon dont se présente l'échantillon
conditionne : le type de réseau, le nombre de cellules d'entrée, le nombre de cellules de sortie et la
façon dont il faudra mener l'apprentissage, les tests et la validation.
Élaboration de la structure du réseau : la structure du réseau dépend étroitement du type des
échantillons. Il faut d'abord choisir le type de réseau : un perceptron standard, un réseau de
Hopfield, un réseau à décalage temporel (TDNN), un réseau de Kohonen, un Artmap...
Apprentissage : cette phase consiste tout d'abord à calculer les pondérations optimales des
différentes liaisons, en utilisant un échantillon. La méthode la plus utilisée est la backpropagation :
on entre des valeurs aux cellules d'entrées et en fonction de l'erreur obtenue en sortie, on corrige les
poids accordés aux pondérations. C'est un cycle qui est répété jusqu'à ce que la courbe d'erreurs du
8
réseau converge (il faut bien prendre garde à ne pas sur-entraîner un réseau de neurones qui
deviendra alors moins performant). Il existe d'autres méthodes d'apprentissage telles que le
quickprop par exemple, mais la plus utilisée reste encore la rétropropagation. On peut distinguer
deux types d'apprentissage : l’apprentissage «supervisé» et l'apprentissage «non supervisé».
Lorsqu' on connaît en tous points ou seulement en certains points, les valeurs que doit avoir
la sortie du réseau en fonction des entrées correspondantes, on dit que l'apprentissage est
«supervisé» , métaphore qui signifie qu'un «professeur» peut fournir au réseau des «exemples» de ce
que celui-ci doit faire.
Un réseau de neurones peut également être utilisé dans un but de visualisation ou d'analyse de
données : on dispose d'un ensemble de données, représentées par des vecteurs de grande dimension,
et l'on cherche à les regrouper, selon des critères de ressemblance qui sont inconnus à priori. Ce type
de tâches est connu en statistique sous le nom de méthodes «d'agrégation» (en anglais clustering).
On peut utiliser les réseaux de neurones pour réaliser une tâche assez voisine : à partir de données
décrites par des vecteurs de grande dimension, trouver une représentation de ces données dans un
espace de dimension beaucoup plus faible (typiquement de dimension 2) tout en conservant les
«proximités» ou «ressemblances» entre ces données. Il n'y a donc pas là de «professeur», puisque
c'est au réseau de découvrir les ressemblances entre les éléments de la base de données, et de les
traduire par une proximité dans la carte de dimension 2 qu'il doit produire. Les réseaux à
apprentissage non supervisé les plus étudiés et utilisés sont les «cartes auto-organisatrices» ou
«cartes de Kohonen», ceux que nous utiliserons.
Validation : une fois le réseau calculé, il faut procéder à des tests pour vérifier que le réseau
réagit bien comme on le souhaite : c'est la validation. Il y a plusieurs méthodes pour faire cela : la
cross validation, le bootstrapping... La méthode la plus simple étant de garder une partie de
l'échantillon réservé à l'apprentissage pour la validation et faire ainsi une validation hors-échantillon.
3.2. Cartes de Kohonen ou cartes auto-organisatrices (réseau de neurones
non supervisé)
3.2.1 L'algorithme de Kohonen
Il s'agit d'un algorithme de représentation des données qui a été défini par Teuvo Kohonen
dans les années 80.
Soit un ensemble de données xi en dimension n et un réseau de N neurones disposés selon
une topologie déterminée :
- à 1, 2 ou 3 dimensions (j’utiliserai des réseaux à 2 dimensions),
- selon un maillage défini (carré, hexagonal . . .),
- avec une forme définie (ligne, carré, rectangle, cube, ...).
Exemples de différentes formes de neurones:
9
Carte carrée en dimension 2, chaque
neurone est représenté par un carré
hexagone
Carte carrée en dimension 2, chaque
neurone est représenté par un
Ces neurones sont dotés :
- d'un vecteur de poids wi qui pointe dans l'espace des données et susceptible d'être adapté,
- d'un voisinage sur l'espace du réseau,
- de relations de compétition entre les neurones vis-à-vis des données,
- de relations de coopération entre les neurones entre voisins pour l'adaptation.
L'objectif est de trouver des positions pour les vecteurs wi dans l'espace des données telle que la
topologie locale soit respectée : deux neurones voisins dans l'espace de sortie ont des vecteurs
voisins dans l'espace d'entrée.
L'algorithme est illustré par la figure ci-dessus : on part d'une distribution aléatoire des vecteurs de
poids wi, puis on choisit au hasard une donnée de l'ensemble d'apprentissage. A chaque itération :
1. on cherche le neurone i* dont le vecteur d'entrée wi est le plus proche de x, on l'appelle «neurone
gagnant», c'est la phase de compétition, i* = argmin( ||x- wi || )
i
2. on adapte le vecteur wi * dans la direction de la donnée x par l'expression :
wi *(t) = wi *(t-1) + α (t) [x-wi *(t-1)]
3. on adapte les vecteurs des neurones i dans un voisinage Vi * du neurone i* (phase de
coopération) par l'expression :
wi (t) = wi (t-1) + α (t) [x-wi (t-1)] . g (di i*/ λ(t)) , i Є Vi *
α (t) est le gain d'adaptation qui varie linéairement ou en 1/t, di i* est la distance, dans l'espace
des neurones, entre le neurone i et le neurone i*, g est la fonction noyau, λ(t) est le rayon du
voisinage qui décroît de la même manière que α (t).
10
On rapproche donc de la donnée les vecteurs poids du neurone gagnant et des neurones voisins.
Après un certain nombre d'itérations, quand la distribution des données est compatible avec la
structure du réseau, l'algorithme converge vers une situation où les vecteurs wi pavent l'espace
d'entrée en respectant la topologie locale correspondant à celle des neurones.
n
Sur la figure suivante, on visualise la quantification d'erreur, c’est-à-dire
‡”x
k =1
2
k
- w i*k (somme des
carrés des distances entre les données et leur neurone gagnant) et la position des neurones et des
données au bout d'une itération :
Figure du haut : quantification d’erreur en fonction du nombre d’itérations
Figure du bas : représentation des données + et des neurones o
Reprenons la même figure mais à la fin de l'apprentissage donc après plusieurs itérations :
11
Figure du haut : quantification d’erreur en fonction du nombre d’itérations
Figure du bas : représentation des données + et des neurones o
On observe donc que la quantification d'erreur converge et que les neurones se sont bien répartis sur
l'ensemble des données.
3.2.2 Utilisation pour la classification
Parmi les différentes applications réalisées à l'aide des cartes auto-organisatrices, un assez
grand nombre sont des tâches de classification. L'auto-organisation, telle que nous venons de la
décrire, ne permet pas de résoudre directement ce type de problèmes : le résultat de l'apprentissage
non supervisé permet d'affecter une observation à un neurone de la carte, indépendamment de toute
notion de classe. L'idée principale de l'algorithme de Kohonen est de faire apparaître des
groupements cohérents (les neurones de la carte) en relation avec l'application traitée. Si l'application
envisagée consiste en un problème de classification en S classes, les différents neurones doivent
s'intégrer au mieux avec celles-ci. On cherche alors à affecter chaque neurone de la carte à l'une des S
classes. Le problème de classification se résume à celui de l'étiquetage de chaque neurone de la carte
au moyen de l'une des S classes du problème.
3.3 Exemples de cartes à partir de données simulées
Pour me familiariser avec les fonctions de la toolbox Matlab «SOM Toolbox» développée
par l'équipe de Kohonen., j'ai dans un premier temps réalisé des programmes avec des données
simulées afin de comprendre l'impact de la variation des différents paramètres (taille de la carte,
rayon de voisinage, nombre d’itérations…) sur les résultats obtenus.
12
3.3.1 Application en deux dimensions
Le programme gaussdim2.m génère des données de densité de probabilité gaussienne : on
génère trois ensembles de données (X1, X2 et X3) en deux dimensions à l'aide de la fonction
gener1.m. On choisit pour ce programme des moyennes très différentes de façon à ce que les trois
ensembles soient bien disjoints :
Moyenne
X1
M1= [4 ; 4]
X2
M2= [-0.5 ; 0]
X3
M3= [9 ; 8]
On définit trois classes : les données de X1(respectivement X2, X3) appartiennent à la classe
1(respectivement 2,3). Voici les données obtenues :
On a au total 90 données : 40 pour X1, 30 pour X2, 20 pour X3. On choisit de faire une
carte avec 16 neurones, on effectue l'apprentissage de cette carte, voici la carte apprise :
13
Figure du haut : quantification d’erreur en fonction du nombre d’itérations
Figure du bas : représentation des données + et des neurones o
La quantification d'erreur converge bien et les neurones se sont bien répartis sur l'ensemble des
données.
Une fois la carte apprise, on peut déterminer pour chaque neurone l’ensemble des données
qui lui sont affectées, on peut ainsi attribuer au neurone l’étiquette qui correspond à la classe de ces
données. On étiquette donc les neurones avec la classe et le nombre de données par classe.
Voici la carte obtenue :
14
Sur la carte obtenue, on visualise les neurones suivant la première variable des vecteurs de données.
La barre de couleur représente les valeurs de la première variable des vecteurs poids des neurones.
On constate que la majorité des neurones dont la classe est 1 ont un poids à peu près égal à 4 (vert
sur l’échelle), ce qui correspond à la valeur choisie pour la première coordonnée de M1 (moyenne de
X1). Les neurones dont la classe est 2 ont un poids à peu près égal à -0.5 (bleu foncé), valeur
choisie pour la première coordonnée de M2. Il en est de même pour les neurones labellisés avec la
classe 3, puisqu'on on avait choisi 9 comme première coordonnée de M3.
Visualisation selon la seconde variable :
15
On peut faire les mêmes observations que pour la visualisation selon la première variable.
On fait une matrice de confusion qui permet de voir si les données sont bien ou mal classées :
en fait, on confronte les classes des données qu'on avait au départ avec celles obtenues après
recherche du neurone gagnant pour chaque donnée, on prend donc la classe du neurone auquel la
donnée est affectée. Voici la matrice de confusion obtenue :
cl1
cl2
cl3
cl1
40
0
0
cl2
0
30
0
cl3
0
0
20
Le but est d'avoir le maximum de données sur la diagonale puisque ce sont les données bien classées.
Dans l'exemple traité ici, les résultats sont tout à fait satisfaisants, ce qui est normal, puisque les
trois ensembles de données étaient très séparés au départ.
Ensuite arrive l'étape de validation, on crée un programme valid2d.m où l'on génère d'autres
données de densité de probabilité gaussienne avec la même moyenne et le même écart-type que dans
gaussdim2.m, et pour ces données on va chercher les neurones gagnants en se servant de la carte
apprise dans le programme gaussdim2.m. On peut alors comparer les matrices de confusion
obtenues : on obtient exactement la même matrice pour la validation que précédemment.
3.3.2 Application en trois dimensions
Le programme gaussdim3.m génère trois ensembles de données de densité de probabilité
gaussienne (X1, X2 et X3) en trois dimensions à l'aide de la fonction gener3D.m. On choisit cette
fois-ci des moyennes un peu plus proches que dans le programme précédent mais toujours
différentes de façon à ce que les trois ensembles soient relativement disjoints :
16
Moyenne
X1
M1= [1 ; 1 ; 1]
X2
M2= [-0.5 ; 0 ; 0]
X3 M3= [1.5 ; 1.5 ; 1.5]
On définit trois classes : les données de X1(respectivement X2, X3) appartiennent à la classe
1(respectivement 2,3). Voici les données obtenues :
On a au total 90 données : 40 pour X1, 30 pour X2, 20 pour X3. On choisit de faire une
carte avec 16 neurones, on effectue l'apprentissage de cette carte. Voici la carte apprise :
17
Figure du haut : quantification d’erreur en fonction du nombre d’itérations
Figure du bas : représentation des données + et des neurones o
On étiquette par la suite les neurones avec la classe et le nombre de données par classe. Voici la carte
obtenue :
18
Sur la carte obtenue, on visualise les neurones suivant la première variable des vecteurs de données.
Visualisation selon la seconde et la troisième variable :
19
On remarque que certains neurones sont labellisés avec plusieurs classes, on va donc étiqueter la
20
carte en prenant pour chaque neurone la classe avec le plus de données, c'est-à-dire la classe la plus
probable. Voici la nouvelle carte labellisée :
21
La valeur choisie pour les trois coordonnées de M1 est 1, on constate que certains neurones
labellisés avec la classe 1 ont une couleur correspondante à 1(donc un poids égal à 1) et d'autres non.
Ces résultats étaient prévisibles du fait que les trois ensembles de données ont été choisis beaucoup
plus proches que dans le programme précédent, c'est pour cela qu'un neurone peut à la fois avoir des
données de la classe 1, 2 et 3. Les neurones qui n'ont pas leur vecteur poids correspondant à la
valeur de la moyenne choisie au départ sont des neurones qui contiennent des données de différentes
classes (on peut le constater en comparant la carte labellisée avec toutes les classes et celle labellisée
avec la classe la plus probable).
Voici la matrice de confusion obtenue :
cl1
cl2
cl3
cl1
30
3
8
cl2
7
27
2
cl3
3
0
10
Seulement 60.3% des données sont bien classées : les résultats obtenus sont moins satisfaisants que
ceux du programme gaussdim2, du fait que les ensembles de données sont moins disjoints. On a par
exemple, 10 des 20 données de la classe 3 qui se retrouvent dans la classe 3 et 8 qui se retrouvent
dans la classe 1, donc mal classées.
On crée ensuite le programme de validation valid3d.m où l'on génère d'autres données de
densité de probabilité gaussienne avec la même moyenne et le même écart-type que dans
gaussdim3.m, et pour ces données on va chercher les neurones gagnants en se servant de la carte
apprise dans le programme gaussdim3.m. On peut alors comparer la matrice de confusion obtenue à
la précédente :
22
cl1
cl2
cl3
cl1
26
5
12
cl2
9
25
2
cl3
5
0
6
51.3% des données sont bien classées.
Les matrices sont assez voisines. Les performances en validation sont identiques à celles obtenues
en apprentissage. Les ambiguïtés ne sont pas dues à un mauvais apprentissage mais inhérentes au
problème lui-même.
4. Application aux températures de brillance TMI
4.1 Représentation des données
-Lecture du fichier de données
Le fichier d’apprentissage du programme classifTb.m contient des vecteurs de données et les
taux de pluie correspondants. Les vecteurs de données sont de dimension 9, ces 9 composantes
représentent les températures de brillance du radiomètre :
Températures
de
brillance
Tb1
Tb2
Tb3
Tb4
Tb5
Tb6
Tb7
Tb8
Tb9
Fréquences
(GHz)
10.65
10.65
19.35
19.35
21.3
37.0
37.0
85.5
85.5
Polarisation
H
V
H
V
V
H
V
H
V
On note X l'ensemble des vecteurs de données qui correspondent donc à des températures de
brillance. On note X_cls le vecteur contenant les classes des vecteurs de données, la classe est le taux
de pluie.
-Initialisation et apprentissage de la carte
Les ordres de grandeurs des températures de brillance étant légèrement différents, on
normalise les données afin de donner la même importance à chacun des canaux. La normalisation des
données se fait à l’aide de la fonction som_var_norm qui normalise la variance de chaque
composante à 1 et la moyenne à 0.
On a presque 15000 vecteurs de données, on peut donc choisir un nombre de neurones assez
grand : si il y a trop peu de neurones, il y aura trop de données par neurones et donc des taux de
pluie très différents, donc on ne pourra pas faire une bonne classification, mais si on veut que les
cartes restent lisibles on ne peut pas en prendre trop non plus. Après plusieurs tests, on a choisi
finalement de faire une carte avec 225 neurones. A la fin de l'apprentissage de la carte, on visualise
23
les données et les neurones suivant les différentes températures de brillance pour vérifier que la carte
a bien appris ; En effet, il faut que les neurones soient bien répartis sur tout l'ensemble des données.
On ne peut pas tracer des vecteurs de données de dimension 9, on va donc visualiser les données et
les neurones en deux dimensions ; Voici les figures obtenues en traçant par exemple Tb1 en fonction
de Tb2 :
Représentation des données + et des neurones o
Tb3 en fonction de Tb4 :
24
Représentation des données + et des neurones o
Tb4 en fonction de Tb5 :
Représentation des données + et des neurones o
Tb6 en fonction de Tb7 :
25
Représentation des données + et des neurones o
et Tb8 en fonction de Tb9 :
Représentation des données + et des neurones o
Les neurones sont bien répartis sur l'ensemble des données, la carte est donc bien apprise.
26
4.2 Classification des données
-Définition de classes
On attribue à chaque vecteur de données une classe en fonction du taux précipitant radar
correspondant :
Taux
précipitant
(en mm/h)
0 ≤ R< 0.1
0.1 ≤ R < 1
1≤ R<5
5 ≤ R < 10
R≥10
Classe
1
2
3
4
5
Plus de la moitié des vecteurs de données du fichier ont un taux de pluie inférieur à 1, c’est pourquoi
les classes correspondant aux taux de pluie faibles sont beaucoup plus étroites.
-Labellisation de la carte avec les classes définies
On étiquette les neurones avec la classe en ayant pris la classe la plus probable et le nombre
de données par classe, voici la carte étiquetée :
27
On peut observer une certaine relation entre les températures de brillance et le taux de pluie: les
neurones correspondant aux taux de pluie les plus forts (classe3, 4 et 5) sont ceux dont la
température de brillance à 37GHz est la plus forte, mais on ne peut pas généraliser cela à tous les
neurones : le neurone (1,3) (j'utilise la notation matricielle pour désigner les neurones) est étiqueté
classe 5 alors que sa température de brillance est plutôt basse.
Matrice de confusion obtenue sur l’ensemble d’apprentissage :
cl1
cl2
cl3
cl4
cl5
cl1
290
229
7
0
0
cl2
1468
5932
1140
6
3
cl3
11
678
3032
485
107
cl4
0
3
167
237
78
cl5
0
1
27
64
121
68.23% des données sont bien classées. En faisant varier les bornes des classes, on n’arrive pas
améliorer la matrice de confusion, d’où une autre approche.
-Labellisation de la carte avec le taux de pluie moyen et le plus probable
Étant donné que l'on a du mal à ajuster les intervalles des classes pour obtenir une matrice de
confusion satisfaisante, on décide de ne pas définir de classe. D'une part, on calcule le taux de pluie
moyen de chaque neurone en faisant la moyenne des taux de pluie des données du neurone. D'autre
28
part, on trace pour chacun des neurones son histogramme de taux de pluie (en prenant un pas de
1mm/h), et on récupère le taux de pluie pour lequel il y a le plus de données, c'est-à-dire le plus
probable. On peut remarquer que certains histogrammes (voir figure ci-après) sont très bons, par
exemple les histogrammes des neurones (1,13), (1,14), (3,10), (3,12) et bien d’autres : en effet, sur
ces histogrammes, on observe un pique pour un certain taux de pluie, donc beaucoup de données qui
ont le même taux de pluie et peu de données avec des taux de pluie différents, pour ces neurones on
peut donc prendre en compte le taux de pluie le plus probable. Au contraire, les histogrammes des
neurones (1,7), (3,1), (4,10) et bien d’autres aussi sont beaucoup moins satisfaisants : il y a
plusieurs taux de pluie qui ont le même nombre de données, pour ces neurones il faut donc mieux
prendre en compte le taux de pluie moyen. On va donc ensuite réaliser une carte où chacun des
neurones sera labellisé avec son taux de pluie moyen et son taux de pluie le plus probable, et où la
taille du neurone est proportionnelle au taux de pluie moyen.
29
30
31
Sur la carte étiquetée, on voit bien que les taux de pluie moyens les plus forts (les plus gros
neurones) sont en haut à gauche, alors qu’en bas à droite, on a des taux de pluie très faibles.
L’organisation de la carte réalisée uniquement à partir des données radiométriques donne bien de
l’information sur le taux de pluie correspondant.
Par contre, il y a beaucoup plus de neurones correspondant à des taux de pluie faibles
(<2mm/h) ; Or, nous sommes plus particulièrement intéressés par la restitution des taux de pluie les
plus forts, qui sont les plus rares, mais les plus importants d’un point de vue géophysique.
Carte réalisée en ayant pris que les données dont le taux de pluie est supérieur à 4mm/h
Comme il y a plus de la moitié des données dont le taux de pluie est inférieur à 1mm/h, dans
le programme classifTbfortR.m, on décide de réaliser une carte en effectuant l’apprentissage que sur
les données dont le taux de pluie est supérieur à 4mm/h, afin d’obtenir une classification plus précise
de ces données. Ainsi pour l’inversion des données, on pourra se servir de la combinaison des deux
cartes de Kohonen. Voici les histogrammes des taux de pluie obtenus ainsi que la carte des neurones
étiquetés avec le taux de pluie moyen et le plus probable :
32
33
34
35
La carte obtenue est plutôt satisfaisante car en regardant l'étiquetage des neurones, on voit qu'on a
un grand nombre de valeurs différentes des taux de pluie moyens.
5. Inversion des données radiométriques
Dans le programme inversion.m , on charge un fichier de données qui contient des vecteurs de
températures de brillance et les latitudes et longitudes correspondantes. Pour l’élaboration de la
première image, on recherche quel est le neurone gagnant pour chaque vecteur de donnée en se
servant uniquement de la carte réalisée à partir de tous les taux de pluie. On affecte alors à chaque
vecteur de donnée le taux de pluie moyen du neurone gagnant. On crée alors un nouveau tableau avec
la latitude, la longitude et le taux de pluie moyen correspondant et on se sert de ce tableau pour
réaliser une image où l’on place les points dont les coordonnées sont la latitude et la longitude et la
couleur représente le taux de pluie. Voici l'image obtenue :
Carte des taux de pluie réalisée en utilisant une carte de Kohonen
On peut la comparer avec l’image qui a été faite en utilisant une approche bayésienne comme
méthode d’inversion des données. Voici l’image :
36
Carte des taux de pluie réalisée en utilisant une approche bayésienne
L’image de référence qui sert de comparaison est celle réalisée à partir des taux de pluie radar :
Carte des taux de pluie restitués par le radar
37
Le but est donc d’obtenir une image qui se rapproche le plus possible de l’image radar. On va donc
réaliser une seconde image en combinant les deux réseaux de neurones et en se servant à la fois du
taux de pluie moyen et du taux de pluie le plus probable :
- on recherche quel est le neurone gagnant pour chaque vecteur de données en se servant dans un
premier temps de la carte réalisée à partir de tous les taux de pluie. On affecte alors à chaque vecteur
de données le taux de pluie le plus probable du neurone gagnant, si celui-ci est représenté par au
moins 20% des données, sinon on prend le taux de pluie moyen du neurone gagnant,
- on récupère alors les vecteurs de données pour lesquels on a trouvé un taux de pluie supérieur à
4mm/h, et on se sert alors de la carte réalisée à partir des taux de pluie supérieurs à 4mm/h pour ces
données. On recherche donc le neurone gagnant pour chaque vecteur de données, et comme
précédemment, on affecte à chaque vecteur le taux de pluie le plus probable du neurone gagnant, si
celui-ci est représentée par au moins 20% des données, sinon on prend le taux de pluie moyen du
neurone gagnant,
- on crée alors un nouveau tableau avec la latitude, la longitude et le taux de pluie correspondant.
Voici l'image obtenue :
Carte des taux de pluie réalisée en utilisant deux cartes de Kohonen
On obtient donc une image relativement proche de l’image faite à partir des taux de pluie radar. On
retrouve bien les zones où il pleut fortement et les zones où il pleut très peu aux mêmes latitude et
longitude. Cependant, le taux de pluie maximum (10.82mm/h) n’est pas aussi élevé que celui obtenu
sur l’image radar (15.90mm/h), et sur notre image on a quelques zones de taux de pluie forts qui ne
sont pas présentes sur l’image radar.
38
Enfin, on a calculé pour chaque neurone son écart-type de taux de pluie, puis on a créé un
tableau avec la latitude, la longitude et l’écart-type correspondant, on a donc pu faire une nouvelle
image :
Carte des écarts-type
En comparant cette image avec l’image des taux de pluie que j’ai faite, on peut remarquer que les
écarts-type les plus grands correspondent aux taux de pluie les plus forts, ce qui explique donc le
fait qu’on ait quelques différences entre mon image des taux de pluie et celle du radar dans les zones
où il pleut fort.
39
6. Conclusion
La réalisation de cartes de Kohonen, méthode de classification non supervisée de type
neuronale, m’a donc servie à inverser les données radiométriques afin de restituer le taux de pluie.
L’image obtenue au bout de trois mois de stage est plutôt satisfaisante ; Bien entendu, elle n’est pas
définitive : on peut continuer à faire des recherches pour l’affiner, et avoir une image encore plus
ressemblante à l’image du radar.
Pour améliorer les résultats, on pourrait par exemple corriger l’étiquetage de certains
neurones. En effet, pour un neurone n’ayant pas un histogramme satisfaisant, il faudrait prendre en
compte les taux de pluie des neurones voisins, et le labelliser suivant ces taux de pluie.
Une autre idée consisterait à calculer d’une autre façon les taux de pluie moyens des
neurones. Au lieu de faire la moyenne des taux de pluie des données pour chaque neurone, on
pourrait calculer une moyenne pondérée par les distances des données au neurone : ainsi, les
données les plus proches du neurone auront plus de poids que les données les plus éloignées.
Ce stage m’a été très enrichissant et très bénéfique. En effet, d’une part, il m’a permis de
consolider mes connaissances en Matlab, puisque j’ai dû réaliser des programmes en utilisant des
fonctions de la toolbox que je ne connaissais absolument pas. D’autre part, je n’avais aucune notion
en physique de télédétection et sur les réseaux de neurones. J’ai donc appris quelques généralités sur
la physique en télédétection, et j’ai acquis des connaissances sur le fonctionnement d’un réseau de
neurones, et surtout, sur la réalisation de cartes de Kohonen.
40
7. Bibliographie
[Dreyfus 2002] G.Dreyfus, J.-M. Martinez, M. Samuelides, M. B. Gordon, F. Badran, S. Thiria,
L. Hérault, 'Réseaux de neurones, méthodologie et applications',Eyrolles , janvier 2002.
[Moreau 2000] 'Restitution de paramètres atmosphériques par radiométrie hyperfréquence spatiale.
Utilisation de méthodes neuronales'.
[Burlaud 2003] 'Restitution des profils de dégagement de chaleur latente par radiométrie
hyperfréquence. Application aux cyclones tropicaux'.
[Thiria 1997] Sylvie Thiria, Yves Lechevallier, Olivier Gascuel, Stéphane Canu, 'Statistique et
méthodes neuronales', Dunod, septembre 1997.
41
8. Annexes
Annexe 1 : fonctions utilisées dans les programmes
-fonctions utilisées pour la génération de données de densité de probabilité gaussienne :
gener1 : fonction qui génère un nuage de points 2D selon une loi gaussienne de moyenne M et
d'écart-type E et qui retourne la matrice de coordonnées à deux colonnes (x, y) de n points
générés
->arguments ([ ] sont optionnels)
n
[M]
[E]
[theta]
(scalar) nombre de points
(vector) moyenne du nuage en 2 dimensions, par défaut [0,0]
(vector) écart-type du nuage, par défaut [1,1]
(scalar) angle d'Azimuth selon lequel le nuage est tourné autour de son
centre, par défaut 0
gener3D : fonction qui génère un nuage de points 3D selon une loi gaussienne de moyenne M et
d'écart-type E et qui retourne la matrice de coordonnées à trois colonnes (x, y, z) de n
points générés
->arguments ([ ] sont optionnels)
n
[M]
[E]
[theta]
(scalar) nombre de points
(vector) moyenne du nuage en 3 dimensions, par défaut [0,0,0]
(vector) écart-type du nuage, par défaut [1,1,1]
(scalar) angle d'Azimuth selon lequel le nuage est tourné autour de son
centre, par défaut 0
Les fonctions suivantes utilisées sont dans la toolbox Matlab «SOM Toolbox» développée
par l'équipe de Kohonen.
-Définition et initialisation de la carte
som_data_struct : fonction qui donne la structure des données d'une carte auto-organisatrice
->arguments ([ ] sont optionnels)
data
[name]
(scalar) matrice de données
(string) nom de la table de données
42
[labels]
(cell matrix) label pour chaque vecteur de données
[comp_names] (cell array) nom de chaque composante des données
[normalization] (string) nom de la méthode de normalisation (on utilisera 'som_var_norm '
normalisation de la variance)
som_normalize_data : fonction qui normalise la matrice de données ou la structure de données
->arguments ([ ] sont optionnels)
sData
[arg]
(struct or matrix) structure de données ou matrice de données avec des
données non normalisées
(string or struct) définit la méthode de normalisation, on utilisera
'som_var_norm' qui normalise la variance de chaque composante à 1 et la
moyenne à 0.
som_init : fonction qui crée et initialise une carte auto-organisatrice
->arguments ([ ] sont optionnels)
sData
(struct or matrix) structure de données ou matrice de données
[msize]
[init_type]
(vector) dimensions de la carte
(string) type d'initialisation linéaire ('linear') ou aléatoire ('random'), par
défaut linéaire
(string) type de treillis de la carte 'rect' ou 'hexa', par défaut 'hexa'
(string) forme de la carte 'rect' ou 'cyl' ou 'toroid', par défaut 'rect'
[lattice]
[shape]
-Apprentissage ou entraînement de la carte
som_train : fonction qui effectue l'apprentissage de la carte auto-organisatrice
->arguments ([ ] sont optionnels)
sMap
sData
[epochs]
[radius]
[alpha_ini]
[alpha_type]
[tracking]
(struct) structure de la carte auto-organisatrice
(struct or matrix) structure de données ou matrice de données utilisée pour
l'apprentissage
(scalar) nombre d'itérations
(scalar or vector) rayon initial d'apprentissage (radius_ini) ou rayons initial
et final d'apprentissage ([radius-ini radius_fin])
(scalar) le taux initial d'apprentissage
(string) fonction du taux d'apprentissage 'linear' ou 'inv', par défaut 'linear'
(scalar) niveau de la surveillance
0 - temps
1 - temps et quantification de l'erreur
2 - tracé de la quantification de l'erreur
3 - tracé de la quantification de l'erreur et des 2 premières composantes
43
-Étiquetage
som_label : fonction qui ajoute les labels sur une carte ou efface les labels d'une carte
->arguments ([ ] sont optionnels)
sTo
inds
Labels
[mode]
(struct) table ou structure dans laquelle sont mis les labels
(vector or matrix or string) indices des vecteurs dans lesquels sont mis les
labels
(string matrix or cell matrix of strings or cell array of cells) les labels
(string) 'add' ou 'replace' ou 'clear', par défaut 'add'
som_hits : fonction qui calcule le nombre de données pour chaque neurone de la carte
->arguments ([ ] sont optionnels)
sMap
sData
(struct or matrix) structure de la carte auto-organisatrice ou matrice des
vecteurs de poids
(struct or matrix) structure de données ou matrice de vecteurs de données
som_show : fonction qui affiche la carte les composantes sélectionnées et la u-matrice, celle-ci
permet de visualiser la distance entre les neurones
->arguments ([ ] sont optionnels)
sMap
[comps]
[scale]
[colorbardir]
[M]
(struct) structure de la carte auto-organisatrice
(vector or string) vecteur des indices des composantes ou chaîne de
caractères 'all', par défaut 'all'
(string) pour afficher des valeurs de données normalisées ou
dénormalisées, 'normalized' ou 'denormalized', par défaut 'normalized'
(string) direction de la barre de couleurs, 'horiz' ou 'vert', par défaut 'vert'
(matrix) matrice de données spécifiant la taille de chaque neurone, par
défaut 1
som_addlabels : fonction qui écrit les labels sur la figure
->arguments ([ ] sont optionnels)
sMap
[lab_n]
[p]
[points]
[clr]
(struct) structure de la carte auto-organisatrice
(matrix or string) matrice ou chaîne de caractères ('all' par défaut) qui
indique quels labels doivent être affichés
(vector or string) vecteur ou chaîne de caractères ('all' par défaut) qui
indique quels neurones sont étiquetés
(scalar) taille de la police, par défaut 10
(string) couleur de la police, par défaut noire
44
som_bmus : fonction qui trouve les neurones gagnants (the Best Matching Units) de la carte pour
les vecteurs donnés et qui retourne le neurone gagnant pour chaque vecteur de données
et la quantification d'erreur correspondante.
->arguments ([ ] sont optionnels)
sMap
sData
[which]
[mask]
(struct or martix) structure de la carte auto-organisatrice
(struct or matrix) structure de données ou matrice de données
(vector) quels neurones gagnants doivent être retournés, par défaut
seulement le premier
(vector) vecteur utilisé dans le calcul de la distance, par défaut lu dans
sMap
Annexe 2 : programmes
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
PROGRAMME GAUSSDIM2
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
clear all
close all
rep1=input('voulez vous creer un nouveau fichier de donnees
(O)\n ou
utiliser le fichier existant
(1)?\n')
rep2=input('voulez vous creer une nouvelle carte
(O)\n ou continuer l
apprentissage de la meme carte
(1)?\n')
if rep1 == 0
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%Génération de trois ensembles de données gaussiennes :
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
X1=gener1(40,[4 4],[1 1]);
X2=gener1(30,[-0.5,0],[1,1]);
X3=gener1(20,[9 8],[1 1]);
X1_cls=ones(40,1);
X2_cls=2*ones(30,1);
X3_cls=3*ones(20,1);
X=[X1;X2;X3];
X_cls=[X1_cls ; X2_cls;X3_cls];
%on visualise les données
plot(X1(:,1),X1(:,2),'b*',X2(:,1),X2(:,2),'r*',X3(:,1),X3(:,2),'g*');
title('Visualisation des données');
legend('X1','X2','X3');
pause
n_data=length(X_cls);
%%%%%%%%%%%%%%%%%%%%%%
%definition de labels
%%%%%%%%%%%%%%%%%%%%%%
45
g_labs=cell(n_data,1);
for g_cell=1:n_data,
g_labs{g_cell}={ sprintf('%d', X_cls(g_cell)) };
end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%definition des noms des variables d'entree
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
g_varnames={ {'var1'},{'var2'} };
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%definition de la structure des donnees
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
sData=som_data_struct(X,'gaussienne',g_labs,g_varnames);
else
load sData;
end
save sData sData X X_cls;
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%initialisation de la carte topologique
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
if rep2 == 0
msize=[4 4];
init_type='random';
lattice='hexa';
shape='rect';
sMap=som_init(sData,msize,init_type,lattice,shape);
%%%%%%%%%%%%%%%%%%%%%%%%%%%
%apprentissage de la carte
%%%%%%%%%%%%%%%%%%%%%%%%%%%
%entrainement de la carte
radius=[3 1];
alpha=0.1;
alpha_type='linear';
tracking=3;
sMap=som_train(sMap,sData,1,radius,alpha,alpha_type,tracking);
pause
epochs=44;
radius=[3 1];
alpha=0.1;
alpha_type='linear';
tracking=3;
sMap=som_train(sMap,sData,epochs,radius,alpha,alpha_type,tracking);
%entrainement fin de carte;
epochs=60;
radius=[1 0.3];
alpha=0.05;
alpha_type='linear';
tracking=3;
sMap=som_train(sMap,sData,epochs,radius,alpha,alpha_type,tracking);
pause
else
load sMap;
46
%entrainement de la carte
epochs=45;
radius=[0.3 0.1];
alpha=0.05;
alpha_type='linear';
tracking=3;
sMap=som_train(sMap,sData,epochs,radius,alpha,alpha_type,tracking);
end
%%%%%%%%%%%%%%%%%%%%
%effacer tout label
%%%%%%%%%%%%%%%%%%%%
sMap=som_label(sMap,'clear');
%%%%%%%%%%%%%%%%%
%calcul des hits
%%%%%%%%%%%%%%%%%
Hits=som_hits(sMap,sData);
%%%%%%%%%%%%%%%%%%%%%%%%%
%Visualisation des poids
%%%%%%%%%%%%%%%%%%%%%%%%%
figure
h=som_show(sMap);
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%ajout de la cardinalite comme label et affichage
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
H1=Hits(:);
I1=1:length(H1);
sMap=som_label(sMap,I1',num2cell(H1));
title('labelliser avec le nombre de donnees par cellule');
h1b1=som_addlabels(sMap);
%%%%%%%%%%%%%%%%%%%%
%effacer tout label
%%%%%%%%%%%%%%%%%%%%
sMap=som_label(sMap,'clear');
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%labelliser chaque cellule avec la classe et la cardinalite
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
[Bmus, Qerrors]=som_bmus(sMap,sData);
Hits=som_hits(sMap,sData);
nbclasses=max(X_cls);
%on definit et remplit une matrice de cardinalite par classe et par
%cellule
Matclass=zeros(prod(sMap.msize),nbclasses);
for gDon=1:length(X_cls)
gCell=Bmus(gDon);
Matclass(gCell,X_cls(gDon))=Matclass(gCell,X_cls(gDon))+1;
end
%boucle par cellule de la carte
for gCell=1:prod(sMap.msize)
%boucle par classe et recherche de donnees
%de la classe dans la cellule gCell de la boucle
47
cellLabels=cell(1);
for gClass=1:nbclasses
if Matclass(gCell,gClass)~=0
cellLabels{1}=[num2str(gClass) '(' num2str(Matclass(gCell,gClass))
')' ];
sMap=som_label(sMap,gCell,cellLabels{1});
end
end
end
for i=1:2
figure
h=som_show(sMap,i);
hlbl=som_addlabels(sMap);
end
%%%%%%%%%%%%%%%%%%%%
%effacer tout label
%%%%%%%%%%%%%%%%%%%%
sMap=som_label(sMap,'clear');
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%on labellise avec la classe la plus probable
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%boucle par cellule de la carte
for gCell=1:prod(sMap.msize)
%boucle par classe et recherche de donnees
%de la classe dans la cellule gCell de la boucle
cellLabels=cell(1);
mx=0;
cellLabels{1}=[num2str(0) '(' num2str(0) ')' ];
for gClass=1:nbclasses
if Matclass(gCell,gClass)~=0
if Matclass(gCell,gClass)>mx;
cellLabels{1}=[num2str(gClass) '('
num2str(Matclass(gCell,gClass)) ')' ];
mx=Matclass(gCell,gClass);
end
end
end
sMap=som_label(sMap,gCell,cellLabels{1});
end
for i=1:2
figure
h=som_show(sMap,1);
hlbl=som_addlabels(sMap);
end
save sMap sMap Matclass;
%on recupere les labels
[N,C]=max(Matclass');
[Bmus, Qerrors]=som_bmus(sMap,sData);
C_cls=C(Bmus)
%%%%%%%%%%%%%%%%%%%%%%
%Matrice de confusion
%%%%%%%%%%%%%%%%%%%%%%
48
c=max(X_cls);
confuse=0*ones(c,c);
for i=1:length(X_cls)
confuse(X_cls(i),C_cls(i))=confuse(X_cls(i),C_cls(i))+1;
end
confuse
%on obtient :
%confuse =
%
%
%
40
0
0
0
30
0
0
0
20
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
PROGRAMME VALID2D
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
clear all
close all
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%Génération de trois ensembles de données gaussiennes :
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
X1=gener1(40,[4 4],[1 1]);
X2=gener1(30,[-0.5,0],[1,1]);
X3=gener1(20,[9 8],[1 1]);
X1_cls=ones(40,1);
X2_cls=2*ones(30,1);
X3_cls=3*ones(20,1);
Xval=[X1;X2;X3];
Xval_cls=[X1_cls ; X2_cls;X3_cls];
plot(X1(:,1),X1(:,2),'b*',X2(:,1),X2(:,2),'r*',X3(:,1),X3(:,2),'g*');
pause
n_data=length(Xval_cls);
%%%%%%%%%%%%%%%%%%%%%%
%definition de labels
%%%%%%%%%%%%%%%%%%%%%%
g_labs=cell(n_data,1);
for g_cell=1:n_data,
g_labs{g_cell}={ sprintf('%d', Xval_cls(g_cell)) };
end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%definition des noms des variables d'entree
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
g_varnames={ {'var1'},{'var2'} };
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%definition de la structure des donnees
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
sDatavalidation=som_data_struct(Xval,'gaussienne',g_labs,g_varnames);
load sMap ;
49
%on recupere les labels
[N,C]=max(Matclass');
[Bmus, Qerrors]=som_bmus(sMap,sDatavalidation);
Cval_cls=C(Bmus);
%%%%%%%%%%%%%%%%%%%%%%
%Matrice de confusion
%%%%%%%%%%%%%%%%%%%%%%
c=max(Xval_cls);
confuse=0*ones(c,c);
for i=1:length(Xval_cls)
confuse(Xval_cls(i),Cval_cls(i))=confuse(Xval_cls(i),Cval_cls(i))+1;
end
confuse
%on obtient
%confuse =
%
%
%
40
0
0
0
30
0
0
0
20
%%%%%%%%%%%%%%%%%%%%%%%%
%Matrice de probabilité
%%%%%%%%%%%%%%%%%%%%%%%%
[Bmus, Qerrors]=som_bmus(sMap,sDatavalidation);
Cval_cls=Matclass(Bmus,:);
proba=zeros(size(Cval_cls));
nbcol=size(Cval_cls,2);
for i=1:length(Cval_cls)
sligne=sum(Cval_cls(i,:));
if sligne==0
for j=1:nbcol
proba(i,j)=0;
end
else
for j=1:nbcol
proba(i,j)=Cval_cls(i,j)/sligne;
end
end
end
seuil=input('choisissez un seuil entre 0 et 1\n');
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%Nouvelle matrice de confusion
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
c=max(Xval_cls);
confuse2=0*ones(c,c+1);
[N,Cv]=max(proba');
I=find(N>seuil);
Cv_cls(I)=Cv(I);
I=find(N<=seuil);
Cv_cls(I)=c+1;
for i=1:length(Xval_cls)
confuse2(Xval_cls(i),Cv_cls(i))=confuse2(Xval_cls(i),Cv_cls(i))+1;
end
confuse2
%on obtient
50
% confuse2 =
%
%
%
40
0
0
0
30
0
0
0
20
0
0
0
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
PROGRAMME GAUSSDIM3
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
close all
rep1=input('voulez vous creer un nouveau fichier de donnees
(O)\n ou
utiliser le fichier existant
(1)?\n');
rep2=input('voulez vous creer une nouvelle carte
(O)\n ou continuer l
apprentissage de la meme carte
(1)?\n')
if rep1 == 0
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%Génération de trois ensembles de données gaussiennes :
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
[z X1]= gener3D(40,[1,1,1],[1,1,1],60);
[Z X2]=gener3D(30,[-0.5,0, 0],[1,1,1],20);
[Z X3]=gener3D(20,[1.5,1.5, 1.5],[1,1,1],20);
X1_cls=ones(40,1);
X2_cls=2*ones(30,1);
X3_cls=3*ones(20,1);
X=[X1;X2;X3];
X_cls=[X1_cls ; X2_cls;X3_cls];
%visualisation des donnees
plot3(X1(:,1),X1(:,2),X1(:,3),'b*',X2(:,1),X2(:,2),X2(:,3),'r*',X3(:,1),X3(:,2),
X3(:,3),'g*');
grid on
title('Visualisation des données');
legend('X1','X2','X3');
pause
n_data=length(X_cls);
%%%%%%%%%%%%%%%%%%%%%%
%definition de labels
%%%%%%%%%%%%%%%%%%%%%%
g_labs=cell(n_data,1);
for g_cell=1:n_data
g_labs{g_cell}={ sprintf('%d', X_cls(g_cell)) };
end
51
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%definition des noms des variables d'entree
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
g_varnames={ {'var1'},{'var2'},{'var3'} };
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%definition de la structure des donnees
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
sData=som_data_struct(X,'gaussienne',g_labs,g_varnames);
else
load sData;
end
save sData sData X X_cls;
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%initialisation de la carte topologique
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
if rep2 == 0
msize=[4 4];
init_type='random';
lattice='hexa';
shape='rect';
sMap=som_init(sData,msize,init_type,lattice,shape);
%%%%%%%%%%%%%%%%%%%%%%%%%%%
%apprentissage de la carte
%%%%%%%%%%%%%%%%%%%%%%%%%%%
%entrainement de la carte
epochs=45;
radius=[5 1];
alpha=0.1;
alpha_type='linear';
tracking=3;
sMap=som_train(sMap,sData,epochs,radius,alpha,alpha_type,tracking);
%entrainement fin de carte
epochs=90;
radius=[1 0.3];
alpha=0.05;
alpha_type='linear';
tracking=3;
sMap=som_train(sMap,sData,epochs,radius,alpha,alpha_type,tracking);
pause
else
load sMap;
%entrainement de la carte
epochs=45;
radius=[0.3 0.1];
alpha=0.05;
alpha_type='linear';
tracking=3;
sMap=som_train(sMap,sData,epochs,radius,alpha,alpha_type,tracking);
end
%%%%%%%%%%%%%%%%%%%%
%effacer tout label
%%%%%%%%%%%%%%%%%%%%
52
sMap=som_label(sMap,'clear');
%%%%%%%%%%%%%%%%%
%calcul des hits
%%%%%%%%%%%%%%%%%
Hits=som_hits(sMap,sData);
%%%%%%%%%%%%%%%%%%%%%%%%%
%Visualisation des poids
%%%%%%%%%%%%%%%%%%%%%%%%%
figure
h=som_show(sMap);
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%ajout de la cardinalite comme label et affichage
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
H1=Hits(:);
I1=1:length(H1);
sMap=som_label(sMap,I1',num2cell(H1));
title('labelliser avec le nombre de donnees par cellule');
h1b1=som_addlabels(sMap);
%%%%%%%%%%%%%%%%%%%%
%effacer tout label
%%%%%%%%%%%%%%%%%%%%
sMap=som_label(sMap,'clear');
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%labelliser chaque cellule avec la classe et la cardinalite
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
[Bmus, Qerrors]=som_bmus(sMap,sData);
Hits=som_hits(sMap,sData);
nbclasses=max(X_cls);
%on definit et remplit une matrice de cardinalite par classe et par
%cellule
Matclass=zeros(prod(sMap.msize),nbclasses);
for gDon=1:length(X_cls)
gCell=Bmus(gDon);
Matclass(gCell,X_cls(gDon))=Matclass(gCell,X_cls(gDon))+1;
end
%boucle par cellule de la carte
for gCell=1:prod(sMap.msize)
%boucle par classe et recherche de donnees
%de la classe dans la cellule gCell de la boucle
cellLabels=cell(1);
for gClass=1:nbclasses
if Matclass(gCell,gClass)~=0
cellLabels{1}=[num2str(gClass) '(' num2str(Matclass(gCell,gClass))
')' ];
sMap=som_label(sMap,gCell,cellLabels{1});
end
end
end
for i=1:3
figure
h=som_show(sMap,i);
hlbl=som_addlabels(sMap);
53
end
%%%%%%%%%%%%%%%%%%%%
%effacer tout label
%%%%%%%%%%%%%%%%%%%%
sMap=som_label(sMap,'clear');
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%on labellise avec la classe la plus probable
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%boucle par cellule de la carte
for gCell=1:prod(sMap.msize)
%boucle par classe et recherche de donnees
%de la classe dans la cellule gCell de la boucle
cellLabels=cell(1);
mx=0;
cellLabels{1}=[num2str(0) '(' num2str(0) ')' ];
for gClass=1:nbclasses
if Matclass(gCell,gClass)~=0
if Matclass(gCell,gClass)>mx;
cellLabels{1}=[num2str(gClass) '('
num2str(Matclass(gCell,gClass)) ')' ];
mx=Matclass(gCell,gClass);
end
end
end
sMap=som_label(sMap,gCell,cellLabels{1});
end
for i=1:3
figure
h=som_show(sMap,i);
hlbl=som_addlabels(sMap);
end
save sMap sMap Matclass;
%%%%%%%%%%%%%%%%%%%%%%%%
%on recupere les labels
%%%%%%%%%%%%%%%%%%%%%%%%
[N,C]=max(Matclass');
[Bmus, Qerrors]=som_bmus(sMap,sData);
C_cls=C(Bmus)
%%%%%%%%%%%%%%%%%%%%%%
%Matrice de confusion
%%%%%%%%%%%%%%%%%%%%%%
c=max(X_cls);
confuse=0*ones(c,c);
for i=1:length(X_cls)
confuse(X_cls(i),C_cls(i))=confuse(X_cls(i),C_cls(i))+1;
end
confuse
%on obtient :
%confuse =
%
30
7
3
54
%
%
3
8
27
2
0
10
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% PROGRAMME VALID3D
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
close all
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%Génération de trois ensembles de données gaussiennes :
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
[z X1]= gener3D(40,[1,1,1],[1,1,1],60);
[Z X2]=gener3D(30,[-0.5,0, 0],[1,1,1],20);
[Z X3]=gener3D(20,[1.5,1.5, 1.5],[1,1,1],20);
X1_cls=ones(40,1);
X2_cls=2*ones(30,1);
X3_cls=3*ones(20,1);
Xval=[X1;X2;X3];
Xval_cls=[X1_cls ; X2_cls;X3_cls];
plot3(X1(:,1),X1(:,2),X1(:,3),'b*',X2(:,1),X2(:,2),X2(:,3),'r*',X3(:,1),X3(:,2),
X3(:,3),'g*');
grid on
pause
n_data=length(Xval_cls);
%%%%%%%%%%%%%%%%%%%%%%
%definition de labels
%%%%%%%%%%%%%%%%%%%%%%
g_labs=cell(n_data,1);
for g_cell=1:n_data,
g_labs{g_cell}={ sprintf('%d', Xval_cls(g_cell)) };
end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%definition des noms des variables d'entree
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
g_varnames={ {'var1'},{'var2'},{'var3'} };
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%definition de la structure des donnees
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
55
sDatavalidation=som_data_struct(Xval,'gaussienne',g_labs,g_varnames);
load sMap Matclass;
%%%%%%%%%%%%%%%%%%%%%%%%
%on recupere les labels
%%%%%%%%%%%%%%%%%%%%%%%%
[N,C]=max(Matclass');
[Bmus, Qerrors]=som_bmus(sMap,sDatavalidation);
Cval_cls=C(Bmus)
%%%%%%%%%%%%%%%%%%%%%%
%Matrice de confusion
%%%%%%%%%%%%%%%%%%%%%%
c=max(Xval_cls)
confuse=0*ones(c,c);
for i=1:length(Xval_cls)
confuse(Xval_cls(i),Cval_cls(i))=confuse(Xval_cls(i),Cval_cls(i))+1;
end
confuse
%on obtient
%confuse =
%
26
9
5
%
5
25
0
%
12
2
6
%%%%%%%%%%%%%%%%%%%%%%%%
%Matrice de probabilité
%%%%%%%%%%%%%%%%%%%%%%%%
[Bmus, Qerrors]=som_bmus(sMap,sDatavalidation);
Cval_cls=Matclass(Bmus,:);
proba=zeros(size(Cval_cls));
nbcol=size(Cval_cls,2);
for i=1:length(Cval_cls)
sligne=sum(Cval_cls(i,:));
if sligne==0
for j=1:nbcol
proba(i,j)=0;
end
else
for j=1:nbcol
proba(i,j)=Cval_cls(i,j)/sligne;
end
end
end
seuil=input('choisissez un seuil entre 0 et 1\n');
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%Nouvelle matrice de confusion
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
c=max(Xval_cls);
confuse2=0*ones(c,c+1);
[N,Cv]=max(proba');
I=find(N>seuil);
Cv_cls(I)=Cv(I);
I=find(N<=seuil);
Cv_cls(I)=c+1;
for i=1:length(Xval_cls)
confuse2(Xval_cls(i),Cv_cls(i))=confuse2(Xval_cls(i),Cv_cls(i))+1;
56
end
confuse2
%on obtient
%confuse2 =
%
26
6
%
5
22
%
12
1
5
0
6
3
3
1
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
PROGRAMME CLASSIFTB
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
clear all
close all
rep1=input('voulez reapprendre la carte (0)\n
ou utiliser la meme (1)\n');
if rep1==0
rep2=input('voulez vous creer une nouvelle carte (O)\n ou continuer l
apprentissage de la meme carte (1)?\n')
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%on lit le fichier de donnees
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
load -ascii Test_Cecile.dat;
n_data=size(Test_Cecile,1);
n_col=size(Test_Cecile,2);
X=Test_Cecile(1:2:n_data,1:9);
X_cls=Test_Cecile(1:2:n_data,10);
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%on regroupe par exemple les taux de precipitations en 5 classes
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
nX_cls=zeros(length(X_cls),1);
for i=1:length(X_cls)
if X_cls(i)<0.1
nX_cls(i)=1;
elseif (X_cls(i)>=0.1 & X_cls(i)<1)
nX_cls(i)=2;
elseif (X_cls(i)>=1 &X_cls(i)<5)
nX_cls(i)=3;
elseif (X_cls(i)>=5 &X_cls(i)<10)
nX_cls(i)=4;
else
nX_cls(i)=5;
57
end
end
%%%%%%%%%%%%%%%%%%%%%%
%definition de labels
%%%%%%%%%%%%%%%%%%%%%%
Tb_labs=cell(n_data/2,1);
for Tb_cell=1:n_data/2,
Tb_labs{Tb_cell}={ sprintf('%d', nX_cls(Tb_cell)) };
end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%definition des noms des variables d'entree
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Tb_varnames={
{'Tb1'},{'Tb2'},{'Tb3'},{'Tb4'},{'Tb5'},{'Tb6'},{'Tb7'},{'Tb8'},{'Tb9'} };
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%definition de la structure de la carte
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
sData= som_data_struct(X,'TMI',Tb_labs,Tb_varnames,'som_var_norm');
%%%%%%%%%%%%%%%%%%%%%%%%%%%
%normalisation des donnees
%%%%%%%%%%%%%%%%%%%%%%%%%%%
sData=som_normalize_data(sData,'som_var_norm');
save sData;
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%initialisation de la carte topologique
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
if rep2 == 0
msize=[15 15];
init_type='random';
lattice='hexa';
shape='rect';
sMap=som_init(sData,msize,init_type,lattice,shape);
%entrainement de la carte
epochs=500;
radius=[3 1];
alpha=0.1;
alpha_type='linear';
tracking=3;
sMap=som_train(sMap,sData,epochs,radius,alpha,alpha_type,tracking);
%entrainement fin de carte;
epochs=500;
radius=[1 0.3];
alpha=0.05;
alpha_type='linear';
tracking=3;
sMap=som_train(sMap,sData,epochs,radius,alpha,alpha_type,tracking);
%on trace les donnees et les neurones pour toutes les temperatures de
%brillance
figure
for i=1:8
hold on
58
plot(sData.data(:,i),sData.data(:,i+1),'b+');
plot(sMap.codebook(:,:,i),sMap.codebook(:,:,i+1),'ro');
hold off
pause
clf
end
else
load sMap;
%entrainement de la carte
epochs=500;
radius=[0.3 0.1];
alpha=0.05;
alpha_type='linear';
tracking=3;
sMap=som_train(sMap,sData,epochs,radius,alpha,alpha_type,tracking);
%on trace les donnees et les neurones pour toutes les temperatures de
%brillance
for i=1:8
figure
hold on
plot(sData.data(:,i),sData.data(:,i+1),'b+');
plot(sMap.codebook(:,:,i),sMap.codebook(:,:,i+1),'ro');
hold off
pause
clf
end
end
%%%%%%%%%%%%%%%%%%%%
%effacer tout label
%%%%%%%%%%%%%%%%%%%%
sMap=som_label(sMap,'clear');
%%%%%%%%%%%%%%%%%
%calcul des hits
%%%%%%%%%%%%%%%%%
Hits=som_hits(sMap,sData);
%%%%%%%%%%%%%%%%%%%%%%%%%
%Visualisation des poids
%%%%%%%%%%%%%%%%%%%%%%%%%
figure
h=som_show(sMap);
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%ajout de la cardinalite comme label et affichage
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
H1=Hits(:);
I1=1:length(H1);
sMap=som_label(sMap,I1',num2cell(H1));
title('labelliser avec le nombre de donnees par cellule');
h1b1=som_addlabels(sMap);
%%%%%%%%%%%%%%%%%%%%
%effacer tout label
%%%%%%%%%%%%%%%%%%%%
sMap=som_label(sMap,'clear');
59
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%labelliser chaque cellule avec la classe et la cardinalite
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
[Bmus, Qerrors]=som_bmus(sMap,sData);
Hits=som_hits(sMap,sData);
nbclasses=max(nX_cls);
%on definit et remplit une matrice de cardinalite par classe et par
%cellule
Matclass=zeros(prod(sMap.msize),nbclasses);
for tbDon=1:length(nX_cls)
tbCell=Bmus(tbDon);
Matclass(tbCell,nX_cls(tbDon))=Matclass(tbCell,nX_cls(tbDon))+1;
end
%boucle par cellule de la carte
for tbCell=1:prod(sMap.msize)
%boucle par classe et recherche de donnees
%de la classe dans la cellule tbCell de la boucle
cellLabels=cell(1);
for tbClass=1:nbclasses
if Matclass(tbCell,tbClass)~=0
cellLabels{1}=[num2str(tbClass) '('
num2str(Matclass(tbCell,tbClass)) ')' ];
sMap=som_label(sMap,tbCell,cellLabels{1});
end
end
end
figure
h=som_show(sMap,6);
hlbl=som_addlabels(sMap);
%%%%%%%%%%%%%%%%%%%%
%effacer tout label
%%%%%%%%%%%%%%%%%%%%
sMap=som_label(sMap,'clear');
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%quand plusieurs classes sont presentes dans une cellule
%on labellise avec la classe la plus probable%%%%%%%%%%%%
%boucle par cellule de la carte
for tbCell=1:prod(sMap.msize)
%boucle par classe et recherche de donnees
%de la classe dans la cellule gCell de la boucle
cellLabels=cell(1);
mx=0;
cellLabels{1}=[num2str(0) '(' num2str(0) ')' ];
for tbClass=1:nbclasses
if Matclass(tbCell,tbClass)~=0
if Matclass(tbCell,tbClass)>mx;
cellLabels{1}=[num2str(tbClass) '('
num2str(Matclass(tbCell,tbClass)) ')' ];
mx=Matclass(tbCell,tbClass);
end
end
60
end
sMap=som_label(sMap,tbCell,cellLabels{1});
end
figure
h=som_show(sMap,6);
hlbl=som_addlabels(sMap);
save sMap sMap Matclass;
else
load sMap;
load sData;
end
%%%%%%%%%%%%%%%%%%%%
%effacer tout label
%%%%%%%%%%%%%%%%%%%%
sMap=som_label(sMap,'clear');
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%on trace les histogrammes representant les taux de pluie pour chaque
%neurone%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
RR=[0:1:80];
figure
for i=1:prod(sMap.msize)
cellLabels=cell(2);
[Bmus, Qerrors] = som_bmus(sMap,sData);
iDon = find(Bmus == i);
[ix(i),il]=size(iDon);
if ix(i)~=0
%X_cls contient les taux de pluie
clear R
%on calcule pour chaque neurone son taux de pluie moyen
Rmoyen(i)=mean(X_cls(iDon));
R=X_cls(iDon);
%on trace l histogramme
subplot(sMap.msize(1),sMap.msize(2),i);
n= hist(R,RR);
[m,l]=max(n);
Rpro(i)=RR(l);
bar(RR,n)
I=find(n~=0);
if max(RR(I))~=0
axis([0 max(RR(I)) 0 max(n)]);
else
axis([0 3 0 max(n)]);
end
%on labellise avec le taux de pluie moyen et le plus represente
cellLabels{1}=[num2str(Rmoyen(i),3)];
cellLabels{2}=[num2str(Rpro(i))];
sMap=som_label(sMap,i,cellLabels{1});
sMap=som_label(sMap,i,cellLabels{2 });
if max(n)>=(sum(n)/5)
Rnew(i)=RR(l);
else
Rnew(i)=mean(X_cls(iDon));
end
ecty(i)=std(X_cls(iDon));
end
61
end
save
save
save
save
Rmoyen;
Rpro;
Rnew;
ecty;
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%on trace la carte labellisee avec le taux de pluie moyen et le plus represente
%la taille du neurone est proportionnelle au taux de pluie
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
figure
Rbis=reshape(Rmoyen,sMap.msize(1),sMap.msize(2));
h=som_show(sMap,6,[],[],Rbis);
hlbl=som_addlabels(sMap);
title('Carte labellisée avec le taux de pluie moyen et le plus représenté avec
toutes les Tbs');
%%%%%%%%%%%%%%%%%%%%%%%%
%on recupere les labels
%%%%%%%%%%%%%%%%%%%%%%%%
[N,C]=max(Matclass');
[Bmus, Qerrors]=som_bmus(sMap,sData);
C_cls=C(Bmus);
%%%%%%%%%%%%%%%%%%%%%%
%Matrice de confusion
%%%%%%%%%%%%%%%%%%%%%%
c=max(nX_cls);
confuse=0*ones(c,c);
for i=1:length(nX_cls)
confuse(nX_cls(i),C_cls(i))=confuse(nX_cls(i),C_cls(i))+1;
end
confuse
%on obtient :
%confuse =
%
%
%
%
%
290
229
7
0
0
1468
5932
1140
6
3
11
678
3032
485
107
0
3
167
237
78
62
0
1
27
64
121
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
PROGRAMME CLASSIFTBFORTR
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
clear all
close all
rep1=input('voulez reapprendre la carte (0)\n
ou utiliser la meme (1)\n');
if rep1==0
rep2=input('voulez vous creer une nouvelle carte (O)\n ou continuer l
apprentissage de la meme carte (1)?\n')
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%on lit le fichier de donnees
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
load -ascii Test_Cecile_II.dat;
n_data=size(Test_Cecile_II,1);
n_col=size(Test_Cecile_II,2);
Xold=Test_Cecile_II(1:2:n_data,1:9);
Xold_cls=Test_Cecile_II(1:2:n_data,10);
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%on n'utilise que les donnees dont le taux de precipitation est superieur
%a 4 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
X_clsnew=[];
Xnew=[];
for i=1:length(Xold_cls)
if Xold_cls(i)>=4
X_clsnew=[X_clsnew;Xold_cls(i)];
Xnew=[Xnew;Xold(i,:)];
end
end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%on prend 2/3 des donnees pour l'apprentissage%
63
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
X=[Xnew(1:3:size(Xnew,1),:);Xnew(2:3:size(Xnew,1),:)];
X_cls=[X_clsnew(1:3:length(X_clsnew));X_clsnew(2:3:length(X_clsnew))];
n_data=length(X_cls)
pause
%on trace chaque Tb en fonction du taux de pluie :
for i=1:2:9
figure
plot(X_cls,X(:,i),'b*');
end
pause
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%et le tiers restant pour la validation%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Xval=[Xnew(3:3:size(Xnew,1),:)];
X_clsval=X_clsnew(3:3:length(X_clsnew));
n_dataval=length(X_clsval)
pause
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%on regroupe les taux de precipitations en 3 classes
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
nX_cls=zeros(length(X_cls),1);
for i=1:length(X_cls)
if X_cls(i)<7
nX_cls(i)=1;
elseif (X_cls(i)>=7 & X_cls(i)<10)
nX_cls(i)=2;
else
nX_cls(i)=3;
end
end
nX_clsval=zeros(length(X_clsval),1);
for i=1:length(X_clsval)
if X_clsval(i)<7
nX_clsval(i)=1;
elseif (X_clsval(i)>=7 & X_clsval(i)<10)
nX_clsval(i)=2;
else
nX_clsval(i)=3;
end
end
%%%%%%%%%%%%%%%%%%%%%%
%definition de labels
%%%%%%%%%%%%%%%%%%%%%%
Tb_labs=cell(n_data,1);
for Tb_cell=1:n_data,
Tb_labs{Tb_cell}={ sprintf('%d', nX_cls(Tb_cell)) };
end
Tb_labsval=cell(n_dataval,1);
for Tb_cell=1:n_dataval,
Tb_labsval{Tb_cell}={ sprintf('%d', nX_clsval(Tb_cell)) };
end
64
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%definition des noms des variables d'entree
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Tb_varnames={
{'Tb1'},{'Tb2'},{'Tb3'},{'Tb4'},{'Tb5'},{'Tb6'},{'Tb7'},{'Tb8'},{'Tb9'} };
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%definition de la structure de la carte
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
sData5= som_data_struct(X,'TMI',Tb_labs,Tb_varnames,'som_var_norm');
sDataval= som_data_struct(Xval,'TMI',Tb_labsval,Tb_varnames,'som_var_norm');
%%%%%%%%%%%%%%%%%%%%%%%%%%%
%normalisation des donnees
%%%%%%%%%%%%%%%%%%%%%%%%%%%
sData5=som_normalize_data(sData5,'som_var_norm');
save sData5;
sDataval=som_normalize_data(sDataval,'som_var_norm');
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%initialisation de la carte topologique
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
if rep2 == 0
msize=[15 15];
init_type='random';
lattice='hexa';
shape='rect';
sMap5=som_init(sData5,msize,init_type,lattice,shape);
%%%%%%%%%%%%%%%%%%%%%%%%%%%
%apprentissage de la carte
%%%%%%%%%%%%%%%%%%%%%%%%%%%
Q=[];
Qval=[];
%entrainement de la carte
for i=1:10,
epochs=20;
radius=[3-0.2*(i-1) 3-0.2*i];
alpha=0.1;
alpha_type='linear';
tracking=3;
figure(1)
sMap5=som_train(sMap5,sData5,epochs,radius,alpha,alpha_type,tracking);
[Bmus,Qerrors]=som_bmus(sMap5,sData5);
[Bmus,Qerrorsval]=som_bmus(sMap5,sDataval);
Q=[Q mean(Qerrors.^2)];
Qval=[Qval mean(Qerrorsval.^2)];
end
%entrainement fin de carte;
for i=1:10
epochs=20;
radius=[1-0.09*(i-1) 1-0.09*i];
alpha=0.05;
alpha_type='linear';
tracking=3;
sMap5=som_train(sMap5,sData5,epochs,radius,alpha,alpha_type,tracking);
[Bmus,Qerrors]=som_bmus(sMap5,sData5);
[Bmus,Qerrorsval]=som_bmus(sMap5,sDataval);
65
Q=[Q mean(Qerrors.^2)];
Qval=[Qval mean(Qerrorsval.^2)];
end
%on trace l'erreur d'apprentissage et l'erreur de generalisation
figure(2)
x=[1:20];
plot(x,Q,'r-',x,Qval,'b-')
save Q;
save Qval;
pause
%on trace les donnees et les neurones pour toutes les temperatures de
%brillance
figure
for i=1:8
hold on
plot(sData5.data(:,i),sData5.data(:,i+1),'b+');
plot(sMap5.codebook(:,:,i),sMap5.codebook(:,:,i+1),'ro');
hold off
pause
clf
end
else
load sMap5;
load Q;
load Qval;
%entrainement de la carte
for i=1:10
epochs=20;
radius=[0.1-0.009*(i-1) 0.1-0.009*i];
alpha=0.05;
alpha_type='linear';
tracking=3;
figure(1)
sMap5=som_train(sMap5,sData5,epochs,radius,alpha,alpha_type,tracking);
[Bmus,Qerrors]=som_bmus(sMap5,sData5);
[Bmus,Qerrorsval]=som_bmus(sMap5,sDataval);
Q=[Q mean(Qerrors.^2)];
Qval=[Qval mean(Qerrorsval.^2)];
end
%on trace l'erreur d'apprentissage et l'erreur de generalisation
figure(2)
x=[1:30];
plot(x,Q,'r-',x,Qval,'b-')
pause
%on trace les donnees et les neurones pour toutes les temperatures de
%brillance
for i=1:8
figure
hold on
plot(sData5.data(:,i),sData5.data(:,i+1),'b+');
plot(sMap5.codebook(:,:,i),sMap5.codebook(:,:,i+1),'ro');
hold off
pause
clf
end
end
%%%%%%%%%%%%%%%%%%%%
%effacer tout label
66
%%%%%%%%%%%%%%%%%%%%
sMap5=som_label(sMap5,'clear');
%%%%%%%%%%%%%%%%%
%calcul des hits
%%%%%%%%%%%%%%%%%
Hits=som_hits(sMap5,sData5);
%%%%%%%%%%%%%%%%%%%%%%%%%
%Visualisation des poids
%%%%%%%%%%%%%%%%%%%%%%%%%
figure
h=som_show(sMap5);
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%ajout de la cardinalite comme label et affichage
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
H1=Hits(:);
I1=1:length(H1);
sMap5=som_label(sMap5,I1',num2cell(H1));
title('labelliser avec le nombre de donnees par cellule');
h1b1=som_addlabels(sMap5);
%%%%%%%%%%%%%%%%%%%%
%effacer tout label
%%%%%%%%%%%%%%%%%%%%
sMap5=som_label(sMap5,'clear');
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%labelliser chaque cellule avec la classe et la cardinalite
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
[Bmus, Qerrors]=som_bmus(sMap5,sData5);
Hits=som_hits(sMap5,sData5);
nbclasses=max(nX_cls);
%on definit et remplit une matrice de cardinalite par classe et par
%cellule
Matclass=zeros(prod(sMap5.msize),nbclasses);
for tbDon=1:length(nX_cls)
tbCell=Bmus(tbDon);
Matclass(tbCell,nX_cls(tbDon))=Matclass(tbCell,nX_cls(tbDon))+1;
end
%boucle par cellule de la carte
for tbCell=1:prod(sMap5.msize)
%boucle par classe et recherche de donnees
%de la classe dans la cellule tbCell de la boucle
cellLabels=cell(1);
for tbClass=1:nbclasses
if Matclass(tbCell,tbClass)~=0
cellLabels{1}=[num2str(tbClass) '('
num2str(Matclass(tbCell,tbClass)) ')' ];
sMap5=som_label(sMap5,tbCell,cellLabels{1});
end
end
end
67
figure
h=som_show(sMap5,6);
hlbl=som_addlabels(sMap5);
%%%%%%%%%%%%%%%%%%%%
%effacer tout label
%%%%%%%%%%%%%%%%%%%%
sMap5=som_label(sMap5,'clear');
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%quand plusieurs classes sont presentes dans une cellule
%on labellise avec la classe la plus probable%%%%%%%%%%%%
%boucle par cellule de la carte
for tbCell=1:prod(sMap5.msize)
%boucle par classe et recherche de donnees
%de la classe dans la cellule gCell de la boucle
cellLabels=cell(1);
mx=0;
cellLabels{1}=[num2str(0) '(' num2str(0) ')' ];
for tbClass=1:nbclasses
if Matclass(tbCell,tbClass)~=0
if Matclass(tbCell,tbClass)>mx;
cellLabels{1}=[num2str(tbClass) '('
num2str(Matclass(tbCell,tbClass)) ')' ];
mx=Matclass(tbCell,tbClass);
end
end
end
sMap5=som_label(sMap5,tbCell,cellLabels{1});
end
figure
h=som_show(sMap5,6);
hlbl=som_addlabels(sMap5);
save sMap5 sMap5 Matclass;
else
load sMap5;
load sData5;
end
%%%%%%%%%%%%%%%%%%%%
%effacer tout label
%%%%%%%%%%%%%%%%%%%%
sMap5=som_label(sMap5,'clear');
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%on trace les histogrammes representant les taux de pluie pour chaque
%neurone%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
RR=[4.5:1:80];
figure
for i=1:prod(sMap5.msize)
cellLabels=cell(2);
[Bmus, Qerrors] = som_bmus(sMap5,sData5);
68
iDon = find(Bmus == i);
[ix(i),il]=size(iDon);
if ix(i)~=0
%X_cls contient les taux de pluie
clear R
%on calcule pour chaque neurone son taux de pluie moyen
Rmoyen2(i)=mean(X_cls(iDon));
R=X_cls(iDon);
%on trace l histogramme
subplot(sMap5.msize(1),sMap5.msize(2),i);
n= hist(R,RR);
[m,l]=max(n);
Rpro(i)=RR(l);
bar(RR,n)
I=find(n~=0);
axis([4 31 0 max(n)]);
%on labellise avec le taux de pluie moyen et le plus represente
cellLabels{1}=[num2str(Rmoyen2(i),3)];
cellLabels{2}=[num2str(Rpro(i))];
sMap5=som_label(sMap5,i,cellLabels{1});
sMap5=som_label(sMap5,i,cellLabels{2 });
if max(n)>=(sum(n)/5)
Rnew2(i)=RR(l);
else
Rnew2(i)=mean(X_cls(iDon));
end
ecty2(i)=std(X_cls(iDon));
end
end
save Rmoyen2;
save Rnew2;
save ecty2;
RR=[4.5:1:80];
figure
for i=1:prod(sMap5.msize)
cellLabels=cell(2);
[Bmus, Qerrors] = som_bmus(sMap5,sData5);
iDon = find(Bmus == i);
[ix(i),il]=size(iDon);
if ix(i)~=0
%X_cls contient les taux de pluie
clear R
R=X_cls(iDon);
%on trace l histogramme
subplot(sMap5.msize(1),sMap5.msize(2),i);
n= hist(R,RR);bar(RR,n)
I=find(n~=0);
axis([4 max(RR(I)) 0 max(n)]);
end
end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%on trace la carte labellisee avec le taux de pluie moyen et le plus represente
%la taille du neurone est proportionnelle au taux de pluie
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
figure
Rbis=reshape(Rmoyen2,sMap5.msize(1),sMap5.msize(2));
h=som_show(sMap5,5,[],[],Rbis);
hlbl=som_addlabels(sMap5);
69
title('Carte labellisée avec le taux de pluie moyen et le plus représenté en ne
prenant que les taux de pluie supérieurs à 4');
%%%%%%%%%%%%%%%%%%%%%%%%
%on recupere les labels
%%%%%%%%%%%%%%%%%%%%%%%%
[N,C]=max(Matclass');
[Bmus, Qerrors]=som_bmus(sMap5,sData5);
C_cls=C(Bmus);
%%%%%%%%%%%%%%%%%%%%%%
%Matrice de confusion
%%%%%%%%%%%%%%%%%%%%%%
c=max(nX_cls);
confuse=0*ones(c,c);
for i=1:length(nX_cls)
confuse(nX_cls(i),C_cls(i))=confuse(nX_cls(i),C_cls(i))+1;
end
confuse
%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%
%Inversion des données
%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%on lit le fichier de donnees
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
load -ascii Cecile_TestIII.dat;
n_datainv=size(Cecile_TestIII,1);
Xinv=Cecile_TestIII(:,3:11);
lat=Cecile_TestIII(:,1);
long=Cecile_TestIII(:,2);
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%definition des noms des variables d'entree
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Tbinv_varnames={
{'Tb1'},{'Tb2'},{'Tb3'},{'Tb4'},{'Tb5'},{'Tb6'},{'Tb7'},{'Tb8'},{'Tb9'} };
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%definition de la structure de la carte
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
sDatainv= som_data_struct(Xinv,'TMI',[],Tbinv_varnames,'som_var_norm');
%%%%%%%%%%%%%%%%%%%%%%%%%%%
%normalisation des donnees
%%%%%%%%%%%%%%%%%%%%%%%%%%%
sDatainv=som_normalize_data(sDatainv,'som_var_norm');
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%recherche du neurone gagnant pour chaque vecteur de donnees
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
load sMap;
load Rmoyen;
70
load Rpro;
load Rnew;
load ecty;
[Bmus, Qerrors]=som_bmus(sMap,sDatainv);
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%on affecte à chaque donnée le taux de pluie moyen du neurone gagnant
%correspondant%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
for i=1:n_datainv
Xinv_cls(i)=Rmoyen(Bmus(i));
end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%on fait la meme chose avec le taux de pluie le plus probable
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
for i=1:n_datainv
Xinv2_cls(i)=Rpro(Bmus(i));
end
for i=1:n_datainv
Xinv3_cls(i)=Rnew(Bmus(i));
ecart(i)=ecty(Bmus(i));
end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%on crée notre nouvelle table de données avec la latitude, la longitude et
%le taux de pluie%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
M=[lat';long';Xinv_cls];
fid=fopen('kiki.dat','w');
fprintf(fid,'%8.2f %8.2f %8.2f\n',M)
fclose(fid);
M2=[lat';long';Xinv2_cls];
fid=fopen('kiki2.dat','w');
fprintf(fid,'%8.2f %8.2f %8.2f\n',M2)
fclose(fid);
M3=[lat';long';Xinv3_cls];
fid=fopen('kiki3.dat','w');
fprintf(fid,'%8.2f %8.2f %8.2f\n',M3)
fclose(fid);
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%on récupère les données dont le taux de pluie est supérieur à 4 pour faire un
%tableau en se servant des deux cartes
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
load sMap5;
load Rnew2;
load ecty2;
Xinvf=[];
for i=1:n_datainv
if Xinv3_cls(i)>=4
Xinvf=[Xinvf;Xinv(i,:)];
end
end
sDatai= som_data_struct(Xinvf,'TMI',[],Tbinv_varnames,'som_var_norm');
sDatai=som_normalize_data(sDatai,'som_var_norm');
[Bmus, Qerrors]=som_bmus(sMap5,sDatai);
for i=1:length(Xinvf)
71
Xinvf_cls(i)=Rnew2(Bmus(i));
ecartf(i)=ecty2(Bmus(i));
end
n=1;
for i=1:n_datainv
if Xinv3_cls(i)>=4
Xinv3_cls(i)=Xinvf_cls(n);
ecart(i)=ecartf(n);
n=n+1;
end
end
M4=[lat';long';Xinv3_cls];
fid=fopen('kiki4.dat','w');
fprintf(fid,'%8.2f %8.2f %8.2f\n',M4)
fclose(fid);
%on fait un tableau avec les ecarts-type :
M5=[lat';long';ecart];
fid=fopen('ecartype.dat','w');
fprintf(fid,'%8.2f %8.2f %8.2f\n',M5)
fclose(fid);
72