[PYTHON] Créez une IA qui identifie le visage de Zuckerberg grâce à l'apprentissage en profondeur ② (construction de modèles d'IA)
Ceci est une continuation de l'article précédent "Créer une IA qui identifie le visage de Zuckerberg avec l'apprentissage en profondeur ① (préparation des données d'apprentissage)". Cet article est la deuxième partie.
Ce que nous faisons, c'est "une IA qui identifie le visage de Zuckerberg". Utilisez TensorFlow de la bibliothèque d'apprentissage en profondeur de Google. Des exemples de vidéos de ce que j'ai fait cette fois sont ici.
Article précédent a collecté des données d'image de visage pour être entraînées par TensorFlow, donc cette fois nous allons construire un modèle d'IA pour TensorFlow! Le travail de la partie TensorFlow est rude
** "(1) Conception du modèle d'apprentissage TensorFlow-> (2) Apprendre et entraîner les données de visage-> (3) Rendre possible de juger le visage de n'importe quelle image en utilisant les résultats d'apprentissage" **
Je vais continuer avec le flux. Cette fois, je décrirai la procédure de ** "Conception d'un modèle d'apprentissage de TensorFlow (conception d'un réseau de neurones)" **.
Ensuite, puisque nous avons collecté des données d'image de visage pour l'apprentissage la dernière fois, la conception du modèle d'apprentissage est la suivante!
② Concevoir un modèle d'apprentissage pour TensorFlow
1. Avant d'utiliser TensorFlow
Si vous ne possédez pas les connaissances requises pour réellement faire un apprentissage en profondeur avec TensorFlow, ce qui suit n'aura aucun sens, je vais donc vous présenter ceux qui sont particulièrement utiles et fortement mémorables lorsque je suis débutant.
[Lié au Deep Learning]
① Réseau neuronal et apprentissage en profondeur Ce fut une grande expérience d'apprentissage pour moi d'expliquer en détail ce qui se passe dans les coulisses au niveau des formules mathématiques. Je pense que vous devriez le lire après avoir atteint le point où "j'ai en quelque sorte compris l'apprentissage en profondeur, mais je ne comprends pas." Cependant, il est trop détaillé et je ne comprends qu'environ 10%. ② [L'intelligence artificielle dépasse-t-elle les humains (livre)](https://www.amazon.co.jp/%E4%BA%BA%E5%B7%A5%E7%9F%A5%E8%83%BD % E3% 81% AF% E4% BA% BA% E9% 96% 93% E3% 82% 92% E8% B6% 85% E3% 81% 88% E3% 82% 8B% E3% 81% 8B-% E8% A7% 92% E5% B7% 9D% EF% BC% A5% EF% BC% B0% EF% BC% B5% EF% BC% A2% E9% 81% B8% E6% 9B% B8-% E6 % 9D% BE% E5% B0% BE-% E8% B1% 8A-ebook / dp / B00UAAK07S) Un livre de M. Matsuo de l'Université de Tokyo qui est du genre "Cette personne parle d'apprentissage profond!" Au Japon (??). Je l'ai lu il y a environ deux ans et il était dans le Kindle donc je l'ai relu. Il est très facile à comprendre car il explique «Qu'est-ce que le deep learning?» Pour que tout le monde puisse le comprendre sans utiliser de mots ou de formules difficiles. C'est peut-être le plus simple à comprendre.
[En rapport avec Tensor Flow]
③ Mémo Sugyan Il a écrit divers exemples en utilisant TensorFlow et est au-delà du niveau mémo. (Si vous oubliez cette note, article d'entretien personnel sera recommandé comme publicité chaque fois que vous ouvrirez Facebook. Était w) ④ Traduction en japonais du tutoriel TensorFlow Il a traduit le didacticiel officiel TensorFlow en japonais. Je suis reconnaissant aux étudiants débutants et avancés de l'avoir traduit en japonais. ⑤ Je ne suis ni programmeur ni data scientist, mais j'ai touché Tensorflow pendant un mois, donc c'est super facile à comprendre ⑥ Depuis que j'ai touché Tensorflow pendant 2 mois, j'ai expliqué le réseau de neurones convolutifs d'une manière facile à comprendre avec 95,04% d'identification «hiragana manuscrite» Les deux ci-dessus ont expliqué le didacticiel TensorFlow, qui a été très utile lors de l'apprentissage! ⑦ Reconnaissance faciale des membres Momokuro par TensorFlow ⑧ Identifiez la société de production de l'anime Yuruyuri avec TensorFlow Cette fois, j'ai fait référence aux deux ci-dessus au niveau du code. Je ne pourrais pas faire quelque chose qui fonctionnerait sans cet article. Je suis profondément reconnaissant m (_ _) m
En regardant ça comme ça, il y a étonnamment beaucoup de gens au Japon qui touchent TensorFlow. C'était l'impression que. Merci à tous ceux qui m'ont aidé m (_ _) m
2. Concevoir un modèle de formation pour TensorFlow
Maintenant, écrivons le traitement de TensorFlow. Le ** «Learning Model Design» ** de TensorFlow est considéré comme la partie la plus importante de l'apprentissage en profondeur. Il n'est peut-être pas exagéré de dire que cette ** "conception d'un modèle d'apprentissage (réseau neuronal) est un apprentissage en profondeur" **.
Avant de vous y précipiter, essayez le didacticiel TensorFlow, etc. et assurez-vous que TensowFlow est au moins installé et qu'il fonctionne correctement. (Il est encore mieux d'essayer le tutoriel avancé CNN)
La configuration et les didacticiels de TensorFlow sont omis ici. Référence: TensorFlow MNIST For ML Beginners Tutorial Implementation
La structure du modèle d'apprentissage TensorFlow (réseau de neurones) sera cette fois le ** réseau de neurones convolutifs (CNN) ** expliqué dans l'édition experte du tutoriel TensorFlow. Puisque nous allons procéder à la structure d'une couche de couches cachées, je pense qu'elle a exactement la même structure que le tutoriel **.
En ce qui concerne la structure des répertoires, j'ai mis le dossier de données d'image de visage et les fichiers de traitement liés à tensorflow dans un dossier appelé tensorflow, qui a été créé en installant tensorflow selon la formule.
(Cette fois, le traitement lié à la conception du modèle d'apprentissage et à l'exécution de l'apprentissage est résumé dans un fichier appelé main.py ''. Le code ci-dessous fait partie de main.py ''.)
Structure du répertoire
/tensoflow
main.py(J'écrirai le modèle d'apprentissage et le processus d'apprentissage ici)
eval.py(Un fichier qui renvoie les résultats de cas de n'importe quelle image)
/data(Données de visage collectées dans l'article précédent)
/train
/zuckerbuerg
/elonmusk
/billgates
data.txt
/test
/zuckerbuerg
/elonmusk
/billgates
data.txt
Après cela, les dossiers et fichiers créés lors de l'installation de tensorflow se trouvent dans le dossier tensorflow.
(J'ai fait de mon mieux pour laisser un commentaire dans le code, mais je ne le comprends pas parfaitement, et j'apprécierais que vous puissiez faire remarquer qu'il y a un mauvais mot m (_ _) m Quoi qu'il en soit, j'ai eu l'impression que les fonctions fournies par TensorFlow faisaient tous les calculs détaillés. )
main.py(Modèle d'apprentissage faisant partie de)
#Modèle d'apprentissage faisant partie de l'IA(réseau neuronal)Créer
# images_placeholder:Espace réservé pour l'image, keep_prob:lieu de taux d'abandon_titulaire devient un argument
#Sort et renvoie la probabilité de chaque étiquette pour l'image d'entrée
def inference(images_placeholder, keep_prob):
#Écart type de poids 0.Initialiser avec une distribution normale de 1
def weight_variable(shape):
initial = tf.truncated_normal(shape, stddev=0.1)
return tf.Variable(initial)
#Biais par rapport à l'écart type 0.Initialiser avec une distribution normale de 1
def bias_variable(shape):
initial = tf.constant(0.1, shape=shape)
return tf.Variable(initial)
#Créer une couche de convolution
def conv2d(x, W):
return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')
#Créer une couche de regroupement
def max_pool_2x2(x):
return tf.nn.max_pool(x, ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1], padding='SAME')
#Entrée de données d'image 28px au format vectoriel*Revenir à l'image 28px(Peut-être)。
#Cette fois c'est une image couleur donc 3(1 pour monochrome)
x_image = tf.reshape(images_placeholder, [-1, IMAGE_SIZE, IMAGE_SIZE, 3])
#Créer la première couche de la couche de convolution
with tf.name_scope('conv1') as scope:
#L'argument est[width, height, input, filters]。
# 5px*Filtrage des images dans la plage de 5 pixels
#l'entrée est 3 car cette fois c'est une image couleur(Peut-être)
#Détecter 32 fonctionnalités
W_conv1 = weight_variable([5, 5, 3, 32])
#Remplacez la valeur du biais
b_conv1 = bias_variable([32])
#Les pièces susceptibles d'être utiles en tant que fonctions sont laissées, et les pièces qui sont peu susceptibles d'être utilisées comme fonctions sont
#Comprendre qu'il n'est pas traité comme une fonctionnalité comme 0(Fonction Relu)
h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)
#Création de la couche de pooling 1
# 2*Créez un cadre de 2 tailles et définissez les caractéristiques du cadre sur 1.*Se convertit en une taille de 1(Fonctionnalités de compression)。
#Ce cadre 2*Comprendre cette diapositive par 2 pour appliquer le travail de compression à l'image entière
#Résumez grossièrement les fonctionnalités subdivisées par une compréhension approximative d'une manière légèrement meilleure(Compresse)
with tf.name_scope('pool1') as scope:
h_pool1 = max_pool_2x2(h_conv1)
#Création de la deuxième couche de la couche de convolution
with tf.name_scope('conv2') as scope:
#Filtrage à nouveau avec la sortie de la première couche comme entrée de la deuxième couche
# 5px*Image de l'ordre de 5 px(?)Filtrer
#L'entrée est de 32 car la sortie de 32 caractéristiques de la première couche est entrée.
#Détecter 64 fonctionnalités
W_conv2 = weight_variable([5, 5, 32, 64])
#Remplacez la valeur du biais(Identique à la première couche)
b_conv2 = bias_variable([64])
#Disposition des fonctionnalités détectées(Identique à la première couche)
h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
#Création du pooling layer 2(Identique à la couche ennuyeuse 1)
with tf.name_scope('pool2') as scope:
h_pool2 = max_pool_2x2(h_conv2)
#Création de la couche 1 entièrement connectée
with tf.name_scope('fc1') as scope:
W_fc1 = weight_variable([7*7*64, 1024])
b_fc1 = bias_variable([1024])
#Convertir l'analyse d'image en vecteur
h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])
#Comme le premier et le second, il active les fonctionnalités détectées.
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)
#paramètres d'abandon
#Il est optimisé uniquement pour les données d'entraînement, il n'est donc pas vraiment utilisable
#Il semble jouer un rôle dans la prévention du «surapprentissage» qui devient l'IA
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
#Création de la couche 2 entièrement connectée(Lire la couche)
with tf.name_scope('fc2') as scope:
W_fc2 = weight_variable([1024, NUM_CLASSES])
b_fc2 = bias_variable([NUM_CLASSES])
#Normalisation par fonction softmax
#Convertir la sortie du réseau neuronal jusqu'à présent en probabilité de chaque étiquette
with tf.name_scope('softmax') as scope:
y_conv=tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)
#Probabilité de chaque étiquette(Quelque chose comme?)rends le. Additionnez toutes les probabilités calculées pour chaque étiquette pour obtenir 1
return y_conv
C'est la seule conception de modèle d'apprentissage, mais ce que nous faisons
** ① Prenez ce que vous voulez caractériser comme entrée et transmettez-le à la couche supérieure (suivante) → ② Apprenez diverses choses en fonction du modèle d'apprentissage de cette couche pour détecter et sortir les entités → ③ La couche précédente La sortie (caractéristique) de est transmise en tant qu'entrée à la couche suivante, et ① à ③ sont répétés pour le nombre de couches → ④ La probabilité que la première entrée à la fin corresponde à l'étiquette préparée revenir**
Je suis conscient que c'est comme ça.
Dans TensorFlow, les données sont au format ** tensol ** (des données comme une matrice), et les données circulent de plus en plus vers chaque couche, donc c'est ** "TensorFlow" **. Et, à mesure que cette ** hiérarchie s'approfondit, nous apprenons de plus en plus de fonctionnalités **, donc c'est ** "Deep Learning" **. Je vois! Nommage facile à comprendre. w
3. Visualisez le modèle d'apprentissage conçu (réseau neuronal)
Une fonctionnalité appelée ** TensorBoard ** fournie avec TensorFlow vous permet de le voir visuellement avec cette structure de réseau neuronal conçue.
Accédez au 6006!
#### **`./Pour les données, spécifiez le répertoire dans lequel les données d'entraînement sont stockées. J'ai mis les images dans un répertoire appelé data.`**
Ce TensorBoard semble être l'une des fonctions caractéristiques de TensorFlow, et il est certainement étonnant de voir facilement divers résultats. Vous pouvez en savoir plus sur TensorBoard par google. Vous ne pourrez peut-être pas voir le graphique tant que vous n'aurez pas réellement entraîné les données (?)
Hmmmmmmmm. sûrement
** Remodeler l'image saisie comme espace réservé pour l'image → entrer dans le 1er calque (conv1) → 1er regroupement (pool1) → le transmettre au 2ème calque (conv2) → …… **
Il semble que ce soit exactement la même que la structure du réseau neuronal du modèle d'apprentissage conçu. génial. Facile à comprendre.
Le nom de chaque couche (comme conv1) est nommé dans la partie '' avec tf.name_scope ('conv1') comme portée: partie du code du modèle de formation ci-dessus. Il semble que le paramétrage de TensorBorad lui-même se fasse dans la partie de summary_writer = tf.train.SummaryWriter (FLAGS.train_dir, sess.graph_def) '' qui apparaît dans le code plus tard.
La couche cachée du modèle d'apprentissage est cette fois une couche, mais le logiciel AI Go le plus puissant du monde, "AlphaGo", semble être ridiculement compliqué quand on regarde cette structure de réseau neuronal. (Je pense que c'était dans un article quelque part.)
③ Laissez le modèle d'apprentissage entraîner réellement les données
C'est la fin de la ** conception d'un modèle d'apprentissage **, qui semble être le plus important pour utiliser TensorFlow. (Bien que ce soit le même que ce tutoriel.) Ensuite, utilisons réellement ce modèle d'apprentissage conçu pour apprendre la grande quantité de données sur le visage collectées plus tôt. La suite risque d'être à nouveau longue, donc d'après l'article ci-dessous ↓
Cliquez ici pour la ** Partie 3 ** suivante: Créer une IA qui identifie le visage de Zuckerberg par apprentissage profond ③ (Apprentissage des données)
** "Créez une IA qui identifie le visage de Zuckerberg grâce à l'apprentissage en profondeur"
GitHub：https://github.com/AkiyoshiOkano/zuckerberg-detect-ai
Résultat du jugement bonus
Résultat du jugement de jouer avec le détecteur Zuckerberg
M. Bill Gates qui a pu juger par le flux du développement
Aussi M. Ilone Mask
Juger le président Trump
Recommended Posts