svmbanconote

8/7/2019 SVMBanconote

1/31

Universita degli Studi di Siena

Facolta di Ingegneria dell Informazione

SVM Banconote

Rossinelli Emanuele

Anno Accademico 2010/2011


2/31

Indice

1 Introduzione 2

2 Hardware 4

2.1 Optoelettronica . . . . . . . . . . . . . . . . . . . . . . . . . . 42.2 Meccanica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42.3 Progetto elettronico . . . . . . . . . . . . . . . . . . . . . . . 52.4 Software embedded . . . . . . . . . . . . . . . . . . . . . . . . 6

3 Software 8

3.1 Raccolta dei dati dalla seriale . . . . . . . . . . . . . . . . . . 83.2 Rappresentazione della banconota . . . . . . . . . . . . . . . . 83.3 Labeling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93.4 Salvataggio e caricamento dei dati raccolti . . . . . . . . . . . 93.5 La libreria libsvm . . . . . . . . . . . . . . . . . . . . . . . . . 103.6 Definizione delle Support Vector Machines . . . . . . . . . . . 113.7 Costruzione del Training Set . . . . . . . . . . . . . . . . . . . 123.8 Cross-validation . . . . . . . . . . . . . . . . . . . . . . . . . . 14

3.8.1 Il parametro . . . . . . . . . . . . . . . . . . . . . . 143.8.2 Il parametro C . . . . . . . . . . . . . . . . . . . . . . 153.8.3 Stima dei parametri con cross-validation . . . . . . . . 15

3.9 Learning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163.10 Test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

4 Risultati 19

4.1 Rappresentazione delle banconote . . . . . . . . . . . . . . . . 194.2 Risultati Sperimentali . . . . . . . . . . . . . . . . . . . . . . 204.3 Vincolo di inserimento delle banconote . . . . . . . . . . . . . 21

5 Conclusioni e sviluppi futuri 23

5.1 Conclusioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235.2 Sviluppi Futuri . . . . . . . . . . . . . . . . . . . . . . . . . . 23

A Appendice: Codice in linguaggio C del Software Embedded

25

1


3/31

1 Introduzione

Il task da svolgere era inizialmente il riconoscimento di banconote, senza fo-calizzare lattenzione su problemi di verifica. Grazie allhardware utilizzato,per, il sistema si rivelato in grado di discriminare banconote false. In real-t, non avendo a disposizione delle banconote contraffatte da professionistiper fare i test, questa supposizione si basa sulle prove effettuate con semplicifotocopie di banconote.

A causa della difficile reperibilit di numerose banconote da 200 e da 500Euro, la macchina stata progettata per riconoscere solamente i tagli da 5,10, 20, 50 e 100 Euro. Ad ogni modo, bastano poche modifiche al software

SVM per estendere il funzionamento alle banconote di tagli superiori, o piin generale, a sistemi di monetazione totalmente differenti da quello preso inesame. Diciamo, quindi, che si tratta di una macchina general purpose.

La progettazione della macchina si articolata in quattro fasi:

progettazione e sviluppo della parte elettronica;

progettazione e sviluppo della parte meccanica;

progettazione e sviluppo della parte informatica embedded;

progettazione e sviluppo della parte informatica riguardante lintelli-genza artificiale.

Ovviamente le diverse fasi non sono indipendenti, ma strettamente cor-relate luna allaltra. Una modifica nella parte meccanica comporta verosi-milmente cambiamenti nelle parti elettronica e/o informatica. Nel seguitonon verr data grande importanza alla parte meccanica, che verr illustratainsieme alla parte elettronica e alla parte informatica lato embedded, nelcapitolo Hardware.

2


4/31

3


5/31

2 Hardware

Lidea di base quella di voler leggere una banconota. La lettura di talebanconota viene fatta attraverso sensori di luce infrarossa. Utilizzando duesensori ad infrarossi (uno sul lato destro e uno sul lato sinistro della bancono-ta) e prelevando 60 campioni sulla lunghezza della banconota, si ottiene unarappresentazione della banconota costituita da 120 numeri interi. Lutilizzodella luce infrarossa permette di estrarre non solo linformazione relativa alcolore della banconota, ma anche linformazione relativa al tipo di carta uti-lizzata per la stampa della banconota. grazie a questo fatto che banconotefotocopiate vengono facilmente identificate come false dal sistema.

2.1 Optoelettronica

Per prelevare i campioni ad infrarossi della banconota, sono stati utilizzaticomponenti optoelettronici di basso costo, in particolare:

LED ad emissione infrarossa modello Vishay TSAL7600;

Fotodiodo rilevatore di luce infrarossa modello Optek OP999.

