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

PETN - Molecola animata

Questo esplosivo si presenta sotto forma di solido cristallino bianco ed inodore. La velocità di detonazione del PETN alla densità di 1.7 g/cm3 è di 8,400 m/s. Il calore prodotto dall’esplosione è di 5,862 kj per chilogrammo, o una volta e mezza quello prodotto dal TNT. La formula bruta del PETN è C(CH2ONO2)4, con una densità teorica massima dei cristalli di 1.773 g/cm3. Fonde alla temperatura di 141° C, con una temperatura di auto-ignezione di 190 °C.

La preparazione della pentrite comporta la nitrazione della pentaeritrite con una mistura concentrata di acido nitrico e solforico. Il metodo migliore è tuttavia quello di utilizzare solamente acido nitrico molto concentrato (98%+), visto che l’utilizzo di una mistura di acidi potrebbe creare dei sottoprodotti instabili. Avviene la seguente reazione:

C(CH₂OH)₄ + 4HNO₃ → C(CH₂ONO₂)₄ + 4H₂O

Reagenti e Materiali

• Acido solforico concentrato al 98% (H2So4)

• Acido nitrico concentrato al 65% (HNO3)

• Pentaeritrite

• Acetone

• Acqua distillata

• Bicarbonato di sodio (NaHCO3)

• Due becker puliti

• Una pipetta

Procedimento

• Viene preparato un bagno di acqua fredda per raffreddare un becker contenete 34 ml di acido nitrico. 24,8ml di acido solforico vengono messi lentamente con una pipetta nel becker contenete l’acido nitrico. La miscela produrrà molto calore, e sarà necessario aggiungere del ghiaccio e del sale nel bagno d’acqua fredda in cui sta immerso il becker.

• Viene ora preparato un secondo bagno d’acqua fredda/ghiaccio da usare in caso di emergenza se la temperatura del becker dovesse salire troppo.

• Con la miscela di acidi, precedentemente creata, alla temperatura di circa -25° C, vengono aggiunti 10g di pentaeritrite, 2g alla volta. È importante mescolare la miscela durate l’aggiunta del composto. A nitrazione terminata, la temperatura comincerà a scendere, e la mistura acquisterà una certa densità. Una bassa temperatura iniziale è la chiave per una buona sintesi. La temperatura non deve in nessun caso superare gli 0° C. Se vengono a formarsi dei fumi rosso/marroni (N2O4 / NO2 ), significa che il miscuglio è ad una temperatura troppo alta, e necessita di essere subito raffreddato.

• Il composto viene mescolato per altri 10 minuti, dopo l’aggiunta di tutto il pentaeritrite. La mistura vine allora messa in un bagno di acqua calda a 45° C per 25 minuti. Questo consentirà di aumentare la quantità di PETN finale. È importate mantenere la temperatura a 45° C senza andare oltre, continuando a mescolare.

• La mistura viene diluita con 450ml di acqua fredda (0-1°C) e l’eccesso di acqua successivamente decantato dopo che i cristalli si saranno depositati sul fondo. La mistura deve essere aggiunta lentamente all’acqua calda, in quanto un eccesso di acido solforico può provocare un innalzamento della temperatura, che potrebbe portare ad una decomposizione del prodotto finale

• Il PETN viene filtrato e lavato con acqua fredda, e quindi neutralizzato con una soluzione calda di bicarbonato di sodio.

• 200ml di acetone vengono riscaldati a 50°C, ed il PETN vine mescolato al suo interno finché sarà completamente dissolto (Solubilità: 58g/100ml di acetone a 50° C). Asciugare il PETN prima di questo passaggio, richiederà meno acetone.

• La mistura di PETN e acetone viene filtrata e posta in un becker contenete 600ml di acqua/ghiaccio tritato, che farà precipitare il PETN sul fondo sotto forma di cristalli. La soluzione viene filtrata ottenendo i cristalli di PETN. Quest’ultimo viene poi lasciato asciugare. Si otterranno circa 22g di prodotto con una rendita del 91% circa.

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:

1. Leggere il messaggio da un file di testo
2. 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.
3. Modificare i bit meno significativi per adattarli a quelli del messaggio
4. 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:

1. 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 2¹⁰ = 1024.
2. 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.
3. 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!

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

Lactucina - molecola animata

Illustrazione descrittiva

ESTRAZIONE COMUNE

