TensorFlow est un outil polyvalent pour créer des modèles d'apprentissage automatique.
Dans cet article, nous verrons comment créer un système de reconnaissance faciale avec TensorFlow, un framework d'apprentissage automatique open source. Nous passerons en revue les processus essentiels pour créer un système de reconnaissance faciale réussi, de la collecte et de la préparation des données à la formation et à l'évaluation d'un modèle.
Vous obtiendrez une expérience de première main avec TensorFlow pour créer une reconnaissance faciale à l'aide d'extraits de code et d'exemples concrets. Vous êtes invités à suivre notre progression.
Introduction à TensorFlow
TensorFlow est une bibliothèque gratuite et open-source. Il s'agit d'une boîte à outils mathématique symbolique qui utilise le flux de données et la programmation différentiable. Vous pouvez gérer une gamme de tâches avec elle, y compris en profondeur Réseau neuronal la formation.
TensorFlow est puissant et adaptable. De même, c'est un excellent outil pour développer et déploiement de modèles d'apprentissage automatique. Vous pouvez construire des modèles complexes avec plusieurs couches et opérations tensorielles. De plus, les modèles pré-construits dans la bibliothèque peuvent être affinés pour des besoins spécifiques.
De plus, TensorFlow a une communauté d'utilisateurs énorme et en pleine expansion. Il existe donc une pléthore d'informations et d'aide pour les personnes qui découvrent la plate-forme.
TensorFlow est populaire pour machine learning en partie parce qu'il fournit un flux de travail de bout en bout. Ainsi, vous pouvez facilement construire, former et déployer des modèles. Il fournit des outils et des stratégies pour améliorer et mettre à l'échelle les modèles afin de répondre à des demandes spécifiques. Cela varie du prétraitement des données au déploiement du modèle.
Qu'est-ce que la reconnaissance faciale ?
La reconnaissance faciale est un vision par ordinateur tâche qui identifie l'identification d'une personne en fonction de son visage. Cette technique reconnaît les traits du visage, tels que la forme et la texture des yeux, du nez et de la bouche.
Et, il les compare à une base de données de visages connus pour identifier une correspondance. La reconnaissance faciale a plusieurs utilisations, notamment les systèmes de sécurité, l'organisation des photos et l'authentification biométrique.
La précision des algorithmes de reconnaissance faciale a considérablement augmenté ces dernières années grâce aux percées de l'apprentissage automatique.
Importation des bibliothèques nécessaires
Avant de commencer quoi que ce soit, nous devons importer les bibliothèques nécessaires à notre modèle. Tensorflow (tf) est importé et utilisé pour créer et former le modèle. <(p>
"numpy" effectue des calculs mathématiques et le traitement des données.
"matplotlib.pyplot" est importé en tant que plt et utilisé pour cartographie des données et visualisations.
Enfin, "fetch lfw people" est importé de sklearn. ensembles de données et utilisé pour charger l'ensemble de données de reconnaissance faciale. Cette fonction fait partie de la boîte à outils scikit-learn. Grâce à cette fonction, nous n'avons pas eu à télécharger un autre jeu de données. Ceci est déjà intégré dans sckit-learn.
De plus, il vous donne accès à une large gamme de ensembles de données pour l'apprentissage automatique applications. Dans ce scénario, nous utilisons la méthode fetch lfw people pour récupérer l'ensemble de données "Labeled Faces in the Wild" (LFW). Il comprend des photos de visages de personnes ainsi que les étiquettes qui les accompagnent.
Ces bibliothèques sont essentielles à la mise en œuvre et à l'évaluation de notre modèle de reconnaissance faciale.
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt from sklearn.datasets
import fetch_lfw_people
Prétraitement et chargement de l'ensemble de données de reconnaissance faciale
Dans cette partie, nous utilisons la fonction « récupérer les personnes lfw » pour prétraiter les données de reconnaissance faciale. Tout d'abord, nous utilisons fetch lfw people avec l'option "min faces per person=60". Cela indique que nous ne voulons inclure dans l'ensemble de données que les personnes qui ont au moins 60 photos. Par conséquent, nous nous assurons que notre modèle dispose de données adéquates pour apprendre. En outre, cela réduit le risque de surajustement.
Les données et les étiquettes de l'objet faces sont ensuite extraites et affectées aux variables X et y. X hol.
Nous sommes maintenant prêts à former notre modèle de reconnaissance faciale à l'aide de données et d'étiquettes prétraitées.
faces = fetch_lfw_people(min_faces_per_person=60)
X = faces.data
y = faces.target
target_names = faces.target_names
Fractionnement des ensembles d'entraînement et de test
Dans cette étape, nous avons divisé notre ensemble de données de reconnaissance faciale en deux moitiés à l'aide de la méthode de fractionnement de test de train à partir de la sélection sklearn.model. L'objectif de ce découpage est d'évaluer les performances de notre modèle après l'entraînement
La fonction train test split accepte en entrée les données X et les étiquettes y. Et, il les divise en ensembles de formation et de test. Nous sélectionnons test size=0.2 dans cet exemple. Cela implique que 20 % des données seront utilisées comme ensemble de test et 80 % comme ensemble d'apprentissage. De plus, nous utilisons random state=42 pour nous assurer que les données sont divisées de manière cohérente à chaque fois que le code est exécuté.
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)
Préparation des données
Le but du prétraitement des données est de les préparer pour l'entrée dans le modèle. Les données sont prétraitées dans ce code en divisant chaque point de données par 255.
Qu'est-ce qui nous a motivés à y parvenir ? La normalisation est une procédure de prétraitement utilisée dans l'apprentissage automatique pour garantir que toutes les fonctionnalités sont à la même échelle. Dans ce scénario, la division par 255 met les données à l'échelle dans une plage de 0 à 1, ce qui est une étape habituelle de normalisation des données d'image.
Cela accélère la convergence du modèle et peut augmenter ses performances.
X_train = X_train / 255.0
X_test = X_test / 255.0
Création du mode
Nous voulons identifier l'individu dont le visage apparaît sur une photo. Dans ce cas, nous utiliserons un réseau entièrement connecté, souvent appelé réseau dense. C'est un réseau de neurones artificiels qui a été utilisé pour créer le modèle.
Les réseaux de neurones artificiels sont calqués sur le fonctionnement et l'organisation du cerveau humain. Ils sont constitués de nœuds de traitement de l'information ou de neurones qui sont reliés entre eux. Chaque neurone d'une couche d'un réseau dense est lié à chaque neurone de la couche au-dessus.
Le modèle comporte quatre couches dans ce code. Pour être introduites dans la couche suivante, les données d'entrée sont aplaties dans la première couche en un tableau unidimensionnel. Les neurones 128 et 64 des deux couches suivantes sont donc complètement liés.
La fonction d'activation ReLU est une fonction d'activation unique utilisée par ces couches. Avec cela, nous pouvons faire en sorte que le modèle apprenne des corrélations non linéaires entre les entrées et les sorties. La dernière couche utilise la fonction d'activation softmax pour faire des prédictions. Et, c'est une couche entièrement connectée avec autant de neurones qu'il y a de classes potentielles.
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')
])
Compilation du modèle
Le modèle est compilé à l'aide de la fonction "compile". Nous devons préparer le modèle pour la formation. Nous allons donc définir l'optimiseur, la fonction de perte et les métriques qui seront utilisées pour évaluer le modèle.
Lors de l'entraînement, l'optimiseur se charge de modifier les paramètres du modèle. L'optimiseur "Adam" est une technique d'optimisation d'apprentissage en profondeur populaire.
Nous utilisons la fonction de perte pour évaluer les performances du modèle sur les données d'apprentissage. Étant donné que les étiquettes cibles sont des nombres entiers reflétant la classe de l'image plutôt que des vecteurs encodés à chaud, la fonction de perte «d'entropie croisée catégorique clairsemée» est favorable.
Enfin, nous définissons les métriques pour évaluer le modèle, dans ce cas, la "précision".
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
Formation modèle
Nous allons utiliser la fonction "fit" pour former le modèle.
Nous fournirons les données d'entraînement (train X) et les étiquettes associées (train y), ainsi que le nombre d'époques (itérations) à exécuter sur 10. La procédure d'entraînement modifie les poids du modèle pour réduire une perte (la différence entre libellés prédits et réels) et améliorer la précision des données d'entraînement.
model.fit(X_train, y_train, epochs=10)
Évaluation du modèle
Maintenant, nous devons évaluer le modèle formé sur les données de test. Nous utilisons la perte de test et la précision du test sont utilisées pour évaluer les performances du modèle. Sur le test des données de test X et le test des étiquettes de test y, nous devons appeler "la fonction model.evaluate"
La fonction génère la précision du test et la perte de test. Les variables perte de test et précision du test contiennent respectivement ces valeurs. Enfin, nous utilisons la fonction "print" pour afficher la précision du test.
test_loss, test_accuracy = model.evaluate(X_test, y_test)
print("Test accuracy:", test_accuracy)
Prédire les classes et obtenir les classes prédites
À l'aide du modèle d'apprentissage et des données de test, l'algorithme effectue des prédictions. Lorsque les données de test sont transmises à la méthode "model.predict", elle génère un tableau de prédictions pour chaque image de l'ensemble de test.
Le nom de la classe cible pour chaque image est ensuite extrait de la liste des "noms cibles" à l'aide de la fonction "np.argmax" pour identifier l'index avec la plus grande probabilité prédite. Cet index est ensuite utilisé pour déterminer la classe prédite pour chaque image.
En utilisant une compréhension de liste, toutes les prédictions du tableau « prédictions » sont soumises à cette méthode, ce qui donne la liste des « classes prédites ».
predictions = model.predict(X_test)
predicted_classes = [target_names[np.argmax(prediction)] for prediction in predictions]
Visualiser les prédictions
Nous pouvons maintenant voir à quoi ressemble notre modèle.
Pour évaluer les performances du modèle, les 10 premières photos et leurs prédictions seront affichées. Il tracera les photos en niveaux de gris et affichera à la fois la classe réelle de l'image et la classe prédite par le modèle à l'aide du module matplotlib.pyplot.
La fonction "imshow" est utilisée par la boucle for pour tracer chacune des 10 premières photos de l'ensemble de test. Les noms cibles[y test[i]] et les classes prédites[i] sont utilisés pour déterminer respectivement la classe réelle et la classe prédite de l'image. Les titres de chaque parcelle sont alors indiqués par ces classements.
Enfin, le tracé est affiché à l'aide de la méthode 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()
Emballer
TensorFlow offre un environnement complet et flexible pour créer des modèles d'apprentissage automatique.
En affinant le modèle pour répondre à des exigences particulières ou en ajoutant de nouveaux développements dans l'apprentissage automatique, la précision du modèle peut être encore augmentée.
TensorFlow et la reconnaissance faciale seront probablement de plus en plus utilisés dans des secteurs tels que les systèmes de sécurité, l'authentification biométrique et les soins de santé à l'avenir. Nous verrons bientôt des innovations fascinantes.
Soyez sympa! Laissez un commentaire