Riconoscimento facciale con python, Guide, Progetti e Ricerche di Programmazione Avanzata

Scarica Riconoscimento facciale con python e più Guide, Progetti e Ricerche in PDF di Programmazione Avanzata solo su Docsity!

Titolo

Riconoscimento facciale con python

Indice

• Introduzione..............................................................................................................................................................
• Titolo Primo...............................................................................................................................................................
• Panoramica principali funzionalità di Python........................................................................................................
  • 1.1 Storia del linguaggio Python
  • 1.2 Applicazioni del linguaggio Python
    • 1.2.1 Data Science
    • 1.2.4 Elaborazione di immagini
  • 1.3 Pycharm
  • 1.4 Descrizione dettagliata OpenCV
• Titolo Secondo........................................................................................................................................................
• Detecting and Recognizing Faces.......................................................................................................................
  • 2.1 Concettualizzazione delle cascate di Haar
  • 2.2 Eseguire il rilevamento del volto con OpenCV
  • 2.3 Performing face detection on a video
  • 2.4 Esecuzione del riconoscimento del volto
  • 2.5 Generazione dei dati per il riconoscimento del volto
  • 2.6 Riconoscimento dei volti
• Titolo Terzo.............................................................................................................................................................
• Performing whit Eigenfaces, Fisherfaces, LBPH...............................................................................................
  • 3.1 Eigenfaces
  • 3.2 Performing whit Fisherfaces and LBPH
  • 3.3 Modifiche per migliorare il risultato e creazione di un Dataset
• Conclusione............................................................................................................................................................
• Bibliografia..............................................................................................................................................................

Viene inoltre affrontato l’argomento del rilevamento dei volti nei video, dimostrando come le tecniche precedentemente illustrate possano essere estese al contesto dinamico dei video. Il lavoro passa poi al tema del riconoscimento dei volti, dettagliando i passaggi necessari per eseguire questa attività complessa. Viene spiegato il processo di generazione dei dati necessari per il riconoscimento del volto, fornendo una visione chiara del lavoro preliminare richiesto per preparare un sistema in grado di identificare i volti. Si esamina in modo più approfondito, discutendo delle varie tecniche e strumenti utilizzati per identificare un volto una volta che è stato rilevato. Io studio approfondisce le tecniche più sofisticate di riconoscimento facciale: Eigenfaces, Fisherfaces e Local Binary Patterns Histograms (LBPH). Utilizzando Python e la libreria OpenCV, viene esplorato il mondo del riconoscimento facciale attraverso metodi matematici e computazionali avanzati. Si inizia con l’analisi sulle Eigenfaces, un approccio che si basa sulla riduzione della dimensionalità e l’analisi dei componenti principali per creare una rappresentazione semplificata, ma efficace, dei volti. Si passa poi alle Fisherfaces, una tecnica simile alle Eigenfaces, ma che si basa sull’Analisi Discriminante Lineare per migliorare l’accuratezza del riconoscimento del volto. Si discute inoltre dell’approccio LBPH, che utilizza una descrizione del volto basata su texture per una rappresentazione più robusta e resistente alle variazioni di luce e ombra. Questo metodo è particolarmente potente nel riconoscere volti in immagini con condizioni di illuminazione variabili. L’ultimo aspetto trattato in questo studio è l’ottimizzazione dei risultati. Viene esplorato il tema delle modifiche che possono essere apportate ai metodi di riconoscimento per migliorare l’accuratezza e l’efficacia del sistema, inoltre attraverso Cameo si puo realizzare una raccolta dati per poi incrementarla con un algoritmo per identificare i volti. In conclusione, questo studio presenta un’analisi approfondita delle tecniche avanzate di riconoscimento facciale, fornendo una comprensione dettagliata dei vari metodi e di come possono essere applicati per migliorare l’accuratezza e l’efficacia del riconoscimento dei volti in tantissimi ambiti, come l’esempio della sicurezza aziendale.

Titolo Primo Panoramica principali funzionalità di Python 1.1 Storia del linguaggio Python Guido Van Rossum, un ricercatore dell’Istituto di Matematica e Informatica (CWI) di Amsterdam, ha dato vita a questo linguaggio di programmazione nel

