Implementació en llenguatge ‘C’ d’una xarxa Fuzzy ARTMAP amb...

Implementació en llenguatge ‘C’ d’una xarxa Fuzzy ARTMAP amb una estratègia de votin

TITULACIÓ: Enginyeria Tècnica Industrial en Electrònica Industrial

AUTORS:Jordi Vila Romero .

DIRECTORS: Jesús Brezmes Llecha .

DATA: Maig de 2010.

2

INDEX

1 Introducció .......................................................................................................... 4

1.1 Antecedents .................................................................................................. 4

1.2 Objectius ...................................................................................................... 4

2 Base teòrica: La xarxa Fuzzy Artmap ................................................................. 6

2.1 Conceptes basics .......................................................................................... 6

2.2 Algoritme ..................................................................................................... 7

2.3 Fuzzy Logic ................................................................................................. 8

2.4 Estratègia de vot ........................................................................................... 9

3 Programació de la xarxa .................................................................................... 10

3.1 Descripció global ....................................................................................... 10

Funció ‘fzcc’ ...................................................................................................... 10

Funció ‘fzand’ .................................................................................................... 11

Funció ‘fzm’ ....................................................................................................... 11

Funció ‘inifzart’ ................................................................................................. 12

Funció ‘obtenervalores’ ..................................................................................... 12

Funció ‘crearfichero’ .......................................................................................... 13

Funció ‘estadisticas’ ........................................................................................... 13

Funció ‘desordena’ ............................................................................................. 13

Funció ‘trainfzmap’ ............................................................................................ 14

Funció ‘fziart’..................................................................................................... 15

Funció ‘evalfzmap’ ............................................................................................ 15

Menú principal ................................................................................................... 16

4 Fluxgrames ........................................................................................................ 18

4.1 Menú principal ........................................................................................... 18

4.2 Funció ‘inifzart’ ......................................................................................... 19

4.3 Funció ‘fzm’ .............................................................................................. 19

4.4 Funció ‘fzand’ ............................................................................................ 20

4.5 Funció ‘fzcc’ .............................................................................................. 21

4.6 Funció ‘obtenervalores’ ............................................................................. 22

4.7 Funció ‘crearfichero’ ................................................................................. 23

4.8 Funció ‘desordena’ .................................................................................... 24

4.9 Funció ‘estadisticas’ .................................................................................. 25

4.10 Funció ‘trainfzmap’ ................................................................................... 26

4.11 Funció ‘evalfzmap’ .................................................................................... 27

4.12 Funció ‘fziart’ ............................................................................................ 28

5 Resultats ............................................................................................................ 29

3

5.1 Proves inicials ............................................................................................ 29

5.2 Experiments reals ....................................................................................... 35

6 Manual d’Usuari ................................................................................................ 58

6.1 Instal·lació ................................................................................................. 58

6.2 Format dels fitxers d’entrada. .................................................................... 59

6.3 Operació ..................................................................................................... 59

7 Conclusions ....................................................................................................... 63

8 Annexes ............................................................................................................. 64

8.1 Codi ............................................................................................................ 64

4

1 Introducció

1.1 Antecedents

La teoria de la ressonància adaptiva (ART) és un intent de modelar certes facetes del comportament del sistema nerviós i perceptiu humà . Aquesta teoria va estar proposada a partir dels treballs de Stephen Grossberg a la Universitat de Boston durant el anys noranta. Partint d'investigacions en el camp de la psicologia es van buscar les lleis que regeixen el comportament humà. Una vegada descrites qualitativament aquestes lleis, es va buscar un model matemàtic capaç de reflectir-les.

El dilema entre l'estabilitat, capacitat de mantenir la informació apresa pel sistema, i la plasticitat, capacitat d'incorporar nova informació, és assumit com una de les principals característiques de la teoria ART. L’altre dilema que assumeix la teoria ressonant adaptiva és el soroll de saturació que es planteja com la capacitat del sistema per a ser sensible davant senyals de baixa intensitat sense amplificar el soroll dels senyals ni saturar-se davant entrades d'alta intensitat.

Un altre fonament d’aquesta teoria és la recerca de sistemes que siguin dinàmics i que treballin en temps real, entenent-se per treball en temps real el fet que la fase d'aprenentatge i de funcionament del sistema no estan dissociades. El sistema ha de ser capaç d'anar incorporant informació (aprendre) al mateix temps que està funcionant.

Aquestes característiques han fet que sigui una xarxa neuronal molt utilitzada en tota mena d’estudis a la URV, concretament al departament d’Enginyeria Electrónica. Molts dels experiments a on s’han fet servir estan basats en l’aplicació de les xarxes neuronals per a la classificació de diferents gasos a partir de senyals de sensors semiconductors.

Partint d’una xarxa creada pel doctor Jesús Brezmes en el llenguatge de programació de Matlab, nosaltres crearem una de nova rèplica en llenguatge ‘C’ per millorar el rendiment de l’anterior, estudiarem el seu funcionament i realitzarem varies proves per a comparar els resultats obtinguts de la nova xarxa.

En aquesta nova xarxa aplicarem la estratègia de vot, que permet donar una mesura de fiabilitat (mesura estadística) als resultats de classificació donats per la xarxa FUZZY ARTMAP. Es important recalcar que l’estratègia de vot requereix d’una gran càrrega de computació i es per aquest motiu que es vol implementar la xarxa en un codi el mes optimitzat possible.

1.2 Objectius

El propòsit d’aquest projecte es optimitzar la velocitat d’execució d’una xarxa

neuronal ‘Fuzzy Artmap’ implementada en ‘MATLAB’ (llenguatge interpretat) traduint-la al llenguatge ‘C’ (codi compilat). Per fer això hem agafat la xarxa creada pel nostre tutor Jesús Brezmes a la seva tesis doctoral i la hem traduït aplicant els coneixements adquirits de ‘C’ a la carrera.

5

A mes, com a segon objectiu, s’ha afegit afegit la possibilitat de fer servir la “Estratègia de Vot”, la qual cosa dona molt mes sentit al fet de optimitzar el codi ja que els càlculs son molt més intensius i l’estalvi de temps es fonamental. L’objectiu inclou fer servir la nova xarxa amb mostres de prova per tal de comparar els resultats i els temps d’execució en matlab.

6

2 Base teòrica: La xarxa Fuzzy Artmap

2.1 Conceptes basics

Las xarxes del tipus ARTMAP son una classe de xarxes neuronals que implementen un aprenentatge supervisat per una posterior classificació dels vectors multidimensionals d’entrada en una sèrie de categories de sortida.

La xarxa Fuzzy ARTMAP es una generalització a vectors analògics (amb components compreses entre ‘0’ i ‘1’) de la xarxa binària ARTMAP.

La xarxa Fuzzy ARTMAP presenta grans avantatges que fan d’aquest paradigma una opció molt interessant. Entre les seves avantatges podem destacar les següents:

• Un aprenentatge ràpid de les mesures de l’entrenament, que ens permet implementarl’algoritme en dispositius programables de baix cost, aplicar validacions encreuades d’ordre 1 (“leave-one-out”) i provar amb diferents combinacions de paràmetres.

• Aprenentatge amb un reduït conjunt de mesures d’entrenament, molt interessant per a qualsevol aplicació experimental en la que fos costosa l’obtenció de conjunts de mesures extenses. Aquesta xarxa presenta una habilitat per aprendre ràpidamentesdeveniments singulars que apareixen molt poques vegades en el conjunt d'entrenament.Per tant, en el conjunt esmentat no és necessari que hagi el mateix nombre de mesures de cada classe perquè funcioni correctament.

• Aprenentatge continu (en temps real) de noves característiques sense oblidar l’aprés amb anterioritat, aspecte molt útil per a adaptar-se a derives produïdes per sensors.

• En comparació amb altres tipus de xarxes neuronals, la Fuzzy ARTMAP determina automàticament les neurones de la seva capa oculta. A mes maximitza el poder de generalització aprenent al 100% el conjunt d'entrenament.

• Una vegada entrenada és possible extreure regles de classificació a partir dels pesos obtinguts després del període d'entrenament el que pot donar a llum sobre els processos interns i com influeixen en la categorització de resultats.

No obstant això, la seva implementació pràctica presenta un problema que ha de ser tractat amb molta cautela. Tal com s'ha comentat amb anterioritat, la xarxa aprèn el 100% de les mesures del conjunt d'entrenament sacrificant el mínim possible la generalització. No obstant això la presència de mesures errònies (“outliers”) en el conjunt d'entrenament pot requerir un increment del valor de vigilància excessiu, la qual cosa perjudicarà seriosament la capacitat de generalització de la xarxa. La xarxa implementada en aquest projecte es una versió lleugerament diferent de la original que evita aquest problema. Resumint la xarxa Fuzzy ARTMAP és una xarxa de classificació amb aprenentatge supervisat. En una fase d'entrenament la xarxa necessita que se li subministri un conjunt de mesures. Cada mesura ha de contenir un vector d'entrada, que detalla els paràmetres amidats en cada experiència, i un vector de sortida que codifica la categoria que se li ha d'assignar. Posteriorment, en la fase d'avaluació, nomeses subministra el vector d'entrada i la xarxa classifica aquesta mesura seguint els criteris apresos en la fase d'entrenament.

7

2.2 Algoritme

Bàsicament, una xarxa Fuzzy Artmap està formada per dues xarxes Fuzzy Art connectades entre si per un vector de relacions denominat ‘Mapfield’. A una de les dues xarxes (la qual denominarem A) li arriben els vectors d'entrada (V).

A la xarxa B li arriben, en la fase d'entrenament, els vectors que codifiquen la categoria correcta de cada mesura del conjunt d'entrenament (C). La figura 2.2.1 esquematitza aquest concepte.

Figura 2.2.1, Esquema general d’una xarxa Fuzzy Artmap.

Inicialment, en la xarxa A, el vector de vigilància és zero. En la xarxa B se sol donar un valor igual a la unitat, ja que les mesures que hagin de esser classificades conjuntament enviaran a la xarxa B codificacions idèntiques. A més, qualsevol vector de codificació diferent, per semblança que sigui a la resta, ha de ser detectat i ha d'activar una neurona de sortida diferent en la xarxa B.

Cada vegada que se subministra una mesura d'entrenament, la xarxa A activa un node i la xarxa B activa un altre. El mapa que les uneix aprèn a relacionar nodes activats.D'aquesta forma, a cada nou node que s'activa en la xarxa A se li associa un node en B. Cal destacar que els nodes B normalment seran imatge de diversos nodes A (cada categoria conté diverses mesures), mentres que cadascuna de les categories creades en A només tindrà una imatge en B (cada mesura solament pot pertànyer a una categoria).

Quan una nova mesura activa un node en A ja existent, es comprova si la imatge d'aquest node assignada pel ‘mapfield’ coincideix amb el node que s'ha activat en B paral·lelament. En el cas que no coincideixin, s'incrementa el valor del paràmetre de vigilància fins que la neurona que s'activi en A tingui per imatge la neurona activada en B. Si no es troba cap es crearà una nova i el mapa li assignarà com imatge el node B activat.

En definitiva, el valor de vigilància en A solament s'incrementa l’ estrictament necessari perquè la xarxa A separi en nodes diferents les mesures que han d'estar classificades en diferents categories. Suposant un paràmetre d'aprenentatge igual a la unitat per a ambdues xarxes es pot demostrar que aquest algorisme aprèn a classificar correctament el 100% dels vectors d'entrenament. A més, aquest aprenentatge és ràpid i estable. A continuació es detalla l'algorisme de forma esquemàtica:

8

ARTa: Xarxa fuzzy art a la qual arriben els vectors d'entrada.

ARTb: Xarxa fuzzy art a la qual arriben els vectors de sortida (només durant l’entrenament).

Mapfield: Mòdul de mapejat que relaciona nodes de sortida de ARTa amb nodes de sortida de ARTb

Entrades: Suposarem que el vector d'entrada de cada mesura és V i el vector que codifica la seva classificació correcta C .

Normalització: Els vectors V i C es normalitzen amb codificació complementària, passant a ser els vectors I i D respectivament.