I due componenti vengono montati uno davanti allaltro, in modo chela corrente diretta passante sul fotodiodo sia proporzionale alla quantitdi radiazione infrarossa captata, a causa appunto dellemissione del LED.

Inserendo ora una banconota tra il LED e il fotodiodo, il fascio di infrarossiriesce ancora a passare e a raggiungere il rilevatore, ma con unintensitmolto minore, in funzione delle caratteristiche della banconota nel punto incui c passaggio di luce. immediato rendersi conto che amplificando tale segnale e utilizzando ilmodulo ADC (convertitore analogico digitale) di un microcontrollore, sarsemplice ottenere informazioni significative riguardo alla banconota inserita.Sono state usate due coppie Led-Fotodiodo per la lettura della banconota(dora in avanti chiamate sensori di lettura), e unulteriore coppia per rilevarelinserimento della banconota stessa (dora in avanti chiamata sensore dipresenza), cos da poter conoscere listante in cui avviare i motori che si

occuperanno del trascinamento.

2.2 Meccanica

Per permettere il campionamento della banconota, questultima deve esserenecessariamente 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


6/31

elevata per i nostri scopi, ed quindi regolata grazie allutilizzo di un mo-

toriduttore (due coppie di ingranaggi che modificano il rapporto di uscita a256: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.

2.3 Progetto elettronico

Come abbiamo illustrato, il progetto si compone di due sensori di lettura edi un sensore di presenza. I valori dei corrispondenti fotodiodi vengono lettimediante una conversione analogico-digitale, effettuata dal microcontrollore

installato, un PICmicroR

PIC24F04KA201 della Microchip. Il programmaeseguito dal microcontrollore descritto nel capitolo successivo. Per il mo-mento basti sapere che utilizzato per effettuare le letture dei sensori (conlADC), per gestire la temporizzazione (attraverso un timer), per comandareil motore e per inviare dati al PC collegato mediante porta seriale/USB.

Lo schema seguente illustra il funzionamento di ciascuna coppia led-fotodiodo.

La resistenza R4, nel circuito trasmettente, serve per limitare la corren-te sul diodo led, e quindi per evitare la rottura dello stesso. La radiazioneinfrarossa trasmessa viene captata dal fotodiodo OP999 nel cirucito riceven-

te: la corrente che scorre su tale diodo sar proporzionale alla quantit diluce che irradia il componente. Per prelevare una differenza di potenzialeproporzionale a tale corrente stata inserita la resistenza R1. Tale tensioneviene inviata allamplificatore operazionale X1, montato in configurazionenon invertente con guadagno

A = 1 +R2

R3 15 (1)

Il che dovrebbe garantire un utilizzo dellintero range convertibile dallA-DC: da 0 a 3.3V (tensione di alimentazione).

5


7/31

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 modelloBC337. Lo schema del circuito illustrato in figura 2.3.

Il componente X1 rappresenta il motore, mentre il diodo D1 ha funzioniprotettive: impedisce alla tensione di flyback di distruggere il transistor.

Una volta che il microcontrollore ha elaborato i dati, non resta che inviarlial PC. Il collegamento con il PC avviene tramite la porta seriale; se la seria-le non fosse disponibile sul computer, possibile effettuare il collegamentocon una porta USB utilizzando un emulatore di porta seriale (RS232 - USBconverter). I livelli logici previsti dal protocollo RS232 non sono compatibili

con i livelli logici TTL-compatibili forniti dal controllore. Per questo statoutilizzato un componente elettronico la cui funzione proprio quella di in-terfacciare i due protocolli: si tratta del Maxim MAX232 R.

Non resta che esaminare la parte software del progetto.

2.4 Software embedded

Possiamo schematizzare il funzionamento della macchina nei seguenti passi:

La banconota viene inserita nella macchina e rilevata dal sensore di

presenza; Il motore viene avviato, per iniziare il processo di trascinamento;

Non appena la banconota si trova per la prima volta sotto ai sensoridi lettura, si entra nella modalit di cattura;

Ad ogni interrupt sollevato dal timer si prelevano valori dei sensori dilettura dallADC e si inviano al PC tramite lUART;

Sollevati 60 interrupt come appena descritto, la lettura terminata;

6


8/31

Si attende che il sensore di presenza torni libero (ovvero, si attende che

la banconota sia trascinata sufficientemente in avanti affinch non siapi rilevata dal sensore di presenza)

Si attende un breve intervallo di tempo fissato, per permettere allabanconota di essere espulsa;

Il motore viene spento.

Data la semplicit del programma eseguito dal microcontrollore, che so-stanzialmente realizza i passi appena descritti, evitiamo di commentarlo erimandiamo il lettore a prendere visione del codice in appendice.Come abbiamo gi accennato, una banconota viene rappresentata con 60

valori dei due sensori di lettura. Ogni volta che sono disponibili nuovi valoridei due sensori, questi vengono inviati sulla seriale utilizzando il seguenteprotocollo:

PIC UART: * sens1 - sens2 - lettura *

dove sens1 e sens2 rappresentano i valori numerici (compresi tra 0 e 1023)corrispondenti ai sensori di lettura, e lettura un numero progressivo da 1a 60. Questultimo parametro non indispensabile, ma pu essere usato pereseguire un controllo di integrit dei dati ricevuti sul computer. I caratteriasterisco servono per identificare linizio e la fine di ogni pacchetto, mentre

il carattere meno serve per separare i valori numerici da inviare.

7


9/31

3 Software

I dati prodotti dalla macchina vengono raccolti ed elaborati da un software inesecuzione su un PC, scritto in linguaggio C#. In questo capitolo verrannoillustrate le varie parti del software, dalla lettura dei dati in arrivo sullaseriale fino allutilizzo degli algoritmi di Kernel Machines per classificare lebanconote date in pasto al sistema.Il problema di riconoscimento delle banconote prevede una fase iniziale incui viene raccolto un quantitativo non definito di banconote: il training set.Questi dati vengono quindi utilizzati nel processo di cross-validation, perstimare buoni valori dei parametri in gioco. Quindi, si addestra il softwareutilizzando i dati raccolti e i parametri definiti al passo precedente. A questo

punto non rimane che utilizzare il programma ai fini del riconoscimento.

3.1 Raccolta dei dati dalla seriale

Allavvio del software, necessario specificare su quale porta seriale col-legata la macchina. Quindi, connettersi al dispositivo. Da ora in avanti ilsoftware sempre in ascolto su questa porta, in attesa di dati da processare.Lelaborazione dei dati ricevuti viene fatta da un thread apposito, che la-vora in background. In particolare, i pacchetti (come illustrato nel capitolo2.4) vengono analizzati e, se non presentano anomalie, vengono trasforma-ti in un oggetto di tipo lettura, che rappresenta li-esima parte dellinterabanconota, per i = 1, 2, ..., 60.

struct lettura{

public int sensore1;

public int sensore2;

public int indice;};

Linsieme delle letture viene memorizzato in una lista cos definita:

private List TempBanconota = new List();

Quando questa lista raggiunge 60 elementi, lintera banconota stataacquisita, e pu essere quindi creato loggetto banconota (il pattern), come

descritto nella sezione successiva.

3.2 Rappresentazione della banconota

Una banconota rappresentata da un oggetto di tipo banconota, definitocome segue:

struct banconota

{public List letture;

public int[] y;

};

8


10/31

che non nientaltro che una lista di letture (per lesattezza, 60 letture),

associato a un vettore di interi detto y (target), la cui utilit diverr chiaranel seguito.Quando unintera banconota risulta acquisita, viene creato un oggetto diquesto tipo a partire dalla lista di letture TempBanconota, e memorizzatonella variabile lastbanconota, che rappresenta il pattern. Quando questavariabile associata a un valore (ovvero, diversa da null), possibile utiliz-zare questa informazione per fare il labeling della banconota stessa (il lavorodel supervisor) oppure, se la fase di apprendimento gi stata eseguita, sipu richiedere di fare riconoscimento della banconota.

3.3 Labeling

Il labeling il processo in cui un supervisore del sistema associa a ciascunpattern il target desiderato. Nel nostro caso, il supervisore introduce nellamacchina un certo numero di esempi, indicando per ogni esempio la classe diappartenenza (ovvero il taglio della banconota), cos che la macchina riescaad apprendere il modello desiderato. Linterfaccia utente del software per-mette, data una banconota, di specificare se si tratta di 5 EUR, 10 EUR, 20EUR, 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 dicliccare sul tasto 20 EUR. Allora i target y relativi alla banconota vengono

impostati nel seguente modo:y[0] = -1; //5 EURy[1] = -1; //10 EUR

y[2] = +1; //20 EUR

y[3] = -1; //50 EURy[4] = -1; //100 EUR

Se la banconota acquisita viene etichettata come un falso, tutti i targetvengono messi a -1.Ogni nuova banconota acquisita ed etichettata viene aggiunta ad una listadi banconote mantenuta in memoria con la seguente struttura:

private List banconote = new List();

3.4 Salvataggio e caricamento dei dati raccolti

Per permettere allutente di aggiugere nuovi pattern etichettati allelencodi banconote acquisite in qualsiasi momento, previsto il salvataggio e ilcaricamento della lista banconote. Questo risultato si ottiene facilmentedichiarando le struct sopra illustrate con lattributo [Serializable]. In questomodo, possibile utilizzare la serializzabilit degli oggetti, in combinazionecon la classe BinaryFormatter:

9


11/31

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();

Analogamente, il caricamento dei dati salvati si traduce nelle seguentirighe di codice:

FileInfo f = new FileInfo(@"temp.dat");

FileStream s = f.Open(FileMode.Open, FileAccess.Read, FileShare.None);BinaryFormatter b = new BinaryFormatter();

this.banconote = (List)b.Deserialize(s);

s.Close();

3.5 La libreria libsvm

LIBSVM una libreria sviluppata per utilizzare gli algoritmi di intelligenzaartificiale relativi alle Support Vector Machines, che disponibile anche inlinguaggio C#. La libreria si compone delle seguenti strutture:

svm_parameter: rappresenta i parametri utilizzati dalla SVM perlapprendimento, come C, e il tipo di kernel;

svm_problem: rappresenta il training set del problema che vogliamorisolvere;

svm_node: rappresenta ciascun elemento del pattern, ed costituitoda un valore intero x (la lettura del sensore nel nostro caso) e un valoreintero index (il numero progressivo di lettura);

svm_model: rappresenta il modello prodotto dalla fase di learningdella SVM.

e viene usata tramite le seguenti funzioni:

svm_cross_validation: funzione utilizzata per ottenere la stima deiparametri mediante cross-validation;

svm_train: esegue il learning sui dati del training set e restituisce ilmodello svm_model.

10


12/31


13/31

Come illustrato nellesempio (in cui i cerchietti sono elementi apparte-nenti alla classe di interesse), il nuovo pattern (molto diverso dagli elementia cui la macchina stata addestrata) verrebbe classificato come apparte-nente alla stessa classe dei cerchi, pur non avendo niente in comune, datala distanza. La propensione al verificarsi di simili situazioni intuibilmentemolto alta in uno spazio 120-dimensionale, come nel nostro caso.Queste situazioni non generano anomalie con lutilizzo 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 consideratoappartenente alla classe dei cerchi.

3.7 Costruzione del Training Set

Come abbiamo visto, la libreria SVM esegue il learning a partire da un ogget-to di tipo svm_problem. Per questioni pratiche, le banconote che vengonoacquisite o caricate da un file sono memorizzate nella lista banconote. Lafunzione illustrata di seguito costruisce il svm_problem i-esimo a partiredalla lista banconote.Per poter trattare tutti i problemi allo stesso modo, dobbiamo inserire co-me primo pattern nel problema i-esimo un pattern appartenente alla classein questione. Questo necessario perch internamente la libreria libsvm sicostruisce una lista di target (nel nostro caso 1 e -1) man mano che li trovanel problema.

12


14/31

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 lelemento appartiene alla classe in questione.

* quindi il primo esempio che mettiamo nel problema 0 (dei 5 euro)* deve essere una banconota da 5 euro

*/

bool firsttime = true;int firstgoodex = -1;

for (int j = 0, h = 0; h < l; h++){

if (firsttime == false &&

firstgoodex == h) continue;

if (firsttime == true &&

banconote.ElementAt(h).y[k] == -1) continue;

else if(firsttime==true){firsttime = false;

firstgoodex = h;

}

problem[k].x[j] = new svm_node[n];

for (int i = 0, s = 0; i < n; i+=2, ++s)

{problem[k].x[j][i] = new svm_node();

problem[k].x[j][i+1] = new svm_node();

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;

}}

Alla fine della procedura il svm_problem k-esimo stato creato. Inparticolare x rappresenta linsieme degli esempi, y rappresenta linsieme deitarget (per ciascun esempio), ed l rappresenta il numero totale di esempi.

13


15/31

3.8 Cross-validation

La cross-validation una tecnica statistica che consiste nella suddivisionedel dataset totale in k parti e, ad ogni passo, la parte k-esima del datasetviene ad essere il validation dataset, mentre la restante parte costituisce iltraining dataset. Cos, per ognuna delle k parti si allena il modello, evitan-do quindi problemi di overfitting, ma anche di campionamento asimmetricodel 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 loverfit-ting. indispensabile per ottenere risposte significative dalle SVM; procedere pertentativi di C e una pratica assolutamente fallimentare, visto che i va-lori sono strettamente correlati al particolare task da risolvere, e quindi nonpredicibili. Cercare i valori ottimi per C e senza usare cross-validation, masemplicemente addestrando il classificatore con il training set e misurandonele prestazioni sul test set (il dataset in questo caso lunione del training set edel test set), porterebbe probabilmente a scegliere modelli in cui loverfittingla fa da padrone.

3.8.1 Il parametro

Lunico parametro che possibile impostare relativamente ai kernel gaussiani il , che rappresenta linverso della varianza nelle curve gaussiane, come

evidente dallespressione del kernel:

K(xi, xj) = e||xixj ||

2

= e||xixj ||

2

22 (2)

In particolare, tanto pi grande il valore di e tanto pi piccole sonole curve di separazione. Quindi aumentando si chiede alla SVM di esse-re molto selettiva, con conseguente minor generalizzazione. Avere curve diseparazione piccole si traduce in un vantaggio dal punto di vista della nonaccettazione di falsi e della errata classificazione: le SVM tenderanno a darerisposte positive solo se il pattern molto simile agli elementi della stessaclasse appresi durante il learning. Per contro, data lalta imprecisione della

nostra macchina (a causa dellhardware di basso costo), scegliere un ecces-sivamente grande porterebbe ad un difficile riconoscimento delle banconote.Il software tenderebbe a non accettare la maggior parte delle banconote.

14


16/31

Scegliendo un piccolo valore di si ottiene il comportamento oppo-sto: il software diverrebbe molto morbido nella classificazione dei patternin ingresso, dando risultati poco sensati.

3.8.2 Il parametro C

Il parametro C utilizzato nella risoluzione del problema di ottimizzazionevincolata, ed esprime la propensione della SVM a tollerare gli errori. La suaintroduzione fondamentale in quanto permette la soluzione di problemii cui dati non sono linearmente separabili nello spazio delle features, unasituazione questa possibile perch

non possiamo essere sicuri che il kernel utilizzato riesca effettivamentea separare linearmente i dati;

non possiamo escludere errori durante il labeling dei pattern da partedel supervisore.

Maggiore il valore di C, minore la tolleranza agli errori, conseguente-mente la SVM commetter un basso numero di errori, a discapito per dellageneralizzazione.

3.8.3 Stima dei parametri con cross-validation

Come stato illustrato, utilizzare buoni valori per i parametri di fondamen-tale importanza per ottenere risultati soddisfacenti. La stima dei parametri

avviene secondo il seguente schema (grid search):

1. Per ogni coppia (Ci, j), i=1, 2, .. |C| , j = 1, 2, .. ||

(a) Cross-validation sul dataset utilizzando la coppia (Ci, j)

(b) Valutazione della percentuale di errori commessi dal modello

2. Salvataggio della coppia (Ch, k) per cui la percentuale di errori com-messi minima.

15


17/31

Dove i vettori C e sono

C= {25, 23, 21, 2, 23, 25, 27, 29, 211, 213} (3)

= {215, 213, 211, 29, 27, 25, 23, 21, 2, 22} (4)

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]);