1989. Nonostante abbia guadagnato grande popolarità negli ultimi anni, il suo obiettivo originale era di migliorare la famiglia di linguaggi usati dal gruppo di hacker Unix. Figura 1.1: Storia di Python (blog.eduonix) Dopo un’approfondita analisi, Van Rossum iniziò a sviluppare questo nuovo linguaggio di programmazione, che attualmente è uno dei più significativi, grazie alle sue numerose librerie dedicate alla Data Science e all’Intelligenza Artificiale. L’obiettivo era di creare un linguaggio completamente gratuito, e per questo tutte le librerie e i programmi associati a Python sono stati resi

1.2 Applicazioni del linguaggio Python Prima di concentrarci sull’oggetto di studio, è bene fare una panoramica di tutte le possibili applicabilità di questo linguaggio: 1.2.1 Data Science Le librerie che sono messe a disposizione, possono creare grafici, statistiche, diagrammi, grafici 3d e etc. La gestione dell’analisi dei dati è governata da pacchetti specializzati per i dati tra cui, Numpy che serve per i calcoli scientifici, Pandas open source che si occupa di modellare e gestire flessibilmente i dati in maniera veloce. Per quanto concerne le librerie, tra le più importanti, Matplotlib che trasforma i dati in grafici, ma abbiamo Seaborn, Ggplot2 e altri. Figura 1.2: fonte freecodecamp.org esempi di grafici con Seaborn (kent.medium) Nell’immagine 1.1 possiamo vedere come i grafici vengono descritti in qualsiasi maniera, e di come si può dare una libera espressione di come rappresentare una determinata quantità. Bokeh si occupa di browser interattivi moderni e Pandas in veste di libreria riesce a generare molti modelli di visualizzazione dati.

1.2.4 Elaborazione di immagini L’elaborazione delle immagini permette, catturate da una videocamera o macchina fotografica di poi elaborare i dati raccolti, ma non si limita a questo, può anche analizzare e creare un vero e proprio database di informazioni attraverso le immagini che vengono fornite. Tra le varie librerie vi è OpenCV software open source che permette di implementare un’istruzione fine all’apprendimento “Machine learing” ed a creare una visione artificiale. Altre librerie che non passano in secondo piano sono Scikit-image, che contiene una serie di algoritmi, Numpy questo usa processare i pixel delle immagini come un array 2D, SciPy contiene varia funzione per l’elaborazione multidimensionale. Figura 1.3 Esempio di ritaglio volto eseguito da OpenCV in funzione (pyimagesearch) In questo paragrafo abbiamo analizzato i più rinomanti impieghi di Python, si è limitato a descrivere una piccola quantità delle risorse che vengono fornite dalle

codice in base alla lingua, il rilevamento degli errori e le correzioni al volo del codice. 1.4 Descrizione dettagliata OpenCV OpenCV è stato creato per fornire un’infrastruttura comune per le applicazioni di visione artificiale e per accelerare l’uso della percezione della macchina nei prodotti commerciali. Essendo un prodotto con licenza Apache 2, OpenCV semplifica l’utilizzo e la modifica del codice da parte delle aziende. Figura 1.5 Codice OpenCV e sezione volto da identificare (Viso) La libreria ha più di 2500 algoritmi ottimizzati, che include un set completo di algoritmi di computer vision e machine learning classici ed all’avanguardia. Questi algoritmi possono essere utilizzati per rilevare e riconoscere volti, identificare oggetti, classificare azioni umane nei video, tenere traccia dei movimenti della telecamera, tracciare oggetti in movimento, estrarre modelli 3D di oggetti, produrre nuvole di punti 3D da telecamere stereo, unire immagini per produrre un’alta risoluzione immagine di un’intera scena, trovare immagini simili da un database di immagini, rimuovere gli occhi rossi dalle immagini scattate con il flash, seguire i movimenti degli occhi, riconoscere lo scenario e stabilire marcatori per sovrapporlo con la realtà aumentata, ecc.