Pesos: El vector de pesos de la categoria k de la xarxa ARTa es denominarà AKW . El

vector de pesos de la categoria j de la xarxa b es denominarà BJW . El ‘mapfield’ té un sol

vector de longitud igual al nombre de nodes activats en A. La component k-ésima del vector indica el node imatge en ARTb del node k de la xarxa ARTa.

Match tracking: Originalment, el paràmetre de vigilància de ARTa, aρ , és un valor

base (en la majoria dels casos se li dona un valor inicial de zero). Si una mesura en a activa un node J en ARTa la imatge de la qual a través del ‘mapfield’ no coincideix amb l'activació produïda en ARTb, llavors el valor de vigilància en ARTa s'incrementa segons l'equació 2.2.2, el que forçarà l'activació d'un node diferent en ARTa:

I

WI AJ

a

Λ=ρ

Figura 2.2.2, Equació del increment del valor de vigilancia.

Mode d'avaluació: La xarxa ARTb es desactiva. La xarxa ARTa rep un vector que fa que s'activi el seu node k. La sortida de la xarxa és el valor de la component k-éssima del vector de ‘mapfield’.

2.3 Fuzzy Logic

Aquesta teoria ens permet manejar i processar certs tipus d'informació en els quals es

tractin termes inexactes, imprecisos o subjectius. D'una manera similar a com ho fa el cervell humà, és possible ordenar un raonament basat en regles imprecises i en dades incompletes.

Per això hem d'ampliar la teoria de conjunts i la lògica booleana de manera que un individu pugui pertànyer parcialment a un conjunt i que les operacions lògiques a més d'uns i zeros, puguin ser 0,01 o 0,75.

Així podem esmentar algunes deles avantatges d’aquesta aproximació:

9

• És fàcil d'entendre conceptualment. Els conceptes matemàtics darrere d'aquesta teoria són molt simples. El que la fa atractiva és la naturalitat amb la qual un pot expressar problemes de certa complexitat.

• És flexible. Una vegada dissenyat un algorisme fuzzy és fàcil canviar les regles de comportament.

• Les dades poden ser imprecises i no obstant això, el sistema ha de funcionar igualment. • Es poden modelitzar sistemes no-lineals de complexitat arbitrària. • El sistema fuzzy pot ser construït sobre la base de l'experiència d'experts. Això és un

gran avantatge si ho comparem amb les xarxes neuronals on la xarxa entrenada és com una caixa negra, especialment en problemes complexos.

• Pot combinar-se amb tècniques de control convencionals. • Es basa en el llenguatge natural. Com veurem en el disseny dels controladors, és senzill

expressar les instruccions com regles fuzzy.

Llavors la Lògica Fuzzy és una forma per a aconseguir els resultats desitjats.

2.4 Estratègia de vot

En el cas de les xarxes Fuzzy, s’ha demostrat matemàticament que en la fase

d’avaluació, si alterem l’ordre de les mesures d’entrada, les respostes poden ser diferents. Per aquest motiu s’aplica l’anomenada estratègia de vot, en la que es desordenen les mesures per obtenir les respostes varies vegades. Finalment, per a cada mesura, s’escull la resposta més votada.

En el nostre programa agafem la matriu d’avaluació, que es on guardem els valors de les mesures, i cridem a la funció ‘desordena’. Aquesta funció ens desordena de manera totalment aleatòria la posició de les mesures que volem avaluar, files de la matriu, i les guarda en una nova matriu. Per desordenar la matriu de mesures generem una nova matriu d’una sola columna i tantes files com a mesures te la matriu d’avaluació. En aquesta nova matriu assignem un valor aleatori a cada fila compres entre 0 i 100000 fent servir la funció ‘rand’ del llenguatge ‘C’ i una vegada tenim tots els valors introduïts els ordenem de major a menor aplicant aquest nou ordre a les matrius d’avaluació, d’aquesta manera ens queden desordenades les mesures i les seves classes corresponents.

El nostre programa fa tantes matrius desordenades com l’usuari indiqui en la variable

‘repeticiones’. Per tant una vegada tenim les matrius desordenades tornem a executar la fase d’avaluació fent servir aquestes.

Llavors, l’estadistic associat a cada mesura i la seva classificació està lligat al número de vegades que ha estat classificada en una determinada categoria després de repetir la execució en diferents ordres de presentació.

Finalment podem verificar en el fitxer de text ‘estadisticasgenerales’, generat per la funció ‘estadisticas’, els percentatges d’encert de les classes de les mesures avaluades despres de l’aplicació de l’estratègia de vot, en el que hem pogut comprovar com els resultats varien en funció de les repeticions de l’estratègia de vot.

Per tant podem dir que en l’estratègia de vot els càlculs son molt mes intensius i els resultats més fiables.

10

3 Programació de la xarxa

Per programar la nostra xarxa hem fet servir el llenguatge de programació ‘C’ aplicant els coneixements adquirits a la carrera. S’ha escollit la codificació en C per ser un llenguatge compilat i per caracteritzar-se per ser molt eficient en el càlcul matricial gracies a la seva filosofia de punters.

La aproximació ha sigut partir de les funcions creades en ‘Matlab’per anar traduint-les i adaptant-les per poder fer-les funcionar amb el compilador de ‘C’ Visual Basic.

Moltes d’aquestes funcions han sofert canvis en les seves variables per poder executar correctament les operacions matemàtiques de la xarxa ja que el llenguatge de ‘C’ no està tan preparat com el de ‘Matlab’ per fer segons quines operacions, especialment amb matrius i vectors (costa mes fer la programació correcta, tot i que despres es força mes eficient i ràpid).

3.1 Descripció global

En el nostre programa inicialment hem creat dues estructures de dades que anomenem ‘matriz’ i ‘matrizint’. Tant una com l’altre ens serveixen per emmagatzemar les dades de les matrius del nostre programa amb la diferència que ‘matriz’ contindrà valors reals i ‘matrizint’ valors sencers.

Aquestes dues estructures estan compostes per tres camps:

• ‘Datos’: Es on es guarden els valors de les matrius (sencers o reals) • ‘Columnas’: Ens guarda el número de columnes de la matriu. • ‘Filas’: Ens guarda el número de files de la matriu.

A continuació anirem explicant cada una de les funcions que composen el programa, anomenant les funcions utilitzades i explicant les tasques realitzades:

Funció ‘fzcc’

Aquesta funció es l’encarregada de fer el complement coding, que consisteix en afegir a una determinada matriu d’entrada la seva matriu complementaria. Per fer això ens doblarà el número de columnes de la matriu d’entrada.

Per tant es necessari passar-li com a paràmetre d’entrada la matriu ‘m’ i ens retornarà la matriu resultant ‘resfcc’.

• ‘m’: Matriu d’entrada a la que volem aplicar el complement coding. • ‘resfcc’: Matriu de sortida resultant de l’aplicació del complement coding.

Per exemple, si la matriu d’entrada es:

0.5 0.8 0.1

0.25 0.9 0.5

11

podem veure la matriu resultant en la que es pot observar l’aplicació del complement coding, ja que les tres primeres columnes contenen els valors de la matriu d’entrada i les tres columnes consecutives son el resultat de la unitat – el valor d’entrada corresponent:

0.5 0.8 0.1 0.5 0.2 0.9

0.25 0.9 0.5 0.75 0.1 0.5

Funció ‘fzand’

La funció ‘fzand’ ens retorna una matriu amb els valors mínims de dues matrius d’entrada diferents. Implementa la funció AND dintre de la lògica difusa.

Per fer aquestes operacions li hem de passar les matrius d’entrada ‘a’ i ‘b’ i ella ens retornarà la matriu ‘c’ amb el resultats.

• ‘a’: Es una de les matrius d’entrada. • ‘b’: Es l’altre matriu d’entrada. • ‘c’: Es la matriu de sortida que conté els valors mínims de les matrius d’entrada ‘a’

i ‘b’.

Per exemple si les matrius d’entrada ‘a’ i ‘b’ son:

0.5 0.8 0.1 0.2 0.5 0.8

0.25 0.9 0.5 0.75 0.1 0.4

La matriu resultant ‘c’ seria:

0.2 0.5 0.1

0.25 0.1 0.4

Funció ‘fzm’

La funció ‘fzm’ ens retorna la suma de tots els elements d’un determinat vector, el seu mòdul tal i com es defineix a la teoria de la lògica borrosa.

Com a paràmetre d’entrada únicament li he de passar ‘m’, i ens retornarà ‘res’ que es el resultat de la suma dels valors de ‘m’.

• ‘m’: Es el vector d’entrada. • ‘res’: Es el resultat de la suma de tots els valors de ‘m’.

12

Per exemple:

Si el vector d’entada es:

0.5 0.8 0.1

El resultat de la funció seria: 1.4

Funció ‘inifzart’

Aquesta funció ens crea un vector de sortida amb el doble de columnes del vector d’entrada i inicialitza tots el seus valors a ‘1’. Aquesta funció es fa servir per a inicialitzar una nova xarxa assignant una matriu de pesos nova.

Per fer això necessitarem passar-li els paràmetres de entrada ‘m’ i ‘ncols’ i ens retornarà els resultats en el paràmetre de sortida ‘matriz’.

• ‘m’: Es la un paràmetre de tipus ‘matriz’, on inclourem els valors del vector que volem transformar.

• ‘ncols’: Es el número de columnes del vector ‘m’. • ‘matriz’: Es el vector de sortida que ens retorna la funció.

Per exemple:

Si el vector d’entrada ‘m’ fos:

0.5 0.8 0.1

El vector de sortida ‘matriz’ seria:

1 1 1 1 1 1

Funció ‘obtenervalores’

Aquesta funció es la que ens llegeix els fitxers de text on l’usuari prèviament a emmagatzemat les dades de les mesures tant per al procés d’entrenament com en el d’avaluació. Cal tindre en compte el format dels fitxers de text on guardem les mesures, ja que perque funcioni correctament cada mesura correspondrà a una fila del fitxer i els parametres d’aquesta aniran separats per una tabulació i en el cas de les classes el fitxer haurà de ser de una columna i tantes files com a mesures tinguem. Una vegada hem llegit els fitxers guardem les dades directament a la memòria del programa fent una reserva amb la funció malloc de ‘C’. Hem fet servir la funció malloc perquè d’aquesta manera el nostre programa es mes flexible al no tindre limitacions respecte la grandària dels fitxers, ja que

13

ens permet fer la reserva de memòria exacte en funció dels valors que hi hagin dins dels fitxers.

Aquesta funció en Matlab no era necessària, ja que Matlab crea i elimina les variables automàticament sense importar-li la grandària d’aquestes.

Els paràmetres d’aquesta funció son ‘m’ i ‘nom’.

• ‘m’: Es la matriu on es guarden les dades llegides directament de fitxer • ‘nom’: Es directament el nom del fitxer de text que volem llegir.

Funció ‘crearfichero’

Aquesta funció ens permet crear un fitxer de text partint d’una matriu de dades del nostre programa. Per tant aquesta funció la farem servir per emmagatzemar els resultats de la matriu de pesos obtinguda en la fase d’entrenament per fer-la servir posteriorment a la fase d’avaluació. En aquesta funció necessitem passar-li el nom del fitxer que voler crear i la matriu que conté les dades que volem introduir dins del fitxer de text.

Els paràmetres que fem servir son ‘m’ i ‘nom’.

• ‘m’: Es la matriu de dades que volem transformar en un fitxer de text. • ‘nom’: Es directament el nom del fitxer de text que volem crear.

Funció ‘estadisticas’

Aquesta funció en la encarregada de generar un fitxer de text, que anomenarem ‘estadisticasgenerales.txt’, en base als resultats obtinguts a la fase d’avaluació. En aquest fitxer de text especificarem les mesures que s’han avaluat i el tipus de classe que són en tant per cent, d’aquesta manera podrem visualitzar fàcilment el percentatge d’encert de les mesures que hem avaluat.

