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. 5
Applicazione 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: 6
Successivamente, 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. 7
Una 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: 9
Conclusioni 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