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.

Abbiamo finito l’implementazione della rete ed ora possiamo passare alla parte relativa all’addestramento della stessa, che come ho già detto, verrà realizzata tramite algoritmi genetici. Vediamo la classe Chromosome:

class Chromosome {
	public:
		Chromosome(int c_w);
		Chromosome(vector<double> weights); // overload
		void setWeight(int i, double val);
		double getWeight(int i) const;
		void setFitness(double fit);
		double getFitness() const;
		int getWeightsNum() const;
		void mutate();
	private:
		vector<double> DNA;
		double fitness;
};

Innanzitutto essa possiede due costruttori. Il primo serve nel caso volessimo inizializzare un cromosoma con pesi random specificando solamente il numero dei pesi (in pratica la lunghezza del DNA); il secondo serve quando vogliamo creare un cromosoma con dei pesi ben precisi passandogeli come argomento: quest’ultimo viene usato per implementare una funzione che permette di salvare i pesi dopo che la rete neurale è allenata e di poterli caricare per evitare di dover ripetere ogni volta l’allenamento.

Come potete vedere le funzioni getWieght(int) e setWeight(int, double) hanno dei compiti abbastanza evidenti così come setFitness(double) e getFitness().

La funzione mutate() applica il famoso operatore genetico delle mutazione al cromosoma, vediamone il codice:

void Chromosome::mutate() {
	if (dRand() <= MUTATION_RATE) {
		DNA[rand()%DNA.size()] += wRand()*MAX_PERTURBATION;
	}
}

Viene generato un numero random compreso tra 0 e 1 e se è minore del valore di MUTATION_RATE la mutazione viene effettuata. Nella parte sugli algoritmi genetici avevamo visto che, quando il DNA è codificato in forma binaria la mutazione agisce semplicemente trasformando uno 0 in un 1 o viceversa. Nel nostro caso, invece, la mutazione non fa altro che aggiungere o sottrarre un piccolo valore compreso tra 0 e MAX_PERTURBATION ad un peso qualsiasi del DNA (wRand() genera infatti un numero compreso tra -1 e 1 quindi il valore di MAX_PERTURBATION può essere sottratto o aggiunto, a seconda del numero generato da wRand()).

La classe Population ingloba un array di oggetti Chromosome* cioè la popolazione vera e propria, più una serie di metodi come la riproduzione, il crossover, etc… ecco il codice:

class Population {
	public:
		Population(int c_num, int c_numw);
		void crossover(Chromosome* a1, Chromosome* a2, Chromosome* b1, Chromosome* b2);
		Chromosome* getChromosomeFromTournament();
		void next();

		Chromosome* best();
		Chromosome* worst();
		Chromosome* operator[](int i);
	private:
		int length;
		vector<Chromosome*> popv;
};

Il costruttore è abbastanza semplice: prende come argomenti il numero di individui di cui è formata la popolazione, ed il numero di pesi per ogni individui cioè la lunghezza del DNA (che chiaramente è uguale per tutti gli individui).

Il metodo del crossover incrocia il DNA dei primi due cromosomi che gli passiamo come argomento e lo mette negli ultimi due, sempre se il numero random generato sia minore della costante CROSSOVER_RATE: un valore di quest’ultima costante pari a 0.7, per esempio, vuol dire che nel 70% dei casi il crossover viene effettuato. Se ciò non avviene gli individui si riproducono così come sono.

void Population::crossover(Chromosome* a1, Chromosome* a2, Chromosome* b1, Chromosome* b2) {
	if (dRand() <= CROSSOVER_RATE) {
		int crosspoint = rand()%length;

		for (int i = 0; i < crosspoint; i++) {
			b1->setWeight(i, a1->getWeight(i));
			b2->setWeight(i, a2->getWeight(i));

			b1->setWeight(length-(i+1),
			a1->getWeight(length-(i+1)));
			b2->setWeight(length-(i+1),
			a2->getWeight(length-(i+1)));
		}
	} else { // Se non fa il crossover riproduce gli stessi cromosomi.
		b1 = a1;
		b2 = a2;
	}
}

La funzione getChromosomeFromTournament() svolge il cosiddetto “torneo” fra i cromosomi e seleziona quello con il miglior fitness. Essa non è altro che il nostro metodo di selezione:

Chromosome* Population::getChromosomeFromTournament() {
	vector<Chromosome*> r;
	for (int i = 0; i < NUM_TOUR; i++) {
		r.push_back(popv[rand()%popv.size()]);
	}
	sort(r.begin(), r.end(), compareChromosomes);
	return r[0];
}

Per svolgere il “torneo” viene creato un vettore che conterrà i cromosomi scelti casualmente dalla popolazione: NUM_TOUR è un’altra costante che definisce quanti cromosomi saranno scelti. Più NUM_TOUR è alta più basse saranno le probabilità degli individui più deboli di sopravvivere e ricordate che questo può non essere sempre un vantaggio; nel caso estremo in cui NUM_TOUR sia uguale alla grandezza della popolazione verrebbe sempre e solo scelto il cromosoma migliore della prima generazione (che poi tanto buono non è visto che nella prima generazione il DNA è random) portando così a tutt’altro che la soluzione del problema.

L’array così ottenuto viene ordinato in base al fitness (la funzione compareChromosomes() non fa altro che restituire il cromosoma che ha il fitness minore tra i due che riceve come argomento) e così l’elemento 0 dell’array conterrà quello con il fitness più basso (ricordate che per noi fitness più basso equivale ad errore più basso e quindi a punteggio migliore) mentre l’ultimo quello con fitness più alto. Questa funzione, insieme a quella del crossover, viene utilizzata nel metodo next() che effettua la riproduzione dell’intera popolazione finchè non si ha una nuova popolazione con lo stesso numero di individui della precedente.