Per obtindre aquests resultats lo que fem es llegir el fitxer que ens guarda els índex de les mesures en el procés d’avaluació ‘ficheroindices.txt’, que l’hem creat en aquesta pròpia funció mitjançant els fitxers de repetició ‘fichero6...txt’, i llegint el fitxer ‘resultadosgenerales.txt’ que ens guarda els resultats de cada mesura avaluada, d’aquesta manera sabem el número de vegades que ens ha donat correcte el resultat d’una mesura concreta. Partint d’aquests resultats treure’m el percentatge d’encert.

En aquesta funció li passarem els paràmetres ‘medidas’, ‘repeticiones’ i ‘clase’.

• ‘medidas’: Es el número de mesures que li passem a la xarxa en la fase d’avaluació. • ‘repeticiones’: Es el número de vegades que apliquem l’estratègia de vot. • ‘clase’: Es el número de classes diferents que hi ha entre les mesures que hem fet

servir per la fase d’avaluació.

Funció ‘desordena’

Aquesta funció la hem creat per fer l’estratègia de vot, ja que ens permet desordenar de manera totalment aleatòria les mesures del fitxer d’avaluació. Per desordenar la matriu de mesures generem una nova matriu d’una sola columna i tantes files com a mesures te la matriu d’avaluació. En aquesta nova matriu assignem un valor aleatori

14

a cada fila compres entre 0 i 100000 fent servir la funció ‘rand’ del llenguatge ‘C’ i una vegada tenim tots els valors introduïts els ordenem de major a menor aplicant aquest nou ordre a les matrius d’avaluació, d’aquesta manera ens queden desordenades les mesures i les seves classes corresponents. Aquesta operació la fa tantes vegades com l’usuari desitgi i ens va guardant els resultats en diferents fitxers de text, que posteriorment farem servir en la fase d’avaluació.

Per fer servir aquesta funció li passarem els paràmetres ‘ficherodatos1’, ‘ficherodatos2’, ‘destino1’, ‘destino2’, ‘destino3’ i ‘repeticiones’.

• ‘ficherodatos1’: Es el fitxer que conté les mesures de la fase d’avaluació. • ‘ficherodatos2’: Es el fitxer que conté les classes de les mesures de la fase

d’avaluació. • ‘destino1’: Es la direcció on es guardaran els fitxers de mesures d’avaluació

desordenats. • ‘destino2’:Es la direcció on es guardaran els fitxers de les classes de les mesures

d’avaluació desordenats. • ‘destino3’:Es la direcció on es guardaran els fitxers que contindran les posicions de

com han quedat desordenades les mesures. • ‘repeticiones’: Es el número de vegades que farem servir l’estratègia de vot.

Funció ‘trainfzmap’

Aquesta es una de les funcions més importants del nostre programa ja que es la encarregada de fer l’entrenament de la xarxa neuronal.Per fer l’entrenament aquesta funció necessitarà una matriu d’entrada amb una sèrie de mesures i una matriu de sortida que contindrà les diferents classes de les mesures de la matriu d’entrada. Amb aquestes dades, un seguit d’operacions matemàtiques anirà relacionant els valors de les mesures amb la classe a la que pertanyen. D’aquesta relació en sortirà una nova matriu que en diem matriu de pesos i que posteriorment farem servir per a la fase d’avaluació.

Per fer servir aquesta funció es important passar-li els següents paràmetres d’entrada:

• vigbase: Valor de vigilància inicial, normalment es posa zero ja que la funció ho puja de forma automàtica.

• vigb: Valor de vigilància de la xarxa fuzzy art B. És un valor fix ja que la xarxa no ho modifica i sol posar-se un valor molt proper a un, per exemple 0.995.

• lra: Learning rate per a la xarxa A: Valors propers a la unitat fan que la xarxa aprengui mes depressa, adient per a mesures molt fiables. Un valor proper a zero fa que l'aprenentatge sigui mes lent però mes robust, ideal per a mesures mes sorolloses.

• lrb: es lo mateix que lra però per a la xarxa B, però en aquest cas se sol posar un valor igual a la unitat.

• alfa: És una petita constant que serveix de desempat en algunes ocasions, se sol posar un valor per defecte típic de 0.0001.

• ent: Matriu d'entrada amb les mesures, cada fila correspon a una mesura diferent, cada columna a una variable.

15

• sal: Classe o identificació de cada mesura. És un vector d'una sola columna, cada fila o element de la columna correspon a la classe de la mesura en qüestió.

D’un altre banda aquesta funció ens actualitzarà els següents paràmetres:

• viga: Valor de vigilància obtingut després de l'entrenament, la pròpia funció ho haurà elevat des del valor base (vigbase) especificat inicialment al necessari per a aprendre al 100% el conjunt d'entrenament.

• wija: Pesos modificats després de l'entrenament. Tindrà tantes files com neurones s'hagin creat mes una fila final d'uns. És la matriu de pesos de la fuzzy artmap A.

• wijb: Pesos modificats després de l'entrenament. Es lo mateix que wija però per a la fuzzy artmap B.

• wab: mapfield, o camp de relació. Relaciona les activacions de neurones de la xarxa fuzzy artmap A amb els de la xarxa fuzzy artmap B.

• wijab: Matriu de pesos. Cada fila correspon als pesos d'una neurona, els pesos es componen de vectors fila codificats en "complement coding". Inicialment, si no s'ha entrenat prèviament, serà un vector d'una fila d'uns.

Funció ‘fziart’

Aquesta funció es un altre de les mes importants del programa, per no dir que es la mes important ja que es l’encarregada de fer les operacions matemàtiques tan en la fase d’entrenament com en la fase d’avaluació per aconseguir la matriu de pesos actualitzada entre la matriu de mesures i les seves classes. Per tant aquesta funció es la que farà que la nostra xarxa es faci intel·ligent, d’aquesta manera una vegada activem la fase d’avaluació només passant-li les noves mesures la nostra xarxa endevinarà de quina classe son.

Per fer servir aquesta funció li passarem els següents paràmetres d’entrada:

• ro: És el valor de vigilància per a aquest cas. • lr: Learning rate amb el qual es diu a la funció. • alfa: Constant de desempat, com anteriorment el seu valor típic es 0.0001. • entr: Vector fila (és a dir, d'una sola fila) amb la mesura a avaluar en aquest

moment. • wija: Matriu de pesos actual de la xarxa (sigui l'A o la B, ja que aquesta

funció s'utilitza per a implementar les dues xarxes)

Per un altre banda aquesta funció ens actualitzarà els següents paràmetres:

• act: Dóna el valor de la neurona de sortida activada. Tot són zeros excepte la neurona activada, que és un u.

• wijb: Pesos de sortida després de modificar els d'entrada (wija).

Funció ‘evalfzmap’

Aquesta funció, que es també de les mes importants del programa. Ens agafarà les matrius d’avaluació introduïdes mitjançant un fitxer de text pel usuari, i en funció de les dades obtingudes a la fase d’entrenament ens avaluarà aquestes noves mesures i ens determinarà a quina classe pertany cadascuna.

16

Des de aquesta funció igual que en la fase d’entrenament anirem cridant a la funció ‘fziart’ on es faran un seguit d’operacions matemàtiques, però en aquest cas amb les matrius de mesures d’avaluació, i una vegada fetes totes aquestes operacions obtindrem els resultats segons la nostra xarxa i els compararem amb els resultats reals per saber quin ha estat el percentatge d’encert de la nostra xarxa.

Quan ja hem fet la primera avaluació es quan entraríem a aplicar l’estratègia de vot, que consisteix en repetir un cert número de vegades la fase d’avaluació però desordenant les matrius de mesures.

Per fer servir aquesta funció cal tenir en compte els següents paràmetres d’entrada:

• viga: S'utilitza el valor obtingut durant l'entrenament per a la xarxa fuzzy art A.

• vigb: S'utilitza el valor obtingut durant l'entrenament per a la xarxa fuzzy art B.

• lra: És el learning rate que s'utilitzés en la xarxa fuzzy art A, el normal és que s'utilitzi el mateix valor que es va utilitzar en l'entrenament. De tota manera, si se li dóna un valor de zero, llavors la xarxa d’avaluació només donarà resultats però no modificarà els seus pesos. Si el seu valor no és zero, a més d'avaluar la xarxa aquesta funció modificarà els pesos per a anar perfeccionant l'entrenament amb les mesures d’avaluació. En aquest segon cas es pot dir que la xarxa va aprenent (o perfeccionant el seu aprenentatge) en temps real.

• lrb: Sol posar-se 0.95 o un, com en l'entrenament. És el learning rate de la xarxa fuzzy artmap B.

• alfa: El mateix valor de l'entrenament. • wija: La matriu dels pesos de la xarxa A aconseguits després de

l'entrenament. • wijb: La matriu dels pesos de la xarxa B aconseguits després de

l’entrenament. • wijab: Vector mapfield (que relaciona neurones de la xarxa A amb les de la

xarxa B) obtingut en l'entrenament. • ent: Matriu amb les mesures d’avaluació que alimentarà a la xarxa A. • sal: Classe o identificació de les mesures d’avaluació(teòricament és la xarxa

la que tindria que retornar aquest valor, però s’envien per a fer estadístiques i comparar la predicció de la xarxa amb els valors reals).

Per un altre banda aquesta funció ens actualitzarà els següents paràmetres:

• viga: Nou valor modificat de viga, recordem que en l’avaluació la xarxa segueix aprenent.

• wija: Pesos millorats de la xarxa B. • vigb: Nou valor de vigilància B, encara que no sol canviar. • wijb: Nous valors per als pesos de la xarxa Fuzzy Artmap B.

Menú principal

En aquest apartat es on anirem cridant totes les funcions anteriorment descrites per a l’execució correcta del nostre programa.

17

Inicialment, com en tots els programes de ‘C’, crearem les variables que farem servir durant l’execució del programa.

Mes endavant demanarem per pantalla a l’usuari que ens introdueixi els noms dels fitxers de text on guarda les mesures tant per a la fase d’entrenament com per la d’avaluació. Una vegada introduïts cridem a la funció ‘obtenervalores’ per llegir aquests fitxers i guardar el contingut en les matrius de la memòria del nostre programa.

També demanem per pantalla els paràmetres de resolució i vigilància i els guardem en variables per fer-los servir posteriorment en el cos del programa.

Una vegada ja tenim tots aquest valors comencem l’execució de la nostra xarxa neuronal cridant a la funció ‘trainfzmap’ per executar la fase d’entrenament.

Quan ja ha finalitzat la fase d’entrenament la nostra xarxa ja es intel·ligent, per tant ja podem executar la fase d’avaluació perque sigui la pròpia xarxa la que ens doni els resultats de les mesures, entrarem en la fase d’avaluació cridant a la funció ‘evalfzmap’.

A la primera avaluació que fem únicament li passem les mesures ordenades i d’aquesta manera calculem el temps que triga la funció d’avaluació desde que la cridem fins que retorna al menú principal.

Posteriorment fem servir l’estratègia de vot cridant a la funció ‘desordena’ per que ens faci tants fitxer d’avaluació desordenats com l’usuari ens hagi demanat. Per tant fent servir un bucle cridarem a la funció d’avaluació tantes vegades com fitxers d’avaluació tinguem.

Per finalitzar cridem a la funció ‘estadisticas’ per obtindre els resultats de la nostra avaluació.

18

4 Fluxgrames

4.1 Menú principal

19

4.2 Funció ‘inifzart’

4.3 Funció ‘fzm’

INICI

DECLARACIO DE

VARIABLES

SUMA DELS VALORS DE

LA MATRIU

FI

20

4.4 Funció ‘fzand’

DECLARACIO DE

VARIABLES

COMPAREM VALOR PER

VALOR EN LA MATEIXA

POSICIO DE LES MATRIUS

D'ENTRADA A I B

CREACIO MATRIU AMB

ELS VALORS MINIMS DE

A I B

GUARDEM EL

VALOR DE A

GUARDEM EL

VALOR DE B

NOSI

21

4.5 Funció ‘fzcc’

INICI

DECLARACIO DE VARIABLES I

RESERVA DE MEMORIA DE LA

NOVA MATRIU

COPIA DELS VALORS DE

LA MATRIU D'ENTRADA

AFEGIN EL SEU

COMPLEMENTARI

FI

22

4.6 Funció ‘obtenervalores’

INICI

DECLARACIO DE

VARIABLES

LLEGIR FITXER

FI

RESERVAR MEMORIA PER

LA MATRIU DE DADES

LLEGIR FITXER

COPIAR DADES A LA

MATRIU

FINAL FITXER

SI

NO

23

4.7 Funció ‘crearfichero’

INICI

DECLARACIO DE

VARIABLES

CREAR FITXER

COPIAR DADES MATRIU EN

EL FITXER

FINAL MATRIUNO

TANCAR FITXER

SI

24

4.8 Funció ‘desordena’

INICI

DECLARACIO DE

VARIABLES

LLEGIR DE FITXERS MATRIUS A

DESORDENAR

FINAL ESTRATEGIA DE VOT

CREAR UNA MATRIU AMB LES FILES DESORDENADES

ALEATORIAMENT

FI

DESORDENAR MATRIUS INICIALS EN FUNCIO D'AQUESTA ULTIMA

CREAR FITXERS AMB LES MATRIUS

DESORDENADES

SI

NO

25

4.9 Funció ‘estadisticas’

INICI

DECLARACIO

DE

VARIABLES

LLEGIR FITXERS QUE

GUARDEN ELS INDEX

DE LES MATRIUS

LLEGIR FITXER DE

RESULTATS

FI

GUARDAR EN UNA MATRIU

ELS RESULTATS ORDENATS

SEGONS ELS INDEX

CREAR FITXER

'ESTADISTICASGENERALES'

FENT EL % DE LA MATRIU

ANTERIOR

26

4.10 Funció ‘trainfzmap’

27

4.11 Funció ‘evalfzmap’

28

4.12 Funció ‘fziart’

MESURA RESONA

AMB NODE i?

t = CALCUL PARAMETRE

ASSEMBLANÇA

ACTUALITZAR PESOS

NODE i

SORTIDA = PESOS

ACTUALITZATS, i

5 Resultats

5.1 Proves inicials

Hem fet una sè

xarxa, variant les matrius d’entradad’avaluació.

Per una altre banda també hem un temporitzador, pcomparar amb la xarxa feta en Matlab, ja que aquest es un del objectius prioritaris del nostre projecte.

Per iniciar les nostres proves vam crear una gràfica on vam

sèrie de mostres per a la fase d’entrenament i una l’altre sèrie de mostres per la fase d’avaluació, tal i com es mostra a la següent imatge.

Figura 5 Els quadrats externs son les mostres que pasarem en la fase d’entren

els punts interns son les mostres que pasarem en la fase avaluació.En aquest cas hem fet servir quatre tipus de mesures, les mostres que

en el primer quadrant de la gràfica (0 a 0.5, 0 a 0.5) direm que son del tipus 0.2, les que estan al segon quadrant (0.5 a 1, 0 a 0.5) son del tipus 0.4, les del tercer

29

una sèrie de exercicis per comprovar el funcionament de la nostra , variant les matrius d’entrada tant de la fase d’entrenament com de la fase

Per una altre banda també hem col·locat en diferents posicions del un temporitzador, per obtenir els temps de resposta de la nostra xarxa i podercomparar amb la xarxa feta en Matlab, ja que aquest es un del objectius prioritaris

Per iniciar les nostres proves vam crear una gràfica on vam tres per a la fase d’entrenament i una l’altre sèrie de mostres per la fase

d’avaluació, tal i com es mostra a la següent imatge.

Figura 5.1.1, gràfica de representació de les mesures.

Els quadrats externs son les mostres que pasarem en la fase d’entrenels punts interns son les mostres que pasarem en la fase avaluació.

En aquest cas hem fet servir quatre tipus de mesures, les mostres que en el primer quadrant de la gràfica (0 a 0.5, 0 a 0.5) direm que son del tipus 0.2, les

gon quadrant (0.5 a 1, 0 a 0.5) son del tipus 0.4, les del tercer

rie de exercicis per comprovar el funcionament de la nostra tant de la fase d’entrenament com de la fase

posicions del programa er obtenir els temps de resposta de la nostra xarxa i poder-los

comparar amb la xarxa feta en Matlab, ja que aquest es un del objectius prioritaris

Per iniciar les nostres proves vam crear una gràfica on vam col·locar una tres per a la fase d’entrenament i una l’altre sèrie de mostres per la fase

, gràfica de representació de les mesures.

Els quadrats externs son les mostres que pasarem en la fase d’entrenament, i els punts interns son les mostres que pasarem en la fase avaluació.

En aquest cas hem fet servir quatre tipus de mesures, les mostres que estan en el primer quadrant de la gràfica (0 a 0.5, 0 a 0.5) direm que son del tipus 0.2, les

gon quadrant (0.5 a 1, 0 a 0.5) son del tipus 0.4, les del tercer

30

quadrant (0.5 a 1, 0.5 a 1) son del tipus 0.6, i les del quart quadrant (0.5 a 1, 0 a 0.5) son del tipus 0.8.

Amb aquest exercici tan simple, comprovarem que la nostra xarxa neuronal funciona correctament.

Les coordenades de les mesures mostrades a l’anterior gràfica son les següents:

Entrenament

(Y) (X) tipus

0,1 0,1 0,2

0,05 0,2 0,2

0,15 0,3 0,2

0,2 0,1 0,2

0,3 0,2 0,2

0,1 0,8 0,4

0,05 0,9 0,4

0,2 0,75 0,4

0,3 0,85 0,4

0,2 0,95 0,4

0,75 0,8 0,6

0,8 0,9 0,6

0,85 0,75 0,6

0,9 0,9 0,6

0,95 0,8 0,6

0,8 0,1 0,8

0,8 0,25 0,8

0,9 0,05 0,8

0,95 0,25 0,8

0,99 0,1 0,8

Avaluació

(Y) (X) tipus

0,15 0,15 0,2

0,15 0,25 0,2

0,2 0,2 0,2

0,15 0,85 0,4

0,15 0,89 0,4

0,2 0,87 0,4

0,85 0,8 0,6

0,85 0,85 0,6

0,9 0,83 0,6

0,85 0,15 0,8

0,85 0,2 0,8

0,92 0,18 0,8

31

A continuació mostrem els resultats obtinguts a la fase d’avaluació sense haver utilitzat l’estratègia de vot.

Figura 5.1.2, resultats obtinguts a la fase d’avaluació.

Tal i com es pot veure a l’imatge anterior els resultats han estat perfectes ja que hi ha hagut un encert del 100% en les classes de les mesures d’avaluació que en aquest cas eran diferents a las mesures introduïdes a la fase d’entrenament. També es pot observar que en aquesta primera avaluació passem les dades ordenades segons el seu tipus, primer les de tipus 0.2, que en pantalla ens equival a ‘0’, després les del tipus 0.4 que es ‘1’, després les de tipus 0.6 que son ‘2’ i per últim les de tipus 0.8 que son les ‘3’, ja que la nostra xarxa reconeix que hi ha diferentes classes i assigna a cada classe un valor partint de ‘0’ fins al número de classes que haguem introduït, en aquest cas en concret com hi ha 4 classes assignarà de ‘0’ a ‘3’.

A continuació fem servir l’estratègia de vot amb sis repeticions, que vol dir que pasarem les mostres d’avaluació sis vegades desordenant-les entre elles aleatòriament.

En la següent imatge podem veure com les mesures estan desordenades.

Figura 5.1.3, resultats obtinguts en la primera votació.

32

També podem observar com el percentatge d’encert a tornat a ser del 100%, igual que a la resta de fases d’avaluació on anem desordenant les mesures aleatòriament, per lo que podríem dir que en aquest exercici el funcionament de la nostra xarxa neuronal ha estat perfecte.

A continuació mostrem les imatges amb el resultats obtinguts en les diferents fases d’avaluació aplicant l’estratègia de vot.

Figura 5.1.4, resultats obtinguts en la segona votació.

Figura 5.1.5, resultats obtinguts en la tercera votació.

33

Figura 5.1.6, resultats obtinguts en la quarta votació.

Figura 5.1.7, resultats obtinguts en la cinquena votació.

34

Figura 5.1.8, resultats obtinguts en la sisena votació.

Per últim hem col·locat un temporitzador al inici i final de la primera fase d’avaluació per mesurar únicament el temps que triga la nostra xarxa en fer una avaluació de les mostres introduïdes. En aquest cas el temps que ha trigat el nostre programa en fer la fase d’avaluació ha estat de 10ms, tal i com es pot observar en la següent imatge.

Figura 5.1.9, resultats obtinguts del temps d’execució en la fase d’avaluació.

35

Finalment el nostre programa ens crea el fitxer ‘estadisticasgenerales.txt’ on es guarden en tant per cent els resultats obtinguts en totes les fases d’avaluació incloent les fetes en l’aplicació de l’estratègia de vot.

A continuació mostrem el contingut d’aquest fitxer de text on podem

observar els resultats obtinguts. clase0 clase1 clase2 clase3 Medida 0: 100.00 0.00 0.00 0.00 Medida 1: 100.00 0.00 0.00 0.00 Medida 2: 100.00 0.00 0.00 0.00 Medida 3: 0.00 100.00 0.00 0.00 Medida 4: 0.00 100.00 0.00 0.00 Medida 5: 0.00 100.00 0.00 0.00 Medida 6: 0.00 0.00 100.00 0.00 Medida 7: 0.00 0.00 100.00 0.00 Medida 8: 0.00 0.00 100.00 0.00 Medida 9: 0.00 0.00 0.00 100.00 Medida 10: 0.00 0.00 0.00 100.00 Medida 11: 0.00 0.00 0.00 100.00 Aquest fitxer ens mostra les mesures avaluades i els tipus de mesures

possibles, i ens en tant per cent el tipus el tipus de mesura que és en funció dels resultats obtinguts a la fase d’avaluació.

En aquest cas podem veure clarament com el percentatge dels tipus de les

mesures es del 100%, ja que en totes les fases d’avaluació la nostra xarxa ha encertat la classe de totes les mesures. Això vol dir que en totes les fases d’avaluació en las que hem aplicat l’estratègia de vot la nostra xarxa ha encertat la classe de les mesures introduïdes.

Per exemple si la mesura 0 l’avaluessim 10 vegades i la xarxa encertes en vuit ocasions que es de classe 0 i en dos que es de classe 1, podriem observar com als resultats la mesrura 0 es un 80% de classe 0 i un 20% de classe 1.

5.2 Experiments reals

Per continuar amb les probes hem fet cinc exercicis més, però ara amb un

tipus de mostres bastant més complexes que les anteriors, ja que aquestes mostres no tenen dos paràmetres (y, x) sinó que cada mostra tindrà deu paràmetres. Per aquest motiu no hem fet cap gràfica de la posició de les mesures ja que no es poden representar punts de deu dimensions en un full.

En aquest segon exercici, li pasarem a la nostra xarxa, en la fase

d’entrenament, un fitxer de text que contindrà cinquanta-set mostres de deu paràmetres cadascuna i cada tres mostres seran d’un tipus diferent, començant pel tipus 0.01 i acabant pel 0.19, per tant hi hauran 19 tipus de mostres diferents.

36

La primera proba que farem consistirà en passar les mateixes mesures tant a la fase d’entrenament com a la fase d’avaluació, sense aplicar l’estratègia de vot.

A continuació mostrem el contingut dels fitxers de text on es poden veure les mesures i els tipus.

Figura 5.2.1, valors de les mesures reals.

37

Figura 5.2.2, valors de les classes de les mesures reals.

38

Els resultats obtinguts en aquest exercici son els següents.

Figura 5.2.3, resultats obtinguts en la fase d’avaluació.

39


Figura 5.2.5, resultats obtinguts del temps d’execució en la fase d’avaluació.

40

En aquest segon exercici hem pogut comprovar, com els resultats en la fase d’avaluació han tornat a ser del 100% d’encert, per lo que la nostra xarxa no ha fallat en cap mesura, també es pot observar com el temps d’execució de la fase d’avaluació ens a augmentat a 40ms, això es degut a que el fitxer de les mesures introduït es més complexa ja que hi havien 57 mesures de 19 classes diferents.

En la següent imatge mostrem el contingut del fitxer de text que ens genera el programa amb els resultats en tant per cent.

Figura 5.2.6, contingut del fitxer de resultats.

41

Per continuar amb les probes, en el següent exercici farem servir el mateix fitxer de mesures que en l’exercici anterior, però en aquest cas a la fase d’avaluació només li pasarem una mesura de cada tipus per lo que ens quedarà un fitxer per la fase d’avaluació de 19 mesures. En la fase d’entrenament el fitxer serà de 57 mesures de 19 tipus diferents, tal i com el del anterior exercici.

En la següents imatges mostrem el contingut del fitxers d’entrenament.

Figura 5.2.7, valors de les mesures reals per l’entrenament.

42

Figura 5.2.8, valors de les classes de les mesures reals per l’entrenament.

43

A continuació mostrem el contingut del fitxers d’avaluació.

Figura 5.2.9, valors de les mesures reals per l’avaluació.

Figura 5.2.10, valors de les classes de les mesures reals per l’avaluació.

44

En la següent imatge mostrem els resultats obtinguts en la fase d’avaluació.


Figura 5.2.12, resultats del temps d’execució de la fase d’avaluació.

Com hem pogut observar, hi ha hagut un encert del 100% ja que no ha fallat en cap de les 19 mesures, d’altre banda podem veure com el temps d’execució ha sigut de 40ms igual que en l’exercici anterior, ja que tot i havent introduït 19 mesures eren de 19 tipus diferents i això es lo que ens fa que el temps d’execució hagi estat el mateix.

45

En la següent imatge mostrem el contingut del fitxer de text generat pel nostre programa on es veu clarament que l’encert ha estat del 100% en totes les mesures.

Figura 5.2.13, contingut del fitxer de resultats.

46

Per continuar amb les proves, en el següent exercici tornarem a introduir els mateixos fitxers per la fase d’entrenament que en l’exercici anterior, en canvi a la fase d’avaluació li pasarem el mateix fitxer de les 19 mesures de 19 tipus diferents però en aquest cas desordenades, amb lo que la primera mesura avaluada no te per que ser de classe 0 sinó que pot ser de qualsevol de les 19 classes que hi han.

A continuació mostrem el contingut del fitxer amb les 19 mesures que

pasarem a la fase d’avaluació.

Figura 5.2.14, contingut del fitxer de mesures per a la fase d’avaluació.

47

En la següent imatge podem veure clarament com les mesures introduïdes estan desordenades, ja que per exemple en aquest cas la primera mesura es de classe 0.19.

Figura 5.2.15, contingut del fitxer de classes per a les mesures per a la fase d’avaluació.

A continuació mostrem els resultats obtinguts amb la nostra xarxa a la fase d’avaluació.


48

Figura 5.2.17, temps d’execució en la fase d’avaluació.

Tal i com es pot veure en les imatges anteriors, el percentatge d’encert a estat del 100%, ja que no ha fallat en cap de les mesures tot i havent-les desordenat.

A continuació mostrem el contingut del fitxer de text on podem veure aquests resultats.

Figura 5.2.18, contingut del fitxer de resultats del encert de les mesures.

49

En el següent exercici modificarem els fitxers de la fase d’entrenament introduint les 19 primeres mesures ordenades una de cada classe, del la classe 1 a la 19, i la resta de mesures desordenades aleatòriament, tal i com podem observar en les següents imatges.

Figura 5.2.19,contingut del fitxer de mesures per a la fase d’entrenament .

50

Figura 5.2.20,contingut del fitxer de classes de les mesures per a la fase d’entrenament .

51

En canvi a la fase d’avaluació li passarem les mateixes dades que en l’exercici anterior, les 19 mesures desordenades, tal i com podem veure en les següents imatges.

Figura 5.2.21,contingut del fitxer de mesures per a la fase d’avaluació.

Figura 5.2.22,contingut del fitxer de classes de les mesures per a la fase

d’avaluació.

52

Un altre vegada em pogut comprovar que la nostra xarxa ha encertat la classe de les 19 mesures introduïdes a la fase d’avaluació, tal i com podem observar en les següents imatges.

Figura 5.2.23,resultats en la primera execució d’avaluació.

Figura 5.2.24,temps d’execució de la funció d’avaluació.

53

En aquesta imatge podem veure el contingut del fitxer de text on es veuen clarament els percentatges d’encert de la nostra xarxa:

Figura 5.2.25,contingut del fitxer de resultats d’encert de les mesures.

54

Per terminar amb les probes, hem fet un últim exercici en el que li pasarem a la nostra xarxa un fitxer amb 10 mesures de dos classes diferents ‘0’ i ‘1’, a la fase d’entrenament i a la fase d’avaluació li pasarem un altre fitxer amb 12 mesures de les dues classes anteriors, però en diferència als altres exercicis aquestes mesures no les haurem passat a la fase d’entrenament, per lo que dificulta l’encert de la nostra xarxa.

Per un altre banda farem servir l’estratègia de vot on podrem comprovar que efectivament variant l’ordre de les mesures en la fase d’entrenament ens varia el percentatge d’encert.

En la següent imatge podem veure els resultats de la primera fase d’avaluació en la que les mesures li passem de forma ordenada, i l’encert es del 100%:

Figura 5.2.26,resultats obtinguts en la primera fase d’avaluació.

Ara apliquem l’estratègia de vot cinc vegades en la que podem observar com el percentatge d’encert ens varia, tal i com veiem en les següents imatges:

Figura 5.2.27,resultats obtinguts en la primera aplicació de l’estratègia de vot.

55

Figura 5.2.28,resultats obtinguts en la segona aplicació de l’estratègia de vot.

Figura 5.2.29,resultats obtinguts en la tercera aplicació de l’estratègia de vot.

56

Figura 5.2.30,resultats obtinguts en la coarta aplicació de l’estratègia de vot.

Figura 5.2.31,resultats obtinguts en la cinquena aplicació de l’estratègia de vot.

57

Finalment mostrem el resultat del temps d’execució de la funció d’avaluació i el contingut del fitxer que ens guarda els resultats finals amb el tant per cent d’encert de les mesures.

Figura 5.2.32,temps d’execució de la funció d’avaluació.

Figura 5.2.33,contingut del fitxer de resultats del percentatge d’encert de les mesures.

58

6 Manual d’Usuari

El manual d’usuari s’entrega junt amb el programa dins d’un CD.

6.1 Instal·lació

Inicialment hem de crear una nova carpeta al disc dur del nostre ordinador

que anomenarem fuzzyartmap que es on aniran tots els arxius del programa. Llavors hem de introduir el CD a la nostra lectora i copiar l’arxiu FUZZYARTMAP.EXE a la carpeta fuzzyartmap creada anteriorment al disc dur del ordinador (C:\fuzzyartmap) per posteriorment executar-lo.

Després agafarem els fitxers de text on tenim les mostres que volem fer

servir per a l’execució de la xarxa i els guardarem també a la carpeta fuzzyartmap del disc dur del ordinador (C:\fuzzyartmap).

Per últim crearem dins de la carpeta fuzzyartmap (C:\fuzzyartmap) tres

carpetes noves que anomenarem: ‘fichero4’, ‘fichero5’ i ‘fitchero6’. Es molt important crear aquestes tres carpetes amb els noms indicats ja que el nostre programa durant la fase en la que apliquem l’estratègia de vot, les farà servir per emmagatzemar les noves matrius desordenades.

En la següent imatge es mostra la situació del disc dur (C:\) una vegada fetes

les operacions anteriors.

Figura 6.1.1, Imatge del contingut de la carpeta ‘fuzzyartmap’.

59

6.2 Format dels fitxers d’entrada.

Es molt important tindre en compte el format dels fitxers d’entrada que

farem servir amb el programa ja que si no es el correcte el nostre programa no funcionaria.

Aquests fitxers han de ser de text, acabats amb l’extensió ‘.txt’, es poden

crear per exemple amb el bloc de notes de Windows. El contingut han de ser valors reals que han d’estar normalitzats entre ‘0’ i

‘1’. Hi hauran dos tipus de fitxers que li passarem al nostre programa, els que

contenen les mesures i els que contenen les classes d’aquestes mesures (‘targets’). Per a cada mesura crearem una fila amb tots els seus paràmetres separats per

un tabulador i al final d’aquesta i haurà un final de carro (pressionarem enter). D’aquesta manera anirem introduint tantes files com mesures vulguemintroduir.

En el cas de les classes es una columna de tants valors com a mesures hi

hagin en el fitxer anterior, per tant introduirem una classe i seguidament hi haurà un final de carro, i així fins haver introduïts totes les classes.

6.3 Operació

Quan ja ho tenim preparat farem doble clic sobre el fitxer

FUZZYARTMAP.EXE guardat anteriorment al disc dur (C:\fuzzyartmap). A continuació automàticament es posarà en marxa el nostre programa

obrint-se una finestra que ens demanarà que introduïm per teclat els noms dels fitxers de les mesures que hem guardat anteriorment al disc dur (C:\fuzzyartmap), s’ha de tenir en compte de introduir correctament la ubicació on tenim guardats els fitxers, tal i com es mostra en la següent imatge.

Figura 6.3.1, petició del primer nom de fitxer per pantalla.

60

Desprésd’introduir la ubicació de cada un dels fitxers pressionarem la tecla ‘enter’ per passar al següent.

Quan ja estiguin els quatre fitxers introduïts el programa ens demanarà per

teclat els paràmetres de vigilància i resolució que volem fer servir, els anirem introduint de la mateixa manera que els fitxers, tal i com es pot veure en la següent imatge.

Figura 6.3.2, petició dels parametres de resolucio per pantalla.

Una vegada introduïts tots aquests paràmetres el programa entrarà

automàticament a executar la xarxa fuzzy artmap mostrant per pantalla al finalitzar la primera fase d’avaluació els resultats obtinguts, tal i com es pot observar en la següent imatge.

Figura 6.3.3, resultats obtinguts en la primera fase d’avaluació.

61

Posteriorment ens demanarà per teclat que introduïm el número de vegades que volem executar la estratègia de vot. Aquest programa està fet per executar un màxim de 25 vegades l’estratègia de vot, per tant haurem d’introduir un valor entre ‘0’ i ‘25’.

En el cas d’introduir ‘0’ el programa entendrà que no volem aplicar la estratègia de vot i per tant finalitzarà la seva execució, si no repetirà el procés tantes vegades com el valor del número que haguem introduït, tal y com es pot observar en les imatges següents.

Figura 6.3.4, petició del número de vegades que volem aplicar l’estratègia de vot.

En aquest cas només apliquem una vegada l’estratègia de vot.

Figura 6.3.5, resultats obtinguts a la fase d’avaluació en la primera votació.

62

Al final del programa ens mostra per pantalla el temps d’execució de la funció d’avaluació, tal y com es pot veure en la següent imatge.

Figura 6.3.6, visualització per pantalla del temps d’execució de l’avaluació. Una vegada finalitzada l’execució del programa anirem a la carpeta ‘fuzzyartmap’ (c:\fuzzyartmap) on podrem visualitzar els resultats generals obrint el fitxer ‘resultadosgenerales.txt’, tal i com es mostra a la següent imatge:

Figura 6.3.7, contingut de la carpeta ‘fuzzyartmap’ després de l’execució del programa.

63

7 Conclusions

Una vegada realitzades totes les probes i exercicis hem pogut comprovar com el funcionament de la nostra xarxa ha estat correcte, ja que en la majoria del exercicis el percentatge d’encert a la fase d’avaluació ha estat del 100%.

També hem pogut comprovar com la nostra xarxa creada en llenguatge ‘C’ es molt més ràpida que la xarxa creada en Matlab, gràcies a les probes realitzades anteriorment amb les dues xarxes i comparant els temps d’execució de la fase d’avaluació.

A continuació mostrem una taula comparativa amb els resultats obtinguts en els exercicis anteriors amb les dues xarxes, on es pot veure clarament la millora en el temps d’execució:

Número de

mesures

avaluades

Número de

paràmetres de

cada mesura

Número de

classes de les

mesures

Temps

d'execució en

Matlab

Temps

d'execució en

'C'

Primer

exercici 12 2 4 88ms 10ms

Segon


Tercer


Quart


Cinquè


Sisè exercici 10 10 2 140,8ms 16ms

Figura 7.1, taula de resultats dels temps d’execució de l’avaluació.

Per tant veien els resultats obtinguts podem afirmar que hem aconseguit l’objectiu principal del nostre projecte que era d’incrementar la velocitat d’execució.

Per un altre banda podem dir que amb l’opció de l’estratègia de vot ens ha donat dades de confiança estadística a les classificacions, ja que amb la seva aplicació hem aconseguim reduir errors de classificació.

64

8 Annexes

8.1 Codi

#include <time.h> #include <stdio.h> #include <math.h> #include <stdlib.h> #include <string.h> Estructures de matrius per a dades de tipus real. struct mat { float *datos; int filas,columnas; }; typedef struct mat matriz; Estructures de matrius pera dades de tipus sencer. struct matint { int *datos; int filas,columnas; }; typedef struct matint matrizint; Prototips de les Funcions void estadisticas(int medidas,int repeticiones,int classe); void desordena(char ficherodatos1[],char ficherodatos2[], char destino1[],char destino2[],char destino3[],int repeticiones); void crearfichero(matriz *m, char nom[]); void obtenervalores(matriz *m,char nom[]); void trainfzmap(float *vigbase, float *vigb, float *lra, float *lrb, float *alfa,matriz *ent,matriz *sal,float *viga,matriz *wija,matriz *wijb,int *wab,matriz *wijab); void evalfzmap(float *viga,float *vigb,float *lra,float *lrb,float *alfa,matriz *wija, matriz *wijb,matriz *wijab,matriz *evalent,matriz *evalsal); int fziart(float *ro, float *lr, float *alfa,matriz *entr,matriz *wija,matriz *wijb); matriz fzcc(matriz *m);

65

matriz fzand(matriz *a,matriz *b); float fzm(matriz *m); matriz* inifzart(matriz *m,int ncols); Declaració de les funcions //------------------------------------- INIFZART ------------------------------------------------ matriz* inifzart(matriz *m,int ncols) { //funció que ens dobla la dimensió del vector d’entrada i inicialitza totes les seves posicions a '1'. int i,j; if (ncols==0) i=2; else i=ncols*2; m->columnas=i; m->filas=1; m->datos=(float*)malloc((i*100)* sizeof(float)); for (j=0;j<m->columnas;j++) m->datos[j]=1; return(m); } //------------------------------------- TRAINFZMAP ------------------------------------ void trainfzmap(float *vigbase, float *vigb, float *lra, float *lrb, float *alfa, matriz *ent,matriz *sal,float *viga, matriz *wija, matriz *wijb, int *wab, matriz *wijab) { //Aquesta funció serveis per fer l’entrenament de la xarxa Fuzzy artmap. int epoch,reset,maxa,contwhile,i=0,j=0,pos=0; int *real=NULL,*outa=NULL,c; float suma,suma2; matriz a,pent,psal,pa,p1,pwija,temp; a.datos=NULL; pent.datos=NULL;

66

psal.datos=NULL; pa.datos=NULL; p1.datos=NULL; pwija.datos=NULL; temp.datos=NULL; wab=NULL; a=fzcc(ent); viga=vigbase; epoch=0; reset=1; maxa=0; real=(int*) malloc(ent->filas* sizeof(int)); outa=(int*) malloc(ent->filas* sizeof(int)); wab=(int*) malloc(ent->filas* sizeof(int)); //Actualitzem el primer valor de wab a ‘-1’. wab[0]=-1; wijab->datos[0]=-1; wijab->filas=1; wijab->columnas=1; // Reservem memòria per a la matriu‘temp’amb les mateixes dimensions que la matriu d’entrada (ent). temp.datos=(float*)malloc((ent->filas*ent->columnas)*4*sizeof(float)); //multipliquem per 4 la dimensió de l’entrada. temp.columnas=1; temp.filas=1; psal.datos=(float*)malloc(sal->columnas*sizeof(float)); psal.columnas=sal->columnas; psal.filas=1; pent.datos=(float*)malloc(ent->columnas*sizeof(float)); pent.columnas=ent->columnas; pent.filas=1; pwija.datos=(float*)malloc(ent->columnas*sizeof(float)); pwija.columnas=wija->columnas; pwija.filas=1; pa.datos=(float*)malloc(a.columnas*sizeof(float)); pa.columnas=a.columnas; pa.filas=1;

67

p1.datos=(float*)malloc(ent->columnas*ent->filas*sizeof(float)); p1.columnas=a.columnas; p1.filas=1; wija=inifzart(wija,ent->columnas); wijb=inifzart(wijb,sal->columnas); while (reset>0) { epoch++; reset=0; for (i=0;i<ent->filas;i++) { for (j=0;j<sal->columnas;j++) { pos=sal->columnas*i+j; psal.datos[j]=sal->datos[pos]; //El vector ‘psal’ens guarda totes les columnes de la fila 'i' de sal } for (j=0;j<ent->columnas;j++) { pos=ent->columnas*i+j; pent.datos[j]=ent->datos[pos]; //El vector ‘pent’ ens guarda totes les columnes de la fila 'i' de ent } real[i]=fziart(vigb,lrb,alfa,&psal,wijb,wijb); for (j=0;j<ent->columnas;j++) { pos=ent->columnas*i+j; pent.datos[j]=ent->datos[pos]; //El vector ‘pent’ ens guarda totes les columnes de la fila 'i' de ent } outa[i]=fziart(viga,lra,alfa,&pent,wija,&temp); contwhile=0; while(wab[outa[i]]!=real[i]) { if (wab[outa[i]]==-1) { wab[maxa]=real[i]; wijab->datos[maxa]=real[i]; maxa++; wijab->filas++; wab[maxa]=-1; wijab->datos[maxa]=-1; }

68

else { reset++; for(j=0;j<a.columnas;j++) { pos=a.columnas*i+j; pa.datos[j]=a.datos[pos]; } for(j=0;j<wija->columnas;j++) { pos=wija->columnas*outa[i]+j; pwija.datos[j]=wija->datos[pos]; } pwija.columnas=wija->columnas; p1=fzand(&pa,&pwija); suma=fzm(&p1); suma2=fzm(&pa); *viga=0.01+fzm(&p1)/fzm(&pa); outa[i]=fziart(viga,lra,alfa,&pent,wija,&temp); } } for(c=0;c<temp.filas*temp.columnas;c++) wija->datos[c]=temp.datos[c]; wija->columnas=temp.columnas; wija->filas=temp.filas; } } free(temp.datos); } //------------------------------------EVALFZMAP-----------------------------------// void evalfzmap(float *viga,float *vigb,float *lra,float *lrb,float *alfa,matriz *wija, matriz *wijb,matriz *wijab,matriz *evalent,matriz *evalsal) { //Aquesta funció es l’encarregada de fer la fase d’avaluació de la xarxa. int nsnc,cuelgue,abc,i,j,ok,nok,totalwija,totalwijb,totalwijab,pos,totalent; int c; matriz wijabucle,wijbbucle,wab,psal,pent,temp,a; float *testviga=NULL,disroup,disrodown,disromin; float resolucion; int *real=NULL,*outa=NULL,*pred=NULL; float rateok; //Calculem tots els elements de les matrius ‘wija’ y ‘wijb’.

