Prima di tutto va detto che in questo articolo non descriverò la costruzione di un moderno oscilloscopio, e non ne tratterò nemmeno la parte pratica. Lo scopo è quello di analizzare lo schema di un rudimentale oscillografo a transistor più che altro a scopo di studio. Comunque nessuno vieta, a chi lo volesse, di costruire realmente questo strumento, infatti posso garantire che se seguirete bene lo schema esso funzionerà senza troppi problemi. La pecca è che potrete misurare al massimo frequenze di 1 mhz, oltre ad essere monotraccia e ad essere privo – ovviamente – delle caratteristiche degli ultimi oscilloscopi digitali.

L’oscillografo che andrò a descrivere è decisamente rudimentale, e le sue caratteristiche non sono certo al passo con i tempi, tuttavia è ottimo per arrivare a comprendere meglio come funziona questo utilissimo strumento di misura:
Può effettuare misure da 3hz a 1 mhz (ma già qui si ha qualche perdita in db); Possibilità di trigger; Amplificatore anche per tensioni continue; Attenuatore con scala pretarata con una buona approssimazione; Amplificatore orizzontale (X) con fase identica a quello verticale (Y); Possibilità di essere alimentato sia in continua che in alternata. Si sa, inoltre, che per gli strumenti di misura è sempre necessaria un’alimentazione il più possibile stabile, e che non muti né in frequenza né in tensione. Per questo sarà presentato anche uno schema di un alimentatore sufficientemente stabile. Questo oscilloscopio utilizza un tubo a raggi catodici, anche perché non c’è proprio nulla di digitale in questo schema, e vi posso assicurare che schemi come questi, dove non ci sia neanche l’ombra di un integrato, sono davvero difficili da reperire al giorno d’oggi malgrado siano ottimi per scopi di studio.

Ma passiamo ad analizzare il circuito:

Gli schemi del progetto possono essere scaricati qui: schemi oscilloscopio

.

Amplificatore verticale (Y)

L’amplificatore verticale è formato soltanto da due stadi amplificatori in controfase: questa soluzione è adottabile preferibilmente perché consente di ottenere un’ottima stabilità contro le variazioni di temperatura e dei parametri dei transistor. All’ingresso dell’amplificatore si trova un partitore di tensione tarato che, eventualmente, può essere compensato anche in frequenza, nel modo che citerò più avanti; l’impedenza di ingresso risulta costante per ciascuna posizione del commutatore ed ha un valore di 1 megaohm, compresa la sonda inserita nel puntale.

A causa delle tensioni di lavoro relativamente elevate, le resistenze di carico del collettore sono alquanto elevate. Ad ogni modo l’amplificatore fornisce un’ottima risposta e quindi un buon guadagno fino alla frequenza di un megahertz. Nel circuito di ingresso di questo amplificatore è inserita una compensazione in corrente continua tarata per il valore di zero volt, per cui, cortocircuitando l’ingresso dell’amplificatore, la linea di riferimento della base dei tempi sullo schermo del tubo a raggi catodici rimane al centro dello schermo. L’amplificatore è insensibile alle variazioni di temperatura comprese tra i 10° C ed i 45° C. Quando lo strumento è alimentato con l’accumulatore (batteria), se la tensione di alimentazione dovesse diminuire, può darsi che la linea dello 0 sullo schermo del tubo si sposti: per ovvia a questo inconveniente si provvederà a regolare il potenziometro P5 (vedere schema) fino a riportare nelle normali posizioni la linea di riferimento.

.

Amplificatore del trigger