void Population::next() {
	vector<Chromosome*> newPop;

	sort(popv.begin(), popv.end(), compareChromosomes);

	Chromosome* b1 = new Chromosome(length);
	Chromosome* b2 = new Chromosome(length);

	// Garantisce la sopravvivenza dell'inviduo con il fitness piu' alto
	// della popolazione precedente.
	for (int i = 0; i < ELITISM; i++) {
		newPop.push_back(popv[0]);
	}
	while (newPop.size() < popv.size()) {
		Chromosome* a1 = getChromosomeFromTournament();
		Chromosome* a2 = getChromosomeFromTournament();

		crossover(a1, a2, b1, b2);
		b1->mutate();
		b2->mutate();
		newPop.push_back(b1); newPop.push_back(b2);
	}

	popv = newPop;
}

Viene creato inizialmente un nuovo vettore che conterrà i nuovi individui ed il vettore contenente la popolazione viene ordinato in ordine di fitness (come abbiamo fatto nel metodo per svolgere il “torneo”): questo serve per mettere in atto un procedimento particolare definito elitismo. L’elisitmo consiste nel fare sopravvivere sempre, nella generazione successiva, una o più copie dell’elemento che nella generazione precedente aveva totalizzato il punteggio migliore: questo ci garantisce che, quali che siano le ricombinazioni che vengono effettuate sui nuovi individui, non perderemo mai il risultato raggiunto, e inoltre, queste copie possono fornire un aiuto decisivo al raggiungimento della soluzione. ELITISM è una costante che definisce quante copie del miglior cromosma vadano inserite nella nuova popolazione. Nel ciclo while vengono selezionati due cromosomi dal “torneo”, viene fatto su di loro il crossover e sui nuovi individui generati viene effettuata una mutazione (sempre con la percentuale che abbiamo stabilito nella costante MUTATION_RATE) e poi vengono inseriti nel nuovo vettore. Quando questo vettore raggiunge le dimensioni della vecchia popolazione, si esce dal ciclo ed esso viene copiato sulla popolazione originale.

Le altre funzioni della classe sono abbastanza ovvie: best() serve a selezionare il cromosoma con il fitness migliore, worst() il peggiore e l’overloading dell’operatore [] ci permette di accedere ai membri della popolazione come se fossero elementi di un array senza dover scrivere un apposita funzione del tipo getChromosome(int i) (come quella che abbiamo usato per i neuroni: volendo anche lì si può fare infatti l’overloading dell’operatore []).

Manca solo una classe per riunire tutto il codice che abbiamo fatto fino ad ora e la nostra rete sarà utilizzabile (anche se, in pratica, e’ utilizzabile anche da adesso con qualche sforzo in più): la vedremo nella prossima parte, intanto vi do i link a tutte le parti precedenti:

1. Reti neurali e algoritmi genetici I
2. Reti neurali e algoritmi genetici II
3. Reti neurali e algoritmi genetici III

Alla prossima…

TWM - xterm ed emacs

Vediamo innanzitutto come avviarlo. Ovviamente do per scontato che abbiate già configurato il server X e vi funzioni tutto alla perfezione. Prendete il vostro file .xinitrc e modificatelo aggiungendo in una nuova riga:

twm

verificate che non siano segnati altri window manager onde evitare conflitti, quindi salvate il file.Prima di avviare la grafica è opportuno copiare il file di configurazione di TWM nella vostra home, così da avere una personalizzazione solo per il vostro utente. Il file si trova solitamente in /etc/X11/system.twmrc. Dovete copiarlo nella vostra home rinominandolo semplicemente .twmrc. È anche possibile rinominarlo .twmrc.<nome_display> per avere un file di configurazione diverso per ogni display X.

Prima di avviarlo, tuttavia, è meglio verificare che nel menù di TWM ci sia un collegamento quantomeno ad un terminale, come xterm, altrimenti non potreste farci nulla:

menu "main"
{
"Main Menu"		f.title
""			f.nop
"XTerm"    f.exec  "xterm &"
"Show Icon Manager"	f.showiconmgr
"Hide Icon Manager"	f.hideiconmgr
""			f.nop
"Exit"		f.menu "Quit-Verify"
}

Come vedete si tratta di aggiungere un collegamento al terminale, ma questo solo nel caso che il file di configurazione non sia già stato modificato dalla vostra distribuzione. Molte versioni di linux, infatti, lo configurano in automatico, inserendo numerosi programmi nei sotto menù; tra poco vedremo comunque come aggiungere delle voci manualmente. Fatti gli opportuni cambiamenti al file di configurazione non vi resta che lanciare x:

$ startx

