Sebbene le matrici di convoluzione, chiamate anche “kernel“, possano essere di qualsiasi dimensione, le piu’ usate sono quelle 5×5 e 3x3. In questo articolo prenderemo in considerazione solo le seconde, che sono sufficienti a creare una grande varieta’ di effetti. La matrice va applicata separatamente ad ogni canale dell’immagine (R, G, B) nel seguente modo. Supponiamo di operare esclusivamente sul canale R, visto che le operazioni sono analoghe agli altri canali, e di avere pixel con i valori indicati nella matrice a sinistra a cui vogliamo applicare la matrice di convoluzione presente a destra:
|
|
Il pixel evidenziato in rosso e’ quello su cui stiamo lavorando in questo momento, mentre la matrice a destra e’ il nostro kernel. Per applicare il filtro di convoluzione sul pixel dobbiamo immaginare di sovrapporre l’elemento centrale della matrice kernel con il pixel che stiamo considerando e di fare la somma di tutti i prodotti degli elementi sovrapposti. In poche parole dobbiamo moltiplicare gli elementi corrispondenti tra le due matrici e sommare tutti i risultati. Notate che non stiamo effettuando una normale moltiplicazione tra matrici (cioe’ un prodotto riga per colonna)!
Nel nostro caso il calcolo e’:
255*0 + 180*0 + 100*0 + 125*0 + 175*1 + 150*0 + 0*0 + 123*0 + 20*0 == 175
La matrice di convoluzione che abbiamo scelto, potrebbe essere paragonata alla matrice identita’ nel caso di un prodotto tra matrici. Come la matrice identita’ non cambia il risultato, cosi’ questa matrice fornisce come risultato lo stesso pixel e quindi l’immagine di output rimane invariata. Ovviamente questo e’ un caso particolare, e alla fine dell’articolo vedremo alcuni degli effetti prodotti da altre matrici particolari.
Comunque, quando la matrice di convoluzione viene applicata a tutti i pixel dell’immagine il lavoro e’ terminato ed abbiamo ottenuto la nostra immagine modificata. Vediamo alcune parti del codice in C++ che trovate allegato alla fine dell’articolo. Ah, il codice fa uso, come al solito, delle librerie EasyBMP per la gestione delle BMP.
int mat[DIM][DIM];
typedef struct pixel {
int red, green, blue;
};
Creiamo una matrice DIMxDIM (dove DIM = 3 nel nostro caso), che sara’ la nostra matrice di convoluzione, e creiamo un nostro tipo per descrivere i pixels. Dopo aver fatto inserire all’utente i 9 valori degli elementi della matrice, possiamo iniziare i calcoli. Nelle righe 38-56 (non le scrivo qua perche’ vengono formattate male) svolgiamo i calcoli veri e propri. Gli indici i e j sono le coordinate x e y del pixel che stiamo esaminando; notate che escludiamo i pixel appartenenti al bordo esterno dell’immagine semplicemente perche’ non hanno 8 pixel confinanti come tutti gli altri, e quindi verrebbe piu’ difficile applicare la matrice perche’ dovremmo escludere alcuni pixel dal conteggio; il risultato non cambia di molto.
I nuovi valori dei pixel vengono salvati in un array di oggetti pixel (il typedef che abbiamo definito poco piu’ su). Quello che ci manca è riportare questi valori in un intervallo 0…255. Sappiamo infatti che 255 e’ il valore massimo per ogni componente di un pixel, ma dall’applicazione del nostro filtro, potremmo avere (e’ spesso e’ cosi’) valori che superano questa soglia. Per fare cio’ calcoliamo la somma di tutti gli elementi della matrice di convoluzione e dividiamo tutti i valori di output per questa somma. Se dopo questa operazione ci saranno ulteriori valori > 255, li imposteremo uguali a 255, cosi’ come imposteremo a 0 quelli < 0.
Vediamo un esempio:
 |
MATRICE DI CONVOLUZIONE 0 -1 0 -1 4 -1 0 -1 0 |
 |