69

totalwija=wija->columnas*wija->filas; totalwijb=wijb->columnas*wijb->filas; totalwijab=wijab->columnas*wijab->filas; totalent=evalent->columnas*evalent->filas; //Reservem la memòria per a les matrius ‘wijabucle’, ‘wijabbucle’, ‘wab’ y ‘temp’. wijabucle.datos=(float*)malloc(totalwija * sizeof(float)); wijabucle.columnas=wija->columnas; wijabucle.filas=wija->filas; if(wijabucle.datos==NULL) printf("NO HAY MEMORIA PARA WIJABUCLE\n"); wijbbucle.datos=(float*) malloc(totalwijb * sizeof(float)); wijbbucle.columnas=wijb->columnas; wijbbucle.filas=wijb->filas; wab.datos=(float*) malloc(totalwijab * sizeof(float)); wab.columnas=wijab->columnas; wab.filas=wijab->filas; temp.datos=(float*) malloc(totalwija * sizeof(float)); temp.columnas=wija->columnas; temp.filas=wija->filas; a.datos=(float*)malloc(totalent*2*sizeof(float)); //Reservem la memòria per als vectors ‘real[]’, ‘outa[]’ i ‘pred[]’. pred=(int*) malloc(evalent->filas* sizeof(int)); real=(int*) malloc(evalent->filas* sizeof(int)); outa=(int*) malloc(evalent->filas* sizeof(int));

