TensorFlow è uno strumento versatile per creare modelli di apprendimento automatico.
In questo post vedremo come creare un sistema di riconoscimento facciale con TensorFlow, un framework di apprendimento automatico open source. Esamineremo i processi essenziali nella creazione di un sistema di riconoscimento facciale di successo, dalla raccolta e preparazione dei dati all'addestramento e alla valutazione di un modello.
Avrai un'esperienza diretta con TensorFlow per creare il riconoscimento facciale con l'aiuto di frammenti di codice ed esempi del mondo reale. Siete invitati a seguire mentre procediamo.
Introduzione a TensorFlow
TensorFlow è una libreria gratuita e open source. È una cassetta degli attrezzi matematica simbolica che utilizza il flusso di dati e la programmazione differenziabile. Puoi gestire una serie di attività con esso, anche in profondità rete neurale formazione.
TensorFlow è potente e adattabile. Allo stesso modo, è un ottimo strumento per sviluppare e distribuzione di modelli di machine learning. Puoi costruire modelli complicati con diversi livelli e operazioni tensoriali. Inoltre, i modelli predefiniti nella libreria possono essere ottimizzati per esigenze specifiche.
Inoltre, TensorFlow ha una comunità di utenti enorme e in espansione. Quindi, c'è una pletora di informazioni e aiuto per le persone che sono nuove sulla piattaforma.
TensorFlow è popolare per machine learning in parte perché fornisce un flusso di lavoro end-to-end. Quindi, puoi facilmente costruire, addestrare e distribuire modelli. Fornisce strumenti e strategie per migliorare e ridimensionare i modelli per soddisfare esigenze specifiche. Varia dalla pre-elaborazione dei dati alla distribuzione del modello.
Cos'è il riconoscimento facciale?
Il riconoscimento facciale è un visione computerizzata compito che identifica l'identificazione di una persona in base al suo volto. Questa tecnica riconosce i tratti del viso, come la forma e la consistenza degli occhi, del naso e della bocca.
E li confronta con un database di volti noti per identificare una corrispondenza. Il riconoscimento facciale ha diversi usi, inclusi i sistemi di sicurezza, l'organizzazione delle foto e l'autenticazione biometrica.
La precisione degli algoritmi di riconoscimento facciale è notevolmente aumentata negli ultimi anni grazie alle scoperte nel machine learning.
Importazione delle librerie necessarie
Prima di iniziare qualsiasi cosa, dobbiamo importare le librerie necessarie per il nostro modello. Tensorflow (tf) viene importato e utilizzato per creare e addestrare il modello. <(p>
"numpy" esegue calcoli matematici e l'elaborazione dei dati.
"matplotlib.pyplot" viene importato come plt e utilizzato per grafici e visualizzazioni dei dati.
Infine, "fetch lfw people" viene importato da sklearn. set di dati e utilizzato per caricare il set di dati di riconoscimento facciale. Questa funzione fa parte del toolkit scikit-learn. Grazie a questa funzione non abbiamo dovuto caricare un altro set di dati. Questo è già integrato in sckit-learn.
E ti dà accesso a una vasta gamma di set di dati per l'apprendimento automatico applicazioni. In questo scenario, utilizziamo il metodo fetch lfw people per recuperare il set di dati "Labeled Faces in the Wild" (LFW). Comprende le foto dei volti delle persone e le etichette che le accompagnano.
Queste librerie sono fondamentali per l'implementazione e la valutazione del nostro modello di riconoscimento facciale.
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt from sklearn.datasets
import fetch_lfw_people
Preelaborazione e caricamento del set di dati di riconoscimento facciale
In questa parte, utilizziamo la funzione "fetch lfw people" per preelaborare i dati di riconoscimento facciale. Innanzitutto, usiamo fetch lfw people con l'opzione "min faces per person=60". Ciò indica che vogliamo includere nel set di dati solo le persone che hanno almeno 60 foto. Quindi, ci assicuriamo che il nostro modello abbia dati adeguati da apprendere. Inoltre, questo riduce il pericolo di overfitting.
I dati e le etichette dell'oggetto facce vengono quindi estratti e assegnati alle variabili X e y. X vacanza
Ora siamo pronti per addestrare il nostro modello di riconoscimento facciale utilizzando dati ed etichette preelaborati.
faces = fetch_lfw_people(min_faces_per_person=60)
X = faces.data
y = faces.target
target_names = faces.target_names
Divisione di training e set di test
In questa fase, abbiamo diviso il nostro set di dati di riconoscimento facciale in due metà utilizzando il metodo di suddivisione del test del treno dalla selezione sklearn.model. L'obiettivo di questa suddivisione è valutare le prestazioni del nostro modello dopo l'allenamento
La funzione train test split accetta come input i dati X e le etichette y. E li divide in set di addestramento e test. Selezioniamo test size=0.2 in questo esempio. Ciò implica che il 20% dei dati verrà utilizzato come set di test e l'80% come set di addestramento. Inoltre, utilizziamo random state=42 per garantire che i dati vengano divisi in modo coerente ogni volta che viene eseguito il codice.
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
Preparazione dei dati
Lo scopo della pre-elaborazione dei dati è prepararli per l'inserimento nel modello. I dati vengono preelaborati in questo codice dividendo ogni punto dati per 255.
Cosa ci ha spinto a raggiungere questo obiettivo? La normalizzazione è una procedura di pre-elaborazione utilizzata nell'apprendimento automatico per garantire che tutte le funzionalità siano sulla stessa scala. In questo scenario, la divisione per 255 ridimensiona i dati in un intervallo compreso tra 0 e 1, che è un normale passaggio di normalizzazione dei dati immagine.
Ciò accelera la convergenza del modello e può aumentarne le prestazioni.
X_train = X_train / 255.0
X_test = X_test / 255.0
Creazione della modalità
Vogliamo identificare l'individuo il cui volto appare in una foto. In questo caso, utilizzeremo una rete completamente connessa, spesso nota come rete densa. È una rete neurale artificiale che è stata utilizzata per creare il modello.
Le reti neurali artificiali sono modellate sul modo in cui il cervello umano opera ed è organizzato. Sono costituiti da nodi di elaborazione delle informazioni o neuroni collegati. Ogni neurone in uno strato in una rete densa è collegato a ogni neurone nello strato sopra di esso.
Il modello ha quattro livelli in questo codice. Per essere inseriti nel livello successivo, i dati di input vengono appiattiti nel primo livello in un array unidimensionale. I neuroni 128 e 64 nei due strati successivi, di conseguenza, sono completamente collegati.
La funzione di attivazione ReLU è una funzione di attivazione unica utilizzata da questi livelli. Con ciò, possiamo fare in modo che il modello apprenda le correlazioni non lineari tra gli input e gli output. L'ultimo strato utilizza la funzione di attivazione softmax per fare previsioni. Ed è uno strato completamente connesso con tanti neuroni quante sono le potenziali classi.
model = tf.keras.models.Sequential([
tf.keras.layers.Flatten(input_shape=(62 * 47,)),
tf.keras.layers.Dense(128, activation='relu'),
tf.keras.layers.Dense(64, activation='relu'),
tf.keras.layers.Dense(len(target_names), activation='softmax')
])
Compilazione del Modello
Il modello viene compilato utilizzando la funzione “compila”. Dobbiamo preparare il modello per l'addestramento. Quindi, definiremo l'ottimizzatore, la funzione di perdita e le metriche che verranno utilizzate per valutare il modello.
Durante l'addestramento, l'ottimizzatore ha il compito di modificare i parametri del modello. L'ottimizzatore "adam" è una popolare tecnica di ottimizzazione del deep learning.
Usiamo la funzione di perdita per valutare le prestazioni del modello sui dati di addestramento. Poiché le etichette di destinazione sono numeri interi che riflettono la classe dell'immagine piuttosto che vettori codificati one-hot, la funzione di perdita "sparse categorical crossentropy" è favorevole.
Infine, definiamo le metriche per valutare il modello, in questo caso "accuratezza".
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
Modello di formazione
Useremo la funzione "fit" per addestrare il modello.
Forniremo i dati di addestramento (treno X) e le relative etichette (treno y), oltre a impostare il numero di epoche (iterazioni) da eseguire a 10. La procedura di addestramento modifica i pesi del modello per ridurre una perdita (la differenza tra etichette previste e reali) e migliorare l'accuratezza dei dati di addestramento.
model.fit(X_train, y_train, epochs=10)
Valutazione del modello
Ora, dobbiamo valutare il modello addestrato sui dati di test. Utilizziamo la perdita di test e l'accuratezza del test per valutare le prestazioni del modello. Sul test X dei dati di test e sul test delle etichette di test y, dobbiamo chiamare "la funzione model.evaluate"
La funzione emette l'accuratezza del test e la perdita del test. Le variabili perdita di test e accuratezza del test, rispettivamente, contengono questi valori. Infine, utilizziamo la funzione "stampa" per produrre l'accuratezza del test.
test_loss, test_accuracy = model.evaluate(X_test, y_test)
print("Test accuracy:", test_accuracy)
Predire le classi e ottenere le classi previste
Utilizzando il modello di addestramento ei dati del test, l'algoritmo effettua previsioni. Quando i dati del test vengono passati al metodo "model.predict", genera un array di previsioni per ogni immagine nel set di test.
Il nome della classe di destinazione per ciascuna immagine viene quindi recuperato dall'elenco dei "nomi di destinazione" utilizzando la funzione "np.argmax" per identificare l'indice con la massima probabilità prevista. Questo indice viene quindi utilizzato per determinare la classe prevista per ciascuna immagine.
Utilizzando una comprensione dell'elenco, tutte le previsioni nell'array "previsioni" sono soggette a questo metodo, risultando nell'elenco delle "classi previste".
predictions = model.predict(X_test)
predicted_classes = [target_names[np.argmax(prediction)] for prediction in predictions]
Visualizzare le previsioni
Ora possiamo vedere come appare il nostro modello.
Per valutare come sta andando il modello, verranno mostrate le prime 10 foto e le loro previsioni. Traccerà le foto in scala di grigi e visualizzerà sia la classe effettiva dell'immagine sia la classe prevista dal modello utilizzando il modulo matplotlib.pyplot.
La funzione "imshow" viene utilizzata dal ciclo for per tracciare ciascuna delle prime 10 foto del set di test. I nomi di destinazione[y test[i]] e le classi previste[i] vengono utilizzati per determinare rispettivamente la classe effettiva e la classe prevista dell'immagine. I titoli di ogni trama sono poi indicati da queste classificazioni.
Infine, il grafico viene visualizzato utilizzando il metodo plt.show().
for i in range(10):
plt.imshow(X_test[i].reshape(62, 47), cmap='gray')
plt.title(f"True: {target_names[y_test[i]]}, Predicted:{predicted_classes[i]}")
plt.show()
Incartare
TensorFlow offre un ambiente completo e flessibile per la creazione di modelli di machine learning.
Mettendo a punto il modello per soddisfare requisiti particolari o aggiungendo nuovi sviluppi nell'apprendimento automatico, l'accuratezza del modello può essere ulteriormente aumentata.
TensorFlow e il riconoscimento facciale saranno probabilmente utilizzati sempre più in settori come i sistemi di sicurezza, l'autenticazione biometrica e l'assistenza sanitaria in futuro. Vedremo a breve affascinanti innovazioni.
Lascia un Commento