L’esatto triggering è ottenuto mediante un circuito trigger di Shmitt. Questo circuito, come qualcuno saprà, ha l’inconveniente di richiedere all’ingresso tensioni elevate. Pertanto, per avere quest’impulso trigger di valore elevato, si usa un amplificatore sovrapilotato. Ogni volta che la somma risultante dal segnale e dall’impulso trigger, sulla base del transistor AC107, sorpassa lo zero, la tensione al collettore di questo transistor cambia. Il fianco di questo impulso di commutazione viene differenziato ed applicato alla base dei tempi. A motivo di questo particolare circuito triggering, il livello dell’impulso differenziato viene a dipendere dalla frequenza, per cui si rende necessario commutare contemporaneamente il condensatore differenziatore insieme a quelli della base dei tempi orizzontale.

.

Generatore della base dei tempi orizzontale

La base dei tempi dell’oscilloscopio è formata da un circuito flip-flop monostabile, che riceve una reazione aggiuntiva attraverso l’emettitore. Mediante il potenziometro da 20 kohm (P7 nello schema), il circuito monostabile trigger si può regolare fino alla posizione astabile. Il punto di lavoro ottimo si trova poco prima della condizione di funzionamento auto-oscillante.

La tensione a dente di sega viene prelevata dal condensatore che si trova nel circuito dell’emettitore. Il dente di sega viene portato all’amplificatore orizzontale (X), attraverso uno stadio a collettore comune, con collettore a massa. Un altro transistor amplificatore produce una tensione rettangolare ricavata dalla base dei tempi con una ampiezza di ben 70 volt, che serve per la regolazione della luminosità del tubo a raggi catodici. Anche qui si richiede un transistor che possa sopportare un valore di tensione considerevole.

Amplificatore orizzontale (X)

L’amplificatore orizzontale è formato da un solo stadio in controfase. Questo stadio è dimensionato più o meno come l’analogo stadio dell’amplificatore verticale. Si deve fare attenzione che le placchette di deflessione degli assi X ed Y abbiamo lo stesso valore di tensione, in modo da impedire, sullo schermo a raggi catodici, possibili distorsioni.

.

Il tubo a raggi catodici e l’alimentazione

Per la produzione delle varie tensioni di alimentazione degli amplificatori e del tubo a raggi catodici vengono impiegati due alimentatori, per cui è possibile adoperare lo strumento sia con una batteria che con la tensione di rete (230 v). Ovviamente i trasformatori – i cui dati verranno forniti in seguito – sono abbastanza particolari, e probabilmente sarà necessario crearseli da se o farseli avvolgere da qualche professionista. La frequenza di detti trasformatori non è la stessa: quella per la conversione CC/CA deve avere circa 40 khz, l’altra, quella per la rete luce, deve avere 50 hz.

Nell’ impiego ad accumulatore, nel caso questo iniziasse a scaricarsi, non soltanto vengono a diminuire le tensioni di alimentazione degli amplificatori (e quindi anche l’amplificazione), ma diminuisce contemporaneamente anche l’alta tensione. Questo, che a prima vista potrebbe sembrare un difetto, in effetti non lo è, poiché la sensibilità di deflessione del tubo catodico aumenta, per cui la diminuzione di amplificazione viene alquanto compensata da questo fatto. Così, per una variazione di tensione del 10% sull’accumulatore, non si ha nessuna perdita di guadagno o difetto di funzionamento. L’accumulatore dovrebbe essere da 6 volt, ed in grado di erogare 2 Ah.

Tubo a raggi catodici

Il tubo a raggi catodici più adatto a questo schema sarebbe uno non più grande di 3”, che possieda inoltre controlli di luminosità, fuoco ed astigmatismo. Questi controlli sono incredibilmente utili per uno strumento come l’oscilloscopio, e ne aumentano l’usabilità. L’accumulatore, invece, dovrebbe essere da 6 volt, ed in grado di erogare 2 Ah.

Trasformatore

Per quanto concerne il trasformatore di alimentazione dirò che esso deve essere costituito dai seguenti avvolgimenti:

Primario:

2×75 spire 0,3 (W1)

2×40 spire 0,8 (W2)

Secondario:

36 spire 0,9 (W3)

120 spire 0,45 (W4)

685 spire 0,15 (W5)