Insieme ad aziende affermate come Google, Yahoo, Microsoft e altre che utilizzano la libreria, ci sono molte startup come Applied Minds, VideoSurf e Zeitera, che fanno ampio uso di OpenCV. Gli usi implementati di OpenCV spaziano dall’unione di immagini di streetview, al rilevamento di intrusioni nei video di sorveglianza in Israele, al monitoraggio delle attrezzature minerarie in Cina, al rilevamento di incidenti di annegamento in piscina in Europa, ispezionando le etichette sui prodotti nelle fabbriche di tutto il mondo fino al rilevamento rapido dei volti in Giappone. Titolo Secondo Detecting and Recognizing Faces La visione computazionale rende possibili molte operazioni, tra queste, vi è il rilevamento dei volti, individuare i volti presenti in un’immagine, e il riconoscimento dei volti, associare un volto a una persona specifica. OpenCV dispone di numerosi algoritmi per il rilevamento e il riconoscimento dei volti, applicabili in vari contesti reali, dalla sicurezza all’intrattenimento. Nella presente sezione, vengono presentate alcune delle funzionalità di OpenCV per il rilevamento e il riconoscimento dei volti, insieme ai file di dati che permettono di tracciare specifiche tipologie di oggetti. Si Analizza in particolare i classificatori a cascata di Haar, che sfruttano il contrasto tra regioni adiacenti di un’immagine per stabilire se l’immagine o la sottoimmagine corrispondono a un tipo conosciuto. Considerando come combinare più classificatori a cascata di Haar in un’unica gerarchia, dove un classificatore identifica una regione principale nel caso in analisi, un volto e altri classificatori identificano le regioni secondarie come gli occhi. Prendendo poi in considerazione il tema fondamentale, ma spesso trascurato, dei rettangoli. Attraverso il disegno, la copia e il ridimensionamento di aree rettangolari di un’immagine, si possono eseguire semplici manipolazioni sulle aree che si sta monitorando. Nel complesso, tratteremo i seguenti argomenti:

• Comprensione delle cascate di Haar.
• Individuazione delle cascate di Haar pre-addestrate fornite con OpenCV, tra cui diversi rilevatori di volti.

2.1 Concettualizzazione delle cascate di Haar Quando si discute di classificazione di oggetti e tracciamento della loro posizione, cosa sta precisamente cercando di identificare? Cosa costituisce una parte riconoscibile di un oggetto? Le immagini fotografiche, anche da una webcam, possono contenere molti dettagli per il piacere visivo. Tuttavia, il dettaglio dell’immagine tende ad essere instabile rispetto alle variazioni di illuminazione, angolo di visione, distanza di visione, movimento della fotocamera e rumore digitale. Inoltre, anche le reali differenze nei dettagli fisici potrebbero non interessarci per la classificazione. Pertanto, un certo metodo di astrazione del dettaglio dell’immagine è utile per produrre risultati stabili di classificazione e tracciamento. Le astrazioni vengono chiamate caratteristiche, che si dice siano estratte dai dati dell’immagine. Un insieme di caratteristiche è rappresentato come un vettore, e il livello di somiglianza tra due immagini può essere valutato in base a una certa misura della distanza tra i vettori di caratteristiche corrispondenti delle immagini. Le caratteristiche di tipo Haar rappresentano un tipo di caratteristica spesso applicata al rilevamento del volto in tempo reale. Sono state utilizzate per la prima volta a questo scopo nell’articolo “ Robust Real-Time Face Detection ”. Ogni caratteristica di tipo Haar descrive il modello di contrasto tra regioni di immagine adiacenti. Per esempio, bordi, vertici e linee sottili generano ciascuno un tipo di caratteristica. Alcune caratteristiche sono distintive nel senso che tipicamente si presentano in una certa classe di oggetto come un volto ma non in altri oggetti. Queste caratteristiche distintive possono essere organizzate in una gerarchia, chiamata cascata, in cui gli strati più alti contengono caratteristiche di maggiore distintività, permettendo a un classificatore di rifiutare rapidamente soggetti che non presentano queste caratteristiche. Per un dato soggetto, le caratteristiche possono variare a seconda della scala dell’immagine e della dimensione del quartiere all’interno del quale viene valutato il contrasto. Quest’ultimo è chiamato dimensione della finestra.