il caricamento è pressoché immediato, e vi ritroverete davanti ad uno schermo completamente vuoto (sempre che non abbiate deciso di avviare dei programmi tramite .xinitrc. Per far apparire il menù basta cliccare in un punto qualsiasi con il tasto sinistro del mouse.
Passiamo ora ad analizzare il file di configurazione. Sempre da TWM, usando il terminale, aprite il file .twmrc con un qualsiasi editor di testo. Potrete salvare i cambiamenti quando vorrete, e vi basterà riavviare TWM per vederli applicati in pochi secondi.

NoGrabServer
RestartPreviousState
DecorateTransients
TitleFont "-adobe-helvetica-bold-r-normal--*-120-*-*-*-*-*-*"
ResizeFont "-adobe-helvetica-bold-r-normal--*-120-*-*-*-*-*-*"
MenuFont "-adobe-helvetica-bold-r-normal--*-120-*-*-*-*-*-*"
IconFont "-adobe-helvetica-bold-r-normal--*-100-*-*-*-*-*-*"
IconManagerFont "-adobe-helvetica-bold-r-normal--*-100-*-*-*"
#ClientBorderWidth

Color
{
BorderColor "slategrey"
DefaultBackground "rgb:2/a/9"
DefaultForeground "gray85"
TitleBackground "rgb:2/a/9"
TitleForeground "white"
MenuBackground "rgb:2/a/9"
MenuForeground "gray85"
MenuBorderColor "slategrey"
MenuTitleBackground "gray70"
MenuTitleForeground "rgb:2/a/9"
IconBackground "rgb:2/a/9"
IconForeground "gray85"
IconBorderColor "gray85"
IconManagerBackground "azure"
IconManagerForeground "gray70"
}

In questa prima parte si definiscono i vari font utilizzati dal wm, oltre che i colori delle varie parti. Per quest’ultimo punto i colori vanno scritti in RGB con notazione esadecimale, ciò significa che se avete un valore di blu pari a 162 dovrete scrivere a2. Da notare che è possibile personalizzare i colori per le diverse finestre:

BorderColor  "red" { "XTerm" "yellow" }

in questo caso settiamo il bordo delle finestre rosso, ma quello dell’xterm giallo. È possibile fare la stessa cosa con qualsiasi variabile.

#
# Define some useful functions for motion-based actions.
#
MoveDelta 3
Function "move-or-lower" { f.move f.deltastop f.lower }
Function "move-or-raise" { f.move f.deltastop f.raise }
Function "move-or-iconify" { f.move f.deltastop f.iconify }

#
# Set some useful bindings.  Sort of uwm-ish, sort of simple-button-ish
#
Button1 = : root : f.menu "main"
Button2 = : root : f.menu "windowops"

Button1 = m : window|icon : f.function "move-or-lower"
Button2 = m : window|icon : f.iconify
Button3 = m : window|icon : f.function "move-or-raise"

Button1 = : title : f.function "move-or-raise"
Button2 = : title : f.raiselower

Button1 = : icon : f.function "move-or-iconify"
Button2 = : icon : f.iconify

Button1 = : iconmgr : f.iconify
Button2 = : iconmgr : f.iconify

Qui vengono prima definite delle funzioni per effettuare le classiche operazioni sulle finestre (sposta, ridimensiona, iconifica etc). Successivamente queste funzioni vengono associate ai diversi tasti del mouse. Anche qui potete cambiare quello che volete, invertire i pulsanti come più vi aggrada (il parametro “root” identifica la scrivania).

Veniamo ora alla parte forse più pratica ed utile del file di configurazione, ovvero le strutture dei menù.

menu "main"
{
"Main Menu"		f.title
""			f.nop
"Show Icon Manager"	f.showiconmgr
"Hide Icon Manager"	f.hideiconmgr
""			f.nop
"Exit"			f.menu "Quit-Verify"
}

menu "Quit-Verify"
{
"Really quit twm?"	f.title
"No, restart twm"	f.restart
"Yes, really quit"	f.quit
}

menu "windowops"
{
"Window Ops"		f.title
""			f.nop
"Iconify"		f.iconify
"Resize"		f.resize
"Move"			f.move
"Raise"			f.raise
"Lower"			f.lower
""			f.nop
"Focus"			f.focus
"Unfocus"		f.unfocus
""			f.nop
"Delete"		f.delete
"Destroy"		f.destroy
}

Queste righe sono quelle che probabilmente troverete anche nel vostro file .twmrc, e sono quelle standard che non comprendono nessun collegamento a nessuna applicazione, né dei sotto menù. Per creare una categoria nel main vi basta inserire una riga di questo genere:

"Linux"		f.menu "/Linux"

In questo modo avrete un primo livello di menù con etichetta “Linux”, a cui potrete aggiungere quante voci vorrete:

menu "/Linux/Aiuto"
{
"APT HOWTO"    f.exec  "/usr/bin/apt-howto &"
}
menu "/Linux/Applicazioni"
{
...
}

Abbiamo così aggiunto due sotto menù alla voce Linux, precisamente Aiuto ed Applicazioni. Tra le parentesi graffe potete aggiungere qualsiasi tipo di collegamento usando la sintassi della riga 3. In questo modo potete costruirvi una rete anche ampia di categorie con le rispettive applicazioni, ottenendo un menù di tutto rispetto.
Sono presenti molte altre variabili, ma per il loro utilizzo vi consiglio di dare un’occhiata alla pagina man di twm. Vorrei invece concludere descrivendo le opzioni che si possono aggiungere al comando twm:

-display <num_display>

Vi permette di avviare TWM su un display X a vostra scelta tra quelli precedentemente avviati

-f <filename>

Potete specificare il nome del file di configurazione che twm dovrà utilizzare. Normalmente controlla il file .twmrc nella vostra home, oppure quello di sistema syestem.twmrc

-v

Questa è una sorta di “verbose mode”, e farà sì che twm stampi a schermo gli eventuali errori che il server X produce. È utile più che altro per sessioni di debugging.

Spero di avervi descritto sufficientemente bene l’utilizzo di questo window manager da “fanatici”, il quale vi permetterà di immergervi completamente in qualsiasi operazione, privati una volta per tutte da qualsivoglia distrazione frivola.

Quando si renderizza l’insieme di Mandelbrot l’appartenenza di un punto all’insieme viene stabilita in base alla divergenza dello stesso. Per testare la divergenza viene applicata la formula su di esso diverse volte e, se il punto non accenna a divergere dopo un determinato numero di iterazioni (detto bailout) il punto viene considerato appartenente all’insieme. Chiaramente questo è scorretto dal punto di vista teorico, perchè si dovrebbe verificare che un punto non diverge quando il bailout tende all’infinito, ma visto che non è possibile effettuare un numero infinito di iterazioni ci si accontenta di un valore di bailout abbastanza alto che consente una notevole approssimazione. Ah, un punto viene considerato divergente quando la sua distanza dall’origine diventa maggiore di 2.

Quando il bailout è abbastanza alto i risultati che otterremo saranno più precisi. Anche se il bailout è relativamente trascurabile per l’insieme di Mandelbrot (con valori abbastanza alti non si nota la differenza tra un valore ed un altro a meno che non stiamo zoomando), esso diviene fondamentale per renderizzare il Buddhabrot, ecco due immagini con valori di bailout diversi:

Buddhabrot N=20

Buddhabrot N=200

I parametri che concorrono a determinare la qualità dei nostri rendering sono i seguenti:

• bailout: come abbiamo appena detto, più il bailout è elevato e minore sarà il margine di errore che potremmo avere su ogni punto. Per esempio, ci sono punti che divergono molto lentamente e che con un bailout basso vengono considerati non divergenti.

• numero di pixels esaminati: di più pixels esaminiamo le traiettorie e più nitida sarà la nostra immagine. Quando il numero di pixels non è sufficiente otteniamo un fastidioso “effetto griglia”.

• risoluzione: ovviamente, più è alta la risoluzione è migliore sarà la nostra immagine. C’è da notare, però, che immagini a risoluzione più alta richiedono un numero di pixels esaminati maggiore per ottenere risultati buoni, rispetto a immagini con risoluzione minore.

I tempi di rendering per questo tipo di frattale sono piuttosto lunghi, e quando i parametri qualitativi sono elevati diventano quasi insopportabili.

Le immagini che abbiamo visto fino ad ora sono tutte in bianco e nero. Per ottenere risultati a colori viene usata una tecnica simile a quella che la NASA usa per colorare le immagini astronomiche, cioè i falsi colori. Così come la NASA assegna un colore diverso ad ogni frequenza della luce che riceve dallo spazio, noi creiamo tre immagini in bianco e nero con diversi valori di bailout e le assegnamo rispettivamente ai canali R, G e B dell’immagine. Otterremo in questa maniera immagini simili alle seguenti:

valore di bailout = 500, risoluzione = 1024x1024, tempo di rendering 50 minuti

I dati di questa immagine non li ricordo... spero mi perdoniate.

(Nota: i colori dell’ultima immagine sono stati leggermente ritoccati con Photoshop)

Bene, per ora è tutto. Spero di scrivere un secondo articolo su questo argomento in cui descriverò un’altra tecnica per renderizzare animazioni con il Buddhabrot (che in realtà può essere immaginato come un oggetti in 4 dimensioni), ma siccome i tempi di rendering sono piuttosto lunghi, dovrete aspettare che finisca di renderizzare un bel video. Allego qui il file sorgente del programma che ho usato per realizzare i rendering: Buddhabrot C++

Alla prossima…

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:

Parte I

Parte II

In primis va chiarito che colui che tenta di violare una trasmissione di informazioni segreta viene chiamato steganalista, e la sua materia di studio è la steganalisi. Secondo il principio di Kerckhoff, valido egualmente anche in crittografia, la sicurezza della steganografia non fa imputata al fatto che il sistema steganografico sia sconosciuto allo steganalista, ma bensì che la sola chiave per accedere all’informazione non sia nota.
Gli attacchi si possono raggruppare in due piccoli gruppi, quelli passivi e quelli attivi:

Attacchi passivi:

stego-only-attack: lo stegoanalista intercetta il file steganografato ed è in grado di analizzarlo. E’ il più importante tipo di attacco contro un sistema steganografico perché è quello che solitamente capita di utilizzare.
stego-attack: il mittente ha usato lo stesso cover ripetutamente per nascondere i dati. Lo steganalista possiede un file steganografato diverso ma originato dallo stesso cover. La differenza è che il messaggio celato all’interno sarà diverso, ma il compito di analisi sarà agevolato dal fatto che il file contenitore è il medesimo. Per rendere inutile questo tipo di attacco, come anche il precedente, basta avere l’accortezza di utilizzare sempre un file contenitore diverso, e soprattutto di scarsa notorietà.
cover-stego-attack: In questo caso lo steganalista intercetta un file steganografato ma è a conoscenza di quale file “vergine” è stato utilizzato come cover. Basterà fare un confrontro tra i due per identificare i bit modificati, ed in caso di assenza di protezioni aggiuntive, risalire all’informazione.
cover-emb-stego-attack: Bè, questo è il caso più favorevole, in cui lo stegoanalista possiede tutte le informazioni necessarie per estrapolare l’informazione. Tuttavia ad successiva sessione i dati potrebbero cambiare, e quindi costringere l’analista ad un stego-only-attack.

Attacchi attivi:

manipulating the stego data: L’analista è in grado di frapporsi tra il mittente ed il destinatario, modificare il file steganografato eliminando l’informazione occultata e quindi inviare il file modificato al destinatario. Una sorta di attacco man in the middle.
manipulating the cover data: In questo caso si è in grado di manipolare il cover e intercettare il file steganografato. Si potrà risalire all’informazione nascosta attraverso passaggi più o meno compessi, magari sempre confrontando i due file cercando di scoprire i bit incriminati.


L’algoritmo di A. Brown e S-Tools

Andrew Brown è l’artefice di uno degli algoritmi steganografici più utilizzati, che lui stesso ha implementato in un software chiamato S-Tools (scaricabile qui).

Si tratta di un algoritmo sostitutivo appartenente alla famiglia LSB. E’ in grado di nascondere più messaggi nello stesso file, che in questo caso può essere un’immagine in formato gif o bitmap oppure un file sonoro con estensione wav. L’algoritmo procede attraverso tre fasi:

• Compressione dei file da nascondere

• Cifratura dei dati mediante vari algoritmi (IDEA, DES, triplo DES e MDC) con password scelta dall’utente

• Generazione casuale di una serie di numeri che individuano i byte dove inserire il messaggio nascosto.

I primi due stadi sono dei preliminari e consentono di pretrattare i dati da nascondere secondo metodi distinti dalla steganografia; essi infatti vengono compressi in modo che occupino meno spazio e quindi criptati per avere un ulteriore grado di sicurezza. Il primo punto consente anche di avere un cover di dimensioni più piccole.

Il terzo passo è il più importante da un punto di vista steganografico. Tale fase si occupa di iniettare il messaggio nascosto nei bit meno significativi di alcuni byte scelti casualmente, o meglio, a seconda della password inserita dall’utente. Considerando come file di copertura un wav, è noto come quest’ultimo si ottiene attraverso la simultanea applicazione dei due procedimenti di campionamento e quantizzazione. Per esempio in Windows la quantizzazione è attuata con 8 o 16 bit, cosicché si può attingere rispettivamente a scale di 256 e 65536 valori. Cambiare il bit meno significativo di alcuni byte che operano la digitalizzazione, soprattutto nel secondo caso, produce modificazioni impercettibili anche alla più sensibile delle orecchie. Si stratta quindi di un processo del tutto analogo a quello adottato per le immagini. La particolarità dell’algoritmo di Brown sta nel fatto che i byte da modificare vengono scelti casualmente e dipendono sempre dalla password immessa dall’utente.

.

Steganografia nei testi : Texto

Alcuni algoritmi sono in grado di nascondere dei messaggi all’interno di frasi opportunamente generate, ed è proprio questo il caso di Texto (sorgenti scaricabili qui), un programma sviluppato da Kevin Maher. Va detto subito che le frasi prodotte, pur avendo un significato grammaticale, assumono un indiscutibile valore semantico, apparendo il più delle volte come periodi demenziali. Ovviamente le frasi generate da Texto sono in inglese, essendo lo stesso autore di lingua anglosassone. Maher ha approntato un dizionario di parole divise in categorie che sono: oggetti, luoghi, verbi, avverbi e aggettivi. Inoltre ha generato delle frase che fanno da template da completare con le parole appena menzionate.
Ogni categoria è costituita da 64 alternative, quindi si possono codificare fino a 6 bit, ed essendo gli spazi vuoti cinque (per ciascun template), il testo segreto per ogni frase può essere costituito da un massimo di 30 bit. Il tutto funziona se il mittente ed il destinatario utilizzano il medesimo dizionario, inoltre è facile intuire come l’esigua quantità di parole faciliti il compito dello steganalista. Tuttavia la sicurezza può essere aumentata ampliando il dizionario ed il numero di template, o magari cifrando il testo prima di steganografarlo.

Permutazioni pseudo-casuali

Gli algoritmi di permutazione pseudo-casuale appartengono sempre alla famiglia degli LSB e si basano ugualmente sulla modifica dei bit meno significativi. La differenza sta nella scelta dei byte da modificare, che non viene fatta come una sequenza seppure random come nel caso di S-Tools, ma con la permutazione di un sottoinsieme di tali byte. Una permutazione di n oggetti è la nuova disposizione degli stessi secondo un nuovo ordine. Il numero totale di permutazioni aumenta in modo esponenziale all’aumentare del numero di oggetti – byte in questo caso. In particolare le permutazioni di n byte sono n! (n fattoriale), quindi anche una piccola frase da 512 bit può essere permutata in talmente tanti modi che l’analizzarli tutti richiederebbe – anche ad un computer – un tempo non indifferente. Scegliendo come successione di byte da modificare una permutazione del sottoinsieme prescelto si perde la caratteristica di ordine, cosicché il messaggio occultato viene “sparpagliato” tra i byte del cover. La distribuzione non ordinata dei bit modificati tra i byte disponibili fornisce un ulteriore elemento di sicurezza contro eventuali attacchi.
Questa è una tecnica utilizzata molto anche in crittografia, ma ovviamente le modalità di impiego sono ben diverse.

.

Conclusione

Bè, si fa per dire. D’altronde di cose da esporre sulla steganografia ce ne sarebbero ancora molte, ma diciamo che per il momento è tutto. Per il futuro ho intenzione di illustrarvi come funziona un’altra interessante applicazione pratica della steganografia, ovvero i file system steganografati. Continuate a seguirci

Gli algoritmi genetici sono algoritmi particolari che si ispirano all’evoluzione naturale delle specie descritta da Darwin. Essi sono molto utilizzati nel risolvere problemi nei quali lo spazio di ricerca delle soluzioni non è ben definito e garantiscono sempre un avvicinamento alla soluzione ideale del problema. In un algoritmo genetico ogni individuo (cromosoma) possiede un DNA che rappresenta una potenziale soluzione del problema. Una popolazione di un certo numero di individui con DNA casuale viene creata e su di essa agiscono varie operazioni atte a simulare la selezione naturale per scegliere via via quelli che più si avvicinano alla soluzione desiderata. Il DNA di ogni individuo è in genere una soluzione del problema codificata in modo da facilitare le operazioni genetiche che bisogna fare su di essa (crossover, mutazioni genetiche, etc…, le vedremo fra poco).

Per fare un esempio, potremmo scegliere di creare un algoritmo genetico che cerchi due numeri interi che diano come somma il numero (intero) passatogli in input. Un esempio di DNA per questo algoritmo potrebbe essere il seguente:

00010100

Dove le due quartine rappresentano i due numeri da noi cercati codificati in forma binaria. La forma binaria non è l’unica possibile per codificare il DNA, infatti ognuno potrebbe scegliere di usare un’altra codifica, ma nel caso appena descritto si rivela abbastanza comoda (anche perchè è di facile decodifica). Ora abbiamo visto come si codifica il DNA, ma come avviene l’evoluzione? Vediamolo.

All’inizio viene creata una popolazione di individui con DNA casuale e ogni individuo di questa popolazione viene valutato, cioè gli viene dato un punteggio più o meno alto in base a quanto si è avvicinato alla soluzione che cerchiamo. Qui entra in gioco una delle parti più importanti nell’algoritmo genetico e cioè la funzione di fitness. Il fitness è proprio il punteggio ottenuto da ogni individuo e questa funzione serve a calcolarlo. Nel nostro caso è molto facile creare una funzione di fitness: per assegnare un punteggio basta semplicemente fare la differenza in valore assoluto tra il numero desiderato in output e il numero ottenuto tramite la somma dei due numeri codificati. Supponiamo di volere il numero 12 come output e di avere due cromosomi con il seguente DNA:

1) 00010010

