SACP-FACE RECOGNITION - SISTEMA DI RICONOSCIMENTO FACCIALE CON RASPBERRY PI 2 E WINDOWS IOT CORE - PAOLO LO GIUDICE
←
→
Trascrizione del contenuto della pagina
Se il tuo browser non visualizza correttamente la pagina, ti preghiamo di leggere il contenuto della pagina quaggiù
SACP-Face Recognition
Sistema di riconoscimento facciale con Raspberry Pi 2 e
Windows IoT Core
Lo Giudice P., Rodà D., Romano R., Tripodi G.
Sommario Presentazione .................................................................................................................................................... 1 Introduzione ...................................................................................................................................................... 2 Windows 10 IoT Core ........................................................................................................................................ 3 Requisiti Hardware ........................................................................................................................................ 4 Configurazione del device e del PC ............................................................................................................... 4 Project Oxford ................................................................................................................................................... 5 Le Face API ..................................................................................................................................................... 5 Le Speaker Recognition API ........................................................................................................................... 5 Applicazione ...................................................................................................................................................... 6 Strumenti hardware ...................................................................................................................................... 6 Sviluppo dell’applicazione ............................................................................................................................. 6 Conclusioni ...................................................................................................................................................... 10
Presentazione
Lo scopo di questo lavoro è scoprire, studiare e testare da vicino le potenzialità del nuovo sistema operativo
Windows 10 IoT Core, pensato per supportare lo sviluppo di applicazioni per dispositivi dell’ecosistema IoT.
In primo luogo verranno introdotti i concetti fondamentali di Internet of Things e Cloud computing,
focalizzandoci in seguito sulle soluzioni proposte da Microsoft in tali ambiti.
In secondo luogo verrà fornita una panoramica su Project Oxford, un progetto ancora in fase sperimentale,
sviluppato da Microsoft per offrire servizi di machine learning per l’analisi dei volti e della voce, come il
riconoscimento delle emozioni, l’identificazione delle persone, etc.
In particolare, il nostro lavoro si è concentrato sul riconoscimento dei volti, al fine di identificare uno specifico
gruppo di persone. A tale scopo, abbiamo realizzato un’applicazione pensata per funzionare su Raspberry Pi2
e di cui verrà in seguito fornita una spiegazione dettagliata.
Infine, proporremo i possibili scenari in cui potrebbe essere utile sfruttare una simile applicazione, nonché i
potenziali sviluppi futuri.
1
Introduzione In un mondo in cui le innovazioni tecnologiche diventano sempre più pervasive, sorge quasi spontanea la necessità di avere dispositivi “smart” con cui poter interagire anche a distanza. Da questa idea nasce IoT (Internet of Things), che consente ad oggetti, animali e persone di trasferire dati sulla rete senza che sia necessaria l’interazione con l’uomo, grazie all’uso di sistemi embedded e di connessioni ad Internet mediante tecnologie wireless. Internet of Things è dunque un insieme di strumenti e applicazioni che permettono non solo alle persone di parlare con le macchine, ma anche agli oggetti di dialogare direttamente tra loro. IoT avrà un forte impatto nella vita di tutti i giorni, considerando il numero di oggetti che avranno bisogno di comunicare per poter svolgere a pieno le proprie funzionalità. Il numero di dispositivi connessi alla rete Internet crescerà esponenzialmente; si prevede infatti che nel 2020 i dispositivi connessi in tutto il mondo saranno circa 50 miliardi. Il Cloud computing sta diventando uno dei servizi più popolari e consente all’utente, attraverso una connessione ad Internet, di eseguire delle operazioni sul Cloud in modo veloce ed efficiente. I dispositivi di IoT sono spesso costituiti da microcontrollori installati su oggetti più grandi (sistemi di controllo, elettrodomestici, abbigliamento, etc.) e hanno ridotte capacità di calcolo. Le capacità del Cloud computing possono quindi essere sfruttate per IoT per creare applicazioni anche molto complesse. Sono molte le aziende del settore, ad esempio Microsoft, Google e Oracle, che forniscono dei servizi di Cloud computing con supporto all’IoT. 2
Windows 10 IoT Core
Windows 10 IoT Core è una versione di Windows pensata
appositamente per piccoli device. Questo nuovo sistema
operativo, infatti, può essere eseguito su Raspberry Pi2,
Arrow DragonBoard 410 e MinnowBoard Max e basa il
proprio funzionamento sulle API UWP (Universal Windows
Platform).
Inoltre, con l’introduzione di Windows 10, Microsoft ha iniziato una collaborazione con Arduino, supportando
le Arduino Wiring API e creando Windows Virtual Shield per Arduino. Le Arduino Wiring API consentono di
caricare con semplicità sketch e librerie direttamente dal noto IDE Microsoft, Visual Studio. Windows Virtual
Shield per Arduino, invece, permette di sfruttare le capacità dei dispositivi Windows 10 tramite protocolli
wireless (Wi-Fi o Bluetooth) o tramite connessione USB, ad esempio per fornire ad Arduino funzionalità come
GPS, display touchscreen, etc.
Grazie a Windows 10 IoT Core, è possibile fornire al device un’interfaccia grafica, sistemi di ricerca, storage
online e altri servizi basati sul Cloud (per esempio Azure). Windows 10 offre la possibilità di scrivere le
applicazioni una sola volta ed eseguirle sia su sistemi mobile che PC, a prescindere dalla loro architettura (x86
piuttosto che ARM). Non è necessario, infatti, modificare il codice sorgente di un’applicazione per farla
funzionare su una particolare tipologia di dispositivi, salvo casi specifici; ciò che realmente viene richiesto a
chi sviluppa un’applicazione per
Windows 10 è di conoscere i
linguaggi di programmazione
Microsoft, quindi C# per quanto
riguarda la parte logica delle
applicazioni e XAML (Extensible
Application Markup Language) per
la parte inerente all’interfaccia
grafica. Questo perché, di fatto,
tutte le piattaforme Windows 10
(PC, smartphone, console, etc.)
condividono lo stesso Kernel: da
qui la nascita dell’ecosistema
UWP, in cui rientra appunto la distribuzione IoT Core.
Un’ulteriore particolarità di Windows 10 IoT Core è data dal fatto che è offerto gratuitamente da Microsoft,
in modo da invogliare gli sviluppatori a prendere in considerazione questo sistema per realizzare i loro
progetti relativi all’ecosistema IoT. Inoltre, per incentivare l’uso di IoT Core è possibile consultare numerosi
esempi, più o meno complessi, che riescono a far comprendere le potenzialità della piattaforma Microsoft.
3
Requisiti Hardware
Per poter eseguire Windows 10 IoT Core, è necessario che il dispositivo abbia le seguenti caratteristiche:
- Memoria
o 256 MB RAM per i dispositivi senza display
o 512 MB RAM per i dispositivi con display
o 2 GB per lo storage
- Processore
o 400MHz sia x86 che ARM
Configurazione del device e del PC
Una volta scelto il dispositivo, esso può essere configurato usando la Windows 10 IoT Core Dashboard, che
consente anche di eseguire delle applicazioni demo. L’accesso alla Dashboard può avvenire anche da remoto
(mediante browser), a partire dall’indirizzo IP del dispositivo, tramite la porta 8080.
Prima di iniziare a sviluppare applicazioni per Windows 10 IoT Core, bisogna configurare anche il PC su cui si
lavorerà. In particolare bisogna assicurarsi di:
1. Possedere la versione 10.0.10240 di Windows 10 o superiore;
2. Avere installato la versione più aggiornata di Visual Studio Community 2015, Visual Studio
Professional 2015, Visual Studio Enterprise 2015 o qualsiasi altra versione di Visual Studio 2015,
purché sia stato integrato il tool Universal Windows App Development. La versione di Visual Studio
2015 deve essere validata;
3. Avere installato Windows IoT Core Project Templates. In alternativa, i template possono essere
caricati direttamente dalla Visual Studio Gallery o dalle estensioni;
4. Abilitare la modalità developer sul dispositivo con Windows 10.
4
Project Oxford
Project Oxford è un’iniziativa di Microsoft che punta a fornire
una serie di servizi di machine learning basati sul cloud, divisi
in tre grandi categorie: Vision, Speech e Language. All’interno
di queste categorie troviamo svariati servizi, testabili mediante esempi di prova, tra cui il riconoscimento
delle emozioni, l’identificazione di una persona attraverso riconoscimento facciale o vocale, la possibilità di
trascrivere un file audio in uno testuale (e viceversa), la capacità di riconoscere la lingua parlata, di correggere
eventuali errori e di far eseguire delle attività a seguito di un determinato comando vocale. Questi servizi
possono essere fruiti direttamente oppure possono essere integrati in applicazioni personalizzate su qualsiasi
dispositivo contenente Windows 10, grazie alla presenza delle API progettate appositamente per la UWP. In
particolare, nel corso di questo nostro lavoro sono state testate le Face API e le Speaker Recognition API.
Le Face API
Le Face API forniscono degli algoritmi per il riconoscimento (con estrazione degli
attributi caratteristici) e l’identificazione dei volti. Le Face Detection API riconoscono i
volti, ne determinano con alta precisione la posizione (massimo 64 volti in un’unica
foto) e ricavano caratteristiche come il sesso, l’età e l’espressione della persona in
questione. Le Face Recognition API identificano i volti e forniscono delle funzionalità
per cui è possibile determinare o verificare l’identità di una persona, a partire da una
serie di foto utilizzate per l’addestramento. In particolare è possibile verificare l’identità, trovare volti simili,
raggruppare automaticamente i volti e identificare le persone. La scelta di usare le Face API in questo
progetto è dettata dal fatto che queste funzionalità sono molto usate nei sistemi di sicurezza per consentire
l’autenticazione attraverso il confronto dell’immagine prelevata da una telecamera con una foto conservata
in un database.
Le Speaker Recognition API
Le Speaker Recognition API forniscono degli algoritmi per verificare ed identificare chi
sta parlando. Le Speaker Verification API possono verificare ed autenticare
automaticamente gli utenti di un sistema grazie al riconoscimento della loro voce.
Affinché questa procedura vada a buon fine è necessario che gli utenti si registrino nel
sistema, ripentendo più volte delle specifiche frasi, in modo da poter estrarre le
caratteristiche peculiari della voce da usare come parametri al momento della
verifica. Le Speaker Identification API possono identificare automaticamente le persone che parlano a partire
dall’analisi di un file audio, che contiene un insieme di voci distinte. Perché una voce sia riconosciuta, la
persona deve registrare un audio (senza alcuna restrizione sul contenuto) di almeno un minuto, in modo che
vengano estratte le caratteristiche della voce. La scelta dell’uso delle Speaker Recognition API in questo
progetto è legata al fatto che la voce ha delle caratteristiche intrinseche uniche e può essere usata per
identificare una persona attraverso un sistema di sicurezza dotato di microfono.
5Applicazione
L’applicazione ha lo scopo di scattare una foto e riconoscere se la persona ritratta fa o meno parte di un
gruppo di persone note, precedentemente registrate nel sistema.
Strumenti hardware
Come preannunciato, l’applicazione è pensata per funzionare su Raspberry Pi2. Per poterne testare il
funzionamento abbiamo utilizzato la seguente strumentazione:
Raspberry Pi2;
Monitor e speaker audio (opzionali);
WebCam USB;
Led giallo, rosso e verde;
Pulsante;
Breadboard;
Cavi eth, hdmi, etc.
Una volta collegati tutti gli strumenti, si ottiene una configurazione del tipo:
(foto)
In particolare, i led sono collegati in maniera opportuna a seconda delle specifiche nel codice
dell’applicazione.
Sviluppo dell’applicazione
Per cominciare a sviluppare un'applicazione di tipo UWP abbiamo bisogno della versione più aggiornata di
Visual Studio 2015, oltre che di Windows 10. Soltanto soddisfacendo questi due requisiti sarà possibile
accedere agli strumenti di sviluppo delle Universal Windows App. Nel caso in cui si voglia sviluppare
un’applicazione rivolta anche a dispositivi IoT, Visual Studio ci dà la possibilità di avviare un progetto Windows
IoT Core, che consiste in un’applicazione universale con già integrate le librerie per sfruttare le funzionalità
dei dispositivi IoT compatibili (nel nostro caso un RPi2).
Il primo passo, quindi, è stato quello di inizializzare un "Nuovo Progetto" per dispositivi IoT, come mostrato
nella seguente figura:
6Successivamente, abbiamo iniziato a sperimentare le funzionalità base del nostro Raspberry Pi 2, con
preinstallato Windows IoT Core, eseguendo degli esempi di prova che ci hanno consentito di prendere
confidenza con gli strumenti in nostro possesso.
Prima di procedere con la descrizione del nostro lavoro, ricordiamo brevemente come si struttura in genere
un’applicazione di tipo UWP. Essa si compone di due parti fondamentali: interfaccia grafica, in XAML, e
componente logica, in C#.
Per la nostra applicazione siamo ricorsi, in una prima fase di setup, ad una struttura di questo tipo:
- Parte in XAML per gestire i controller di una WebCam e mostrare a schermo due riquadri: uno per
l’immagine di anteprima e l’altro per mostrare l’ultima foto scattata;
- Parte in C# per gestire la logica dell’applicazione, a partire dagli eventi di inizializzazione della
WebCam fino alla fase di riconoscimento e identificazione di una persona.
Dopo aver realizzato la struttura base, in grado di attivare e scattare una foto utilizzando esclusivamente il
Raspberry Pi 2, abbiamo proceduto con uno studio approfondito delle librerie di Project Oxford. Un preciso
studio di fattibilità ci ha portati a considerare, tra tutte le possibili soluzioni, un sistema di riconoscimento
mirato all’identificazione di un ristretto gruppo di persone. Per far ciò, abbiamo dapprima creato quello che
viene chiamato un PersonGroup, che consiste in un database contenente gli ID di un certo numero di persone,
ciascuna delle quali associate a 4-5 ritratti fotografici necessari per addestrare l’algoritmo di riconoscimento
facciale. In primo luogo, quindi, abbiamo provveduto a creare un PersonGroup contenente i nostri GUID
(Globally Unique ID), che ci ha permesso poi di testare realmente le librerie. Da precisare che tali informazioni
vengono caricate sui server Microsoft, allestiti appositamente per consentire l’interazione con le API di
Project Oxford.
7Una volta creato il nostro PersonGroup, il terzo passo è stato quello di integrare nell’applicazione di base fin qui realizzata le librerie sul riconoscimento facciale. Personalizzato il nostro codice C#, abbiamo implementato alcuni controller XAML per verificare su schermo l’effettivo funzionamento dell’applicazione. Di seguito uno screen che mostra l’ambiente di lavoro, in riferimento all’interfaccia grafica in XAML: L’applicazione prevede quindi che il soggetto che deve farsi identificare si scatti una foto con la WebCam collegata a Raspberry Pi 2, facendo in modo che il suo volto rientri perfettamente e con le giuste condizioni di luce nel riquadro di anteprima. Scattata la foto, l’applicazione la invia sui server Microsoft sfruttando le API di Project Oxford (è necessario, quindi, che Raspberry Pi 2 sia connesso a Internet), sfruttando così il server per processare l’immagine in modo da avviare le fasi di detecting e identificazione del volto. Se il soggetto appartiene al PersonGroup precedentemente creato, allora il server restituisce un risultato positivo e l’applicazione mostra su schermo il nome della persona identificata. Altrimenti, viene visualizzato un messaggio di errore. 8
Un’ulteriore funzionalità, implementata mediante un apposito web service, prevede un log online; nel
momento in cui una persona viene identificata, l’applicazione provvede a popolare una tabella di log degli
accessi contenuta su un web server di Azure, la piattaforma Cloud di Microsoft. In tal modo, l’applicazione
consente di visualizzare in tempo reale, da qualsiasi dispositivo abbia accesso ad Intenet, il nome delle
persone identificate, con accanto un timestamp.
Una volta terminate le funzionalità previste, abbiamo esteso il tutto a dei componenti fisici; tre led, rosso
giallo e verde, ed un bottone per attivare (con un solo click) due eventi concatenati: scatto di una foto e
identificazione. I led svolgono il ruolo di segnalazione: il led giallo è stato inizializzato ad un valore “alto” di
default (acceso) e comincia a lampeggiare a partire dal momento in cui viene scattata la foto. Se la persona
viene riconosciuta, il led giallo si spegne e viene settato su valore digitale alto il led verde, altrimenti quello
rosso. Dopo cinque secondi l’applicazione si resetta ripristinando tutti i valori a default e consentendo quindi
una nuova identificazione. Ecco come si presenta il sistema con Raspberry Pi 2 una volta completato:
9Conclusioni Al termine del nostro lavoro abbiamo pensato ai possibili scenari in cui potrebbe essere utile un’applicazione come quella da noi realizzata. Un sistema di sicurezza per controllare l’accesso a degli ambienti riservati è sicuramente un contesto in cui sarebbe utile avere un’applicazione che, scattata una foto, riconosce i volti e determina se la persona ritratta è autorizzata o meno ad accedere. Un’applicazione in un contesto simile potrebbe essere l’integrazione ad un impianto di allarme domestico, in cui solo persone note sono autorizzate ad effettuare operazioni di attivazione/disattivazione del sistema di sicurezza. Un ulteriore contesto potrebbe essere l’integrazione ad un sistema di accessi con badge, sia in ambito pubblico che privato, in modo da contrastare l’assenteismo. In particolare il sistema potrebbe scattare una foto al momento della lettura del badge per verificare che l’identità della persona che sta timbrando l’ingresso/uscita corrisponda effettivamente a quella le cui informazioni contenute nel badge. 10
Puoi anche leggere