In questo esempio, e’ stata applicata all’immagine una matrice per individuare i bordi (edge detection). Le immagini sono piuttosto pesanti essendo BMP e quindi non compresse.
Su Internet si trovano facilmente altre matrici di convoluzione associate a risultati particolari. Ecco il codice del programma. Alla prossima.
]]>
Le reti neurali hanno diverse applicazioni e spaziano in diversi campi. In questo paragrafo elencherò alcune applicazioni interessanti che ho trovato sulla rete e poi mostrerò come è possibile creare un molto rudimentale sistema di riconoscimento dii immagini, capace di riconoscere i numeri da 0 a 9.
Alcune applicazioni sono:
Vita artificiale: la vita artificiale tenta di simulare l’evoluzione di organismi viventi tramite computer. Spesso gli organismi sono dotati di reti neurali per svolgere i loro compiti come trovare fonti di cibo, muoversi, etc…
Finanza: prevedere l’andamento dei mercati.
Riconoscimento di forme, immagini, facce, etc…
Quello che noi creeremo è un sistema molto rudimentale di riconoscimento delle immagini, di fatto potra riconoscere solo quelle immagini che gli abbiamo presentato nel training set e non sarà probabilmente in grado di riconoscerle se gli è stato modificato anche solamente qualche pixel. E’ solo un esempio di base per mostrare cosa si può fare, ed anche in maniera abbastanza semplice. Le immagini che la nostra rete neurale sarà capace di riconoscere avranno dimensioni fisse (5×7 pixels) e saranno simili a questa:
Immagine di esempio
I quadratini con il bordo nero sono semplicemente i pixel dell’immagine. Avendo questa immagine 7×5 = 35 pixel in totale, la nostra rete neurale dovrà avere 35 neuroni di input, uno per ogni pixel. Per semplicità l’input potrà essere o 1 o 0, dove 1 simboleggia il colore rosso della precedente immagine e 0 lo sfondo. Così facendo si ottiene una matrice che rappresenta l’immagine, che nel caso di quella appena vista sarebbe questa:
0 0 1 0 0
0 1 1 0 0
0 0 1 0 0
0 0 1 0 0
0 0 1 0 0
0 0 1 0 0
0 1 1 1 0
Nell’allenamento della nostra rete, noi daremo un solo esempio per ogni numero, ma volendo potremmo dare più esempi diversi che rappresentano diversi modi di scrivere il numero 1 e così la nostra rete avrebbe una capacità più alta di riconoscere caratteri diversi (chiaramente l’allenamento sarà più lungo).
Per la nostra rete neurale creeremo noi il training set direttamente su un file di testo o altrimenti, essendo la rete neurale capace di riceve in input solo dei numeri, dovremmo creare un programma che data in input un’immagine crei la matrice numerica associata ad essa, ma siccome il nostro training set sarà molto piccolo le creeremo manualmente. Ogni riga dovrà contenere la rappresentazione di un numero, di conseguenza non avremo matrici nel file di input ma le righe saranno affiancate. Il file di input risulta così:
0 0 1 0 0 0 1 0 1 0 0 1 0 1 0 0 1 0 1 0 0 1 0 1 0 0 1 0 1 0 0 0 1 0 0
0 0 1 0 0 0 1 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 1 1 1 0
0 0 1 1 0 0 1 0 0 1 0 1 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 1 1 1 1
0 0 1 1 0 0 1 0 0 1 0 1 0 0 1 0 0 0 1 0 0 0 0 0 1 0 1 0 0 1 0 0 1 1 0
0 0 0 0 0 0 0 0 1 0 0 0 1 1 0 0 1 0 1 0 1 1 1 1 1 0 0 0 1 0 0 0 0 1 0
0 1 1 1 0 0 1 0 0 0 0 1 0 0 0 0 1 1 1 0 0 0 0 0 1 0 0 0 0 1 0 1 1 1 0
0 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 1 1 0 1 0 0 0 1 1 0 0 0 1 0 1 1 1 0
0 0 0 0 0 1 1 1 1 1 0 0 0 0 1 0 0 0 1 0 0 1 1 1 0 0 1 0 0 0 1 0 0 0 0
0 1 1 1 0 1 0 0 0 1 1 0 0 0 1 0 1 1 1 0 1 0 0 0 1 1 0 0 0 1 0 1 1 1 0
0 1 1 1 0 1 0 0 0 1 1 0 0 0 1 0 1 1 1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 0
Se spezzate ogni riga in parti composte da 5 elementi riottenete la matrice che rapresenta il numero.
Il file di output avrà tante righe quante quelle del file di input e sarà il seguente:
1 0 0 0 0 0 0 0 0 0
0 1 0 0 0 0 0 0 0 0
0 0 1 0 0 0 0 0 0 0
0 0 0 1 0 0 0 0 0 0
0 0 0 0 1 0 0 0 0 0
0 0 0 0 0 1 0 0 0 0
0 0 0 0 0 0 1 0 0 0
0 0 0 0 0 0 0 1 0 0
0 0 0 0 0 0 0 0 1 0
0 0 0 0 0 0 0 0 0 1
I neuroni di output saranno 10 ed ognuno è associato ad un numero. Con il numero 0 il primo neurone emette un segnale mentre gli altri no, con il numero 1 il secondo neurone emette un segnale mentre gli altri no, etc… di conseguenza ci aspettiamo che dopo l’addestramento, quando passiamo in input, per esempio il numero 9 soltanto l’ultimo neurone si attiverà. Il codice è il seguente:
#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>
#include <ctime>
#include <cmath>
using namespace std;
#include "Misc.hpp
#include "GenAlg.hpp"
#include "NeuralNet.hpp"
#include "NNController.hpp"
int main() {
NNController NC(35, 10, 1, 10);
NC.loadTrainingSet("input", "output");
NC.train();
NC.saveWeights("img.txt");
cout << "*** La rete e' allenata ***" << endl;
}
Come vedete, abbiamo creato 35 neuroni di input, 10 di output ed un livello nacosto con 10 neuroni.
LINKS
http://www.ai-junkie.com/ann/evolved/nnt1.html – Questo tutorial in Inglese sulle reti neurali è uno dei migliori che abbia mai letto, tant’è che ne ho preso spunto per scrivere questo. Vengono usati anche lì gli algoritmi genetici per aggiornare la rete e troverete delle somiglianze anche nelle classi del codice (però vi assicuro che il codice per questo tutorial l’ho scritto da zero 
http://www.ai-junkie.com/ga/intro/gat1.html – Tutorial sugli algoritmi genetici, sempre in Inglese.
http://blacklight.gotdns.org/wiki/index.php/Introduzione_ai_sistemi_fuzzy_e_alle_reti_neurali – Implementazione di una rete neurale error back propagation in C, tutorial in Italiano.
http://www.aitalk.net – Forum sull’intelligenza artificiale in lingua Inglese. Contiene anche una piccola sezione in lingua Italiana.
Ho anche realizzato la stessa guida in formato PDF: trovate QUI un archivio contenente tutti i file sorgente di cui abbiamo parlato e la guida in formato PDF (un po meglio impaginata e con qualche illustrazione in piu’).
Alla prossi
L’algoritmo LSB (least significat bit) mira a nascondere un messaggio in un contenitore (immagine, file audiom file video) modificando i bit meno significativi. Nel nostro caso creeremo un programma per nascondere file di testo all’interno di immagini bitmap. Ogni pixel della nostra immagine e’ rappresentato da una terna di numeri che indicano le tre componenti RGB. Modificheremo il bit meno significativo di ogni componente di ogni pixel e lo adatteremo ai bit del nostro messaggio di testo. Il cambiamento che otteremo modificando solo il bit meno significativo sara’ al massimo di una unita’ e, di conseguenza, produrra’ immagini all’apparenza identiche, poiche’ un tale cambiamento non e’ percepibile ad occhio nudo.
Il nostro programma e’ sostanzialmente diviso in due parti: quella per nascondere il testo nell’immagine e quella per recuperarlo.
Steganografare un testo
La prima parte del programma si occupera’ di fare le seguenti operazioni:
- Leggere il messaggio da un file di testo
- Calcolare il numero di pixels necessari ad occultare il messaggio nell’immagine ed accertarsi che l’immagine sia abbastanza grande da poterlo fare. Salvare in forma binaria il valore di ogni componente di questi pixels.
- Modificare i bit meno significativi per adattarli a quelli del messaggio
- Scrivere i nuovi bit su una nuova immagine apparentemente uguale alla prima, ma contenente il testo.
Saltando il passo 1 (che spero chiunque sia capace di fare), passiamo al due:
numbits = message.size()*8; // La stringa message contiene il messaggio letto dal file
numpixels = (numbits%3 == 0 ? numbits/3 : (int)numbits/3 + 1);
numrows = (int)numpixels/img.TellWidth() + 1;
if (numrows > img.TellHeight()) {
cout << "Errore: il messaggio e' troppo lungo per essere contenuto in questa immagine." << endl;
exit(0);
}
for (int i = 0; i < numrows; i++) {
for (int j = 0; j < img.TellWidth(); j++) {
bits.push_back(bitset<8>((int)img(j, i)->Red));
bits.push_back(bitset<8>((int)img(j, i)->Green));
bits.push_back(bitset<8>((int)img(j, i)->Blue));
}
}
Il programma calcola il numero di bit e il numero di pixel necessari in base alla lunghezza del messaggio. Visto che ogni pixel puo’ nascondere 3 bit, il numero di pixel viene calcolato semplicemente dividendo il numero di bit per 3 e arrotondando per eccesso nel caso di resto. numrows contiene invece il numero di righe dell’immagine che bisogna copiare in memoria. Se il numero di righe e’ maggiore dell’altezza del’immagine il programma genera un errore poiche’ l’immagine e’ troppo piccola per contenere il messaggio. Dopo aver fatto cio’, salviamo i tutti i valori RGB dei pixel che ci servono in un array di bitset. bits e’ un vettore (classe vector delle STL) di oggetti bitset, una classe della STL creata appositamente per gestire dati in forma binaria. La notazione bitset<8>(…) crea un oggetto bitset con 8 bit che assumono il valore dell’argomento che gli si passa tra parentesi. Visto che i valori RGB di un’immagine sono compresi tra 0 e 255 8 bit sono sufficienti.
count = 0;
for (int i = 0; i < message.size(); i++) {
bitset<8> temp = bitset<8>(message[i]);
for (int b = 7; b >= 0; b--) {
bits[count].set(0, temp[b]); // 0 e' l'indice del bit meno significativo; temp[b] e' il b-esimo bit della lettera che stiamo esaminando
count++;
}
}
Dopo aver salvato i valori in memoria, dobbiamo modificare il bit meno significativo di ogni elemento salvato per renderlo uguale a quello del nostro messaggio. Il codice qui sopra svolge questo compito: scorre ogni lettera del messaggio e crea un oggetto bitset contenente il valore di quella lettera in binario. Il ciclo innestato scorre tutti i bit della lettera e modifica i bit meno significativi dell’immagine in modo appropriato.
for (int i = 0; i < numrows; i++) {
for (int j = 0; j < img.TellWidth(); j++) {
imgout(j, i)->Red = (int)bits[count++].to_ulong();
imgout(j, i)->Green = (int)bits[count++].to_ulong();
imgout(j, i)->Blue = (int)bits[count++].to_ulong();
}
}
for (int i = numrows; i < img.TellHeight(); i++) {
for (int j = 0; j < img.TellWidth(); j++) {
imgout(j, i)->Red = img(j, i)->Red;
imgout(j, i)->Green = img(j, i)->Green;
imgout(j, i)->Blue = img(j, i)->Blue;
}
}
imgout.WriteToFile("out.bmp");
Una volta che i bit sono stati modificati in maniera corretta, dobbiamo solo riscriverli su una nuova immagine. Il primo ciclo scrive i bit contenenti il messaggio (la funzione to_ulong() converte un bitset nel suo valore decimale), mentre il secondo riscrive semplicemente i valori dei pixel che non sono stati modificati riprendendoli dall’immagine originale.
Recuperare il testo steganografato
La seconda parte del programma e’ quella che, data in input un’immagine recupera il testo contenuto in essa. Un difetto del programma e’ quello di richiedere la lunghezza del messaggio per poterlo estrarre: in realta’ si potrebbe ovviare a questo problema in maniera piuttosto semplice (dopo vedremo come) ma per ora, bisognera’ accontentarsi di andare a tentativi se non si conosce la lunghezza del messaggio completo.
La struttura di questa seconda parte ricalca quella della prima: dopo aver preso in input la lunghezza del messaggio ed aver calcolato in base ad essa il numero di pixel che sono stati modificati, il programma prende dall’immagine i valori delle componenti di questi pixel e li mette in un array di bitset. Un secondo ciclo:
for (int i = 1; i < numbits; i++) {
temp.set(count, bits[i-1][0]);
count--;
if (count == -1) {
count = 7;
cout << (char)temp.to_ulong();
}
}
si occupa di prendere i bit meno significativi a gruppi di 8 e di stampare il corrispondente valore alfanumerico.
Possibili miglioramenti
Il programma in questa maniera e’ piuttosto rudimentale, ecco alcuni possibili miglioramenti che potreste allenarvi a mettere in pratica:
- Evitare di dover richiedere la lunghezza quando bisogna estrarre un messaggio. Una possibilita’ potrebbe essere quella di conservare i primi N bit meno significativi dell’immagine per salvare la lunghezza del messaggio e per estrarla al volo senza doverla richiedere all’utente. 10 bit permetterebbero, per esempio, di salvare un numero fino a 210 = 1024.
- Introdurre la possibilita’ di inserire una chiave. Una chiave potrebbe essere un numero intero N che indicherebbe al programma di modificare non tutti i pixel uno per uno ma di prendere 1 pixel ogni N. Questo ridurrebbe la capacita’ dell’immagine di contenere messaggi ma renderebbe piu’ difficile un’eventuale individuazione del messaggio.
- Introdurre la possibilita’ di crittografare un messaggio prima di steganografarlo per una maggiore sicurezza.
Ecco il codice del programma: Steganografia in C++. Fa uso delle librerie EasyBMP per la gestione delle immagini presenti nell’archivio stesso.
Ciao!
]]>Il concetto di base e’ questo: quando utilizziamo la formula di Mandelbrot e cioe’ Zn+1=Zn2 + C i valori che entrano in gioco sono 4 e sono le parti reali di Z e C e le loro parti immaginarie (d’ora in poi saranno indicate con Z.r, C.r, Z.i, C.i); per ogni possibile combinazione di questi quattro valori avremo un solo valore in uscita, diverso per ogni combinazione. Visto pero’, che non possiamo visualizzare un oggetto in quattro dimensioni, l’unica cosa che possiamo fare e’ visualizzare una sezione bidimensionale dell’oggetto, ed e’ questo quello che accade quando poniamo Z=0 nel renderizzare l’insieme di Mandelbrot. Gli insieme di Julia non sono altro che sezioni dello stesso oggetto ma su piani diversi (che corrispondono ad una diversa scelta del valore iniziale di Z).
In un ambiente tridimensionale abbiamo 3 piani perpendicolari tra di loro; in 4 dimensioni invece, questi piani diventano 6 e sono rappresentati appunto dalle varie coppie possibili dei 4 valori in entrata: [Z.r, Z.i], [Z.r, C.r], [Z.r, C.i], [Z.i, C.r], [Z.i, C.i], [C.r, C.i]. Questi piani sono tutti perpendicolari tra di loro e sono i piani che si riconoscono a prima vista, ma ovviamente il numero di piani su cui potremmo effettuare delle sezioni da visualizzare e’ infinito. Questo e’ il punto che ci permette di renderizzare delle vere e proprie animazioni che includono delle rotazioni del Buddhabrot. Prima di parlare di questo, pero’, vediamo quali sono le modifiche da effettuare al file sorgente che ho distribuito nel precedente articolo per renderizzare sezioni di piani diverse.
In realta’, la modifica da fare e’ una sola ed e’ questa: nella funzione escape() si trova questa parte:
zz[(int)N].r = ZOOM*(Z.r+OFFSET_X)*(WIDTH/2); zz[(int)N].i = ZOOM*(Z.i)*(HEIGHT/2) + HEIGHT/2;
Come vedete, le coordinate che prendiamo in considerazione sono Z.r e Z.i. Basta cambiare questi valori per renderizzare un’altra sezione del frattale. Se al posto di Z.i mettiamo, per esempio, C.r, visualizzeremo l’oggetto visto dal piano [Z.r, C.r].
Vediamo ora come realizzare una rotazione del frattale. Quello che vogliamo fare e’, in poche parole, passare gradualmente dall’immagine di un piano, diciamo [Z.r, Z.i] a quella di un’altro, per esempio, [Z.i, C.r]. Per fare cio’ dobbiamo modificare sempre la formula precedente, nella seguente maniera:
zz[(int)N].r = ZOOM*(rot*Z.r+Z.i*(1-rot)+OFFSET_X)*(WIDTH/2); zz[(int)N].i = ZOOM*(rot*Z.i+C.r*(1-rot))*(HEIGHT/2) + HEIGHT/2;
E’ apparso un nuovo coefficiente, rot. Questo, come potete immaginare, e’ un coefficiente che rappresenta, se vogliamo, l’angolo di rotazione. Per un valore di rot pari a 1, verra’ renderizzato il piano [Z.r, Z.i] poiche’ 1-rot = 0 e quindi le parti Z.i e C.r si annullano. Per rot = 0, avverra’ il contrario. Ovviamente per valori di rot che variano tra 0 e 1 otteremo immagini diverse, per esempio, visto che la rotazione complessiva e’ di 90° (da rot = 0 a rot = 1), rot=0.5 dovrebbe corrispondere ad una rotazione di 45°. Se si renderizzano varie immagini per valori di rot che aumentano progressivamente da 0 a 1, si otterra’ una vera e propria animazione del Buddhabrot rotante.
Ora, se non volete mettervi a modificare manualmente ogni volta il valore di rot, vi conviene aggiungere un paio di cicli for al codice e fare in modo che, ad ogni ciclo, il valore di rot venga modificato per renderizzare un’immagine diversa. Ecco un esempio di “rotazione”, anche se non appare affatto come tale:
Vi lascio un ultimo link alla pagina originale creata da chi ha scoperto questa tecnica (e’ in inglese): http://www.superliminal.com/fractals/bgram/ZrZiOut.htm
]]>
Riunire il tutto.
In questo piccolo paragrafo vedremo come fare comunicare tra loro le due classi attraverso una terza ed ultima classe che si occupa della gestione di tutte le operazioni. In realtà questa classe è superflua perchè è già possibile, con le sole classi Population e NeuralNet, creare una rete neurale funzionante ma essa ci rende molto più comoda la scritture del codice. Essa contiene per lo più funzioni ausiliarie come quella per caricare il training set (senza dover parsare manualmente il file), o per salvare e caricare i pesi della rete neurale e per questo non mi soffermerò molto sul codice. La funzione più importante è quella che esegue l’allenamento della rete neurale, ma vediamo prima il codice della classe:
class NNController {
public:
NNController(int c_numInputNeurons, int c_numOutputNeurons,
int c_numHiddenLayers, int c_numNeuronsPerLayer);
void loadTrainingSet(string inputFile, string outputFile);
void train();
void saveWeights(string file);
void loadWeights(string file);
void test();
private:
vector< vector > inputData; // Training set
vector< vector > outputData;
NeuralNet* N;
Population* P;
Chromosome* C;
};
Il costruttore ha gli stessi parametri di quello della classe NeuralNet che servono ad inizializzare l’oggetto N all’interno di questa classe.
La funzione loadTrainingSet(string inputFile string outputFile) carica appunto il training set: essa riceve come argomenti i nomi di due file, il primo deve contenere gli input da passare alla rete neurale mentre il secondo gli output desiderati corrispondenti agli input. Per esempio, se stiamo addestrando la rete a fare la somma di due numeri, ed il file contenente l’input contenesse:
0 1
0 2
Quello contenente l’output dovrebbe contenere:
1
2
(Gli input devono essere separati tra di loro da uno spazio ed ogni riga deve contenere ovviamente sempre lo stesso numero di input che deve essere a sua volta uguale al numero dei neuroni di input specificato nel codice).
Le funzioni saveWeights(string file) e loadWeights(string file) servono rispettivamente a salvare i pesi della rete neurale (generalmente dopo che questa è allenata) e a poterli caricare in seguito senza dover ripetere l’addestramento.
La funzione test() serve invece a poter testare la rete con vari input dopo che questa è stata allenata. Ho conservato volutamente alla fine la funzione train() perchè è l’unica un po più complessa e serve ad effettuare l’allenamento della rete.
void NNController::train() {
double currentErr = 0; int i = 0; double bestFit = 99999999;<
while (bestFit > MAX_ERROR) {
if (i >= MAX_EPOCHS) {
break;
}
for (int j = 0; j < POPULATION_SIZE; j++) {
currentErr = 0;
for (int k = 0; k < inputData.size(); k++) {
N->run(inputData[k], (*P)[j]);
currentErr += N->globalError(outputData[k]) / inputData.size()
}
(*P)[j]->setFitness(currentErr);
}
bestFit = P->best()->getFitness();
if (i % UPDATE == 0) {
cout << "(" << i << ") - "<< "Best = " << bestFit
<< "\t" << "Worst = " << P->worst()->getFitness()
<< endl;
}
P->next();
i++;
}
}
La funzione esegue un ciclo while che termina o quando il fitness raggiunge un livello accettabile (cioè l’errore raggiunto è minore o uguale all’errore massimo stabilito in precedenza e definito nella costante MAX_ERROR) oppure quando (vedete il break) il numero di epoche (cioè di cicli di riproduzione della popolazione) supera un certo limite. Dentro questo ciclo while c’è un ulteriore ciclo for che scorre tutti gli elementi della popolazione (che, come oramai dovrebbe essere chiaro, rappresenta una configurazione dei pesi della rete neurale) e per ognuno esegue tutto il training set in input. Il fitness di questo individuo sarà l’errore medio che il cromosoma ha sugli elementi del training set. Un errore pari a 0, che corrisponde alla perfezione assoluta, è praticamente impossibile da raggiungere e quindi, a seconda dei casi, ci si può accontentare di un errore più o meno alto come, per esempio, 0.001.
La funzione stampa anche un output ogni tanto per informare l’utente a che punto è arrivato l’allenamento, e dipende dal valore della costante UPDATE: se per esempio questa vale 50, ogni 50 generazioni sarà stampato un messaggio contente i fitness del migliore e del peggiore cromosoma della popolazione corrente.
Quando questa funzione termina la nostra rete neurale è allenata (con un errore massimo stabilito dalla costante MAX_ERROR) ed è possibile testarla tramite il metodo test() fornito dalla stessa classe.
Vediamo ora un codice di esempio di rete neurale realizzata con le nostre classi:
#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>
#include <ctime>
#include <cmath>
using namespace std;
/* Misc.hpp è un header che contiene le varie costanti come
MAX_POPULATION, ELITISM, MAX_TOUR, etc...
Gli altri header contengono le varie classi */
#include "Misc.hpp"
#include "GenAlg.hpp"
#include "NeuralNet.hpp"
#include "NNController.hpp"
int main() {
/* Alla riga seguente creiamo una rete neurale con 2 neuroni
di input, 1 neurone di output e 0 layer nascosti */
NNController NC(2, 1, 0, 0);
/* Carica il training set contenuto nei due file */
NC.loadTrainingSet("input", "output");
NC.train();
cout << "*** La rete e' allenata ***" << endl;
NC.test();
}
Come vedete il codice è davvero basilare eppure una rete neurale come quella di questo esempio, sarebbe in grado di imparare a fare la somma di due numeri con soli tre neuroni!
Come impostare una rete neurale.
Abbiamo visto la creazione pratica di una rete neurale ma come avete notato il risultato ottenuto da una rete dipende da una miriade di fattori come per esempio il numero di livelli, il numero di neuroni presente nei livelli nascosti, la funzione di trasferimento, etc… di conseguenza vi starete probabilmente chiedendo quali sono le impostazioni migliori per una rete neurale. Chiaramente non esistono delle impostazioni migliori in assoluto, ma dipende tutto dal problema che dobbiamo analizzare, di conseguenza quelle che scriverò qui saranno solo delle brevi linee guida da tenere in considerazione ma non delle regole fisse.
Ho gia parlato in precedenza delle funzioni di attivazione e di quali sia più comodo usare a seconda dei casi, ora parleremo del numero dei livelli.
Quanti livelli nascosti vanno usati? Nell’esempio precedente abbiamo creato una rete capace di imparare a fare la somma dei due numeri senza utilizzare nessun livello nascosto e in molti casi può verificarsi questa eventualità. Generalmente, nei casi restanti, un solo livello nascosto è più che sufficiente per ottenere risultati corretti. Dal punto di vista matematico possiamo dire che una rete neurale con i soli livelli si input e outputè capace di risolvere problemi linearmente separabili, mentre per problemi non linearmente separabili sono richiesti uno o più livelli nascosti.
Il numero di neuroni per ogni livello nascosto può essere un’altra incognita nella creazione della rete neurale: esso dipende da più fattori come il numero dei neuroni di input e di output, la dimensione del training set, la funzione di attivazione, l’algoritmo di apprendimento, etc… Esistono diverse regole approssimative che cercano di fornire un modo per calcolare il numero di unità nascoste necessarie (per esempio: “il numero di unità nascoste deve essere sempre minore del doppio dei neuroni di input”) ma molto spesso esse sono inutili. La cosa migliore è fare alcune prove e trovare il numero di unità che fornisce un errore minimo.
]]>Ok, siamo arrivati alla parte più tecnica cioè all’implementazione vera e propria della rete. Ho scelto di utilizzare il C++ e di programmare tutto ad oggetti perchè, anche se questo approccio sacrifica forse un po’ la velocità, rende, almeno per me, il tutto più comprensibile e riutilizzabile (dalle classi che qui espongo ho costruito poi una libreria per l’utilizzo delle reti neurali).
Cominciamo a partire dalle classi della rete neurale.
Le classi Neuron, NeuronLayer e NeuralNet
La prima classe che implementeremo è la classe Neuron, che rappresenta la struttura più piccola della rete neurale: il neurone.
Ogni neurone come abbiamo visto ha dei collegamenti pesati in entrata (tranne i neuroni di input) e un valore, che è contiene il valore del neurone.
Il codice della classe Neuron è il seguente:
class Neuron {
public:
Neuron(int c_numWeights);
void setValue(double v);
double getValue() const;
void setWeight(int i, double v);
double getWeight(int i) const;
int getWeightsNum(bool bias) const;
private:
double value;
vector<double> weights;
};
I metodi di questa classe sono tutti molto facili da capire: riporto qui solamente il codice del costrutture e di getWeightsNum(bool):
// Costruttore
Neuron::Neuron(int c_numWeights) {
for (int i = 0; i < c_numWeights+1; i++) {
weights.push_back(wRand());
}
}
int Neuron::getWeightsNum(bool bias) const {
return (bias) ? weights.size() : weights.size() 1;
}
Il costruttore riceve come argomento il numero dei pesi in entrata per questo neurone e li inizializza a valori random (wRand() è una funzione definita in un file header che restituisce un numero compreso tra -1 e 1). Se osservate bene il ciclo va da 0 a c_numWeights+1 questo perchè viene creato un peso aggiuntivo chiamato bias, la cui funzione vi sarà chiara fra poco.
Nella classe Neuron avremmo potuto anche creare un puntatore a funzione che puntasse alla funzione di attivazione (o funzione di trasferimento) del neurone ed in questa maniera avremmo potuto impostare una funzione di attivazione diversa per ogni neurone (o per ogni livello), ma visto che la nostra funzione sarà uguale per tutti i neuroni, ho preferito non farlo per questioni di semplicità.
E’ arrivato il momento di spendere due parole proprio sulle funzioni di attivazione. La funzione di attivazione può essere una qualunque funzione, come per esempio , ma alcune offrono risultati migliori in base al contesto nella quale sono utilizzate. Scegliere la funzione giusta può essere determinante per ottenere buoni risultati.
Vediamo alcune funzioni comunemente usate:
Funzione a gradino: y = 1 per x >= 0, 0 per x < 0
La funzione a gradino (chiamata così per il suo grafico) è la funzione che più rispetta il comportamento del neurone biologico. Infatti essa restituisce 1, cioè propaga il segnale, se la somma degli input ricevuti e maggiore o uguale a un certo numero , che altro non è che la soglia di attivazione. E’ utile utilizzare questa funzione quando vogliamo che la nostra rete abbia un risultato che o 1 o 0 e che quindi separi gli input che gli forniamo in due classi distinte.
Funzione identità: y = x
Non penso ci sia molto da dire su questa funzione, l’unica cosa da sapere è che si utilizza quando il nostro output non è limitato e può variare da meno infinito a più infinito.
Funzione sigmoidale: y = 1/(1+e^(-x))
La funzione sigmoidale è una delle funzioni più utilizzate. Essa passa sempre per il punto (0, 1/2) ed è compresa tra 0 e 1. Proprio per quest’ultimo fatto non può essere utilizzata se ci aspettiamo come output numeri numeri che non sono compresi in questo intervallo, per i quali è necessario utilizzare altre funzioni.
Tangente iperbolica: y = tanh(x)
La tangente iperbolica è molto simile alla funzione sigmoidale solo che il suo output è compreso tra -1 e 1 e passa sempre per l’origine. Come al solito va utilizzata solo nei casi in cui l’output deve essere compreso tra questi valori e per esempio non andrebbe bene se volessimo allenare la rete a fare la somma di due numeri qualsiasi. In realtà le cose non stanno esattamente così, perchè, come vedremo in seguito, esiste un apposito valore (bias) per ogni neurone che serve a spostare il centro della funzione e quindi ad ottenere valori che non sono più compresi tra -1 e 1 ma tra meno infinito e più infinito.
In ogni caso è comunque preferibile una funzione di trasferimento lineare nei casi in cui il nostro output possa variare in maniera illimitata.
Dopo questa parentesi a proposito delle funzioni di attivazione torniamo alla nostra implementazione. Una volta che il neurone fa la sommatoria pesata di tutti gli input ricevuti passa questo valore alla funzione di attivazione che, a sua volta, restituisce un altro valore. Quest’ultimo sarà propagato ai neuroni successivi e così via.
La seconda classe di cui ci occuperemo è NeuronLayer, che rappresenta uno strato di neuroni:
class NeuronLayer {
public:
NeuronLayer(int c_numNeurons, int c_weightsPerNeuron);
Neuron* getNeuron(int i) const;
int getNeuronsNum() const;
private:
vector<Neuron*> neurons;
};
Come è logico, la classe NeuronLayer dovrà contenere un insieme di neuroni e per questo usiamo la classe vector della STL per istanziare un vettore di oggetti Neuron*.
Anche qui i metodi sono abbastanza semplici: il costruttore riceve come parametri il numero dei neuroni facenti parte del layer ed il numero di collegamenti in entrata (e quindi di pesi) per ogni neurone. La funzione getNeuron(int) riceve come parametro un intero i e restituisce l’i-esimo neurone del livello; l’ultima funzione restituisce il numero totale dei neuroni facenti parti del livello.
Siamo giunti alla parte cruciale del nostro programma e cioè la classe NeuralNet.
Sarà lei che si occuperà di collegare i neuroni fra di loro, di propagare i segnali attraverso i neuroni e di darci l’output restituito dalla rete.
class NeuralNet {
public:
NeuralNet(int c_numInputNeurons, int c_numOutputNeurons,
int c_numHiddenLayers, int c_numNeuronsPerLayer);
void createNet();
void run(vector<double> input, Chromosome* d);
int totalNumWeights(bool bias);
void dump();
double globalError(vector<double> des);
void printOutput();
private:
vector<NeuronLayer*> layers;
int numInputNeurons,
numOutputNeurons,
numHiddenLayers,
numNeuronsPerLayer;
}
Il costruttore della classe NeuralNet riceve in input 4 parametri che sono rispettivamente il numero dei neuroni di input, il numero dei neuroni di output, il numero dei livelli nascosti e il numero di neuroni contenuti nei livelli nascosti.
Il costruttore non fa altro che prendere questi argomenti e salvarli nelle quattro variabili apposite. Il vettore layers contiene dei puntatori ad oggetti NeuronLayer che saranno appunto i vari livelli della rete neurale. Due sono i metodi più importanti di questa classe: createNet() e run(vector<double>, Chromosome*). Il primo inizializza l’array layers creando i livelli necessari ed i collegamenti tra i vari neuroni, mentre il secondo, esegue la rete neurale passandogli in input i valori contenuti nell’array input ed utilizzando come pesi della rete il DNA dell’oggeto Chromosome*. Vediamo il codice di queste due funzioni:
void NeuralNet::createNet() {
if (numHiddenLayers > 0) {
// Se ci sono layer nascosti li crea
NeuronLayer* HL = new NeuronLayer(numNeuronsPerLayer,
numInputNeurons);
layers.push_back(HL);
for (int i = 1; i < numHiddenLayers; i++) {
NeuronLayer* HL = new NeuronLayer(numNeuronsPerLayer,
numNeuronsPerLayer);
layers.push_back(HL);
}
NeuronLayer* OL = new NeuronLayer(numOutputNeurons,
numNeuronsPerLayer);
layers.push_back(OL);
} else {
NeuronLayer* OL = new NeuronLayer(numOutputNeurons,
numInputNeurons);
layers.push_back(OL);
}
}
La prima cosa che la funzione fa è quella di verificare se deve creare dei layer nascosti o meno. Nel primo caso crea il primo layer nacosto in cui ogni neurone ha un numero di pesi pari al numero dei neuroni in input (infatti i neuroni del primo layer ricevono i dati proprio dai neuroni di input) e crea i layer seguenti in cui ogni neurone ha un numero di pesi pari al numero di neuroni presenti negli strati precedenti a lui, che essendo tutti strati nascosti avranno un numero di neuroni pari al contenuto della variabile numNeuronsPerLayer; come ultima cosa viene creato il layer di output. Se non ci sono layer nascosto la prima parte viene saltata e viene creato un layer di output collegato direttamente a quello di input.
La funzione run() è un po più complessa. Ho evitato di scriverla tutta qui per problemi di impagnazione, quindi vi conviene leggerla direttamente dal file sorgente. Comunque, la prima cosa che la funziona fa è controllare che il numero degli input ricevuti dalla funzione corrisponda effettivamente al numero di neuroni di input: se così non è l’esecuzione del programma termina dopo aver stampato un messaggio di errore.
Successivamente la funzione deve impostare i pesi della rete neurale con il DNA del cromosoma che gli passiamo come argomento, per fare questo si utilizzano tre cicli for annidati: il primo scorre tutti i livelli della rete neurale, il secondo tutti i neuroni di ogni livello ed il terzo tutti i pesi di ogni neurone, sosituendoli con quelli presenti nel cromosoma.
Dopo aver impostato i pesi non ci resta altro che dare alla rete l’input e propagarlo attraverso i neuroni. Si usano anche qui tre cicli for annidati per scorrere tutti i neuroni della rete neurale e per calcolare la somma degli input pesati. Notate che c’è un if che distingue due casi: se ci troviamo al primo livello nascosto l’input dovremo prenderlo dai neuroni di input (che altro non sono che gli elementi dell’array passato come argomento): questo lo facciamo alla linea:
totInput += layers[i]->getNeuron(j)->getWeight(k) * input[k];
Come vedete, il k-esimo peso del neurone viene moltiplicato per il k-esimo input, che altro non è che un valore dall’array.
Quando non siamo più al primo livello, ma a quelli successivi l’input andrà preso da neuroni precedenti ed infatti:
totInput += layers[i]->getNeuron(j)->getWeight(k) * layers[i-1]->getNeuron(k)>getValue();
Il k-esimo peso del neurone viene moltiplicato per il valore contenuto nel k-esimo neurone del livello precedente (layers[i-1]). La backslash dopo il * sta solamente ad indicare che la linea è spezzata per ragioni di formattazione, ma che il codice va su una sola riga. La variabile totInput conterrà alla fine del ciclo la sommatoria pesata degli input del neurone. Subito dopo il ciclo viene definita una variabile con il valore dell’ultimo peso del neurone (questo peso non è stato preso in considerazione quando facevamo la sommatoria, se notate, nel ciclo abbiamo passato il parametro false alla funzione getWeightsNum() facendoci così restituire il numero dei pesi meno 1). Questo sarà il bias che alla riga successiva viene sottratto al valore totale del neurone dopo che quest’ultimo è stato passato attraverso la funzione sigmoid() cioè la funzione di trasferimento sigmoidale. Dal punto di vista grafico potete immaginare il bias semplicemente come una traslazione sull’asse y del grafico della funzione e questo comporta che la funzione non sia centrata nel punto per ogni neurone ma che ogni neurone abbia appunto una funzione centrata in un punto differente.
Il compito della funzione è finito qui, poiché dopo tutti questi cicli i neuroni dell’ultimo livello, cioè i neuroni di output conterrano il risultato ottenuto dalla rete.
L’ultima funzione degna di nota è globalError(): essa calcola l’errore della rete facendo la differenza tra ogni output ed il rispettivo output desiderato specificato nel training set. Ci servirà in seguito per assegnare il fitness ad i nostri cromosomi.
Nella prossima parte parleremo delle classi relative alla gestione dei cromosomi e metteremo in pratica quello che abbiamo visto teoricamente nella parte seconda quindi continuate a visitarci!
Link alle parti precedenti:
]]>Le reti neurali sono un argomento molto ostico per molti all’inizio.
Anche io per riuscire ad implementare la mia prima rete neurale funzionante ci ho impiegato molto tempo ma ho soprattutto dovuto provare e riprovare più volte passando per diversi fallimenti. Mi sono accorto che molti dei tutorial che si trovano in giro tralasciano alcuni aspetti o li spiegano in maniera poco chiara, e tra l’altro i tutorial in lingua italiana sull’argomento sono anche pochi.
Con questo tutorial cercherò di creare un documento che comprenda almeno le basi per rendere chiunque lo legga, ed abbia alcuni prerequisiti elencati in seguito, capace di implementare una rete neurale.
Nota sul codice.
Prima di iniziare va scritta una piccola nota sul codice: il codice che troverete nell’archivio che vi sarà dato alla fine di questa guida, non è esattamente lo stesso che trovate scritto in questa serie di tutorial. Questo perchè ho fatto in seguito delle modifiche (minori) che comunque non cambiano in sostanza la struttura del codice, ma aggiungono solo qualche funzionalità alla rete neurale. Non dovrebbe essere difficile seguirlo lo stesso.
PREREQUISITI
Ho cercato di rendere questa guida comprensibile alla maggior parte delle persone (anche a quelle che sull’argomento reti neurali sono poco informate) ma restano sempre degli argomenti che vengono dati per scontati per la comprensione del testo.
Sono:
- Buona conoscenza del C++ e della programmazione OO
- Basi matematiche
- Conoscenza degli algoritmi genetici
L’ultimo punto non è strettamente necessario, visto che tenterò di spiegare almeno quello che serve sapere sugli algoritmi genetici per implementare la nostra rete, ma se avete gia’ una conoscenza dell’argomento di certo avrete meno difficoltà a comprendere alcuni concetti. Alla fine del tutorial sono consigliati una serie di link utili la cui lettura e caldamente consigliata.
PARTE GENERALE
Introduzione.
Questa Parte generale del tutorial contiene alcuni elementi di base come il funzionamento di un neurone biologico, la struttura di un neurone artificiale (cioè quello che noi implementeremo) e la struttura di una rete neurale artificiale. Ho inserito anche una piccola parte sugli algoritmi genetici che non tratta esaustivamente l’argomento ma dovrebbe dare almeno l’infarinatura necessaria a comprendere per quale motivo li useremo e come li useremo. Comunque, come ho scritto sopra, consiglio lo stesso la lettura di altri tutorial più approfonditi se avete difficoltà a comprendere quello che dico sugli algoritmi genetici. Avrei tralasciato volentieri questa parte, perchè penso che molti di voi già la conoscano se hanno letto almeno qualche altro documento sull’argomento reti neurali. Purtroppo mi tocca scriverla lo stesso visto che è un requisito fondamentale per la
comprensione delle parti successive e questo tutorial mira ad essere il più chiaro possibile anche per chi è agli inizi. Comunque, se conoscete già questi argomenti potete tranquillamente saltare tutta la Parte generale del tutorial e passare a leggere direttamente il resto.
Come funziona un neurone biologico.
I neuroni sono le cellule che costituiscono la nostra mente e che trasmettono i segnali nervosi (sia tra di loro che verso le altre parti del corpo). Ogni uomo posside circa 100 miliardi di neuroni (o almeno dovrebbe) variamente collegati tra di loro attraverso una struttura che prende il nome di sinapsi.
Ogni neurone possiede un lungo prolungamento chiamato assone e diverse ramificazioni più piccole che prendono il nome di dendriti. Attraverso i dendriti (che sono collegati agli assoni di altri neuroni) la cellula riceve i segnali che gli vengono inviati, mentre attraverso l’assone viene mandato un nuovo segnale.
Se non avete ben chiaro cio’ che abbiamo detto fino ad ora, l’immagine seguente dovrebbe chiarvi le idee:
Schema di un neurone biologico
(Nella figura sono presenti parti del neurone che non ho nominato, come per esempio la guaina mielinica, perche’ non sono utili al nostro scopo).
In generale, quando un neurone riceve un segnale, se esso supera una certa soglia (detta soglia di attivazione), propaga quel segnale attraverso il suo assone agli altri neuroni, altrimenti resta inattivo.
Come funziona una rete neurale.
Un neurone artificiale tenta di emulare il comportamento di quello biologico, anche se in maniera molto semplificata.
Ogni neurone (d’ora in poi con il termine neurone mi riferirò esclusivamente a quelli artificiali) ha una serie di collegamenti pesati in ingresso e fornisce un output in base agli input ricevuti dai collegamenti. Per collegamento pesato si intende un collegamento al quale è anche associato un peso,
che rappresenta, in poche parole, la forza del collegamento e quindi quanto esso potrà influenzare l’output del neurone.
Il peso non è altro che un numero, generalmente compreso tra 0 e 1 (o tra 1e 1).
L’informazione trasportata dal collegamento (parliamo sempre di un numero) viene moltiplicata per il peso e quindi varia al variare del peso (resta invariata quando esso è uguale a 1, diventa nulla quando è 0 e diventa l’opposto quando è 1).
Come vedremo, sarà proprio il valore dei pesi a determinare l’esattezza dei risultati della nostra rete ed è appunto variando i pesi tramite speciali algoritmi che si tenta di raggiungere una configurazione ottimale. Ricordo che i pesi subito dopo l’inizializzazione della rete hanno valori casuali.
Il neurone, dopo aver ricevuto gli input pesati da tutti i collegamenti in ingresso li somma. La sommatoria degli input pesati viene poi passata ad una funzione chiamata funzione di attivazione che fa propagare il segnale ai neuroni successivi.
Spesso, e questo comportamento differisce da quello del neurone biologico, non viene stabilita una soglia minima di attivazione al di sotto della quale il neurone non invia nessuno stimolo, ma questo dipende dalla funzione di attivazione scelta e lo vedremo più tardi.
Le reti che andremo ad implementare in questo tutorial sono definite reti feedforward perchè l’impulso si propaga sempre nella stessa direzione; esistono molti altri tipi di reti e ognuna è più adatta ad alcuni compiti particolari, ma non ne parleremo in questo tutorial.
Una rete neurale è formata appunto da un certo numero di neuroni, chiaramente molto minore di quello del nostro cervello: in genere alcune decine di neuroni sono in grado di compiere compiti anche piuttosto complessi.
I neuroni di una rete sono organizzati in diversi livelli, o strati, e ognuno di essi ha un compito preciso. Il primo strato è quello di input: contiene i neuroni che ricevono l’input e non hanno collegamenti pesati; non essendo infatti i dati che ricevono provenienti da nessun altro neurone essi immagazzinano semplicemente il dato così come è e lo trasmettono al livello successivo.
Lo strato di input può essere collegato direttamente a quello di output oppure tra di essi si può trovare un certo numero di strati nascosti (hidden layers): per gli scopi di questo tutorial useremo una rete con un solo strato nascosto il quale è più che sufficiente per svolgere i compiti che ci interessano.
Abbiamo visto la struttura di una rete neurale, ma come fa essa ad apprendere? Va detto che esistono due tipi di apprendimento: quello supervisionato (che tratteremo in questo tutorial) e quello non supervisionato.
Usando il primo tipo di apprendimento la rete necessita di una prima fase di addestramento durante la quale le vengono forniti alcuni esempi comprendenti sia l’input che l’output desiderato. La rete viene eseguita con questi input di cui si conosce già in precedenza il risultato e tramite alcuni algoritmi vengono modificati i pesi della rete per fornire risultati sempre più accurati. Quando la fase di allenamento è finita (cioè si e’ raggiunta una soglia minima di errore stabilita in precedenza) la rete è in grando non solo di dare un risultato esatto se gli forniamo gli stessi dati che gli
abbiamo fornito nel training set (gli esempi) ma anche con dati in input che non ha mai visto. Questo avviene perchè la rete non associa un singolo input all’output corrispondente ma scopre la relazione che li lega. Potremmo per esempio allenare una rete neurale ad imparare a fare la somma di due numeri fornendo un training set del genere:
| Primo input | Secondo input | Output desiderato |
| 0.1 | 0.2 | 0.3 |
| 0.1 | 0.3 | 0.4 |
| 0.1 | 0.4 | 0.5 |
| 0.1 | 0.5 | 0.6 |
| 0.1 | 0.6 | 0.7 |
| 0.1 | 0.7 | 0.8 |
| etc… | etc… | etc.. |
Un training set deve essere il più omogeneo possibile, e deve descrivere una grande varietà di esempi. Un training set in cui il primo input è sempre 0.1 non è per niente buono per ottenere dei risultati soddisfacenti. Più è vasto il training set, inoltre, più sarà alta la capacità di generalizzazione della rete, cioè di dare risultati corretti anche quando i dati in input sono per lei sconosciuti, cioè non facevano parte del training set.
Modificando in maniera corretta i pesi della rete essa riconosce la relazione tra gli input e l’output (e cioè, nel nostro caso, che l’output deve essere la somma degli input) e dà un risultato corretto. Ricordatevi comunque che l’applicazione delle reti neurali avviene in campi in cui è più importante la flessibilità e la capacità di generalizzazione della stessa, piuttosto che ottenere risultati precisissimi: quello che voglio dire è che una rete neurale è molto più utile per la sua flessibilità che per la sua precisione, e che per fare la somma di dui numeri è molto meglio usare una calcolatrice. Una rete
addestrata a tale scopo, infatti, dà in genere, risultati approssimati come :
0.5 + 0.5 = 0.99
0.1 + 0.9 = 1.02
o simili.
Chiusa questa piccola parentesi torniamo ai tipi di apprendimento. Il secondo tipo di apprendimento (quello non supervisionato) serve a creare reti
neurali che classificano i dati che gli forniamo in input in diverse categorie (senza fornigli nessun output desiderato, da qui il nome) in base ai loro elementi in comune, ma non verra’ trattato in questo tutorial.
Come avrete capito, la parte più importante per l’apprendimento della rete neurale è la modifica dei pesi fra le connessioni dei neuroni ed è proprio qui che agiscono gli algoritmi di apprendimento. Esistono diversi algoritmi: uno dei piu’ famosi è quello di retro propagazione dell’errore (error back propagation) che mi limiterò a citare solamente visto che noi faremo uso di algoritmi genetici per fare evolvere la nostra rete.
La prima parte del tutorial finisce qui. A presto.
]]>