2) 01000101

Il primo codifica i numeri 1 e 2 in forma binaria (0001 == 1, 0010 == 2) mentre il secondo i numeri 4 e 5 (0100 == 4, 0101 == 5). Ilcromosoma 1) da come risultato 3 mentre il 2) da come risultato 9. Se calcoliamo il fitness semplicemente facendo la differenza il primo avra’ un fitness di 121= 11, mentre il secondo 129= 3. Chiaramente nel nostro esempio il fitness più basso corrisponde al cromosoma migliore e un fitness pari a 0 corrisponde all’aver raggiunto la soluzione perfetta. La funzione di fitness in questo caso è molto semplice, ma spesso è un fattore determinante per la buona riuscita di un algoritmo genetico: scegliere una funzione di fitness al posto di un’altra puo’ cambiare drasticamente i risultati!

Dopo aver calcolato il fitness per tutti gli individui della popolazione, si passa alla riproduzione. La riproduzione avviene emulando la selezione naturale e cioè facendo sopravvivere gli individui più forti (quelli con il fitness migliore) ed eliminando quelli più deboli. Durante la riproduzione avvengono anche i fenomeni del crossover e della mutazione che servono a creare varietà  genetica (altrimenti i cromosomi resterebbero sempre gli stessi) e che vedremo fra un istante.