Per ogni problema viene creato un modello, ovvero il classificatore veroe proprio. Tale modello sintetizza la soluzione calcolata dal problema diottimizzazione vincolata con lapproccio Lagrangiano, ovvero i coefficientii presenti nella funzione

f(x) =l

i=1

iyiK(xi, x) + b (5)

Tale funzione viene usata per fare la predizione come illustrato nel pa-ragrafo successivo. In realt, il modello non lavora sullintero training set,

ma solo sullinsieme dei support vector, ovvero quegli elementi che risultanosignificativi per la definizione delle curve di separazione. Il calcolo pu essereriscritto come

f(x) =

|S|i=1

iyiK(xi, x) + b (6)

dove S rappresenta linsieme dei vettori di supporto.

16


18/31

3.10 Test

Una volta finito lapprendimento del training set, i modelli dei classifica-tori sono pronti per essere usati. Con la seguente funzione una banconotaacquisita viene trasformata in un pattern nel formato atteso dal classificatore.

private svm_node[] BNtoPattern(banconota bn) {

svm_node[] pattern = new svm_node[n];

for (int i = 0, j = 0; i < n; i += 2, ++j)

{pattern[i] = new svm_node();

pattern[i + 1] = new svm_node();

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 conla seguente istruzione

y[i] = svm.svm_predict(model[i], pattern);

y[i] un valore numerico compreso tra -1 e 1. Tanto pi tale valore vicino a 1, e tanto pi alta la confidenza per cui il pattern appartiene allacategoria i-esima. Calcolati quindi y[i] i = 1, 2, 3, 4, 5, la banconota viene

17


19/31

accettata e riconosciuta come appartenente alla categoria j-esima se e solo

se ! y[j] > 0y[h] 0 h = j

(7)

18


20/31

4 Risultati

Data la semplicit della macchina dal punto di vista sia dellelettronica, siadella meccanica (basata su componenti di basso costo e componenti riciclati),i risultati ottenuti sono assolutamente rispettabili.

4.1 Rappresentazione delle banconote

Per valutare la precisione della macchina, sono state fatte delle prove inse-rendo pi volte la stessa banconota e comprando le diverse rappresentazioniottenute. Si vede che le rappresentazioni di una stessa banconota sono moltisimili tra loro, ma molto diverse dalle rappresentazioni di banconote differen-ti. Questo un indizio della possibilit di risolvere con successo il problemadel riconoscimento.

19


21/31

4.2 Risultati Sperimentali

Le prime prove di classificazione sono state eseguite facendo learning su untraining set costituito da 50 esempi, 10 per ogni taglio di banconota. Ilsistema funzionava bene eseguendo i test con le banconote appartenenti altraining set, mentre utilizzando banconote non appartenenti al training setsi verificavano delle classificazioni errate. Gi con un training set doppio leprestazioni si sono rivelate significativamente migliori.Provando ad inserire un falso, questo viene scambiato per una banconotareale. Facendo learning con il falso nel training set, questo comportamentonon si verifica pi. Questo significa che le curve di separazione sono troppoampie, e si dovrebbe aumentare per ridurle. Questoperazione per, se lamacchina non abbastanza precisa, porterebbe a rifiutare anche banconoteautentiche, in quanto le rappresentazioni di banconote dello stesso taglio neltraining set differiscono tra loro.

I valori dei parametri stimati con cross-validation sono stati leggermentemodificati in modo manuale (fase di tuning), ottenendo le coppie:

C5 EUR 213 51210 EUR 213 51220 EUR 213 819250 EUR 213 512100 EUR 213 512

I valori di sono sempre molto piccoli, il che significa che le curve diseparazione sono piuttosto grandi. Questo ci permette di asserire che lamacchina non sufficientemente precisa: rappresentazioni della stessa ban-conota sono distanti tra loro e la SVM costretta ad allargare le superficidi separazione per generalizzare. Invece, i valori di C sono molto alti: per lo

20


22/31

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 Cviene innalzato per costringerla a non tollerarli.

Le prestazioni della macchina, utilizzando i valori di C e illustrati, possonoessere riassunte come segue:

Percentuale di classificazioni errate (banconote scambiate): 0.03%

Percentuale di banconote autentiche non accettate: 10%

Percentuale di banconote false accettate: 0.01%

Lalta percentuale di banconote autentiche non accettate non preoccu-pa, in quanto il reinserimento della banconota porta quasi sempre ad unriconoscimento corretto.

4.3 Vincolo di inserimento delle banconote

Come ultima prova, sono state incluse nel training set banconote inserite nel-la macchina nei quattro modi possibili, e non solamente con inserimento ditesta. I valori di stimati con cross-validation sono risultati molto maggioririspetto al caso precedente. I risultati sono stati tragici: la macchina nonera pi in grado di riconoscere le banconote, task che svolgeva egregiamente

prima di inserire nel training set esempi di banconote inserite in qualsiasiverso.Questo calo di prestazioni ragionevole, in quanto separare le diverse classirisulta ovviamente pi difficile visto che ogni banconota pu essere rappre-sentata in quattro modi diversi, a seconda di come viene inserita. Non solo lecurve di separazione di ciascuna categoria devono essere suddivise in quattrosuperfici di separazione distinte, ma potrebbero avvicinarsi pericolosamentealle curve delle altre categorie. A dimostrazione di questo ci sono i valori di stimati con cross-validation, molto alti, che portano le superfici di separa-zione ad essere molto strette, perdendo generalizzazione.Inoltre laccuracy calcolata con la cross-validation ha dato valori pi bassi

rispetto al caso precedente (siamo passati dal 95% circa al 80%), quindi laseparazione difficile da ottenere. In realt con kernel gaussiani si riescesempre a separare, ma si fa overfitting, e questo dimostrato anche daglialti valori di .

21


23/31

22


24/31

5 Conclusioni e sviluppi futuri

5.1 Conclusioni

Il riconoscimento e talvolta la verifica di banconote un problema con cuiabbiamo a che fare quotidianamente. Luomo fa riconoscimento principal-mente utilizzando la vista, mentre per la verifica utilizza anche il senso deltatto. In poche parole, la quantit di informazione utilizzata dalluomo perrisolvere questo problema enorme se paragonata a quella che sufficien-te per questo riconoscitore automatico. La macchina infatti si basa su 120numeri per ogni banconota; il problema del riconoscimento basato su rappre-sentazioni numeriche di questo tipo improponibile per luomo. Chi svolgemeglio questa operazione?Possiamo concludere che data limprecisione della macchina (che porta adavere rappresentazioni della stessa banconota piuttosto lontane spazialmen-te) si riesce bene a fare riconoscimento solo nel caso in cui le banconotevengano inserite di testa, e quindi che la SVM sia in grado di fare grande ge-neralizzazione (basso valore di ). La verifica dellautenticit delle banconoterisulta un task difficile proprio a causa dei bassi valori di . Il riconoscimentodi banconote inserite in qualsiasi modo non trattabile, proprio perch que-sto task pu essere risolto stringendo molto le curve di separazione, soluzionequesta che rende praticamente nulla la generalizzazione, e conseguentementemolto rara laccettazione di banconote autentiche.

5.2 Sviluppi Futuri

Al fine di ottenere prestazioni migliori possibile effettuare alcune modifichealla macchina.

Creare un sistema che allinea la banconota inserita sul lato sinistro;

Aumentare la precisione dello scorrimento, utilizzando motori passo-passo;

Montare un rullo di scorrimento dopo i sensori di lettura, per trasci-nare completamente la banconota: in questo modo si riesce ad inserire

implicitamente nella rappresentazione della banconota linformazionerelativa alla sua lunghezza (i sensori eseguiranno un numero di letturea vuoto proporzionale allinverso della lunghezza).

Aumentare il numero di campioni o il range numerico dei valori ottenutidalla lettura dei sensori porterebbe probabilmente ad avere un modello conmaggiore complessit senza trarre benefici significativi. Lo spazio delle fea-tures diverrebbe troppo grande, e i dati dovrebbero essere sottoposti ad unaoperazione di scaling per diminuire il tempo di calcolo necessario.

23


25/31

Applicando le modifiche illustrate la macchine diverrebbe molto pi preci-

sa rispetto allo stato attuale. In questo scenario le rappresentazioni dellebanconote dello stesso taglio sarebbero molto simili tra loro (i grafici vistial capitolo 4.1 sarebbero molto pi puliti), conseguentemente si potrebberostringere maggiormente le curve di separazione attorno agli addensamentidi esempi (aumentando il valore di ). Questo si traduce in una maggioreaccuratezza delle predizioni e in una maggiore capacit di riconoscere falsi.

24


26/31

A Appendice: Codice in linguaggio C del Software

Embedded

//*************************************************

// Author: Rossinelli Emanuele// Author Contact: [email protected]

// 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 #include

#include

#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;

void SettingADC( int input ){

//input = 2 ==> AN2 (pin4)

//input = 3 ==> AN3 (pin5)

//input = 4 ==> AN4 (pin7)

if( input == 2 ){

//Configure port pins as analog inputs - AN2 (pin4)AD1CHS = 0b0000000000000010;

}

if( input == 3 ){

//Configure port pins as analog inputs - AN3 (pin5)

AD1CHS = 0b0000000000000011;}

if( input == 4 ){

//Configure port pins as analog inputs - AN4 (pin7)

AD1CHS = 0b0000000000000100;}

}

int ReadingADC( int input ){

25


27/31

int value = 0;

SettingADC( input );

//reading adcAD1CON1bits.ADON = 1;

DelayBigMs( 50 );

while(AD1CON1bits.DONE != 1) ;

value = ADC1BUF0;AD1CON1bits.ADON = 0;

return value;}

void main(void)

{

/******** SETTING CPU *********/

//Selezione della freq. con osc. interno a 8 Mhz OSCCON registerOSCCON = 0b0000000010000000;

CLKDIV = 0b0000000000000000;

/******** SETTING UART *********/

//Set data mode - Simplex - 8 Bit No Parity - 1 Bit Stop

U1MODE = 0b1000100000000000;

//Enable Transmit ( NOW & MASK ) | NEW CONF

U1STA = ( U1STA & 0b0000001100011111 ) | 0b1000000011000000;

//Set Baud Rate to 9600 bps (Fcy = Fosc/2 = 4 MHz)

U1BRG = 25; //25

//Output portTRISB &= 0b1111111111111110;

//Enable UART TXU1STAbits.UTXEN = 1;

/****** SETTING PORT OUTPUT *******///Porta di uscita del PWM (OC1, pin14, port A6)

TRISAbits.TRISA6 = 0;

PORTAbits.RA6 = 0;

/******** (Initial) SETTING ADC *********/

//Select voltage reference source

AD1CON2 = 0b0000000000000000; //Do not scan inputs

//Select the analog conversion clock to match the desired data rate

AD1CON3 = 0b0001111100000000; //Clock: Tcy/2

//Select the appropriate sample/conversion sequence and Turn on AD Module

AD1CON1 = 0b0000000011100110;

AD1CSSL = 0b0000000000000000;

AD1PCFG = 0b0000000000000000;

//Disattiva linterrupt ADC

IEC0bits.AD1IE = 0;

/******** SETTING TIMER *********/

T1CON = 0; //timer reset

T1CONbits.TCS = 0; //internal clock

26


28/31

T1CONbits.TGATE = 0;

T1CONbits.TCKPS = 0b11; //set prescaler 1:256 ==> 1 oscill / 64uT1CONbits.TSYNC = 0;

PR1 = 2150; //Timer1 period! ==> interrupt chiamato circa 10 times/sec

IFS0bits.T1IF = 0; //Reset Timer1 interrupt flag

IEC0bits.T1IE = 1; //Enable Timer1 interrupt

//No nested interrupt

INTCON1bits.NSTDIS = 1;

/******** START TIMER ***********/

T1CONbits.TON = 1;

/******** Loop infinito *******/

while(1)

{

}

} // End main

void SendPacket( int sens1, int sens2, int nlett ){

char pacchetto[15] = "";

char buffer[5] = "";int i = 0, tmp;

//start packet

pacchetto[i++] = *;

//sens1itoa( 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 );

//boundarypacchetto[i++] = -;

//nlettureitoa( buffer, nlett );

tmp = strlen(buffer);

i += tmp;strncat( pacchetto, buffer, tmp );

//end packet

pacchetto[i++] = *;pacchetto[i] = \0;

uart_putstring( pacchetto );

27


29/31

}

//INTERRUPT ROUTINEvoid interrupt ISR( void ) @ T1_VCTR

{

if( IFS0bits.T1IF == 1 ){

long sens0 = 0, sens1 = 0, sens2 = 0;

//Logica

if( mode == 0 )

{

//non sto facendo capture; decidi se entrare o meno

sens0 = ReadingADC( 4 );

if( sens0 < SENSOR_VOID )

{

mode = 1; //inizia il capturing

//accendi motori

PORTAbits.RA6 = 1;

}}

if( mode == 1 ){

//siamo in capture mode



//il motore sta girando.

//Attendi che la banconota arrivi sotto ai sensori,

//se ancora non e arrivataif( nlettura != 0 || ( sens1 < SENSOR_VOID && sens2 < SENSOR_VOID ) )

{

nlettura++;

//invia pacchetto

SendPacket( sens1, sens2, nlettura );

//abbiamo finito?

if( nlettura == N_CAMPIONI )

{

//vogliamo assicuriarci di aver espulso la banconota mode = 2;

//resetta var globalinlettura = 0;

}}

}

if( mode == 2 ){

//spegni i motori quando il sensore di presenza e libero

28


30/31


if( sens0 >= SENSOR_VOID )

{ mode = 0; //torna in fase di attesa nuova banconota

//tieni i motori accesi per un poco,

//in modo da espellere totalmente la banconotaDelayBigMs( 500 );

//spegni motoriPORTAbits.RA6 = 0;

}

}

IFS0bits.T1IF = 0; //reset interrupt

}//end if}

29


31/31

Riferimenti bibliografici

[1] P. Priami A. Frosini, M. Gori, A neural network-based model for papercurrency recognition and verification, IEEE Transactions on NeuralNetworks, Vol. 7, No. 6, 1996.

[2] Wikipedia, Cross-validation, http://en.wikipedia.org/wiki/Cross-validation_(statistics).

[3] dtreg.org, Svm - support vector machines, http://www.dtreg.com/svm.htm.

[4] Chih-Jen Lin Chih-Wei Hu, Chih-Chung Chang, A practical guide to

support vector classification, http://www.csie.ntu.edu.tw/~cjlin/papers/guide/guide.pdf.

30
http://en.wikipedia.org/wiki/Cross-validation_(statistics)http://en.wikipedia.org/wiki/Cross-validation_(statistics)http://www.dtreg.com/svm.htmhttp://www.dtreg.com/svm.htmhttp://www.dtreg.com/svm.htmhttp://www.csie.ntu.edu.tw/~cjlin/papers/guide/guide.pdfhttp://www.csie.ntu.edu.tw/~cjlin/papers/guide/guide.pdfhttp://www.csie.ntu.edu.tw/~cjlin/papers/guide/guide.pdfhttp://www.csie.ntu.edu.tw/~cjlin/papers/guide/guide.pdfhttp://www.dtreg.com/svm.htmhttp://www.dtreg.com/svm.htmhttp://en.wikipedia.org/wiki/Cross-validation_(statistics)http://en.wikipedia.org/wiki/Cross-validation_(statistics)

svmbanconote

Documents