Transcription
1. Introduction: Bienvenue dans le cours de
détection des risques avec le deep learning, où nous créerons une
application de bout en bout capable détecter les mines dans les
images et les vidéos. Je m'appelle l'arsine et je serai votre instructeur
dans ce cours. Je fais de la programmation
depuis 2019. Et je suis l'auteur
du blog, don't
repeat yourself.org, où j'ai plus de 5
000 développeurs chaque mois pour en savoir
plus sur Python, l'apprentissage
automatique et la vision par
ordinateur. La classification des images est une tâche très courante
en vision artificielle. Il s'agit d'une tâche où vous
avez un ensemble d'images et l'unité pour les classer
dans un ensemble de catégories. Dans ce cours, plus précisément, nous allons classer les images
en deux catégories. Sourire et hocher la tête, sourire. Que nous utiliserons le deep learning
et commencerons par entraîner un réseau neuronal convolutif
sur ce jeu de données moins, qui contient des visages de personnes
souriantes et non souriantes. Une fois le réseau sec, nous allons suivre
les étapes suivantes pour détecter les sourires dans les
images et les vidéos. Nous utiliserons les cascades dures
pour détecter un visage, une image. Nous allons ensuite extraire la région du
visage de l'image. Ensuite, nous passerons
la région de taille
au réseau pour classification. Enfin, nous allons
annoter l'image avec
l' étiquette sourire
ou ne pas sourire, en fonction de la
sortie du réseau. Si cela semble excitant, entrons en
classe et commençons à créer notre application de
détection des odeurs.
2. Installation: Dans cette première vidéo, nous allons voir comment installer les packages requis
pour ce projet. Vous pouvez prendre le
fichier
requirements.txt à partir du code source
et installer ce qu'il contient. Ou si vous me
suivez, vous pouvez créer un nouveau fichier
dans le répertoire du projet. Nous allons l'appeler
dxdy de requirement et y insérer les bibliothèques
nécessaires pour ce projet. Nous avons donc besoin de num pi. Nous avons étudié comment
les cyclistes apprennent OpenCV. Nous avons également besoin de caillots de boue. Ensuite, nous avons besoin, maintenant nous enregistrons le fichier. Et la terminologie que nous avons apprise
part du texte ponctuel sur les
exigences en matière d'alimentation. Dans mon cas, les packages
sont déjà installés. Nous pouvons donc voir ici que les
exigences
satisfont déjà à toutes ces bibliothèques. Mais dans votre cas, vous verrez que les packages
sont en cours d'installation. Et cela peut prendre un certain temps
pour les installer tous.
3. Charger les données: Dans cette vidéo, nous
allons charger ces souris. Le jeu de données souris contient plus de 13 000 images en niveaux
de
gris de 64 x 64 pixels en crise. sourient,
mais ils ne sourient pas. Pour les visages non souriants, nous avons plus de
9 000 images. Et pour les visages souriants, nous avons 3 690 images. Le doctype set
est donc déséquilibré, ce qui signifie qu'il y a une distribution uniforme
des images. Une technique courante
pour traiter un ensemble de données déséquilibré consiste
à appliquer une attente de classe. Nous verrons comment procéder
lorsque nous construirons notre modèle. Nous allons donc d'abord
télécharger le jeu de données. Vous pouvez accéder à cette
URL pour la télécharger. Nous allons donc cliquer sur le bouton Enregistrer et nous le
téléchargerons au format zip. Une fois le fichier
téléchargé, nous le décompressons. Nous supprimons ce fichier. Et notre ensemble de données est contenu dans ce dossier Formula
You Smiles. Nous avons donc ici deux sous-dossiers,
positifs et négatifs. Celui-ci contient
des images de visages souriants, comme vous pouvez le voir ici. Et le contenu du
dossier des négatifs, des
images de non-sourire. Comme vous pouvez le voir, les images sont en gris et font un
peu plus de 64 par 64. Normalement, nous pouvons entraîner notre
modèle avec un problème de conduit. Cela ne devrait pas consommer
beaucoup de ressources. N'oubliez pas de copier le dossier dans
le répertoire du projet. Nous sommes maintenant prêts à charger
notre jeu de données à partir de ce fichier. Commençons donc par importer
les packages nécessaires. Nous allons d'abord créer un nouveau fichier
Python, training point p-y. Nous allons commencer par
importer la fonction de
division de test de train de scikit-learn
got wandering selection. Aujourd'hui, avec cette division, nous allons l'utiliser pour diviser notre
ensemble de données en jeu d'entraînement, jeu de
validation
et jeu de test. Ensuite, nous avons la fonction de tableau
d'images. Donc, aucune impulsion dans mon image ou image à matrice. Et puis nous avons à partir de TensorFlow keras dot load in range, que nous utiliserons pour
charger une image à partir de cela. Ensuite, nous avons le modèle
séquentiel. Donc, à partir de servir Flow Keras, Sequential. Ensuite, nous avons besoin d'avocats. Nous aurons donc TensorFlow. Keras, les couches viennent à l"année. Ensuite, nous avons la piscine des moines, puis nous avons la couche aplatie, et enfin la couche dense. Nous avons également besoin du module pyplot, numpy et du package OS. Importons-les également. Nous sommes maintenant prêts
à charger notre jeu de données. Créons donc une fonction
appelée parties d'image, qui amènera le bot au jeu
de données en tant qu'argument. Elle renverra la liste des chemins
d'accès aux images
du jeu de données. Nous pouvons donc d'abord créer une
liste d'extensions valides. Nous allons donc dire que les
formats valides sont égaux à. Gpg inclura P et G. Nous allons donc utiliser cette liste pour vérifier si l'extension de
fichier est une image. Ensuite, créons une liste vide
appelée parties d'image. Est égal à une
liste vide, qui contiendra,
contiendra les parties des images dans
le jeu de données. Ensuite, nous allons regarder
l'arborescence du répertoire racine. Disons que les noms de
vos modules apparaissent sur le mur. Et ici, le chemin est le chemin d'accès au
répertoire courant dans l'arborescence. Et leurs noms sont ceux
des sous-répertoires
du répertoire courant
dans les trois, et les cinq noms sont
les fichiers du répertoire
courant. Commençons donc par l'impression. Voici mon Harris et nous
verrons ce que je vais dire ici. Vous avez beaucoup de plantes. Nous partons tout droit de
cet axone léger. Nous allons lancer notre script. La sortie ici est donc tous les sous-répertoires
du répertoire smiles. Comme vous pouvez le voir, nous avons
les négatifs, les positifs, qui sont ici,
puis les négatifs sept, positifs, sept, qui
sont ici. Et voilà. Nous allons maintenant faire une boucle
sur l'iris final. Nous allons donc écrire
pour le nom dans les noms. Imprimons également le tube et la dernière partie pour
voir ce qui se passe. Nous pouvons donc écrire que vous êtes sur votre propre script couleur. Donc, comme vous pouvez le voir, nous avons ce pot répertoire
puis ce grain fin. Et puis cette couche
a acheté ce nom de fichier, qui est une image, et ainsi de suite. Ce que nous pouvons faire maintenant est
d'extraire l'extension du fichier, qui est soit This, this, et de la comparer à notre, à cette liste pour vérifier si
le nom du fichier est une image. Nous allons donc écrire ici extension. Vous voulez scinder du texte. Nous fournissons un beau nom. Noé. Ensuite, nous écrirons que notre extension est dans la liste des formats
valides. Nous allons construire le
chemin complet vers notre image. Nous allons donc dire que la partie de
l'image est égale à la jointure point, point, point du système d'exploitation. Et ici, nous allons rejoindre
la partie annuaire, qui est celle-ci. Nous définissons ici le nom de la partie. Avec le financement de
cette image particulière. Le nom complet de l'
image sera celui-ci. Et nous devons également ajouter
notre image deux, notre liste. Nous en avons terminé avec cette fonction. Juste des parties d'image écrites. Maintenant, avec cette
fonction, nous avons le chemin complet de chaque image du jeu de données
stocké dans une liste. L'étape suivante consiste donc à utiliser ces parties d'image et à charger
le jeu de données le plus intelligent. Nous pouvons donc dire que nous allons créer une nouvelle fonction. Nommez-le cellule de pesée. Et ici, nous allons
fournir deux arguments. Le premier correspond
aux parties de l'image et le second à la taille
cible des images. Nous allons le définir ici. Supposons que la taille de l'image
soit égale à 3232. Chemins d'image corporelle de l'image Nous pouvons maintenant créer
deux listes vides. Tout d'abord, nous la
nommerons la ville, qui
contiendra les images. Ensuite, nous l'avons lu. Il en va de même pour les étiquettes nommées, qui contiendra l'étiquette pour chaque image souriante
ou non souriante. Ensuite, nous allons commencer
par récupérer les images. Nous pouvons donc faire une boucle sur
les parties de l'image. Nous dirons pour les modules de partie image. Ici nous allons écrire
image is equal to, nous allons charger notre image en utilisant
la fonction load image. Ici, le premier argument
est le chemin qui mène à notre image. Et puis nous avons le
mode couleur, qui est en niveaux de gris. Et puis le dernier argument
est la taille cible, que nous pouvons utiliser
notre taille cible. Ensuite, nous devons convertir
notre image en tableau NumPy. Nous allons simplement écrire l'image deux. Enfin, nous ajoutons
notre image aux données. Nous en avons donc terminé
avec les images. Nous pouvons maintenant obtenir les étiquettes. Maintenant, pour obtenir l'étiquette, nous pouvons l'
extraire de l'image. Mais par exemple, nous allons
imprimer
ici les parties de l'image. Et nous dirons : « Voyez ce que nous obtenons. Les données. Fournissez une boîte d'image. Comme vous pouvez le voir, nous avons le bot de chaque
image de notre jeu de données. Par exemple, voici le chemin complet vers cette image
en particulier. Donc, si nous prenons la partie complète, nous pouvons extraire l'
étiquette de cette partie, qui est ici positive. Donc pour cette image en particulier, la personne sourit. Nous avons un
visage souriant sur cette image. Donc pour obtenir le label, nous trouverons ici cette ligne. Et nous allons écrire label est égal à image bond et
former l'image, mais nous allons la diviser en
fonction du séparateur de répertoire, qui est ce séparateur ici. Et nous allons prendre le
troisième à partir de la fin. C'est donc le premier,
moins un, moins deux
et moins trois. Donc, ici, nous allons obtenir l'étiquette
est égale à deux points positifs. Maintenant, nous allons dire que si notre étiquette
est égale à deux positifs, nous allons l'encoder comme un seul. Nous allons donc en écrire un. Si num est égal à positif, sinon nous
encoderons qu'il a 0. Enfin, nous ajoutons notre
étiquette à notre liste. La dernière étape consiste simplement à renvoyer les données, la liste et la liste. Nous nous assurons de
les convertir en tableau NumPy. Nous allons dire return num pi point, réécrire les étiquettes top et
non pi dot. Nous entendons également la nécessité
de mettre à l'échelle les données à l'échelle de 0,1
en les divisant par 255. Ici, nous pouvons obtenir nos tableaux de données
à l'aide de notre fonction.
4. Former le détecteur de sourire: Dans cette partie, nous
allons construire notre modèle et commencer la formation. Le modèle que nous allons
construire consiste en un
relâchement vers la courbe vers le signe plus qui
apparaît à travers les blogs, suivi d'une couche entièrement
connectée. Comme vous pouvez le voir
sur cette image, nous aurons cette couche mince
que la mise en commun maximale de la couche. Et puis la même chose ici, les couches de regroupement
C plus max. Et puis nous aurons le bloc
entièrement connecté, qui consiste en une couche
aplatie, puis une couche dense et autre couche qui
attendra vers l'extérieur comme. Créons donc une fonction. Nous allons lui donner le nom de modèle. Et cela prendra la bonne forme d'un
argument, qui sera égal à
la science moyenne. Gloss one pour une dimension de
canal. Mais nous n'aurions pas besoin de changer. Dans cette rubrique. Nous utiliserons ces modèles d'
équations pour pouvoir écrire marmonner,
vouloir séquentiel. Nous aurons tous les filtres qui prendront le sale boulot. Le gouverneur signe. Voyons voir, taille trois par trois. Pour l'activation de la fonction
d'observation. Ou les croisades. Même forme. Nous utiliserons l'alarme, mise en commun maximale des
vacances, que nous
utiliserons concis pour mon travail. Et puis la même chose ici de la couche de perte de
fluide des filtres. Nous allons doubler le
nombre de filtres. Et puis la couche aplatie. Avec 256. Tu es honnête. Et pour l'activation de la couche de sortie. Nous l'avons fait. Puisque nous avons affaire à un problème de classification
binaire, nous utiliserons la fonction
d'activation sigmoïde et vous enverrons tous. Vous êtes donc du genre à recevoir le signal
d'activation. Compilons également notre modèle. Nous allons donc modéliser point
compiler la fonction de perte. Bien entendu, nous allons prendre
la croix binaire sur copie. L'optimum est 0. Disons que l'
optimiseur ou les métriques. Prends vraiment le Parker Awesome. Ensuite, nous devons calculer
les poids des classes. Comme je l'ai déjà dit, notre ensemble de données est déséquilibré. Nous devons donc donner plus de poids au verre sous-représenté. Sourire plus, dans ce cas, pour que le modèle accorde
plus d'attention à ce verre. Nous pouvons commencer par contenir
le numéro de chaque étiquette en utilisant la fonction
numpy point unique. Nous dirons donc, j'ai oublié de retourner le modèle. Donc, en retour, le modèle, et nous dirons que le nombre d'étiquettes
est l'appel à non pi. Ce qui se passe sur la
tête, nous serons avec nos étiquettes et nous
dirons « retournez, c'est vrai ». Les colonnes de retour sont égales à afficher, pour renvoyer le numéro
de chaque étiquette. Imprimons-les. Nous dirons que nous
n'aurons pas problème avec les produits. Nous l'avons fait. Allez ici, puisque nous
n'avons pas à étiqueter, toutes les étiquettes sont définies sur 0. Maintenant, nous en sommes à notre script. Ici. Comme vous pouvez le voir, nous avons formé un 01 étiqueté, qui sourit
ou ne sourit pas. Et pour la
variable count, nous avons 9 475. Dépliez cette couche de doublure. Nous en avons 3 690. Nous devons donc maintenant calculer
les poids des classes. Pour ça. Nous pouvons utiliser
une opération plus simple. Nous pouvons donc écrire ici compte. Les nouveaux comptes seront
égaux au nombre maximum, qui est ici, et nous le
divisons par les comptes précédents. Déplaçons à nouveau ces deux
variables. Donc ici, comme vous pouvez le voir, le plus un est
MyInt plus aura les poids à 0,56
supérieurs au plus 0. Créons un dictionnaire qui associera chaque
classe à son poids. Nous pouvons donc écrire plus le
poids est égal. Nous allons utiliser la fonction zip. Donc le dictionnaire. Nous devons maintenant créer un ensemble d'entraînement, un jeu de
validation et un ensemble de tests. Nous prélèverons 20 % des
données pour prier cet ensemble. Et sur les 80 % restants, nous prélèverons 20 % pour
créer le jeu de validation. Commençons donc
par le jeu de test. nous utiliserons la fonction de
répartition des essais de train. Donc nous, nous avons aimé
essayer de essayer de fournir notre journée. Et puis suivi de cette
taille prendra 20 pour cent. Dites, commencez la chute. Ils suivent leur
propre démonstration. Ou à faire. Même chose
pour le jeu de validation. Nous avons juste copié-collé. Souche. Égoutter lentement. Nous fournissons. Bon. Nous sommes maintenant prêts à entraîner nos modèles. Nous allons donc d'abord construire
le modèle en écrivant. Le modèle est égal au module. Et nous allons entraîner le
modèle pour la 20e boîte. La boîte est donc égale à un. L'historien de l'art est
le quantile dirait que c'est la merveille pourquoi aujourd'hui. Le jeu de
validation des données de validation. Et nous devons utiliser le poids plus pour la taille du lot. Dis 64. Dépliez la boîte, une boîte. Nous allons également enregistrer le
modèle pour plus tard. Donc, nous pouvons simplement écrire un ne dit pas et nous le nommerons, nuira à un gloss. Attend et attend
le fichier de départ. Nous utilisons celui d'aujourd'hui. Alors bienvenue. entraînement ne devrait pas
prendre trop de temps.
Vous pouvez donc attendre la fin de l'
entraînement. Donc, comme vous pouvez voir
ce que nos gymnases et hors d'environ 90 pour cent. Mais tracons les courbes
d'apprentissage pour visualiser nos résultats. Je vais donc simplement copier
le code à partir d'ici. n'y a rien de spécial. Ici. Nous ne faisons que tracer la précision de l'entraînement,
la précision de la validation. Ensuite, nous avons la
perte d'entraînement et la validation. Réexécutons donc le script. Nous avons donc ici
la perte d'entraînement, et ici nous avons la précision
de validation de l'entraînement d'environ 1, 2 %. Ce que vous pouvez remarquer que la
précision de la formation et de la validation approximativement ici, puis commencent à diverger. C'est donc un signe
de sur-équipement. Nous pouvons améliorer la précision de notre modèle en utilisant l'augmentation
des données. Mais je ne parlerai pas de
cela dans ce cours. Nous allons donc évaluer notre
modèle dans le jeu de tests. Et nous pouvons appliquer notre modèle
à un résumé ou à quelles images. Donc, cette perte de précision. Il existe un diagramme quantile impliquant l'utilisation de l'ensemble de tests. Ici, nous avons récemment lors de l'
opérateur de perte , Awesome. Donc, nous avons une herbe, c'est approximativement
une personne.
5. Appliquer notre détecteur de sourire aux images: Maintenant que notre modèle est formé, nous allons l'appliquer à
certaines images du monde réel. Créons donc un
nouveau fichier Python. Nous l'appellerons sourire, image
du détecteur, PY. Et nous pouvons commencer à
écrire du code. Nous allons donc importer
souvent disons v. Ensuite, nous
avons de ces modèles. Fonction de charge. Besoin également. Ensuite,
définissons quelques variables. Nous créditons donc que la
largeur est égale à 800. Supposons que la hauteur
soit égale à 600. Nous créons également la couleur bleue, elle est
donc égale à 5500. Maintenant, nous pouvons charger notre image. Voici donc un dossier
avec quelques images. Je vais juste le copier à partir d'ici. J'ai dix images. Nous allons prendre le
premier, nos modèles. Nous allons donc aimer que l'image soit égale
à CV trop haut un marin. Des images. Nous prenons le premier pressentiment. Vous devez également le redimensionner. Nous allons donc aimer l'outil TV, redimensionner l'image et utiliser
la largeur et la hauteur. Et enfin, nous avons converti
en très stupide pour ne pas
convertir le CV des cheveux pour
lire que vous devez gris. Ensuite, nous pouvons commencer à
détecter les visages à l'aide du classificateur
en cascade Haar. J'ai donc
défini ici notre XML par défaut en cascade, face
frontale. Je vais donc simplement le mettre ici, le répertoire du projet,
et nous pouvons le charger en utilisant la fonction CV pour
adopter le classificateur en cascade. Nous allons donc écrire que notre détecteur de
visage est égal à CV vers classificateur
en cascade. Et ici, nous fournissons le nom de nous
devons également charger notre modèle. Nous allons donc dire plus que ce
qui est égal au modèle. Nous avons ici le nom de notre
modèle qui est plus que. Nous pouvons maintenant détecter des visages à l'aide de la fonction de détection multi-échelle. Comme ces rectangles sont
égaux à notre détecteur de visage. Pour le premier argument, nous fournissons notre image en niveaux de gris, puis nous avons
la fausse voiture à l'échelle. Nous allons le mettre en tant que 1.1. Ensuite, nous devons définir
les voisins minimaux, que nous pouvons définir comme tels. Ces paramètres fonctionnent. Eh bien, dans mon cas, mais tu peux
les changer si tu veux. Ici, la
variable des rectangles de face contiendra
les cadres de délimitation des faces. L'étape suivante consiste donc à faire une boucle sur les cadres de délimitation des faces et à
extraire la région de la face. Nous allons dire pour x, y, largeur et hauteur. Dans notre cas. Ici, nous allons d'abord faire
un rectangle autour du visage. Nous aimons donc TV2.com. Ici. Nous connaissons notre image. Et nous allons donner
aux comptes MSDN, qui sont x
et y. Ensuite, nous avons deux fissures diagonales différentes
, qui seraient x plus y plus. Et puis nous avons la couleur bleue et deux pour l'épaisseur. Et la semaine suivante, commencez la région du visage à partir de
l'image en niveaux de gris. Nous avons les coordonnées
du visage ici. Nous allons donc écrire à notre héros pourquoi ? L'appel à Ray. Et nous utiliserons simplement le tranchage. Nous allons donc passer
de y à y plus x.
X plus la largeur. Nous devons également redimensionner la région du
visage et la mettre à l'échelle à 01 branche avant de
l'alimenter dans notre modèle. Nous allons donc mentir ou y est égal
à CV pour ancrer la taille. Ici, nous allons apprendre
à le dimensionner à 32 par 32 car c'est ce que nous
utilisons pour entraîner notre modèle. Ici, pour la
taille de l'image, nous avons 32 par 32. Ensuite, on le met à l'échelle à
01, branche 2, 55. Nous devons également ajouter
l'image à un lot. Nous le ferons, car ici la forme de l'image de
Trente-deux. Trente-deux. Notre modèle a été formé
sur des lots d'images. La nouvelle forme sera donc
égale à T2, T2 par T2. Nous allons donc écrire
y est égal à y. Et nous utiliserons la
fonction point non-piped, nouvel accès à ce
nouvel axe, l'axe y. Et nous garderons
tout pareil ici. Vous pouvez imprimer ici l'avant et après votre accès pour voir
ce qui a changé ici. La forme. C'est la même chose ici. Ici, nous avons une erreur d'
attribut ou deux. Aux États-Unis, c'est une lettre majuscule. Ici. Comme vous pouvez le voir, avant d'ajouter le
nouvel axe est 32 par 32. Et après avoir ajouté
l'axe u ici, Econ132 par 32. Donc maintenant, la dernière étape consiste à passer la région du
visage pour ne pas fonctionner. Pour le classement. Nous ne les supprimons jamais. Nous allons écrire quelle prédiction est égale à la flèche de
prédiction et
imprimons le dictionnaire. Donc, normalement, la prédiction
aura une valeur comprise entre 01. Ici. Vous pouvez voir ici la valeur de la prédiction
pour cette image particulière. La prévision est de 0,6. Donc, ce que nous pouvons faire en ce moment, c'est que notre étiquette est égale à, disons, si la prédiction est
supérieure ou égale à 0,5, nous allons créer l'étiquette sur, nous allons définir l'étiquette sur sourire. Sinon, nous le
réglerons pour ne pas sourire. Nous allons donc étiqueter est
égal à sourire. Si la prédiction est
supérieure ou égale à 0,5, sinon, ne pas sourire. C'est mis dans la nuit. Pour vérifier ce cas, l'étiquette devrait passer
votre temps à sourire pour la journée. Mais la dernière chose à
faire est écrire le texte et l'
image et d'afficher l'image. Comme un CV. Pour mettre le x. Ici, nous allons mettre du texte dessus. Et nous aimerions faire l'
étiquetage et l'image. Pour le texte des coordonnées, nous utiliserons les
coordonnées du visage. Nous allons donc dire x plus x et y. Et pour la police, vous pouvez choisir ceci est, disons celui-ci. Et pour l'échelle de police, disons 0,75, couleur bleue. Façons de voir et CB2. Je suis sûr que nous conservons notre chronique. La personne ne sourit pas, mais notre modèle l'a
détecté lors de l'exploitation minière. Bien entendu, notre modèle n'
est pas précis à 100 %, il s'agit donc d'une prédiction
positive. Essayons avec une autre image. Disons celui-ci. Cette fois-ci. Je suis Armando qui a prédit
avec succès la glissade. Nous pouvons essayer la
personne telle qu'elle est, sans sourire. Nous ne prendrions donc celui-ci qui peut également tester avec
les autres images. Et ça, c'est avec l'image. La personne ne sourit pas. Et notre modèle a été détecté
avec succès.
6. Appliquer notre détecteur de sourire à des vidéos: Maintenant que vous savez comment
détecter les images de sourire, disons comment appliquer deux vidéos de
notre
détecteur de sourire Deep Learning. Créons donc un nouveau fichier Python. Appelez-le détecteur de sourire, PY. Et importons
les bibliothèques pour que le code ne change pas
grand-chose. Je vais simplement copier cette
amende pour la coller ici. Ensuite, nous avons la
largeur et la hauteur. Quand la couleur bleue. Ici, il suffit d'initialiser
les objets de capture vidéo. Nous voudrions donc renouveler votre tasse. Bien sûr, c'est égal à la capture
de CV en vidéo. Nous indiquons ici le
nom de notre vidéo. J'ai ici une vidéo
pré-enregistrée de moi dans laquelle j'ai fait quelques tests. Je vais donc l'utiliser pour
cette partie de la vidéo ici. J'ai fait quelques tests et j'ai
souri et beaucoup d'argent. Nous allons donc mettre ici le
nom de la vidéo mp4. Et puis nous avons la même chose. À partir de cette partie. Nous aurons besoin d'un détecteur de visage,
notre merveille pré-entraînée, et nous allons détecter des visages, perdant la fonction de détection
multi-échelle. Nous allons donc simplement copier
ces trois lignes ici. Voici donc notre dictionnaire. Nous lisons les cadres dans le
navigateur afin de pouvoir commencer à
traiter nos cadres. On peut dire pourquoi c'est vrai. Ensuite, nous allons récupérer l'image suivante de la vidéo. Donc quand on dit frame en fonction
de la capture vidéo. Ensuite, nous allons
le convertir en différentes courbes, CV en CV, CV en BGR. Et ici, nous pouvons utiliser la fonction multi-échelle The digs et nous la passons le long du cadre en niveaux de
gris. Nous pouvons maintenant faire une boucle sur les boîtes de délimitation des
faces. Je vais donc simplement
copier le code d' ici parce que tout
reste le même ici. Il suffit de changer ici l'image, le cadre. Trouve une nouvelle façon. Vous écrivez le texte de la même façon, et nous affichons notre cadre. Il suffit donc de copier le code à partir d'ici. Comment regarder le CV ici dans l'en-tête, nous ne dirions pas que votre CV regarde, attendez, attendez une minute. Le courant est donc égal à q. D'accord ? On s'évade. Enfin, nous avons sorti la
capture vidéo et les fenêtres. Voyons le résultat final. Nous allons dire Python,
trois, lecture du détecteur de sourire. Donc, ici, vous pouvez voir que l'
algorithme n'a aucun problème détecter les sourires et les
sourires de la vidéo. La détection est assez stable.
7. Conclusion: Dans ce cours, vous
apprendrez comment entraîner un réseau
neuronal convolutif pour détecter le sourire dans les
images et les vidéos. La première chose que nous
devons faire est de charger
notre jeu de données à partir du disque et de le
préparer pour notre réseau. Ensuite, nous avons créé
notre réseau de neurones. Ici, nous avons calculé le poids de la classe
pour tenir compte du déséquilibre de classe
dans l'ensemble de données. Et obligent ainsi le modèle à accorder
plus d'attention à la classe
sous-représentée. Dans cette partie, nous avons scindé un jeu de données en
un ensemble de formation, jeu de
validation
et un ensemble de tests, puis nous procédons à l'
entraînement de notre réseau. Nous avons constaté que nous avions atteint une précision de 90 % sur l'ensemble de test. La dernière étape a été de tester notre modèle en images et en vidéos. Pour cela, nous utilisons un classificateur en cascade Haar ici dans cette partie pour détecter
le visage dans l'image. Ensuite, nous avons extrait
dans cette partie région
du visage de
l'image et nous avons lié
la région du visage pour la
prédiction à notre modèle. Enfin, nous avons étiqueté l'image comme souriant
ou ne souriant pas.
Yacine Rouizi