Gli individui da far riprodurre non posso essere scelti casualmente, perchè altrimenti non si assisterebbe mai ad un miglioramento con il passare delle generazioni (ah, per generazione si intende  ogni ciclo completo di riproduzione), perciò esistono vari metodi di selezione e noi useremo quella che viene chiamata selezione a torneo (tournament selection). Giusto per la cronaca, un altro dei metodi di selezioni molto utlizzati è la “roulette  wheel selection” che assegna ad ogni cromosoma una probabilità di essere selezionato direttamente proporzionale al suo fitness. La selezione a torneo consiste nello scegliere casualmente N individui dalla popolazione di partenza e di confrontare il loro fitness: quello con il fitness migliore viene scelto per la riproduzione. La selezione a torneo permette di variare facilmente la pressione selettiva: più è alto il numero N degli individui partecipanti al torneo è più basse saranno le possibilità di riproduzione degli individui con fitness basso (con basso intendo semplicmente peggiore e non minore numericamente, perchè come abbiamo visto, nel nostro caso, un fitness minore equivale ad un punteggio migliore).

Gli individui con fitness basso, sono comunque tutt’altro che inutili perchè in seguito alla ricombinazione genetica, possono fornire materiale utile alla ricerca della soluzione (leggete più avanti per averne un esempio). In genere vengono scelti due cromosomi alla volta (e quindi vengono effettuati due “tornei”) e da loro nascono due nuovi individui. I figli, se così si possono chiamare, non avranno lo stesso patrimonio genetico dei genitori (altrimenti non assisteremmo mai ad un miglioramento e l’individuo migliore della prima generazione resterebbe sempre il migliore per tutte le generazioni seguenti) ma avranno un patrimonio che deriva dal loro in seguito ad alcune modifiche. Ad introdurre queste modifiche sono due operatori genetici: il crossover e la mutazione. Chi ha studiato un po’ di biologia dovrebbe conoscere almeno in linea teorica il crossover: esso avviene quando due cromosomi si rompono in un determinato punto e si scambiano una parte di DNA. Supponiamo di avere due cromosomi:

1) 00100 100 ( 2 + 4 = 6 ) fitness = 6

2) 00011 010 ( 1 + 10 = 11 ) fitness = 1

e supponiamo di scegliere come punto di rottura quello indicato dalla freccia. Effettuando il crossover nasceranno due figli con i seguenti DNA:

1a) 00100010 ( 2 + 2 = 4 ) fitness = 8

2b) 00011100 ( 1 + 12 = 13 )  fitness = 1

che come vedete sono l’incrocio dei due DNA precedenti. Il crossover è fondamentale perchè puo’ produrre nuovi cromosomi che si avvicinano molto di piu’ alla soluzione: nell’esempio il cromosoma 2b) dà come risultato 13 che è quasi la soluzione che cercavamo. E’ interessante notare come, in questo caso, un individuo con fitness basso (il cromosoma 1) con fitness 6) abbia contribuito in maniera fondamentale al raggiungimento della soluzione. Generalmente il crossover non avviene sempre, ma si stabilisce una probabilità (il 70% va bene) con cui farlo avvenire. Dopo aver creato i due nuovi individui su di essi agisce un altro operatore genetico, la mutazione, che effettua un cambiamento su un singolo gene del DNA. Se il DNA è  codificato in forma binaria la mutazione non fa altro che trasforamare uno 0 in un 1 o viceversa. Anch’essa non si verifica in ogni riproduzioni ma ha una probabilità che in genere è molto piu’ bassa rispetto a quella del crossover. Questo procedimento di riproduzione si ripete fino a che la nuova popolazione non ha un numero di individui pari a quella vecchia e poi si ricomincia tutto da capo: si rivaluta il fitness dei nuovi individui (se tutto va bene troveremo qualcuno con un fitness migliore), si effettua una nuova riproduzione, etc… tutto questo si ripete fino a che non troviamo una soluzione accettabile al nostro problema.

