J'ai créé un classificateur de visage Dir en gray en utilisant TensorFlow --⑦ Modèle d'apprentissage

introduction

«J'aimerais étudier à l'avenir, mais pour le moment, je vais le copier.

programme

main.py


#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(?)。

  #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*L'image est filtrée dans une plage de 5 pixels. Puisqu'il s'agit d'une image couleur, l'entrée est 3?
    #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 2 cadres et définissez les caractéristiques du cadre sur 1*Il est bien compressé en 1 minute.
  #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:
    #Le filtrage est à nouveau effectué avec la sortie sur la première couche comme entrée sur la seconde couche.
    #Détecte 64 fonctionnalités. Pourquoi l'entrée 32?(je veux que tu me dises)
    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 de la couche de pooling 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
    #Optimisé uniquement pour les données d'entraînement et 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
  return y_conv

#Calculez le taux d '"erreur" entre le résultat de la prédiction et la bonne réponse
#logits est le résultat du calcul:  float - [batch_size, NUM_CLASSES]
#étiquettes est l'étiquette de réponse correcte: int32 - [batch_size, NUM_CLASSES]
def loss(logits, labels):
  #Calcul de l'entropie croisée
  cross_entropy = -tf.reduce_sum(labels*tf.log(logits))

  #Spécifiez pour afficher dans TensorBoard
  tf.summary.scalar("cross_entropy", cross_entropy)

  #Valeur du taux d'erreur(cross_entropy)rends le
  return cross_entropy

#Erreur(loss)Former un modèle d'apprentissage conçu à l'aide d'une rétropropagation d'erreur basée sur
#Je ne suis pas sûr de ce qui se passe dans les coulisses, mais les poids de chaque couche du modèle d'apprentissage(w)Etc
#Comprendre qu'il est optimisé et ajusté en fonction de l'erreur(?)
# (L'explication du livre "L'intelligence artificielle dépasse-t-elle les humains?")
def training(loss, learning_rate):
  #Comme cette fonction fait tout ça
  train_step = tf.train.AdamOptimizer(learning_rate).minimize(loss)
  return train_step

#Calculer le taux de réponse correct du résultat de prédiction donné par le modèle d'apprentissage à l'inférence
def accuracy(logits, labels):
  #Comparez si l'étiquette de prédiction et l'étiquette de réponse correcte sont égales. Renvoie Vrai s'ils sont identiques
  #argmax est l'indice de la partie avec la plus grande valeur dans le tableau(=Le numéro de l'étiquette qui semble être la réponse la plus correcte)rends le
  correct_prediction = tf.equal(tf.argmax(logits, 1), tf.argmax(labels, 1))

  #booléen correct_Calculez le taux de réponse correct en changeant la prédiction en flottant
  # false:0,true:Convertir en 1 et calculer
  accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))

  #Configurer pour afficher sur TensorBoard
  tf.summary.scalar("accuracy", accuracy)
  return accuracy

Suppléments et excuses

«Tu ne sais pas, non? Je ne comprends qu'en quelque sorte n

Tous les liens de page

Recommended Posts

J'ai créé un classificateur de visage Dir en gray en utilisant TensorFlow --⑦ Modèle d'apprentissage
J'ai créé un classificateur de visage Dir en gray en utilisant TensorFlow --⑥ Programme d'apprentissage
J'ai créé un classificateur de visage Dir en gray en utilisant TensorFlow - (1) Introduction
J'ai créé un classificateur de visage Dir en gray en utilisant l'extraction de visage TensorFlow-④
J'ai créé un classificateur de visage Dir en gray en utilisant TensorFlow - Test de classification de visage
J'ai essayé de faire un classificateur de visage Dir en gris en utilisant TensorFlow --⑬ Jouer (final)
J'ai créé un classificateur de visage Dir en gray en utilisant TensorFlow --⑫ Version Web
J'ai créé un classificateur de visage Dir en gray en utilisant TensorFlow --② Construction de l'environnement
J'ai créé un classificateur de visage Dir en gray en utilisant TensorFlow - Préparation de la version Web
J'ai essayé d'héberger un modèle d'apprentissage en profondeur de TensorFlow à l'aide de TensorFlow Serving
J'ai fait un modèle VGG16 en utilisant TensorFlow (en chemin)
[Python] J'ai créé un classificateur pour les iris [Machine learning]
J'ai créé un site d'apprentissage C ++
J'ai fait un Line-bot avec Python!
Créer un outil de reconnaissance de visage à l'aide de TensorFlow
Créer un modèle d'apprentissage à l'aide de MNIST
Détection de visage à l'aide d'un classificateur en cascade
J'ai essayé de jouer au jeu ○ ✕ en utilisant TensorFlow
Débutant: j'ai créé un lanceur à l'aide d'un dictionnaire
Création d'un modèle de discrimination d'image (cifar10) à l'aide d'un réseau neuronal convolutif
Une histoire sur l'apprentissage automatique simple avec TensorFlow
J'ai créé un jeu ○ ✕ avec TensorFlow
J'ai effectué un processus de connexion / déconnexion en utilisant Python's Bottle.
J'ai essayé d'héberger un exemple de modèle de Pytorch en utilisant TorchServe
J'ai créé un code pour convertir illustration2vec en modèle Keras
[Apprentissage automatique] Classification de texte à l'aide du modèle Transformer (classificateur basé sur l'attention)
J'ai créé un jeu d'introduction au festival scolaire avec Ren'py
〇✕ J'ai fait un jeu
J'ai essayé de refactoriser le modèle CNN de TensorFlow en utilisant TF-Slim
Construire un modèle seq2seq en utilisant la création et l'apprentissage du modèle d'API fonctionnelle de Keras
J'ai créé un lecteur de flux rapide en utilisant feedparser en Python
J'ai essayé d'utiliser Tensorboard, un outil de visualisation pour l'apprentissage automatique
J'ai fait un kit d'apprentissage pour word2vec / doc2vec / GloVe / fastText
J'ai essayé de faire un diagnostic de visage AI pour les golfeuses professionnelles ③
J'ai créé une application d'estimation de l'entraînement musculaire à l'aide du SDK Qore
J'ai essayé d'écrire dans un modèle de langage profondément appris
J'ai créé Chatbot en utilisant l'API LINE Messaging et Python
J'ai essayé la reconnaissance faciale avec Face ++
J'ai fait un texte Python
J'ai essayé d'utiliser magenta / TensorFlow
J'ai fait un robot discord
J'ai essayé de marquer un concours de travesti en utilisant l'API Detect de Face ++
J'ai créé un chat-holdem de serveur de jeu de poker en utilisant websocket avec python
J'ai créé Chatbot en utilisant l'API LINE Messaging et Python (2) ~ Server ~
[Kaggle] J'ai fait une collection de problèmes en utilisant le didacticiel Titanic