Le tensioni al secondario dopo i duplicatori di tensione dovranno risultare con il carico accoppiato:

da W3 = +12 V e -12 V

da W4 = -70 V

da W5 = -500V

Per ottenere questi valori dovrete utilizzare un voltometro settato su 20 kohm per volt, misurando dalla massa.

Riguardo il trasformatore alimentato con la rete luce i valori sono i seguenti:

Primario:

Universale; potenza 40 Watt; frequenza 50 hz

Secondario:

6,3 V 1,2 A

35 V 300 mA

125 V 6 mA

.

Funzione dei comandi

Per finire vi illustro le funzioni dei vari interruttori e potenziometri.

SW1: Tensione CC o CA in entrata al canale Y

SW2: Rotazione di fase positiva o negativa

SW3: Sincronizzazione trigger interna od esterna

SW4: Entrata orizzontale interna od esterna

S1: Partitore di tensione con i seguenti valori: 100 mV; 300 mV; 1 V; 3 V; 10 V; 30 V; 100 V

S2: Tempi per la base dei tempi per i seguenti valori: 0,01 ms; 0,03 ms; 0,1 ms; 0,3 ms; 1 ms; 3 ms; 10 ms

S3: Interruttore di alimentazione (rete/spento/accumulatore)

Potenziometri:

P5: Canale verticale, regolazione di posizione

P6: Scelta del livello trigger

P7: Regolazione della stabilità del trigger

P8: Regolazione unità dei tempi

P9: Regolazione di posizione del canale orizzontale

P10: Luminosità

P11: Fuoco

P12: astigmatismo

.

Spero di avervi dato i giusti input per riuscire a comprendere al meglio i principi che stanno alla base di questo strumento di misura professionale, nonché adattabile ad innumerevoli campi applicativi.

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.

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…

Praticamente tutti conoscono la famosa scoperta di Albert Hofmann, ovvero l’LSD-25. Successivamente alla sua scoperta si fecero numerosi studi a riguardo, e si riuscirono a trovare molti altri suoi analoghi che mantengono il gruppo dietilamide invariato. Alcune ammine dell’acido lisergico sono: Ergonovina, Metilergonovina, LAE-32, MLD-41, DAM-57, CYP-LAD, BOL-148, LSM-775, ALD-52. Tutte queste molecole sono psicoattive, ed in particolare l’ultima menzionata è quella su cui mi soffermerò. L’ALD-52 o anche N-acetil-LSD, è un isomero di struttura dell’LSD. Questo significa che la formula molecolare tre le due è la medesima, ma a cambiare è la formula di struttura.

Questo isomero mantiene molte delle caratteristiche proprie dell’LSD, prima fra tutte la capacità di provocare allucinazioni medio/forti. Oltre a questo aspetto in comune, l’ALD-52 sembrerebbe provocare molta meno ansia o stress psicologico durante il trip, e la pressione sanguinia tende ad aumentare maggiormente. Tuttavia a parità di dosi l’effetto sul sistema nervoso è minore.

Questa molecola venne sintetizzata intorno agli anni 60 dallo stesso Albert Hofmann, e successivamente venne imitato da numerosissimi laboratori clandestini, che sintetizzandolo potevano avere una valida alternativa all’LSD completamente legale. Proprio per questo girò per moltissimo tempo e prese il nome di Orange Sunshine. Questo spiegherebbe le voci che affermano che a quei tempi se ne assumesse molta di più (500-600 microgrammi contro gli 80/100 di oggi). In realtà tutt’ora di ALD-52 se ne trova davvero poca, e probabilmente il costo di produzione dell’LSD è minore – oltre al fatto che ora è anch’essa illegale -, quindi di conseguenza sono sufficienti piccole dosi per ottenere anche effetti piuttosto pesanti.
L’ALD-52 è tuttavia molto instabile, e se esposta a troppa luce od umidità, muta velocemente in LSD. Come detto precedentemente questa sostanza o viene sintetizzata per motivi legali – in quei paesi ove la legge non sia sia ancora adeguata -, oppure per ricercare un trip simile a quello provocato dell’LSD ma con meno effetti indesiderati. Inoltre i noti flashback allucinatori dell’LSD non sembrano manifestarsi dopo l’assunzione di questa ammina, ed anche i post-effetti sono meno intensi di quelli della “molecola madre”.