Per rendere un classificatore a cascata di Haar invariante rispetto alla scala, o in altre parole, robusto ai cambiamenti di scala, la dimensione della finestra viene mantenuta costante, ma le immagini vengono ridimensionate un certo numero di volte; quindi, a un certo livello di ridimensionamento, la dimensione di un oggetto come un volto potrebbe corrispondere alla dimensione della finestra. Insieme, l’immagine originale e le immagini ridimensionate sono chiamate piramide di immagini, e ogni livello successivo in questa piramide è un’immagine ridimensionata più piccola. OpenCV fornisce un classificatore invariante alla scala che può caricare una cascata di Haar da un file XML in un formato particolare. Internamente, questo classificatore converte qualsiasi immagine data in una piramide di immagini. Le cascate di Haar, così come implementate in OpenCV, non sono robuste ai cambiamenti di rotazione o prospettiva. Per esempio, un volto capovolto non è considerato simile a un volto dritto e un volto visto di profilo non è considerato simile a un volto visto di fronte. Un’implementazione più complessa e più intensiva in termini di risorse potrebbe migliorare la robustezza delle cascate di Haar alla rotazione considerando molteplici trasformazioni delle immagini così come molteplici finestre. Le caratteristiche di tipo Haar, introdotte da Paul Viola e Michael Jones nel loro studio del 2001, sono essenziali per il rilevamento del volto in tempo reale. Queste caratteristiche descrivono i pattern di contrasto tra regioni adiacenti di un’immagine, come bordi, vertici e linee sottili. Alcune di queste caratteristiche sono uniche per determinati oggetti, come i volti, e possono quindi essere organizzate in una struttura gerarchica, nota come cascata, che consente al sistema di scartare rapidamente le immagini che non presentano queste caratteristiche. Tuttavia, le caratteristiche rilevate possono variare a seconda della scala dell’immagine e delle dimensioni dell’area all’interno della quale si sta valutando il contrasto, nota come dimensione della finestra. Per affrontare questo problema, viene utilizzata una tecnica di ridimensionamento delle immagini, mantenendo costante la dimensione della finestra. Questo permette al sistema di adattarsi alle variazioni di scala dell’oggetto da rilevare, come un volto. L’insieme di tutte le immagini ridimensionate viene chiamato piramide di immagini.

2.2 Eseguire il rilevamento del volto con OpenCV L’uso di cv2.CascadeClassifier consente di eseguire il rilevamento del volto sia su un’immagine statica che su un flusso video. Il rilevamento del volto su un video è semplicemente l’applicazione del rilevamento del volto su ciascun fotogramma del video. Tecniche più avanzate permetterebbero di tracciare un volto rilevato in modo continuo su più fotogrammi e determinare che il volto è lo stesso in ciascun fotogramma. Tuttavia, è utile sapere che un approccio sequenziale di base funziona bene. Il primo e più basilare metodo per eseguire il rilevamento del volto è caricare un’immagine e rilevare i volti in essa. Per rendere visivamente significativo il risultato, si disegnano dei rettangoli attorno ai volti nell’immagine originale. Il rilevatore di volti è progettato per volti frontali e dritti, quindi si usa un’immagine di persone, nello specifico dei taglialegna, in piedi fianco a fianco e rivolti verso l’osservatore. Figura 2.1: La fotografia in questo esempio è opera di Sergey Prokudin-Gorsky (1863-1944), un pioniere della fotografia a colori.( Joseph Howse, Joe Minichino, Learning Opencv 4 Computer Vision With Python)