Probabilmente sarete un po’ confusi, e ora vi starete chiedendo cosa c’entrino gli algoritmi genetici con le reti neurali. Fra un secondo vi sarà tutto più chiaro. Abbiamo detto che la parte fondamentale per ottenere risultati esatti con una rete neurale è trovare una configurazione ottimale dei pesi e sarà proprio per trovare i valori di tutti i pesi della rete che useremo gli algoritmi genetici. Il DNA dei nostri cromosomi rappresenterà i pesi della rete e via via cercheremo di individuare soluzioni migliori facendo riprodurre quei cromosomi il cui DNA fornisce risultati con un errore più basso quando viene eseguito nella rete. In pratica prendiamo un cromosoma e sostituiamo il suo DNA ai pesi della rete e verifichiamo quant’è l’errore prodotto: in questo caso la funzione di fitness corrisponde semplicemente all’errore, ed anche qui cromosomi con fitness più basso (e quindi con errore più basso) saranno migliori. C’e’ da notare anche che il DNA non verra codificato ma sarà costituito da un semplice vettore di double che contiene tutti i pesi di tutti i neuroni della rete neurale.

La parte sugli algoritmi genetici è terminata e spero che quello che ho scritto sia sufficiente a farvi capire quello che implementeremo. Consiglio ancora una volta a chi non ha ben chiari questi concetti di leggere alcuni dei tuorial sugli algoritmi genetici consigliati in fondo e soprattutto, di provare a realizzare una propria implementazione di un piccolo algoritmo genetico perchè può aiutare molto.

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:

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.

La parola steganografia significa letteralmente – in greco – “scrittura nascosta”, e questo vi potrebbe far pensare subito alla crittografia in quanto anche questa, in un certo senso, ha lo scopo di occultare dei messaggi. Tuttavia fra le due c’è una differenza sostanziale: mentre la crittografia si preoccupa di rendere un messaggio illeggibile agli occhi di una persona non autorizzata, la steganografia fa in modo che una persona non autorizzata non si renda nemmeno conto dell’esistenza del messaggio in questione, malgrado esso sia totalmente in chiaro. La fusione delle due tecniche, cioè steganografare un messaggio criptato, è un ottima soluzione per aumentare il livello di sicurezza.

La steganografia è piuttosto antica come tecnica, e solo ultimamente è stata introdotta in campo digitale. Gli stessi geroglifici egiziani possono essere considerati una sorta di messaggi steganografati, in quanto potrebbero essere dei semplici disegni per chi non ne conosce il significato, ma al contrario fonte di molte informazioni per chi sa decifrarli. A parte questo esempio, i fautori di questa tecnica furono proprio i greci che incidevano il testo su delle tavolette per poi ricoprirle di cera, e quindi occultare il testo. Lo sviluppo concreto della tecnica, tuttavia, fu opera di Johannes Trithemius (pseudonimo di Johann Heidenberg) che inventò quello che oggi è conosciuto a tutti come acrostico, ovvero una frase che si forma mettendo insieme delle parole – in modo più o meno sensato – le cui iniziali vadano a comporre un ulteriore messaggio. Questa tecnica fu comunque perfezionata da Heidenberg stesso, seguendo alcuni piccoli accorgimenti. Più recentemente, ed in particolare durante la seconda guerra mondiale, i nazisti usavano la tecnica dei micropunti fotografici: sono delle particolari fotografie dalle dimensioni irrisorie che una volta sviluppate ed ingrandite svelano il messaggio nascosto.

Questo era un breve excursus storico, ma ora passiamo a cose più tecniche.

La steganogarfia digitale

