TensorFlow es una herramienta versátil para crear modelos de aprendizaje automático.
En esta publicación, veremos cómo crear un sistema de reconocimiento facial con TensorFlow, un marco de aprendizaje automático de código abierto. Repasaremos los procesos esenciales para crear un sistema de reconocimiento facial exitoso, desde recopilar y preparar datos hasta entrenar y evaluar un modelo.
Obtendrá experiencia de primera mano con TensorFlow para crear reconocimiento facial con la ayuda de fragmentos de código y ejemplos del mundo real. Le invitamos a seguirnos a medida que avanzamos.
Introducción a TensorFlow
TensorFlow es una biblioteca gratuita y de código abierto. Es una caja de herramientas matemática simbólica que utiliza flujo de datos y programación diferenciable. Puede manejar una variedad de tareas con él, incluida la profunda red neural entrenamiento.
TensorFlow es poderoso y adaptable. Asimismo, es una gran herramienta para desarrollar y implementación de modelos de aprendizaje automático. Puede construir modelos complicados con varias capas y operaciones de tensor. Además, los modelos preconstruidos en la biblioteca se pueden ajustar para necesidades específicas.
Además, TensorFlow tiene una comunidad de usuarios enorme y en expansión. Por lo tanto, hay una gran cantidad de información y ayuda para las personas que son nuevas en la plataforma.
TensorFlow es popular para máquina de aprendizaje en parte porque proporciona un flujo de trabajo de extremo a extremo. Por lo tanto, puede construir, entrenar e implementar modelos fácilmente. Proporciona herramientas y estrategias para mejorar y escalar modelos para adaptarse a demandas específicas. Varía desde el preprocesamiento de datos hasta la implementación del modelo.
¿Qué es el reconocimiento facial?
El reconocimiento facial es un visión de computadora tarea que identifica la identificación de una persona en base a su rostro. Esta técnica reconoce rasgos faciales, como la forma y textura de los ojos, la nariz y la boca.
Y los compara con una base de datos de caras conocidas para identificar una coincidencia. El reconocimiento facial tiene varios usos, incluidos los sistemas de seguridad, la organización de fotografías y la autenticación biométrica.
La precisión de los algoritmos de reconocimiento facial ha aumentado sustancialmente en los últimos años como resultado de los avances en el aprendizaje automático.
Importación de bibliotecas necesarias
Antes de comenzar, debemos importar las bibliotecas necesarias para nuestro modelo. Tensorflow (tf) se importa y se utiliza para crear y entrenar el modelo. <(p>
“numpy” realiza cálculos matemáticos y procesamiento de datos.
“matplotlib.pyplot” se importa como plt y se usa para gráficos y visualizaciones de datos.
Finalmente, "buscar lfw personas" se importa de sklearn. conjuntos de datos y se utiliza para cargar el conjunto de datos de reconocimiento facial. Esta función es parte del kit de herramientas scikit-learn. Gracias a esta función no tuvimos que cargar otro conjunto de datos. Esto ya está integrado en sckit-learn.
Y le da acceso a una amplia gama de conjuntos de datos para el aprendizaje automático aplicaciones En este escenario, usamos el método fetch lfw people para recuperar el conjunto de datos "Labeled Faces in the Wild" (LFW). Comprende fotos de caras de personas, así como las etiquetas que las acompañan.
Estas bibliotecas son críticas en la implementación y evaluación de nuestro modelo de reconocimiento facial.
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt from sklearn.datasets
import fetch_lfw_people
Preprocesamiento y carga del conjunto de datos de reconocimiento facial
En esta parte, utilizamos la función "buscar personas LFW" para preprocesar los datos de reconocimiento facial. Primero, usamos buscar personas lfw con la opción "caras mínimas por persona = 60". Esto indica que solo queremos incluir personas en el conjunto de datos que tengan al menos 60 fotos. Por lo tanto, nos aseguramos de que nuestro modelo tenga datos adecuados para aprender. Además, esto reduce el peligro de sobreajuste.
Luego, los datos y las etiquetas del objeto de rostros se extraen y asignan a las variables X e y. vacaciones X
Ahora estamos listos para entrenar nuestro modelo de reconocimiento facial utilizando etiquetas y datos preprocesados.
faces = fetch_lfw_people(min_faces_per_person=60)
X = faces.data
y = faces.target
target_names = faces.target_names
División de conjuntos de prueba y entrenamiento
En este paso, dividimos nuestro conjunto de datos de reconocimiento facial en dos mitades utilizando el método de división de prueba de tren de la selección de sklearn.model. El objetivo de esta división es evaluar el rendimiento de nuestro modelo después del entrenamiento.
La función de división de prueba de tren acepta como entradas los datos X y las etiquetas y. Y los divide en conjuntos de entrenamiento y prueba. Seleccionamos test size=0.2 en este ejemplo. Esto implica que el 20 % de los datos se utilizará como conjunto de prueba y el 80 % como conjunto de entrenamiento. Además, usamos estado aleatorio = 42 para garantizar que los datos se dividan de manera consistente cada vez que se ejecuta el 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)
Preparando los datos
El propósito del preprocesamiento de datos es prepararlos para su entrada en el modelo. Los datos se procesan previamente en este código dividiendo cada punto de datos por 255.
¿Qué nos motivó a lograr esto? La normalización es un procedimiento de preprocesamiento utilizado en el aprendizaje automático para garantizar que todas las características estén en la misma escala. En este escenario, dividir por 255 escala los datos a un rango de 0 a 1, que es un paso habitual de normalización de datos de imagen.
Esto acelera la convergencia del modelo y puede aumentar su rendimiento.
X_train = X_train / 255.0
X_test = X_test / 255.0
Creando el modo
Queremos identificar al individuo cuyo rostro aparece en una imagen. En este caso, utilizaremos una red totalmente conectada, a menudo conocida como red densa. Es una red neuronal artificial que se utilizó para crear el modelo.
Las redes neuronales artificiales se modelan según el funcionamiento y la organización del cerebro humano. Están formados por nodos de procesamiento de información o neuronas que están conectadas. Cada neurona de una capa en una red densa está vinculada a cada neurona de la capa superior.
El modelo tiene cuatro capas en este código. Para pasar a la siguiente capa, los datos de entrada se aplanan en la primera capa en una matriz unidimensional. Las neuronas 128 y 64 de las dos capas siguientes, por consiguiente, están completamente unidas.
La función de activación ReLU es una función de activación única utilizada por estas capas. Con eso, podemos hacer que el modelo aprenda correlaciones no lineales entre las entradas y salidas. La última capa emplea la función de activación softmax para hacer predicciones. Y es una capa completamente conectada con tantas neuronas como clases potenciales.
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')
])
Compilación del Modelo
El modelo se compila utilizando la función "compilar". Necesitamos preparar el modelo para el entrenamiento. Entonces, definiremos el optimizador, la función de pérdida y las métricas que se utilizarán para evaluar el modelo.
Durante el entrenamiento, el optimizador se encarga de cambiar los parámetros del modelo. El optimizador "adam" es una popular técnica de optimización de aprendizaje profundo.
Usamos la función de pérdida para evaluar el rendimiento del modelo en los datos de entrenamiento. Debido a que las etiquetas de destino son números enteros que reflejan la clase de la imagen en lugar de vectores codificados one-hot, la función de pérdida de "entropía cruzada categórica dispersa" es favorable.
Finalmente, definimos las métricas para evaluar el modelo, en este caso, “precisión”.
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
Entrenamiento de modelos
Usaremos la función "ajustar" para entrenar el modelo.
Proporcionaremos los datos de entrenamiento (tren X) y las etiquetas relacionadas (tren y), además de establecer el número de épocas (iteraciones) para ejecutar en 10. El procedimiento de entrenamiento modifica los pesos del modelo para reducir una pérdida (la diferencia entre etiquetas pronosticadas y reales) y mejorar la precisión de los datos de entrenamiento.
model.fit(X_train, y_train, epochs=10)
Evaluación del modelo
Ahora, necesitamos evaluar el modelo entrenado en los datos de prueba. Utilizamos la pérdida de prueba y la precisión de la prueba para evaluar el rendimiento del modelo. En la prueba de datos de prueba X y las etiquetas de prueba y prueba, necesitamos llamar a "la función model.evaluate"
La función genera la precisión de la prueba y la pérdida de la prueba. Las variables pérdida de prueba y precisión de prueba, respectivamente, contienen estos valores. Finalmente, usamos la función "imprimir" para generar la precisión de la prueba.
test_loss, test_accuracy = model.evaluate(X_test, y_test)
print("Test accuracy:", test_accuracy)
Predicción de clases y obtención de las clases previstas
Usando el modelo de entrenamiento y los datos de prueba, el algoritmo hace predicciones. Cuando los datos de prueba se pasan al método "model.predict", genera una matriz de predicciones para cada imagen en el conjunto de prueba.
El nombre de la clase de destino para cada imagen se recupera de la lista de "nombres de destino" utilizando la función "np.argmax" para identificar el índice con la mayor probabilidad prevista. Este índice se usa luego para determinar la clase predicha para cada imagen.
Usando una lista de comprensión, todas las predicciones en la matriz de "predicciones" están sujetas a este método, lo que da como resultado la lista de "clases previstas".
predictions = model.predict(X_test)
predicted_classes = [target_names[np.argmax(prediction)] for prediction in predictions]
Visualización de las predicciones
Ahora podemos ver cómo se ve nuestro modelo.
Para evaluar qué tan bien le está yendo al modelo, se mostrarán las primeras 10 fotos y sus predicciones. Trazará las fotos en escala de grises y mostrará tanto la clase real de la imagen como la clase predicha por el modelo usando el módulo matplotlib.pyplot.
La función "imshow" es utilizada por el bucle for para trazar cada una de las primeras 10 fotos del conjunto de prueba. Los nombres de destino[y test[i]] y las clases pronosticadas[i] se utilizan para determinar la clase real y la clase pronosticada de la imagen, respectivamente. Los títulos de cada parcela son luego indicados por estas clasificaciones.
Finalmente, el gráfico se muestra utilizando el 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 entorno completo y flexible para crear modelos de aprendizaje automático.
Al ajustar el modelo para cumplir con requisitos particulares o al agregar nuevos desarrollos en el aprendizaje automático, la precisión del modelo puede aumentar aún más.
Es probable que TensorFlow y el reconocimiento facial se utilicen cada vez más en industrias como los sistemas de seguridad, la autenticación biométrica y la atención médica en el futuro. Veremos innovaciones fascinantes en breve.
Deje un comentario