TensorFlow é unha ferramenta versátil para crear modelos de aprendizaxe automática.
Nesta publicación, veremos como crear un sistema de recoñecemento facial con TensorFlow, un marco de aprendizaxe automática de código aberto. Repasaremos os procesos esenciais para crear un sistema de recoñecemento facial exitoso, desde a recollida e preparación de datos ata a formación e a avaliación dun modelo.
Terá experiencia de primeira man con TensorFlow para crear recoñecemento facial coa axuda de fragmentos de código e exemplos do mundo real. Podes seguirnos mentres avanzamos.
Introdución a TensorFlow
TensorFlow é unha biblioteca gratuíta e de código aberto. É unha caixa de ferramentas matemáticas simbólicas que usa fluxo de datos e programación diferenciable. Podes xestionar unha serie de tarefas con el, incluíndo as profundas rede neural formación.
TensorFlow é poderoso e adaptable. Así mesmo, é unha excelente ferramenta para desenvolver e implantación de modelos de aprendizaxe automática. Podes construír modelos complicados con varias capas e operacións de tensores. Ademais, os modelos preconstruídos na biblioteca pódense axustar para necesidades específicas.
Ademais, TensorFlow ten unha comunidade de usuarios enorme e en expansión. Polo tanto, hai unha infinidade de información e axuda para persoas que son novas na plataforma.
TensorFlow é popular para aprendizaxe de máquina en parte porque ofrece un fluxo de traballo de extremo a extremo. Así, pode facilmente construír, adestrar e implantar modelos. Ofrece ferramentas e estratexias para mellorar e escalar modelos para atender demandas específicas. Varía dende o procesamento previo de datos ata a implantación do modelo.
Que é o recoñecemento facial?
O recoñecemento facial é un visión por computador tarefa que identifica a identificación dunha persoa en función do seu rostro. Esta técnica recoñece trazos faciais, como a forma e textura dos ollos, o nariz e a boca.
E compáraos cunha base de datos de caras coñecidas para identificar unha coincidencia. O recoñecemento facial ten varios usos, incluíndo sistemas de seguridade, organización de fotografías e autenticación biométrica.
A precisión dos algoritmos de recoñecemento facial aumentou substancialmente nos últimos anos como resultado dos avances na aprendizaxe automática.
Importación de bibliotecas necesarias
Antes de comezar calquera cousa, necesitamos importar as bibliotecas necesarias para o noso modelo. Tensorflow (tf) impórtase e utilízase para crear e adestrar o modelo. <(p>
"numpy" realiza cálculos matemáticos e procesamento de datos.
“matplotlib.pyplot” impórtase como plt e úsase para gráficos e visualizacións de datos.
Finalmente, "fetch lfw people" impórtase de sklearn. conxuntos de datos e usados para cargar o conxunto de datos de recoñecemento facial. Esta función forma parte do kit de ferramentas scikit-learn. Grazas a esta función non tivemos que cargar outro conxunto de datos. Isto xa está construído en sckit-learn.
E, dálle acceso a unha ampla gama de conxuntos de datos para a aprendizaxe automática aplicacións. Neste escenario, usamos o método fech lfw people para recuperar o conxunto de datos "Labeled Faces in the Wild" (LFW). Comprende fotos dos rostros das persoas, así como as etiquetas que van con elas.
Estas bibliotecas son fundamentais na implementación e avaliación do noso modelo de recoñecemento facial.
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt from sklearn.datasets
import fetch_lfw_people
Preprocesamento e carga do conxunto de datos de recoñecemento facial
Nesta parte, utilizamos a función "buscar persoas lfw" para preprocesar os datos de recoñecemento facial. En primeiro lugar, usamos fetch lfw people coa opción "min faces per person=60". Isto indica que só queremos incluír no conxunto de datos persoas que teñan polo menos 60 fotos. Polo tanto, asegurámonos de que o noso modelo teña datos adecuados para aprender. Ademais, isto reduce o perigo de sobreadaptación.
Despois extráense os datos e as etiquetas do obxecto caras e asígnanse ás variables X e y. X hol.
Agora estamos preparados para adestrar o noso modelo de recoñecemento facial utilizando datos e etiquetas preprocesados.
faces = fetch_lfw_people(min_faces_per_person=60)
X = faces.data
y = faces.target
target_names = faces.target_names
Separación de conxuntos de adestramento e proba
Neste paso, dividimos o noso conxunto de datos de recoñecemento facial en dúas metades usando o método de división da proba do tren de sklearn.model selection. O obxectivo desta división é avaliar o rendemento do noso modelo despois do adestramento
A función de división da proba do tren acepta como entrada os datos X e as etiquetas y. E, divídeos en conxuntos de adestramento e probas. Seleccionamos o tamaño da proba=0.2 neste exemplo. Isto implica que o 20% dos datos serán utilizados como conxunto de proba e o 80% como conxunto de adestramento. Ademais, usamos o estado aleatorio=42 para asegurarnos de que os datos se dividan de forma consistente cada vez que se realiza o código.
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)
Preparación dos datos
O propósito do preprocesamento dos datos é preparalos para a súa entrada no modelo. Os datos son preprocesados neste código dividindo cada punto de datos por 255.
Que nos motivou a conseguilo? A normalización é un procedemento de preprocesamento usado na aprendizaxe automática para garantir que todas as funcións estean na mesma escala. Neste escenario, dividir por 255 escala os datos a un rango de 0 a 1, que é un paso habitual de normalización de datos de imaxe.
Isto acelera a converxencia do modelo e pode aumentar o seu rendemento.
X_train = X_train / 255.0
X_test = X_test / 255.0
Creando o modo
Queremos identificar o individuo cuxo rostro aparece nunha imaxe. Neste caso, utilizaremos unha rede totalmente conectada, moitas veces coñecida como rede densa. É unha rede neuronal artificial que se utilizou para crear o modelo.
As redes neuronais artificiais son modeladas segundo como funciona e está organizado o cerebro humano. Están formados por nodos de procesamento da información ou neuronas que están enlazadas. Cada neurona dunha capa nunha rede densa está ligada a todas as neuronas da capa superior dela.
O modelo ten catro capas neste código. Para ser introducidos na seguinte capa, os datos de entrada aplanaranse na primeira capa nunha matriz unidimensional. En consecuencia, as neuronas 128 e 64 das dúas capas seguintes están completamente ligadas.
A función de activación de ReLU é unha función de activación única utilizada por estas capas. Con iso, podemos conseguir que o modelo aprenda correlacións non lineais entre as entradas e as saídas. A última capa emprega a función de activación softmax para facer predicións. E, é unha capa totalmente conectada con tantas neuronas como clases potenciais hai.
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')
])
Elaboración do modelo
O modelo compílase mediante a función "compilar". Hai que preparar o modelo para a formación. Así, definiremos o optimizador, a función de perda e as métricas que se utilizarán para avaliar o modelo.
Durante o adestramento, o optimizador encárgase de cambiar os parámetros do modelo. O optimizador "adam" é unha técnica de optimización de aprendizaxe profunda popular.
Usamos a función de perda para avaliar o rendemento do modelo nos datos de adestramento. Dado que as etiquetas de destino son números enteiros que reflicten a clase da imaxe en lugar de vectores codificados nun quente, a función de perda de "entropía cruzada categórica escasa" é favorable.
Finalmente, definimos as métricas para avaliar o modelo, neste caso, a “precisión”.
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
Formación de modelos
Usaremos a función "axustar" para adestrar o modelo.
Proporcionaremos os datos de adestramento (tren X) e as etiquetas relacionadas (tren y), ademais de establecer o número de épocas (iteracións) a executar como 10. O procedemento de adestramento modifica os pesos do modelo para reducir unha perda (a diferenza entre etiquetas previstas e reais) e mellorar a precisión dos datos de adestramento.
model.fit(X_train, y_train, epochs=10)
Modelo de Avaliación
Agora, necesitamos avaliar o modelo adestrado nos datos da proba. Usamos a perda de proba e a precisión da proba utilízase para avaliar o rendemento do modelo. Na proba de datos de proba X e as etiquetas de proba y proba, necesitamos chamar "a función model.evaluate"
A función mostra a precisión da proba e a perda da proba. As variables perda de proba e precisión de proba, respectivamente, conteñen estes valores. Finalmente, usamos a función "imprimir" para mostrar a precisión da proba.
test_loss, test_accuracy = model.evaluate(X_test, y_test)
print("Test accuracy:", test_accuracy)
Predición de clases e obtención das clases previstas
Usando o modelo de adestramento e os datos de proba, o algoritmo fai predicións. Cando os datos da proba se pasan ao método "model.predict", mostra unha matriz de predicións para cada imaxe do conxunto de probas.
O nome da clase de destino para cada imaxe obtén despois da lista de "nomes de destino" mediante a función "np.argmax" para identificar o índice coa maior probabilidade prevista. Este índice úsase entón para determinar a clase prevista para cada imaxe.
Usando unha lista de comprensión, todas as predicións da matriz "predicións" están sometidas a este método, dando como resultado a lista de "clases previstas".
predictions = model.predict(X_test)
predicted_classes = [target_names[np.argmax(prediction)] for prediction in predictions]
Visualización das predicións
Agora podemos ver como queda o noso modelo.
Para avaliar o ben que está a facer o modelo, mostraranse as 10 primeiras fotos e as súas predicións. Representará as fotos en escala de grises e mostrará tanto a clase real da imaxe como a clase prevista polo modelo mediante o módulo matplotlib.pyplot.
A función "imshow" é usada polo bucle for para representar cada unha das 10 primeiras fotos do conxunto de probas. Os nomes dos obxectivos[y test[i]] e as clases previstas[i] úsanse para determinar a clase real e a clase prevista da imaxe, respectivamente. Os títulos de cada parcela indícanse entón mediante estas clasificacións.
Finalmente, o gráfico móstrase mediante o método 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()
Envolver
TensorFlow ofrece un ambiente completo e flexible para crear modelos de aprendizaxe automática.
Ao axustar o modelo para satisfacer requisitos particulares ou engadindo novos desenvolvementos na aprendizaxe automática, a precisión do modelo pode aumentar aínda máis.
TensorFlow e o recoñecemento facial probablemente se utilicen cada vez máis en industrias como os sistemas de seguridade, a autenticación biométrica e a asistencia sanitaria no futuro. En breve veremos innovacións fascinantes.
Deixe unha resposta