//Reservem la memòria per a les matrius ‘psal’ i ‘pent’. psal.datos=(float*) malloc(evalsal->columnas*evalsal->filas* sizeof(float)); psal.columnas=evalsal->columnas; psal.filas=1; pent.datos=(float*) malloc(evalent->columnas*evalent->filas* sizeof(float)); pent.columnas=evalent->columnas; pent.filas=1; disroup=(1-(*viga))/2; disrodown=(*viga)/2; if (disroup<disrodown) disromin=disroup; else disromin=disrodown;

70

resolucion=0.01; testviga=viga; nsnc=1; cuelgue=0; while ((disromin>resolucion)|(nsnc>0)) { cuelgue++; abc=((disromin>0.01)|(nsnc>0)); for(i=0;i<totalwija;i++) { wijabucle.datos[i]=wija->datos[i]; } for(i=0;i<totalwijb;i++) wijbbucle.datos[i]=wijb->datos[i]; for(i=0;i<totalwijab;i++) wab.datos[i]=wijab->datos[i]; a=fzcc(evalent); for (i=0;i<evalent->filas;i++) { for (j=0;j<evalsal->columnas;j++) { pos=evalsal->columnas*i+j; psal.datos[j]=evalsal->datos[pos]; } for (j=0;j<evalent->columnas;j++) { pos=evalent->columnas*i+j; pent.datos[j]=evalent->datos[pos]; } real[i]=fziart(vigb,lrb,alfa,&psal,&wijbbucle,wijb); outa[i]=fziart(testviga,lra,alfa,&pent,&wijabucle,&temp); if(wab.datos[outa[i]]>-1) { for(c=0;c<temp.columnas*temp.filas;c++) wijabucle.datos[c]=temp.datos[c]; wijabucle.columnas=temp.columnas; wijabucle.filas=temp.filas; } } for(i=0;i<evalent->filas;i++)

71

pred[i]=wab.datos[outa[i]]; ok=0; nsnc=0; for (i=0;i<evalent->filas;i++) { if (pred[i]==real[i]) ok++; if (pred[i]==-1) nsnc++; } nok=evalent->filas-ok-nsnc; rateok=100*ok/evalent->filas; if(nsnc>0) *testviga=*testviga-disrodown; else *testviga=*testviga-disroup; disroup=disroup/2; if (disroup<resolucion/3) disroup=resolucion/3; disrodown=disrodown/2; if (disrodown<resolucion/3) disrodown=resolucion/3; if (disrodown<disroup) disromin=disrodown; else disromin=disroup; viga=testviga; for(i=0;i<evalent->filas;i++) pred[i]=wab.datos[outa[i]]; ok=0; nsnc=0; for (i=0;i<evalent->filas;i++) { if (pred[i]==real[i]) ok++; if (pred[i]==-1) nsnc++; }

72

} nok=evalent->filas-ok-nsnc; rateok=100*(ok)/(evalent->filas); printf("Impresion de los resultados de test:\n"); printf("nok: %d\n",nok); printf("ok: %d\n",ok); printf("nsnc: %d\n",nsnc); printf("rateok: %f\n",rateok); for (i=0;i<evalent->filas;i++) { printf("medida %d: pred: %d real: %d\n",i,pred[i],real[i]); } getchar(); //Guardem els resultats de test en el fitxer ‘fichero6.txt’ FILE *f; f=fopen("c:/resultadosgenerales.txt","a"); for (i=0;i<evalent->filas;i++) fprintf(f,"%d ",pred[i]); fprintf(f,"\n"); fclose(f); } //------------------------------------------ FZM --------------------------------------------------- float fzm(matriz *m) { //Aquesta funció ens retorna la suma dels valors del vector d’entrada. int i; float res=0; for (i=0;i<m->columnas;i++) res=res+m->datos[i]; return (res); }