Sono necessarie almeno 2 piante (fiorite) per ottere una quantità apprezzabile di lactucarium. Per estrarre il liquido procuratevi una piccola ciotola in vetro. Cominciate a spezzare i rametti secondari, dove si trovano i fiori, e mettete il liquido che fuoriuscirà nella ciotola. Continuate a spezzare i rametti circa ogni centimetro, e accumulate il succo sempre nella ciotola. Fate lo stesso con il gambo. Le foglie contengono poco “latte”, quindi potete scartarle. Estratto tutto il lactucarium possibile dovete lasciarlo essiccare: ponete la ciotola in luogo asciutto e buio per almeno due giorni, fino ad ottenere una pasta di color marrone scuro.

ESTRAZIONE CHIMICA

Almeno 20g di materiale seccato e privato delle infiorescenze viene messo ammollo in una soluzione di alcol etilico a 95% e lasciato riposare per almeno 24 ore, mescolando ogni tanto. La lactucina è molto solubile nell’alcol, quindi finirà in soluzione con quest’ultimo. Passate le 24 ore un deposito marrone si sarà formato sul fondo, quindi il materiale erbaceo dovrà essere rimosso, e successivamente porre ad evaporare il liquido. Per agevolare questa fase è possibile riscaldarlo con un fornello, mantenendo il liquido ad una temperatura non superiore ai 50° C. Evaporato tutto l’alcol sul fondo rimarrà il lactucarium, che sarà possibile asportare con una lametta.
Quello che si otterrà sarà lactucarium, e non la lactucina pura, in esso sono infatti presenti altre sostanze della pianta solubili in alcol, come ad esempio la clorofilla. Per filtrare tutti questi componenti estranei è possibile porre nuovamente il lactucarium ottenuto in alcol ad altissima percentuale (~100%) e porre il tutto nel frigorifero, in modo da mantenere la temperatura molto bassa. Far evaporare e ripetere il procedimento fino ad ottenere dei cristalli i più puri possibili.

Introduzione

Va anticipato che uno dei linguaggi di programmazione più predisposti al buffer overflow (d’ora in poi BOF) è senza dubbio il C/C++. Infatti a differenza di altri linguaggi permette al programmatore un controllo quasi completo sulla memoria – quasi quanto un linguaggio assembly – ma non sempre fa gli opportuni controlli, a scapito dei programmatori alle prime armi. Linguaggi come il Java, ad esempio, hanno una gestione molto sofisticata della memoria, ricorrendo ad algoritmi di de-allocazione e a sistemi come il Garbage Collector, quindi i rischi di BOF sono molto rari.
Vediamo innanzi tutto cos’è il buffer. Nella sua accezione più generale un buffer è un’area di memoria contigua, con una dimensione prefissata, utilizzata per memorizzare dati omogenei. Nel linguaggio C un buffer è rappresentato dal puntatore all’indirizzo iniziale dell’area di memoria corrispondente. Alcune funzioni della libreria standard del C (strcpy(), strcat(), gets() e la famosa scanf()) operano su buffer di caratteri senza effettuare nessun controllo sulla dimensione del buffer di destinazione (bound checking): semplicemente arrestano la loro scrittura quando non hanno più caratteri disponibili. È evidente che in questi casi è abbastanza facile incorrere in un buffer overflow. Nel caso in cui il buffer mal gestito sia una variabile automatica, sia cioè allocato sullo stack, la situazione può venire sfruttata da un attaccante per sovrascrivere l’indirizzo di ritorno di una chiamata da funzione e forzare così l’esecuzione di codice malevolo, che può essere posizionato sia nel buffer stesso che in una variabile d’ambiente.
In sintesi un buffer overflow avviene quando in un programma, al tempo di esecuzione, una certa istruzione tenta di scrivere dentro ad un buffer più informazioni di quante esso ne possa contenere.

Organizzazione della memoria

È possibile suddividere la memoria allocata ad un processo in tre zone, ognuna specializzata per una determinata funzione: un’area text, un’area dati statica ed un’area dati dinamica:

• L’area text è un’area di sola lettura, collocata nella parte più bassa dello spazio di indirizzamento di un processo, in cui vengono memorizzate le istruzioni del programma ed è condivisa da tutti i processi che eseguono lo stesso codice; un tentativo di scrittura in quest’area dà origine ad un errore.

• L’area dati statica è a sua volta suddivisa in due regioni (data e bss), una per i dati inizializzati ed un’altra per i dati inizializzati; le variabili statiche trovano posto in quest’area.