Dopo aver copiato i file XML della cascata di Haar nella cartella delle cascate, si deve creare lo script di base per eseguire il rilevamento del volto. Il codice importa cv2 e dichiara una variabile face_cascade, che è un oggetto CascadeClassifier che carica una cascata per il rilevamento del volto. Successivamente, si carica l’immagine con cv2.imread e la si converte in scala di grigi perché CascadeClassifier si aspetta immagini in scala di grigi. Il passaggio successivo, face_cascade.detectMultiScale, è dove si esegue effettivamente il rilevamento del volto. I parametri di detectMultiScale includono scaleFactor e minNeighbors. L’argomento scaleFactor, che dovrebbe essere maggiore di 1.0, determina il rapporto di ridimensionamento dell’immagine ad ogni iterazione del processo di rilevamento del volto. Sulla concettualizzazione delle cascate di Haar, questo ridimensionamento è destinato a ottenere l’invarianza di scala abbinando vari volti alla dimensione della finestra. L’argomento minNeighbors è il minimo numero di rilevamenti sovrapposti che sono necessari per conservare un risultato di rilevamento. Il valore restituito dall’operazione di rilevamento è una lista di tuple che rappresentano i rettangoli del volto. La funzione cv2.rectangle di OpenCV permette di disegnare rettangoli alle coordinate specificate. x e y rappresentano le coordinate sinistra e superiore, mentre w e h rappresentano la larghezza e l’altezza del rettangolo del volto. Disegna rettangoli blu attorno a tutti i volti che trova scorrendo la variabile faces, facendo attenzione a utilizzare l’immagine originale per il disegno, non la versione in scala di grigi. Infine, chiama cv2 e cv2.imshow per visualizzare l’immagine processata risultante. Per evitare che la finestra dell’immagine si chiuda automaticamente, inseriamo una chiamata a waitKey, che ritorna quando l’utente preme un tasto qualsiasi:  cv2.imshow(‘Woodcutters Detected!’, img)  cv2.imwrite(‘./woodcutters_detected.jpg’, img)  cv2.waitKey(0) E così facendo, un intero gruppo di taglialegna viene rilevato nella nostra immagine.

2.3 Performing face detection on a video In questa sezione si comprende come eseguire il rilevamento del volto su un’immagine statica. Come menzionato precedentemente, si può ripetere il processo di rilevamento del volto su ogni fotogramma di un video, sia esso un flusso di telecamera o un file video preregistrato. Nel prossimo script, si aprirà un flusso di telecamera, si leggerà un fotogramma, si esaminerà quel fotogramma alla ricerca di volti e si cercano gli occhi all’interno dei volti rilevati. Infine, si disegnano rettangoli blu attorno ai volti e rettangoli verdi attorno agli occhi. Ecco lo script nella sua interezza: Figura 2.3.1: Codice complete per il riconoscimento dei volti in una seguenza di fotogrammi (scritto e preso tramite Pycharm)

Il precedente esempio in parti più piccole e comprensibili:

1. Si importa il modulo cv2. Successivamente, si inizializzano due oggetti CascadeClassifier, uno per i volti e uno per gli occhi.
2. In molti script interattivi, si apre un flusso di telecamera e si inizia a iterare sui fotogrammi. Si prosegue fino a quando l’utente non preme un tasto. Ogni volta che si cattura con successo un fotogramma, lo si converte in scala di grigi come primo passo per elaborarlo.
3. Si rilevano i volti con il metodo detectMultiScale del nostro rilevatore di volti, si utilizzano gli argomenti scaleFactor e minNeighbors. Si utilizza anche l’argomento minSize per specificare una dimensione minima di un volto, nello specifico 120x120. Non viene tentato di rilevare volti più piccoli di questo.
4. Si iterano sui rettangoli dei volti rilevati. Si disegna un bordo blu attorno a ciascun rettangolo nell’immagine a colori originale. Poi, nella stessa regione rettangolare dell’immagine in scala di grigi, si esegue il rilevamento degli occhi. Il rilevatore di occhi è un po’ meno preciso del rilevatore di volti. Potresti vedere ombre, parti delle montature degli occhiali o altre regioni del viso rilevate erroneamente come occhi. Per migliorare i risultati, si può provare a definire roi_gray come una regione più piccola del volto, dato che si può fare una buona supposizione sulla posizione degli occhi in un volto eretto. Si può anche provare a utilizzare un argomento maxSize per evitare falsi positivi troppo grandi per essere occhi. Regolare minSize e maxSize in modo che le dimensioni siano proporzionali a w e h, la dimensione del volto rilevato.