73

//----------------------------------------- FZAND -------------------------------------------------- matriz fzand(matriz *a, matriz *b) { //Funció que ens retorna una matriu amb els valors mínims de les matrius d’entrada a i b. int cont=0,totalcolumnas,validas,i; matriz c; if (a->columnas>b->columnas) { totalcolumnas=a->columnas; c.columnas=a->columnas; c.filas=a->filas; } else { totalcolumnas=b->columnas; c.columnas=b->columnas; c.filas=b->filas; } c.datos=(float*) malloc(totalcolumnas* sizeof(float)); if (c.datos==NULL) { printf("NO HAY MEMORIA (FZAND)\n"); getchar(); } for(i=0;i<c.columnas*c.filas;i++) c.datos[i]=0; if (a->columnas==b->columnas) { for (cont=0;cont<a->columnas;cont++) { if (a->datos[cont]<b->datos[cont]) c.datos[cont]=a->datos[cont]; else c.datos[cont]=b->datos[cont]; } } else { if (a->columnas>b->columnas) { validas=a->columnas-b->columnas; for (cont=0;cont<validas;cont++) { if (a->datos[cont]<b->datos[cont])

74

c.datos[cont]=a->datos[cont]; else c.datos[cont]=b->datos[cont]; } for(cont=b->columnas;cont<a->columnas;cont++) c.datos[cont]=a->datos[cont]; } else { validas=b->columnas-a->columnas; for (cont=0;cont<validas;cont++) { if (a->datos[cont]<b->datos[cont]) c.datos[cont]=a->datos[cont]; else c.datos[cont]=b->datos[cont]; } for(cont=a->columnas;cont<b->columnas;cont++) c.datos[cont]=b->datos[cont]; } } return(c); } //----------------------------------------- FZCC ------------------------------------------------- matriz fzcc(matriz *m) { //Funció que retorna la mateixa matriu d’entrada amb el doble de columnes afegint el complementari dels seus valors. int i,j,c,total,comp; //La variable ncol és el valor de les columnes de la matriu de sortida (resfcc). matriz resfcc; resfcc.columnas=m->columnas*2; resfcc.filas=m->filas; //Comprovem si es tracta d’un vector o d’una matriu. if (m->filas==1) total=m->columnas; else total=m->columnas*m->filas; resfcc.datos=(float*) malloc(total*2 * sizeof(float));

75

//Realitzem la còpia de la taula d’entrada en la sortida i afegim els seus complementaris. comp=0; c=0; i=0; j=0; while (j<total) { resfcc.datos[i]=m->datos[j]; comp=i+m->columnas; resfcc.datos[comp]=1-m->datos[j]; i++; j++; c++; if (c==m->columnas) { i=i+m->columnas; c=0; } } return(resfcc); } //-------------------------------------- FZIART ------------------------------------------------- int fziart(float *ro, float *lr, float *alfa,matriz *entr,matriz *wija,matriz *wijb) { float *t=NULL,*aux=NULL; int i=0,j=0,pos=0; int bucle, punt, *index=NULL,act,totalwija=0,telem=0,posjesus; matriz input,stemp,vwija,tempo, ttemp; input.datos=NULL; stemp.datos=NULL; vwija.datos=NULL; tempo.datos=NULL; ttemp.datos=NULL; float result=0,resultp=0,total; //variables pera la funció sort int c,r,vi; float a;

76

//Generem un vector amb tants valors com a filas de la matriu de mesures de wija . t=(float*) malloc(wija->filas* sizeof(float)); //fem una còpia de la matriu ‘wija’ en la matriu ‘wijb’. totalwija=wija->columnas*wija->filas; for(i=0;i<totalwija;i++) { wijb->datos[i]=wija->datos[i]; } wijb->columnas=wija->columnas; wijb->filas=wija->filas; input=fzcc(entr); //Reservem memòria per a emmagatzemar els valors d’una fila de la matriu ‘wija’. vwija.datos=(float*)malloc(wija->columnas* sizeof (float)); vwija.filas=1; vwija.columnas=wija->columnas; //Reservem memòria per al vector ‘temp’ que ens guarda els resultats temporals de l’operació. tempo.datos=(float*)malloc(wija->columnas* sizeof (float)); tempo.columnas=wija->columnas; tempo.filas=1; j=0; i=0; if (wija->filas>1) { for (i=0;i<wija->filas-1;i++) { //Creem el vector ‘vwija’ amb tots els elements d’una sola fila de la matriu ‘wija’. for (j=0;j<wija->columnas;j++) { pos=wija->columnas*i+j; vwija.datos[j]=wija->datos[pos]; } stemp=fzand(&input,&vwija); ç //'stemp': resultat intermedi de fzand(input,wija(i,:). result=*alfa+fzm(&vwija);

77

//'result': resultat intermedi de alfa+fzm(wija(i,:) for (j=0;j<wija->columnas;j++)

tempo.datos[j]=stemp.datos[j]/result; //Guardem el resultat final de l'operació en la posició [i] de t. t[i]=fzm(&tempo); telem++; } //L'últim valor del vector ho posem a '0'. t[wija->filas-1]=0; } else t[0]=1; telem++; //---------funció sort de Matlab-------------- c=0; r=1; aux=(float*) malloc(telem* sizeof(float)); index=(int*) malloc(telem* sizeof(int)); //copiem els valors de 't' a 'aux' for (j=0;j<telem;j++) { aux[j]=t[j]; }

//Ordenem els valors de la taula aux.

for(c=0;c<telem-1;c++) for(i=c+1;i<telem;i++) if(aux[c]<aux[i]) { a=aux[i]; aux[i]=aux[c]; aux[c]=a; } //introduïm els valors de les posicions en la taula index. for (i=0;i<telem;i++) { j=0; while (aux[i]!=t[j])

78

j++; vi=j; index[i]=vi; } //Canviem el segueixo dels valors de la taula aux. for (i=0;i<telem;i++) aux[i]=aux[i]*(-1); //------------------------------------------- punt=0; if (*ro>1) *ro=1; //----En aquest bucle fem la següent operació: ------------------------------ //------- (fzm(fzand(input,wija(index(punt),:)))/fzm(input))<ro ----------------- int final; ttemp.datos=(float*)malloc(wija->columnas* sizeof (float)); //Reserva de memòria per al vector de resultats ttemp.

ttemp.columnas=wija->columnas; ttemp.filas=1; final=0; bucle=0; while (final!=1) { i=index[punt]; for(j=0;j<wija->columnas;j++) //Creem el vector vwija=wija(index(punt),:) { pos=wija->columnas*i+j; vwija.datos[j]=wija->datos[pos]; } stemp=fzand(&input,&vwija); resultp=fzm(&stemp); result=fzm(&input); total=resultp/result;

79

if (total<*ro) { bucle++; punt++; } else final=1; } // ----------Fast commit slow recode------- int iguales=1; i=index[punt]; for (j=0;j<wija->columnas;j++) { pos=wija->columnas*i+j; vwija.datos[j]=wija->datos[pos]; } while (iguales==1) { for (j=0;j<wija->columnas;j++) { if (vwija.datos[j]!=1) //Comparem tots els elements del vector amb '1' en cas d'haver algun diferent la variable iguals la posem a '0'.

iguales=0; } if (iguales==1) { for(j=0;j<wijb->columnas;j++) { pos=wijb->columnas*i+j; wijb->datos[pos]=input.datos[j]; } } else { for (j=0;j<wija->columnas;j++) { pos=wija->columnas*i+j; stemp.datos[j]=(wija->datos[pos])*(1-(*lr)); } ttemp=fzand(&input,&vwija); for(j=0;j<wija->columnas;j++) ttemp.datos[j]=ttemp.datos[j]*(*lr); for (j=0;j<wijb->columnas;j++) {

80

pos=wijb->columnas*index[punt]+j; wijb->datos[pos]=stemp.datos[j]+ttemp.datos[j]; } } iguales=0; } //----------Final de la modificació-------------- if (punt+1==wija->filas) { for(j=0;j<wijb->columnas;j++) {

posjesus=(wijb->columnas*wijb->filas)+j; posjesus=(wija->filas*wija->columnas)+j;

wijb->datos[posjesus]=1; } wijb->filas++; } act=index[punt]; free(t); t=NULL; free(aux); aux=NULL; free(index); index=NULL; stemp.datos=NULL; free(vwija.datos); vwija.datos=NULL; free(tempo.datos); tempo.datos=NULL; free(ttemp.datos); ttemp.datos=NULL; return(act); } //---------------------------OBTENER VALORES DE FICHERO------------------------// void obtenervalores(matriz *m,char nom[]) { //Funció que genera una matriu, obtenint les dades d'un fitxer de text. FILE *f; float v=0,*a; char c=0; int i=0,j=0,cont=0,totalvalors=0;

81

f=fopen(nom,"r"); if (f==NULL) printf("\nError no se puede leer el archivo indicado.\n"); else { while (!feof(f)) { fscanf(f,"%f",&v); totalvalors++; } totalvalors--; rewind(f); while (!feof(f)) { c=fgetc(f); if(c=='\n') i++; } m->datos=(float*) malloc(totalvalors * sizeof(float)); rewind(f); while (!feof(f)) { fscanf(f,"%f",&v); m->datos[cont]=v; cont++; } j=totalvalors/i; m->columnas=j; m->filas=i; fclose(f); } } //-------------------------------CREAR FICHERO---------------------------------------// void crearfichero(matriz *m, char nom[]) { //Funció específica que serveix per a crear un fitxer de text amb els valors d'una matriu del programa, cridarem a la funció amb una matriu i el nom del fitxer a crear. FILE *f; int cont=0; f=fopen(nom,"w");

82

for (cont=0;cont<m->filas*m->columnas;cont++) { fprintf(f,"%f\n",m->datos[cont]); } fclose(f); } //--------------------------------DESORDENAR MATRIZ---------------------------------// void desordena(char ficherodatos1[],char ficherodatos2[], char destino1[],char destino2[],char destino3[],int repeticiones) { //Funció que genera fitxers de test (entrada / sortida) en funció dels inicials desordenats aleatòriament, genera tants fitxers com el nº de repeticions introduït. Aquesta funció també crea un fitxer nou amb el index de la fila en el qual estaven inicialment les mesures, al que cridem fitxer6.txt.Amb aquest fitxer es pot saber que posició estava inicialment la mesura i que posició és l'actual. matriz m1,m2,m3,temp; matrizint mid; int indice,i,j,numero,c; //Creem la variable indice que serà un nº aleatori per a desordenar les matrius. //numero: és la quantitat de fitxers nous que creguem desordenats. FILE *f; //------- m1=matriu que guarda els valors del primer fitxer de dades. //------- m2=matriu que guarda els valors del segon fitxer de dades. //------- m3=matriu fictícia de nº aleatoris per a desordenar els fitxers de dades. //------- mid=matriu nº de identificacion. obtenervalores(&m1,ficherodatos1); //Obtenim els valors del fitxer‘fichero4’. obtenervalores(&m2,ficherodatos2); //Obtenim els valors del fitxer ‘fichero5’. mid.columnas=1; mid.filas=m1.filas; mid.datos=(int*) malloc(mid.columnas*mid.filas * sizeof(int)); for (i=0;i<mid.filas;i++) for (j=0;j<mid.columnas;j++) mid.datos[mid.columnas*i+j]=i;

83

//Creem la matriu 3 i el vector temp que ens servirà per a desordenar els fitxers. m3.columnas=1;

