Académique Documents
Professionnel Documents
Culture Documents
SVM Banconote
Rossinelli Emanuele
2 Hardware 4
2.1 Optoelettronica . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.2 Meccanica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.3 Progetto elettronico . . . . . . . . . . . . . . . . . . . . . . . 5
2.4 Software embedded . . . . . . . . . . . . . . . . . . . . . . . . 6
3 Software 8
3.1 Raccolta dei dati dalla seriale . . . . . . . . . . . . . . . . . . 8
3.2 Rappresentazione della banconota . . . . . . . . . . . . . . . . 8
3.3 Labeling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
3.4 Salvataggio e caricamento dei dati raccolti . . . . . . . . . . . 9
3.5 La libreria libsvm . . . . . . . . . . . . . . . . . . . . . . . . . 10
3.6 Definizione delle Support Vector Machines . . . . . . . . . . . 11
3.7 Costruzione del Training Set . . . . . . . . . . . . . . . . . . . 12
3.8 Cross-validation . . . . . . . . . . . . . . . . . . . . . . . . . . 14
3.8.1 Il parametro γ . . . . . . . . . . . . . . . . . . . . . . 14
3.8.2 Il parametro C . . . . . . . . . . . . . . . . . . . . . . 15
3.8.3 Stima dei parametri con cross-validation . . . . . . . . 15
3.9 Learning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3.10 Test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
4 Risultati 19
4.1 Rappresentazione delle banconote . . . . . . . . . . . . . . . . 19
4.2 Risultati Sperimentali . . . . . . . . . . . . . . . . . . . . . . 20
4.3 Vincolo di inserimento delle banconote . . . . . . . . . . . . . 21
1
1 Introduzione
Il task da svolgere era inizialmente il riconoscimento di banconote, senza fo-
calizzare l’attenzione su problemi di verifica. Grazie all’hardware utilizzato,
peró, il sistema si é rivelato in grado di discriminare banconote false. In real-
tá, non avendo a disposizione delle banconote contraffatte da professionisti
per fare i test, questa supposizione si basa sulle prove effettuate con semplici
fotocopie di banconote.
2
3
2 Hardware
L’idea di base é quella di voler “leggere” una banconota. La lettura di tale
banconota viene fatta attraverso sensori di luce infrarossa. Utilizzando due
sensori ad infrarossi (uno sul lato destro e uno sul lato sinistro della bancono-
ta) e prelevando 60 campioni sulla lunghezza della banconota, si ottiene una
rappresentazione della banconota costituita da 120 numeri interi. L’utilizzo
della luce infrarossa permette di estrarre non solo l’informazione relativa al
colore della banconota, ma anche l’informazione relativa al tipo di carta uti-
lizzata per la stampa della banconota. É grazie a questo fatto che banconote
fotocopiate vengono facilmente identificate come false dal sistema.
2.1 Optoelettronica
Per prelevare i campioni ad infrarossi della banconota, sono stati utilizzati
componenti optoelettronici di basso costo, in particolare:
2.2 Meccanica
Per permettere il campionamento della banconota, quest’ultima deve essere
necessariamente trascinata sotto i sensori ad infrarossi. Per il trascinamento
é stato utilizzato un motore elettrico in corrente continua alimentato a 3V,
unitamente a un rullo di scorrimento prelevato da una vecchia stampante.
Com’é noto, i motori in continua lavorano molto velocemente, approssima-
tivamente intorno ai 10.000 giri/min. Tale velocitá é senza dubbio troppo
4
elevata per i nostri scopi, ed é quindi regolata grazie all’utilizzo di un mo-
toriduttore (due coppie di ingranaggi che modificano il rapporto di uscita a
256:1).
Il motore utilizzato assorbe una corrente di circa 0.8 A; per fornire tale cor-
rente é stato progettato un amplificatore di corrente con un transistor BJT,
come illustrato nel seguito.
R2
A=1+ ≈ 15 (1)
R3
Il che dovrebbe garantire un utilizzo dell’intero range convertibile dall’A-
DC: da 0 a 3.3V (tensione di alimentazione).
5
Come anticipato, per fornire al motore la corrente necessaria, é stato uti-
lizzato un transistor BJT NPN in grado di fornire fino a 0.8 A: il modello
BC337. Lo schema del circuito é illustrato in figura 2.3.
Una volta che il microcontrollore ha elaborato i dati, non resta che inviarli
al PC. Il collegamento con il PC avviene tramite la porta seriale; se la seria-
le non fosse disponibile sul computer, é possibile effettuare il collegamento
con una porta USB utilizzando un emulatore di porta seriale (RS232 - USB
converter). I livelli logici previsti dal protocollo RS232 non sono compatibili
con i livelli logici TTL-compatibili forniti dal controllore. Per questo é stato
utilizzato un componente elettronico la cui funzione é proprio quella di in-
terfacciare i due protocolli: si tratta del Maxim MAX232
. R
6
• Si attende che il sensore di presenza torni libero (ovvero, si attende che
la banconota sia trascinata sufficientemente in avanti affinché non sia
piú rilevata dal sensore di presenza)
7
3 Software
I dati prodotti dalla macchina vengono raccolti ed elaborati da un software in
esecuzione su un PC, scritto in linguaggio C#. In questo capitolo verranno
illustrate le varie parti del software, dalla lettura dei dati in arrivo sulla
seriale fino all’utilizzo degli algoritmi di Kernel Machines per classificare le
banconote date in pasto al sistema.
Il problema di riconoscimento delle banconote prevede una fase iniziale in
cui viene raccolto un quantitativo non definito di banconote: il training set.
Questi dati vengono quindi utilizzati nel processo di cross-validation, per
stimare buoni valori dei parametri in gioco. Quindi, si addestra il software
utilizzando i dati raccolti e i parametri definiti al passo precedente. A questo
punto non rimane che utilizzare il programma ai fini del riconoscimento.
8
che non é nient’altro che una lista di letture (per l’esattezza, 60 letture),
associato a un vettore di interi detto y (target), la cui utilitá diverrá chiara
nel seguito.
Quando un’intera banconota risulta acquisita, viene creato un oggetto di
questo tipo a partire dalla lista di letture “TempBanconota”, e memorizzato
nella variabile “lastbanconota”, che rappresenta il pattern. Quando questa
variabile é associata a un valore (ovvero, é diversa da null), é possibile utiliz-
zare questa informazione per fare il labeling della banconota stessa (il lavoro
del supervisor) oppure, se la fase di apprendimento é giá stata eseguita, si
puó richiedere di fare riconoscimento della banconota.
3.3 Labeling
Il labeling é il processo in cui un supervisore del sistema associa a ciascun
pattern il target desiderato. Nel nostro caso, il supervisore introduce nella
macchina un certo numero di esempi, indicando per ogni esempio la classe di
appartenenza (ovvero il taglio della banconota), cosí che la macchina riesca
ad apprendere il modello desiderato. L’interfaccia utente del software per-
mette, data una banconota, di specificare se si tratta di 5 EUR, 10 EUR, 20
EUR, 50 EUR, 100 EUR, Falso.
Supponiamo di aver appena acquisito una banconota: la variabile “lastban-
conota” é associata a un valore di tipo “banconota”. Supponiamo adesso di
cliccare sul tasto 20 EUR. Allora i target y relativi alla banconota vengono
impostati nel seguente modo:
y[0] = -1; //5 EUR
y[1] = -1; //10 EUR
y[2] = +1; //20 EUR
y[3] = -1; //50 EUR
y[4] = -1; //100 EUR
9
FileInfo f = new FileInfo(@"temp.dat");
FileStream s = f.Open(FileMode.OpenOrCreate, FileAccess.Write, FileShare.None);
BinaryFormatter b = new BinaryFormatter();
b.Serialize( s, banconote );
s.Close();
this.banconote = (List<banconota>)b.Deserialize(s);
s.Close();
10
3.6 Definizione delle Support Vector Machines
Per risolvere il problema é stato deciso di definire una SVM per ogni taglio
di banconote con cui si intende lavorare. Quindi, sono state definite 5 SVM,
ognuna delle quali si comporta come un classificatore binario. Tutte le SVM
lavorano sull’intero training set, ma con target adeguati al task che singo-
larmente deve essere svolto.
La libreria SVM é utilizzata in modo statico, quindi non é necessario defini-
re 5 istanze della classe. Sono stati definiti 5 problemi, ovvero training set
relativi a ciascun taglio di banconote:
private svm_problem []problem = new svm_problem[c];
11
Come illustrato nell’esempio (in cui i cerchietti sono elementi apparte-
nenti alla classe di interesse), il nuovo pattern (molto diverso dagli elementi
a cui la macchina é stata addestrata) verrebbe classificato come apparte-
nente alla stessa classe dei cerchi, pur non avendo niente in comune, data
la distanza. La propensione al verificarsi di simili situazioni é intuibilmente
molto alta in uno spazio 120-dimensionale, come nel nostro caso.
Queste situazioni non generano anomalie con l’utilizzo di kernel gaussiani,
in quanto la separazione non avviene in modo lineare, ma con curve chiu-
se. Cosí facendo, il pattern da classificare non potrebbe essere considerato
appartenente alla classe dei cerchi.
12
private void create_TrainSet(int k)
{
problem[k] = new svm_problem();
problem[k].x = new svm_node[l][];
problem[k].y = new double[l];
problem[k].l = l; //variabile globale
/* Attenzione:
* vogliamo che il problema k-esimo prenda come primo esempio
* un esempio in cui l’elemento appartiene alla classe in questione.
* quindi il primo esempio che mettiamo nel problema 0 (dei 5 euro)
* deve essere una banconota da 5 euro
*/
problem[k].x[j][i].index =
banconote.ElementAt(h).letture.ElementAt(s).indice;
problem[k].x[j][i+1].index =
banconote.ElementAt(h).letture.ElementAt(s).indice + 1;
problem[k].x[j][i].value_Renamed =
banconote.ElementAt(h).letture.ElementAt(s).sensore1;
problem[k].x[j][i+1].value_Renamed =
banconote.ElementAt(h).letture.ElementAt(s).sensore2;
problem[k].y[j] = banconote.ElementAt(h).y[k];
j++;
if (firstgoodex == h) h = -1;
}
}
13
3.8 Cross-validation
La cross-validation é una tecnica statistica che consiste nella suddivisione
del dataset totale in k parti e, ad ogni passo, la parte k-esima del dataset
viene ad essere il validation dataset, mentre la restante parte costituisce il
training dataset. Cosí, per ognuna delle k parti si allena il modello, evitan-
do quindi problemi di overfitting, ma anche di campionamento asimmetrico
del training dataset, tipico della suddivisione del dataset in due sole parti
(ovvero training e validation dataset).
Viene utilizzata per la stima dei migliori parametri C e γ evitando l’overfit-
ting.
É indispensabile per ottenere risposte significative dalle SVM; procedere per
tentativi di C e γ é una pratica assolutamente fallimentare, visto che i va-
lori sono strettamente correlati al particolare task da risolvere, e quindi non
predicibili. Cercare i valori ottimi per C e γ senza usare cross-validation, ma
semplicemente addestrando il classificatore con il training set e misurandone
le prestazioni sul test set (il dataset é in questo caso l’unione del training set e
del test set), porterebbe probabilmente a scegliere modelli in cui l’overfitting
la fa da padrone.
3.8.1 Il parametro γ
L’unico parametro che é possibile impostare relativamente ai kernel gaussiani
é il γ, che rappresenta l’inverso della varianza nelle curve gaussiane, come
evidente dall’espressione del kernel:
14
Scegliendo un piccolo valore di γ si ottiene il comportamento oppo-
sto: il software diverrebbe molto morbido nella classificazione dei pattern
in ingresso, dando risultati poco sensati.
3.8.2 Il parametro C
Il parametro C é utilizzato nella risoluzione del problema di ottimizzazione
vincolata, ed esprime la propensione della SVM a tollerare gli errori. La sua
introduzione é fondamentale in quanto permette la soluzione di problemi
i cui dati non sono linearmente separabili nello spazio delle features, una
situazione questa possibile perché
15
Dove i vettori C e γ sono
3.9 Learning
Ora che abbiamo i valori di C e γ adatti alla risoluzione del nostro problema,
non ci resta che usarli per addestrare la SVM.
model[i] = new svm_model();
model[i] = svm.svm_train(problem[i], param[i]);
Tale funzione viene usata per fare la predizione come illustrato nel pa-
ragrafo successivo. In realtá, il modello non lavora sull’intero training set,
ma solo sull’insieme dei support vector, ovvero quegli elementi che risultano
significativi per la definizione delle curve di separazione. Il calcolo puó essere
riscritto come
|S|
X
f (x) = αi yi K(xi , x) + b (6)
i=1
16
3.10 Test
Una volta finito l’apprendimento del training set, i modelli dei classifica-
tori sono pronti per essere usati. Con la seguente funzione una banconota
acquisita viene trasformata in un pattern nel formato atteso dal classificatore.
private svm_node[] BNtoPattern(banconota bn) {
pattern[i].index = bn.letture[j].indice;
pattern[i + 1].index = bn.letture[j].indice + 1;
pattern[i].value_Renamed = bn.letture[j].sensore1;
pattern[i + 1].value_Renamed = bn.letture[j].sensore2;
}
return pattern;
}
Quindi, tale pattern puó essere confrontato dal classificatore i-esimo con
la seguente istruzione
y[i] = svm.svm_predict(model[i], pattern);
17
accettata e riconosciuta come appartenente alla categoria j-esima se e solo
se
∃ ! y[j] > 0
(7)
y[h] ≤ 0 ∀h 6= j
18
4 Risultati
Data la semplicitá della macchina dal punto di vista sia dell’elettronica, sia
della meccanica (basata su componenti di basso costo e componenti riciclati),
i risultati ottenuti sono assolutamente rispettabili.
19
4.2 Risultati Sperimentali
Le prime prove di classificazione sono state eseguite facendo learning su un
training set costituito da 50 esempi, 10 per ogni taglio di banconota. Il
sistema funzionava bene eseguendo i test con le banconote appartenenti al
training set, mentre utilizzando banconote non appartenenti al training set
si verificavano delle classificazioni errate. Giá con un training set doppio le
prestazioni si sono rivelate significativamente migliori.
Provando ad inserire un falso, questo viene scambiato per una banconota
reale. Facendo learning con il falso nel training set, questo comportamento
non si verifica piú. Questo significa che le curve di separazione sono troppo
ampie, e si dovrebbe aumentare γ per ridurle. Quest’operazione peró, se la
macchina non é abbastanza precisa, porterebbe a rifiutare anche banconote
autentiche, in quanto le rappresentazioni di banconote dello stesso taglio nel
training set differiscono tra loro.
γ C
5 EUR 2−13 512
10 EUR 2−13 512
20 EUR 2−13 8192
50 EUR 2−13 512
100 EUR 2−13 512
I valori di γ sono sempre molto piccoli, il che significa che le curve di
separazione sono piuttosto grandi. Questo ci permette di asserire che la
macchina non é sufficientemente precisa: rappresentazioni della stessa ban-
conota sono distanti tra loro e la SVM é costretta ad allargare le superfici
di separazione per generalizzare. Invece, i valori di C sono molto alti: per lo
20
stesso motivo illustrato, potrebbe significare che data la diversitá di pattern
relativi ad una stessa categoria, la SVM tende a fare molti errori, per cui C
viene innalzato per costringerla a non tollerarli.
21
22
5 Conclusioni e sviluppi futuri
5.1 Conclusioni
Il riconoscimento e talvolta la verifica di banconote é un problema con cui
abbiamo a che fare quotidianamente. L’uomo fa riconoscimento principal-
mente utilizzando la vista, mentre per la verifica utilizza anche il senso del
tatto. In poche parole, la quantitá di informazione utilizzata dall’uomo per
risolvere questo problema é enorme se paragonata a quella che é sufficien-
te per questo riconoscitore automatico. La macchina infatti si basa su 120
numeri per ogni banconota; il problema del riconoscimento basato su rappre-
sentazioni numeriche di questo tipo é improponibile per l’uomo. Chi svolge
meglio questa operazione?
Possiamo concludere che data l’imprecisione della macchina (che porta ad
avere rappresentazioni della stessa banconota piuttosto lontane spazialmen-
te) si riesce bene a fare riconoscimento solo nel caso in cui le banconote
vengano inserite di testa, e quindi che la SVM sia in grado di fare grande ge-
neralizzazione (basso valore di γ). La verifica dell’autenticitá delle banconote
risulta un task difficile proprio a causa dei bassi valori di γ. Il riconoscimento
di banconote inserite in qualsiasi modo non é trattabile, proprio perché que-
sto task puó essere risolto stringendo molto le curve di separazione, soluzione
questa che rende praticamente nulla la generalizzazione, e conseguentemente
molto rara l’accettazione di banconote autentiche.
23
Applicando le modifiche illustrate la macchine diverrebbe molto piú preci-
sa rispetto allo stato attuale. In questo scenario le rappresentazioni delle
banconote dello stesso taglio sarebbero molto simili tra loro (i grafici visti
al capitolo 4.1 sarebbero molto piú puliti), conseguentemente si potrebbero
stringere maggiormente le curve di separazione attorno agli addensamenti
di esempi (aumentando il valore di γ). Questo si traduce in una maggiore
accuratezza delle predizioni e in una maggiore capacitá di riconoscere falsi.
24
A Appendice: Codice in linguaggio C del Software
Embedded
//*************************************************
// Author: Rossinelli Emanuele
// Author Contact: erossinelli@tiscali.it
// Project Start Date: 16 Dec 2010
// Last Modify Date: 14 Jan 2011
// SVMBanconote Firmware
// PicMicro (R): PIC24F04K201
// Clock: 8MHz (High Frequency Internal Oscillator)
// Data Packet: * sensore1 - sensore2 - #progressivo *
//*************************************************
#include <htc.h>
#include <stdlib.h>
#include <string.h>
#include "usart.c"
#include "mydelay.c"
// Fuses di configurazione
__CONFIG(FWDT, WDTDIS); //Watchdog disabled
__CONFIG(FGS, GWRPU); //Unprotected
/* COSTANTI */
#define SENSOR_VOID 250 //minimo valore dei sensori a vuoto
#define N_CAMPIONI 60
/* Variabili Globali */
int mode = 0;
/* 0: attesa della banconota 1: capturing 2: espulsione */
int nlettura = 0;
if( input == 2 ){
if( input == 3 ){
if( input == 4 ){
25
int value = 0;
SettingADC( input );
//reading adc
AD1CON1bits.ADON = 1;
DelayBigMs( 50 );
while(AD1CON1bits.DONE != 1) ;
value = ADC1BUF0;
AD1CON1bits.ADON = 0;
return value;
}
void main(void)
{
//Output port
TRISB &= 0b1111111111111110;
//Enable UART TX
U1STAbits.UTXEN = 1;
//Select the analog conversion clock to match the desired data rate
AD1CON3 = 0b0001111100000000; //Clock: Tcy/2
AD1CSSL = 0b0000000000000000;
AD1PCFG = 0b0000000000000000;
26
T1CONbits.TGATE = 0;
T1CONbits.TCKPS = 0b11; //set prescaler 1:256 ==> 1 oscill / 64u
T1CONbits.TSYNC = 0;
} // End main
//start packet
pacchetto[i++] = ’*’;
//sens1
itoa( buffer, sens1 );
tmp = strlen(buffer);
i += tmp;
strncat( pacchetto, buffer, tmp );
//boundary
pacchetto[i++] = ’-’;
//sens2
itoa( buffer, sens2 );
tmp = strlen(buffer);
i += tmp;
strncat( pacchetto, buffer, tmp );
//boundary
pacchetto[i++] = ’-’;
//nletture
itoa( buffer, nlett );
tmp = strlen(buffer);
i += tmp;
strncat( pacchetto, buffer, tmp );
//end packet
pacchetto[i++] = ’*’;
pacchetto[i] = ’\0’;
uart_putstring( pacchetto );
27
}
//INTERRUPT ROUTINE
void interrupt ISR( void ) @ T1_VCTR
{
if( IFS0bits.T1IF == 1 ){
//Logica
if( mode == 0 )
{
//accendi motori
PORTAbits.RA6 = 1;
}
}
if( mode == 1 )
{
//siamo in capture mode
sens1 = ReadingADC( 2 );
sens2 = ReadingADC( 3 );
//invia pacchetto
SendPacket( sens1, sens2, nlettura );
//abbiamo finito?
if( nlettura == N_CAMPIONI )
{
//vogliamo assicuriarci di aver espulso la banconota
mode = 2;
}
}
}
if( mode == 2 ){
28
sens0 = ReadingADC( 4 );
//spegni motori
PORTAbits.RA6 = 0;
}
}
29
Riferimenti bibliografici
[1] P. Priami A. Frosini, M. Gori, “A neural network-based model for paper
currency recognition and verification,” IEEE Transactions on Neural
Networks, Vol. 7, No. 6, 1996.
30