• L’area dati dinamica è divisa a sua volta in due parti: lo stack e lo heap. Quest’ultima è un’area dati dinamica che viene allocata a run time attraverso le funzioni del C come malloc() e calloc(), e cresce verso gli indirizzi alti. Viene usato per gestire variabili dinamiche e puntatori. Andrò ora a descrivere un po’ più nel dettaglio lo stack.

Lo stack e sua gestione

Lo stack è quell’area di memoria che si trova sul fondo della memoria e che viene utilizzata durante le chiamate alle funzioni per salvare lo stato corrente dell’esecuzione e per passare i parametri per argomento. Viene gestito con la politica LIFO (Last In, First Out) e mediante due istruzioni fondamentali del linguaggio assembly: PUSH e POP. La prima memorizza un dato, la seconda lo estrae seguendo il modello LIFO, l’ultimo ad entrare è il primo ad uscire. La memorizzazione dei dati nello stack segue un ordine inverso, cioè parte dal fondo e man mano che le informazioni vengono memorizzate, sale verso la cima della memoria.
La gestione dello stack è affidata a due registri a 32-bit molto importanti, chiamati EBP e ESP (base pointer e stack pointer), usati – rispettivamente – per delimitare la cima e il fondo dello stack; quando si esegue una PUSH, il registro ESP viene decrementato di un numero di byte pari alla dimensione del dato memorizzato, quando si esegue una POP il registro ESP viene invece incrementato. Le variazioni di ESP e EBP possono inoltre essere fatte anche direttamente, tramite operazioni di somma e sottrazione (ADD e SUB): ad esempio l’istruzione SUB ESP,5 riserva cinque byte nello stack. Questo tipo di struttura si rivela efficiente e utile nella gestione della gestione delle chiamate di funzioni e procedure in un programma, costituendo quello che è il meccanismo della “call chain”: una funzione può infatti richiamare un’altra funzione che a sua volta può chiamarne un’altra ancora e così via. Il sistema operativo deve poter tener traccia di tutte le chiamate innestate fra loro ed essere in grado di tornare a punti prestabiliti del programma dove richiesto. Ogni chiamata ad una funzione viene tradotta in una istruzione di tipo CALL, che ha l’effetto di congelare l’esecuzione del codice fino a quel punto, passando poi il controllo alla funzione chiamata, dopo aver salvato lo stato corrente e l’indirizzo di ritorno (return address), che servirà per riportare l’esecuzione nel punto in cui si era interrotta (il registro EIP è quello che punta sempre all’istruzione corrente). Da questo meccanismo si evince una prima considerazione importante: poiché l’indirizzo di ritorno viene salvato nello stack, una eventuale corruzione di tale area dati impedirà ad un qualsiasi programma di ritornare in uno stato consistente, con conseguente crash dell’esecuzione.
Per approfondimenti riguardo allo stack si veda il seguente link: Stack on Hacknowledge

Usi malevoli del buffer overflow

Come ho detto ad inizio articolo abbiamo a che fare con un errore particolarmente grave, che permetterebbe ad un hacker di ottenere una shell (anche root in certi casi) sulla macchina vittima.
Detto sinteticamente – comunque nei prossimi articoli vedremo il tutto più nel dettaglio – è possibile far eseguire del codice macchina semplicemente sovrascrivendo l’indirizzo di ritorno e facendolo puntare ad uno shellcode. Quest’ultimo è un “programma” in grado di sfruttare un buffer overflow, e solitamente provoca l’apertura di una shell – per questo shellcode – sulla macchina vittima. Uno shellcode viene solitamente scritto tramite codici esadecimali che identificano le varie istruzioni assembly da eseguire, successivamente questo codice viene iniettato nel buffer e fatto eseguire modificando l’indirizzo di ritorno della funzione vulnerabile. I rischi di un errore del genere in alcuni casi possono essere gravissimi, ad esempio un login che va in buffer overflow se il nome utente è troppo lungo…
Ecco un’immagine che forse vi faciliterà la comprensione di quanto detto:

In ogni caso questo è un overflow dello stack – uno dei più comuni – ma ne esistono anche altri meno conosciuti, ed anche più difficili da sfruttare: heap overflow, frame pointer exception e l’adjacent memory overflow.
L’overflow dello stack rimane il più facile da sfruttare, poiché permette di maneggiare in maniera efficace i registri EBP, ESP e EIP, fondamentali per poter eseguire del codice