//solament posem una columna ja que el que ens interessa és desordenar les files. m3.filas=m1.filas; m3.datos=(float*) malloc(m3.columnas*m3.filas * sizeof(float)); if(m1.columnas>m2.columnas) temp.datos=(float*) malloc(m1.columnas * sizeof(float)); else temp.datos=(float*) malloc(m2.columnas * sizeof(float)); for(numero=0;numero<repeticiones;numero++) { for (i=0;i<m3.filas*m3.columnas;i++) { indice=rand()%(100000); m3.datos[i]=indice; } for(c=0;c<m3.filas-1;c++) for(i=c+1;i<m3.filas;i++) if(m3.datos[c]<m3.datos[i]) { //------------------------------------Matriz mid------------------------------// for(j=0;j<mid.columnas;j++) temp.datos[j]=mid.datos[mid.columnas*i+j]; for(j=0;j<mid.columnas;j++) mid.datos[mid.columnas*i+j]=mid.datos[mid.columnas*c+j]; for(j=0;j<mid.columnas;j++) mid.datos[mid.columnas*c+j]=temp.datos[j]; } //////// Creem les còpies dels fitxers 4 //////// f=fopen(destino1,"w"); for(i=0;i<mid.filas;i++) { for (j=0;j<m1.columnas;j++) { fprintf(f,"%f",m1.datos[m1.columnas*mid.datos[i]+j]); if(j==m1.columnas-1) fprintf(f,"\n"); else fprintf(f," "); } }

84

fclose(f); destino1[20]++; //////// Creem les còpies dels fitxers 5 //////// f=fopen(destino2,"w"); for (i=0;i<mid.filas;i++) { for (j=0;j<m2.columnas;j++) { fprintf(f,"%f",m2.datos[m2.columnas*mid.datos[i]+j]); if(j==m2.columnas-1) fprintf(f,"\n"); else fprintf(f," "); } } fclose(f); destino2[20]++; //////// Creem les còpies dels fitxers 6 //////// f=fopen(destino3,"w"); for (i=0;i<mid.filas;i++) { for (j=0;j<mid.columnas;j++) { fprintf(f,"%d",mid.datos[mid.columnas*i+j]); if(j==mid.columnas-1) fprintf(f,"\n"); else fprintf(f," "); } } fclose(f); destino3[20]++; } } //-------------------------------------ESTADISTICAS----------------------------------------// void estadisticas(int medidas,int repeticiones,int clase) { /Funció que genera el fitxer ‘estadisticasgenerales.txt’ amb els resultats en % d'encert de tipus de classe per a cada mesura introduïda. FILE *f1,*f,*f2,*f3; matriz estadis; float clas[1000]; int cont,v,i,j;

85

char repefich6[]="c:/fichero6/fichero6a.txt"; i=0; j=0; if(repeticiones==0) { estadis.filas=medidas; estadis.columnas=1; estadis.datos=(float*) malloc(estadis.columnas*estadis.filas * sizeof(float)); } else { estadis.filas=medidas; estadis.columnas=repeticiones+1; estadis.datos=(float*) malloc(estadis.columnas*estadis.filas * sizeof(float)); } f1=fopen("c:/ficheroindices.txt","a"); if (f1==NULL) printf("\nError no se puede leer el archivo indicado2.\n"); else { for(cont=0;cont<medidas;cont++) fprintf(f1,"%d ",cont); fprintf(f1,"\n"); } fclose(f1); if(repeticiones!=0) { for(cont=0;cont<repeticiones;cont++) { f=fopen(repefich6,"r"); if (f==NULL) printf("\nError no se puede leer el archivo indicado1.\n"); else { f1=fopen("c:/ficheroindices.txt","a"); if (f1==NULL) printf("\nError no se puede leer el archivo indicado2.\n"); else { while (!feof(f)) { fscanf(f,"%d\n",&v); fprintf(f1,"%d ",v); } fprintf(f1,"\n"); }

86

} fclose(f); fclose(f1); repefich6[20]++; } } f2=fopen("c:/resultadosgenerales.txt","r"); if (f==NULL) printf("\nError no se puede leer el archivo indicado1.\n"); else { f1=fopen("c:/ficheroindices.txt","r"); if (f1==NULL) printf("\nError no se puede leer el archivo indicado2.\n"); else { while (!feof(f1)) { for(j=0;j<estadis.columnas;j++) { for(cont=0;cont<medidas;cont++) { fscanf(f2,"%d",&v); fscanf(f1,"%d",&i); estadis.datos[estadis.columnas*i+j]=v; } } } fprintf(f1,"\n"); } } fclose(f2); f3=fopen("c:/estadisticasgenerales.txt","w"); if (f3==NULL) printf("\nError no se puede leer el archivo indicado1.\n"); else { fprintf(f3," "); for(i=0;i<clase;i++) fprintf(f3,"clase%d ",i); fprintf(f3,"\n\n"); for(cont=0;cont<medidas;cont++) { for(i=0;i<clase;i++) clas[i]=0; for(j=0;j<estadis.columnas;j++)

87

{ for(i=0;i<clase;i++) { if(estadis.datos[estadis.columnas*cont+j]==i) clas[i]++; } } fprintf(f3,"Medida %d: ",cont); for(i=0;i<clase;i++) { clas[i]=clas[i]*100/estadis.columnas; fprintf(f3,"%.2f ",clas[i]); } fprintf(f3,"\n"); } fclose(f3); }

fclose(f1); } //---------------------------------------MENU PRINCIPAL------------------------------------// void main (void) { /////////////Temporitzador////////////////////// clock_t t_ini, t_fin; double secs; /////////////////////////////////////////////// matriz wija, wijab,wijb,ent, sal,evalent, evalsal; float viga,vigb,lra,lrb,alfa,vigbase; int act,*wab,cont,repeticiones,clases;

//la variable ‘clases’ ens determina el nº de tipus de mesures en les que volem treballar.

//Aquests son diferents exercicis que hem fet per comprovar el funcionament de la nostra xarxa, introduint diferents matrius d’entrada tant per a la fase d’entrenament com per a la fase d’avaluació. ////// Prova 1 /////////////////////////////////// /* char fichero1[]="c:/prueba1.txt"; char fichero2[]="c:/prueba2.txt"; char fichero4[]="c:/prueba1.txt"; char fichero5[]="c:/prueba2.txt"; */

88

////// Prova 2 /////////////////////////////////// /* char fichero1[]="c:/prueba1.txt"; char fichero2[]="c:/prueba2.txt"; char fichero4[]="c:/prueba4.txt"; char fichero5[]="c:/prueba5.txt"; */ ////// Prova 3, 4 y 5 /////////////////////////////////// /* char fichero1[]="c:/entreno.txt"; char fichero2[]="c:/ytrain.txt"; char fichero4[]="c:/eval.txt"; char fichero5[]="c:/yeval.txt"; */ //////Fitxers reals//////////////////////////// /* char fichero1[]="c:/p1.txt"; char fichero2[]="c:/p2.txt"; char fichero4[]="c:/p4.txt"; char fichero5[]="c:/p5.txt"; */ ///// Els meus fitxers////////////////////////////// /* char fichero1[]="c:/b1.txt"; char fichero2[]="c:/b2.txt"; char fichero4[]="c:/b4.txt"; char fichero5[]="c:/b5.txt"; */ ///////////////////////////////////////////////// /* char fichero1[]="c:/xentreno.txt"; char fichero2[]="c:/yentreno.txt"; char fichero4[]="c:/xevaluacion.txt"; char fichero5[]="c:/yevaluacion.txt"; */ char fichero3[]="c:/fichero3.txt"; char destino1[]="c:/fichero4/fichero4a.txt"; char destino2[]="c:/fichero5/fichero5a.txt"; char destino3[]="c:/fichero6/fichero6a.txt"; char repefich4[]="c:/fichero4/fichero4a.txt"; char repefich5[]="c:/fichero5/fichero5a.txt"; act=1;

89

printf("****************************************** ***************\n"); printf("****************************************** ***************\n"); printf("****************INICIO PROGRAMA ********** ************\n"); printf("****************** RED NEURONAL ******* **************\n"); printf("*************** FUZZY ARTMAP ********** ***************\n"); printf("****************************************** ***************\n"); printf("****************************************** ***************\n"); printf("********************************** JORDI V ILA ROMERO **\n"); printf("************************************* SEP TIEMBRE 2009 **\n"); printf("****************************************** ***************\n"); printf("****************************************** ***********\n\n\n\n"); //Demanem per teclat el nom dels fitxers amb els quals hem d'operar. printf("Introduce el nombre del fichero de entradas de la fase de entreno:\n (c:/fuzzyartmap/nombre_fichero.txt)\n"); scanf("%s",&fichero1); printf("Introduce el nombre del fichero de salidas de la fase de entreno:\n (c:/fuzzyartmap/nombre_fichero.txt)\n"); scanf("%s",&fichero2); printf("Introduce el nombre del fichero de entradas de la fase de test:\n (c:/fuzzyartmap/nombre_fichero.txt)\n"); scanf("%s",&fichero4); printf("Introduce el nombre del fichero de salidas de la fase de test:\n (c:/fuzzyartmap/nombre_fichero.txt)\n"); scanf("%s",&fichero5); //Carreguem els valors dels fitxers introduïts en el nostre programa. // -------------------------Mesures de la fase d’entrenament---------------------------- obtenervalores(&ent,fichero1); obtenervalores(&sal,fichero2); // -------------------------Mesures de la fase d’avaluació------------------------------- obtenervalores(&evalent,fichero4); obtenervalores(&evalsal,fichero5); //------------------------------------------------------------------------- //Demanem per teclat els valors de resolució. printf("Introduce los valores de viga, vigbase, vigb, lra, lrb y alfa:\n"); scanf("%f",&viga); scanf("%f",&vigbase); scanf("%f",&vigb);

90

scanf("%f",&lra); scanf("%f",&lrb); scanf("%f",&alfa); //Reservem memòria pera la matriu‘wijab’. wijab.datos=(float*) malloc(ent.filas * sizeof(float)); trainfzmap(&vigbase,&vigb,&lra,&lrb,&alfa,&ent,&sal,&viga,&wija,&wijb,wab,&wijab); crearfichero(&wijab,fichero3); clases=wijb.filas-1; t_ini = clock(); evalfzmap(&viga,&vigb,&lra,&lrb,&alfa,&wija,&wijb,&wijab,&evalent,&evalsal); t_fin = clock(); printf("Pulsa una tecla para continuar.\n"); getchar(); getchar(); system("CLS"); secs = (double)(t_fin - t_ini) / CLOCKS_PER_SEC;

printf("Introduce el numero de repeticiones para la ejecucion del 'voting strategy'\n");

printf("y pulsa enter:\n"); scanf("%d",&repeticiones); getchar(); system("CLS"); desordena(fichero4,fichero5,destino1,destino2,destino3,repeticiones); for(cont=0;cont<repeticiones;cont++) { obtenervalores(&evalent,repefich4); obtenervalores(&evalsal,repefich5);

evalfzmap(&viga,&vigb,&lra,&lrb,&alfa,&wija,&wijb,&wijab,&evalent,&evalsal);

printf("Pulsa una tecla para continuar.\n"); getchar(); system("CLS"); repefich4[32]++; repefich5[32]++; } estadisticas(evalent.filas,repeticiones,clases);

91

printf("Tiempo de ejecucion de la funcion de evaluacion\n"); printf("%.16g milisegundos\n\n", secs * 1000.0); ////////////////////////////////////////////////////// printf("**************FINAL DEL PROGRAMA*********** ****\n"); // Esborrem els fitxers que ha creat el nostre programa per a fer les operacions internes del mateix. system("del c:\\fuzzyartmap\\resultadosgenerales.txt"); system("del c:\\fuzzyartmap\\fichero3.txt"); system("del c:\\fuzzyartmap\\ficheroindices.txt"); getchar(); }

Implementació en llenguatge ‘C’ d’una xarxa Fuzzy ARTMAP amb...

Documents

Transcript of Implementació en llenguatge ‘C’ d’una xarxa Fuzzy ARTMAP amb...