Il processo per produrre L’ALD-52 prevede di partire dall’LSD, questo almeno fino a poco tempo fa. Nel 2004 infatti è stato scoperto un procedimento diverso per sintetizzare l’acido lisergico, con il quale è possibile ottenere direttamente l’ALD-52 senza passare forzatamente dall’LSD base. Per chi fosse interessato il procedimento viene illustrato qui (in inglese): A New Synthesis of Lysergic Acid In ogni caso il procedimento non è dei più semplici.

Spero di avervi chiarito abbastanza le idee a proposito di questa ammina parente dell’LSD, forse troppo sconosciuta malgrado le sue interessanti caratteristiche…

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

Vi presento subito lo schema:

.

Lo schema circuitale è oltremodo semplice ed in base a questa ragione si presta ad essere analizzato da chiunque. Il componente responsabile della generazione del rumore è il transistor TR1 (un BC107) il quale è polarizzato inversamente tramite la resistenza R1; tale resistenza. essendo di valore sufficientemente elevato, fa sì che la corrente dell’emettitore di tale transistor risulti molto bassa,  ma a sua volta sufficiente a far sì che la tensione emettitore-base di TR1 assuma un valore tale da portarla alla rottura: in tal modo viene pertanto a generarsi un rumore continuo. Tale rumore presenta a questo punto un’ampiezza (livello) molto bassa che non può essere utilizzata se non dopo un’opportuna amplificazione. A ciò provvede il transistor TR2, che amplifica il segnale inviandolo a sua volta ad un unteriore stadio di amplificazione, costituito dall’integrato uA741. Quest’ultimo viene alimentato con una tensione di 12 v sul piedino 7, mentre viene polarizzato con metà dell’alimentazione sull’ingresso.
Se vorrete rendere udibile il fruscio dovrete collegare all’uscita un amplificatore di bassa frequenza e di conseguenza un altoparlante. Per altri scopi, invece, il segnale che preleverete all’uscita sarà più che sufficiente.

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.

Metilcatinone - molecola animata

Il Metilcatinone (metcatinone, CAT) è un’ammina simpaticomimetica strutturalmente simile alla metedrina. Presenta una funzione carbonilica sul carbonio adiacente al gruppo aromatico e questo (analogamente al dietilpropione) condiziona il superamento della barriera emato-encefalica, modificandone l’intensità dell’effetto a livello del sistema nervoso centrale. Allo stato di base libera è un liquido oleoso di colore giallastro insolubile in H₂O, e solubile nei comuni solventi apolari. Il suo sale più comune è il cloridrato, allo stato di polvere in fiocchi di colore bianco candido, di sapore amaro, odore leggero gradevole, vagamente somigliante al pistacchio.

Questa sostanza ha degli effetti molto simili alla metanfetamina, ma di intensità minore. Gli effetti comuni sono tachicardia, ipertensione, incapacità di smettere di parlare, pupille dilatate e squilibrio delle funzioni sessuali. In generale gli effetti sono quelli che si manifestano con una qualsiasi anfetamina. Un alto dosaggio somministrato per lunghi periodi può portare a paranoia e psicosi, tuttavia interrompendo l’assunzione questi sintomi svaniscono abbastanza velocemente.

Come vedremo ora anche il metilcatinone può essere sintetizzato dall’efedrina tramite un processo di ossidazione:

L’ossidazione (e la riduzione) processa uno solo dei due stereocentri (quello adiacente al fenile), lasciando l’altro intatto. Le due forme in cui è ottenibile l’efedrina sono la levo-, che costituisce la stragrande maggioranza dell’alcaloide naturale, e la forma destro, detta pseudo-efedrina, realizzabile sinteticamente, e presente in tracce in natura. Queste due forme dell’efedrina ruotano da parti opposte il piano della luce polarizzata, pur presentando, però, la medesima configurazione sul C2 (il carbonio propilico recante la funzione azotata), ed è così che per ossidazione sia della levo-efedrina sia della pseudo si otterrà uno solo dei due enantiomeri possibili, esattamente il destro, ed il prodotto che si otterrà è otticamente attivo. Lo stesso avviene per la riduzione. In entrambe le reazioni sia si utilizzi come precursore l’efedrina naturale o la pseudo sintetica si otterranno prodotti otticamente attivi, il metilcatinone e la metedrina entrambi nella forma D, per l’ossidazione e la riduzione, rispettivamente.
La reazione di ossidazione, pur non essendo stereoselettiva, ci consente di ottenere un prodotto otticamente puro. Questo in teoria. In pratica, però, è facile che il metilcatinone ottenuto presenti un certo grado di racemizzazione, se non si opera con attenzione. Infatti, si tratta di un chetone enolizzabile, come si può vedere dalle strutture seguenti:

Per migrazione dell’idrogeno in C2 sull’ossigeno carbonilico il doppio legame si sposta, così il C2 modifica il proprio stato di ibridazione da sp 3 a sp 2, da tetraedrico a trigonale, e conseguentemente cambia anche gli angoli di legame da 109,5° a 120°, il che comporta che quando si ripristina l’assetto originale l’attacco dell’idrogeno può avvenire da ambo le parti del piano delineato dal C2 trigonale e dei suoi tre orbitali sigma, con formazione di due antipodi ottici, ed il prodotto che si otterrà perderà l’attività ottica originale, cioè racemizza. Come per la metedrina, la forma D del metilcatinone è attiva come stimolante del sistema nervoso centrale, la forma L lo è molto meno. Dunque, con la racemizzazione si perderà una notevole parte dell’effetto farmacologico del composto.
Fatta questa parte teorica passiamo ora a qualcosa di più pratico, ovvero al procedimento solitamente utilizzato per ossidare l’efedrina (in questo caso pseudo-efedrina di tipo D).

MATERIALE NECESSARIO:

- Colino o colapasta con buchi relativamente piccoli
- Ghiaccio tritato
- Pastiglie di pseudoefedrina (100 da 30 mg o equivalente).
- Permanganato di potassio (KMnO4).
- Acqua distillata
- Congelatore
- Bilancia più precisa possibile (almeno 0,1 g) o in alternativa una pipetta o altro metodo per misurare i millilitri
- Isopropanolo (dal 70% al 100%)
- Filtri da caffè, o filtri analoghi a trama fine.
- Vari barattoli di vetro e un piatto in Pyrex
- Acido cloridrico (HCl)
- Etanolo, per velocizzare il processo di cristallizzazione (facoltativo)
- Acetone per lavare i cristalli (facoltativo)

ESTRAZIONE DELLA PSEUDO-EFEDRINA HCl:

Porre le pastiglie nel colapasta insieme a un volume all’incirca uguale di ghiaccio tritato, e mescolare sopra un lavandino fino a quando tutto il ghiaccio non si sarà sciolto. A questo punto risciacquare le pastiglie con acqua distillata e riporle in un barattolo di vetro.
Versare sulle pastiglie appena lavate 150 ml di acqua distillata e riscaldare il tutto a microonde, a bassa potenza, fino a farlo diventare caldo (senza bollirlo). Mescolare finchè le compresse non si disgregano e lasciare depositare gli eccipienti sul fondo, in modo da lasciare la pseudoefedrina in soluzione.
Versare la soluzione attraverso un filtro da caffè, facendo in modo di versare solo la parte acquosa e non il deposito solido sul fondo, che andrebbe a ostruire il filtro, e raccoglierlo in un altro barattolo.
Fatto ciò raccogliere il materiale solido nel filtro, rimetterlo nel primo barattolo, aggiungere altri 150 ml di acqua, riscaldare e ripetere la filtrazione. Ripetere di nuovo quest’ ultima parte.