In ambito digitale occultare una qualche informazione equivale a sostituire dei bit relativamente poco importanti (chiamati bit ridondanti) con bit che, rimessi insieme con un opportuno algoritmo, formino un’informazione diversa dal file che li contiene. I dati da nascondere vengono celati all’interno di contenitori (detti cover o medium), i quali possono essere dei file di diversa natura (immagini, video, testi etc). I metodi utilizzati per fare ciò sono sostanzialmente tre:

Iniezione: questo metodo consiste nell’aggiungere – quindi qui non si parla di sostituzione – dei bit all’interno del cover. La pecca di questa tecnica è che la grandezza del file può aumentare anche considerevolmente, a seconda dei bit iniettati, ma ovviamente per dei piccoli dati può andare bene.

Sostituzione: si tratta di sostituire i bit inutili, o meglio ridondanti, presenti nel file, con quelli da noi voluti. A seconda della percentuale di bit sostituiti l’aspetto del file può variare più o meno considerevolmente. In un’immagine, ad esempio, alcuni dettagli potrebbero svanire o degradarsi.

Generazione di un nuovo file: in questo caso non è necessario nessun cover, ma ne viene creato uno che sia perfettamente adatto ad ospitare i dati da occultare. In questo modo eventuali artefatti non si dovrebbero notare.

Vorrei aprire una piccola parentesi riguardo ai watermark ed ai fingerprint.

I watermark non sono altro che messaggi o semplicemente delle firme che vengono nascoste nelle immagini il più delle volte per identificarne l’autore, così da ridurre le violazioni del copyright. Molti programmi di grafica professionale includono questa funzione. Anche svariate macchine fotografiche digitali inseriscono nelle foto dati riguardanti l’esposizione i tempi e quant’altro, ed il tutto può essere all’occorrenza letto. Si tratta anche qui di algoritmi steganografici, che però vengono usati per scopi più pratici che per questioni di sicurezza o privacy.

Il fingerprint, invece, è una sorta di watermark, ma applicato principalmente a dei prodotti software per prevenire la copia pirata degli stessi. In pratica per ogni copia venduta viene iniettato un codice univoco in qualche file del software, ed in caso di necessità questo viene usato per verificare l’autenticità dello stesso, ovvero che non esistano altri software con il medesimo codice.

Ritornando ai suddetti metodi di occultaggio, quello di sostituzione è il più utilizzato, questo perché raggiunge un compromesso tra perdita di informazioni del cover ed informazioni iniettate. Inoltre si può adattare a moltissimi tipi di file.

Per questa introduzione mi limiterò a descrivere uno degli algoritmi di base più diffusi, usato principalmente per occultare informazioni nelle immagini (in questo caso immagini senza compressione, come le bitmap). Si tratta dell’algoritmo LSB (Least Significant Bit, bit meno significativo) che in parole povere non fa altro che sostituire gli ultimi bit di una sequenza di byte, quindi riducendo al minimo gli artefatti. Questo è possibile anche grazie ad alcune nozioni spiegate dalla teoria dell’informazione e dipende dall’entropia sempre minore del 100% che contraddistingue la maggior parte dei file non compressi. Comunque non approfondirò questo argomento in questa sede, anche perché andrei abbastanza fuori tema.

L’algoritmo LSB

Come già detto questo algoritmo non fa altro che cambiare il bit low-end dei vari byte, ad esempio:

1100101(1)

in questo caso l’ultimo bit (1) è quello che possiamo modificare. Vediamo ora com’è possibile sostituire dei bit nelle immagini bitmap, o comunque prive di compressione.
Queste immagini sono solitamente in modalità RGB, cioè ad ogni pixel corrisponde un determinato valore di rosso, verde e blu. 255, 255, 255 = pixel bianco 0, 0, 0 = pixel nero. E così per tutti gli altri colori. Ora, se voi provate a colorare un pixel con la sequenza 255, 253, 255 il risultato vi sembra forse diverso dal bianco? A meno che non abbiate una vista da superdotati, la risposta è no.

Per ogni pixel quindi sono necessari 3 byte per definirne il colore:

1111 1111
1111 1111
1111 1111

in questo caso viene definito il colore bianco, ricordando comunque che il primo byte determina la percentuale di rosso, il secondo di verde, ed il terzo di blu. L’algoritmo sfrutta proprio questa particolarità della struttura delle immagini per inserire dati in bit che sono sostanzialmente irrilevanti.
Quindi poniamo di voler occultare la lettera “a” (01100001) in una sequenza di byte, quale può essere un’immagine:
…
11011010
10001011
11001000
01011010
11001111
11101010
01011010
11001011
…

ecco come procedere:

…
11011010
10001011
1100100(1) <– bit modificato
01011010
1100111(0) <– bit modificato
11101010
01011010
11001011
…

Come avete visto è bastato modificare solo due bit perché gli altri corrispondevano già a quelli da nascondere. In questo caso è praticamente impossibile capire che il file è stato steganografato, ma ovviamente può capitare di dover nascondere molti più bit, e quindi mutarne di più. Per esempio anche una semplice frase che in totale occupa 20 byte necessiterà – nel peggiore dei casi – di una sequenza di 160 byte. Comunque nella quasi totalità dei casi, secondo statistiche, il numero di bit da alterare è circa la metà dei bit da occultare nel file.

L’LSB sta alla base di molti altri algoritmi di sostituzione che riescono ad iniettare informazioni anche in immagini compresse come le jpeg o le gif, oppure in file audio o video. Tratterò questi algoritmi nello specifico in altri articoli, magari anche citando alcuni programmi che ne fanno uso.