Ma vediamo ora com’è possibile prevenire un BOF:

• Non Executable Stack: questa è la soluzione più radicale. Modificando il kernel del sistema si può rendere il segmento che contiene i dati dello stack non-eseguibile, in modo che se accidentalmente o volutamente un programma dovesse finire in quellaa zona di memoria verrebbe generato un cosiddetto protection fault, terminando il processo.

• Random Stack Address: Per poter pilotare il flusso di esecuzione, un exploit deve disporre di indirizzi affidabili e validi da assegnare ai registri EIP e ESP. Utilizzando uno stack con modalità di indirizzamento casuale, si potrebbe complicare la vita ad un eventuale attaccante nella realizzazione di exploit a compatibilità universale, che cioè funzionino in qualsiasi sistema in cui sia presente il programma vulnerabile.

• Bound Checking: Il problema degli overflow nasce principalmente da disattenzioni da parte del programmatore e del compilatore, che non controlla in anticipo se una variabile è soggetta a “traboccare”. Comunque anche nel C/C++ sono presenti alcuni accorgimenti da rispettare, e perfino delle funzioni safe, che appunto effettuano dei controlli sull’input in modo che non superi la grandezza del buffer a cui è destinato. Di seguito degli esempi:

strcpy(buf, ptr); //insicuro
strncpy(buf, sizebuf(buf), ptr); //sicuro

oppure con il classico scanf():

char buf[10];
scanf("%s", buf); //insicuro
scanf("%10s", buf); //sicuro

Nei prossimi due articoli tratterò appunto questo tipo di buffer overflow, applicandolo ai due sistemi operativi più famosi, ovvero Windows e Linux.

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.

La ricina è una proteina che viene comunemente estratta dai semi di ricino (Ricinus communis), li stessi che vengono usati per produrre il rispettivo olio. Questa proteina viene solitamente scartata durante la lavorazione dei semi, ed in alcuni casi usata come medicinale. A contatto con il corpo umano si comporta come una tossina, in grado di inibire la sintesi delle proteine da parte dell’organismo. La dose letale è decisamente piccola, nell’ordine dei 500 microgrammi, e non sono conosciuti antidoti, ma solo un vaccino che potrebbe prevenire gli effetti della sostanza. Proprio per questo motivo la ricina viene usata spesso come arma chimica per attentati et simila: per uccidere un uomo di taglia media è sufficiente graffiarlo con qualche oggetto “sporco” di cristalli di ricina. E’ una sostanza estremamente pericolosa, dal momento che può venire assorbita dalla pelle, anche priva di lacerazioni. Inoltre gli effetti si manifestano molto in fretta se viene ingerita o inalata.

La ricina è una protenia inattivante del ribosoma di tipo 2 (RIP II), si può dividere in due catene molecolari: RTA e RTB (Ricin Toxin A/B), ed è in grado di infiltrarsi all’interno di una cellula (citosol). Dal momento che questa sostanza resiste a molti tipi di pH, il libosoma cellulare (lo stomaco della cellula, detto in parole povere) può fare ben poco per difendere la stessa. Una singola catena molecolare come l’RTA, una volta infiltratasi nella cellula, può depurinare circa 1500 ribosomi al minuto. Le conseguenze sono gravissime già dopo poche ore.

ESTRAZIONE

I semi della pianta vanno triturati abbastanza finemente per poi essere immersi in una soluzione acida. Questa può essere prodotta aggiungendo dell’acido cloridrico a dell’acqua distillata fino a raggiungere un pH ~4. Il tutto andrà mescolato energicamente e lasciato riposare per almeno 24 ore. A questo puntotutti i depositi non solubili vanno filtrati con un filtro a trama fine,  ad ottenere una soluzione priva di parti insolubili.
Ora la ricina è disciolta nella soluzione acida, quindi per farla precipitare va aggiunto del solfato di sodio arrivando ad un pH ~8. il tutto andrà di nuovo filtrato, questa volta conservando il deposito (ricina) e scartando la soluzione acquosa. Sarà meglio effettuare un lavaggio della ricina con una soluzione di solfato di sodio al 20% con acqua distillata, questo rimuoverà eventuali sostanze indesiderate.
Ripetere tutto una seconda volta per ottenere un prodotto più puro.

Come ho già detto questa sostanza è molto pericolosa, e può facilmente entrare in contatto con l’organismo senza le dovute precauzioni. La sua estrazione (anche se solo a fini di studio) è sconsigliata.

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…