PREPARAZIONE DELLA SOLUZIONE DI KMnO4:

Se l’estrazione della pseudoefedrina è stata perfetta, ce ne sono ora in soluzione esattamente 3 grammi. Considerando che il rapporto molare pseudoefedrina/KMnO4 deve essere 2.5 moli contro 1, e che 3 grammi di pseudoefedrina equivalgono a 18.15 mMoli, per la reazione sono necessarie 7.26 mMoli di KMnO4, equivalenti a 1.148 grammi. Se non si dispone di una bilancia di precisione è possibile determinare questa quantità realizzando una soluzione satura di KMnO4, aspettando in modo che il corpo di fondo si depositi del tutto, e misurare 15.45 ml (se non è possibile essere così precisi arrotondare per eccesso).

PREPARAZIONE DELLA REAZIONE:

Diluire i 15 ml (o 1.148 grammi) in 250 ml di acqua distillata e porre il tutto nel congelatore, insieme alla soluzione di pseudoefedrina. Lasciar raffreddare per almeno 4 ore. Per avere un indicazione della temperatura si può controllare quando il ghiaccio inizia a formarsi e lasciare quindi che si sciolga in modo da essere sicuri che la temperatura sia 0°C.

REAZIONE:

Unire le due soluzioni, mescolare e riporre nel congelatore per 8-12 ore. Al termine di questo periodo, il contenuto del vaso avrà cambiato colore, diventando da rosso a limpido, con un deposito marroncino sul fondo. Aggiungere 100 ml di isopropanolo e mescolare.
Se il colore rosso rimane c’è un eccesso di KMnO4 e la sintesi è fallita, oppure non è stato concesso abbastanza tempo alla reazione per avvenire. In ogni caso non lasciar reagire per più di 12 ore. Lasciar riposare la mistura per circa 2 ore, finchè non raggiunge la temperatura ambiente.
Filtrare attraverso 2 filtri da caffè impilati uno sull’altro, in modo da catturare le particelle di manganese che sono precipitate. Dopo una prima filtrazione, raffredare nuovamente e gentilmente la mistura e rifiltrare. Potrebbero essere necessarie più filtrazione successive.

PURIFICAZIONE:

Misurare il ph della soluzione con una cartina tornasole, dovrebbe risultare basico, se risulta acido non sarà necessario aggiungere altro acido.
Se la soluzione risulta basica è necessario aggiungere acido cloridrico in modo da ottenere il sale cloridrato del metacatinone, una forma che, a differenza della forma freebase, non si decompone facilmente in efedrina.
Aggiungere una goccia di HCl alla volta, mescolando e controllando il ph finchè non risulta leggermente acido (compreso tra 5 e 6.5).

Porre il tutto nel piatto di Pyrex, metterlo su un fornello e riscaldarlo gentilmente da sotto, asciugandolo leggermente con un asciugacapelli. Quando i primi cristalli iniziano a formarsi aggiungere l’etanolo, che velocizza il processo di cristallizzazione. Evitare di riscaldare troppo i cristalli o si scioglieranno e tutta la sintesi sarà fallita.

A questo punto è possibile (ma non indispensabile) lavare i cristalli con acetone per renderli più puri e trasparenti, anche se questo potrebbe ridurre drasticamente il prodotto in termini di peso.

Questo è quanto, ovviamente il metilcatinone è una sostanza controllata in italia, ed è presente in tabella 1, quindi ogni processo di sintesi del suddetto composto è da ritenersi assolutamente illegale e non va in nessun caso messo in pratica.

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.