--DeepLearning a plusieurs bibliothèques, mais TensorFlow s'est avéré avoir une notation qui a tendance à être compliquée lors de la création de modèles par rapport à d'autres bibliothèques. --Cette fois, TF-Slim a créé le modèle précédemment J'ai essayé de refactoriser en utilisant une bibliothèque appelée contrib / slim). ―― La refactorisation ne fait que remplacer la notation, et s'il existe une convention Python, elle ignore le pistolet et met un saut de ligne. ――Veuillez noter que c'est un peu difficile à lire car les classes ne sont pas divisées uniquement pour le modèle.
slim_network.py
#!/usr/local/bin/python
# -*- coding: utf-8 -*-
import cv2
import numpy as np
import tensorflow as tf
import tensorflow.python.platform
import tensorflow.contrib.slim as slim
#Nombre d'étiquettes d'identification(Cette fois Zuckerberg:0,Masque Earon: 1,Bill Gates:2 donc 3)
NUM_CLASSES = 3
#Taille de l'image lors de l'apprentissage(px)
IMAGE_SIZE = 28
#Nombre de dimensions de l'image(28* 28*Couleur(?))
IMAGE_PIXELS = IMAGE_SIZE*IMAGE_SIZE*3
#Définir le chemin des données nécessaires à l'apprentissage et l'échelle de l'apprentissage
#Fonction intégrée TensorFlow qui peut enregistrer les réglages de paramètres, les valeurs par défaut et les explications de l'écran d'aide
flags = tf.app.flags
FLAGS = flags.FLAGS
#Données d'entraînement
flags.DEFINE_string('train', '/Users/neriai/Develops/workspace/dir/train/data.txt', 'File name of train data')
#Vérification des données de test
flags.DEFINE_string('test', '/Users/neriai/Develops/workspace/dir/test/data.txt', 'File name of train data')
#Dossier dans lequel les données sont placées
flags.DEFINE_string('train_dir', '/Users/neriai/Develops/workspace/dir/data', 'Directory to put the training data.')
#Nombre d'essais de formation à l'apprentissage des données
flags.DEFINE_integer('max_steps', 100, 'Number of steps to run trainer.')
#Combien d'images à utiliser dans une étude
flags.DEFINE_integer('batch_size', 20, 'Batch size Must divide evenly into the dataset sizes.')
#Si le taux d'apprentissage est trop petit, l'apprentissage ne se poursuivra pas, et s'il est trop grand, l'erreur ne convergera ni ne divergera.
flags.DEFINE_float('learning_rate', 1e-4, 'Initial learning rate.')
#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 model(x_image, keep_prob):
with slim.arg_scope(
[slim.conv2d, slim.fully_connected],
activation_fn=tf.nn.relu,
weights_initializer=tf.truncated_normal_initializer(stddev=0.1),
biases_initializer=tf.constant_initializer(0.1)
):
with slim.arg_scope([slim.max_pool2d], padding='SAME'):
#Créer la première couche de la couche de convolution
conv1 = slim.conv2d(x_image, 32, [5, 5])
#Création de la couche de pooling 1
pool1 = slim.max_pool2d(conv1, [2, 2])
#Création de la deuxième couche de la couche de convolution
conv2 = slim.conv2d(pool1, 64, [5, 5])
#Création de la couche de pooling 2
pool2 = slim.max_pool2d(conv2, [2, 2])
#Création de la couche 1 entièrement connectée
pool2_flat = slim.flatten(pool2)
fc1 = slim.fully_connected(pool2_flat, 1024)
#paramètres d'abandon
dropout = slim.dropout(fc1, keep_prob)
#Création de la couche 2 entièrement connectée
y_conv = slim.fully_connected(dropout, NUM_CLASSES, activation_fn=None)
# #Normalisation par fonction softmax
y_conv = tf.nn.softmax(y_conv)
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(labels_placeholder, model):
#Calculez le taux d '"erreur" entre le résultat de la prédiction et la bonne réponse
cross_entropy = -tf.reduce_sum(labels_placeholder*tf.log(model))
#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)
#(w)
#(?)
# ()
def training(learning_rate, loss):
#(loss)Je ne suis pas sûr de ce qui se passe dans les coulisses, mais je comprends que les poids de chaque couche du modèle d'apprentissage sont optimisés et ajustés en fonction de l'erreur. Entraîne un modèle d'apprentissage conçu à l'aide d'une rétropropagation d'erreur basée sur une erreur divine
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(model, labels_placeholder):
#Comparez si l'étiquette de prédiction et l'étiquette de réponse correcte sont égales. Renvoie Vrai s'ils sont identiques
correct_prediction = tf.equal(tf.argmax(model, 1), tf.argmax(labels_placeholder, 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, tf.float32))
#Configurer pour afficher sur TensorBoard
tf.summary.scalar("accuracy", accuracy)
return accuracy
if __name__ == '__main__':
#Fichier ouvert
f = open(FLAGS.train, 'r')
#Tableau pour mettre des données
train_image = []
train_label = []
for line in f:
#Séparé par des espaces sauf pour les sauts de ligne
line = line.rstrip()
l = line.split()
#Lire les données et réduire à 28x28
img = cv2.imread(l[0])
img = cv2.resize(img, (IMAGE_SIZE, IMAGE_SIZE))
#Après avoir fait la queue, 0-Défini sur une valeur flottante de 1
train_image.append(img.flatten().astype(np.float32)/255.0)
#Étiquette 1-of-Préparez-vous avec la méthode k
tmp = np.zeros(NUM_CLASSES)
tmp[int(l[1])] = 1
train_label.append(tmp)
#Convertir au format numpy
train_image = np.asarray(train_image)
train_label = np.asarray(train_label)
f.close()
f = open(FLAGS.test, 'r')
test_image = []
test_label = []
for line in f:
line = line.rstrip()
l = line.split()
img = cv2.imread(l[0])
img = cv2.resize(img, (IMAGE_SIZE, IMAGE_SIZE))
test_image.append(img.flatten().astype(np.float32)/255.0)
tmp = np.zeros(NUM_CLASSES)
tmp[int(l[1])] = 1
test_label.append(tmp)
test_image = np.asarray(test_image)
test_label = np.asarray(test_label)
f.close()
#Spécifiez la portée à afficher dans le graphique TensorBoard
with tf.Graph().as_default() as graph:
#Tensor pour insérer des images(28*28*3(IMAGE_PIXELS)N'importe quel nombre d'images dimensionnelles(None)J'ai une minute)
images_placeholder = tf.placeholder(tf.float32, shape=(None, IMAGE_PIXELS))
#Tenseur pour mettre une étiquette(3(NUM_CLASSES)N'importe quel nombre d'étiquettes dimensionnelles(None)Entrez les minutes)
labels_placeholder = tf.placeholder(tf.float32, shape=(None, NUM_CLASSES))
#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])
#Tensor temporaire pour mettre le taux d'abandon
keep_prob = tf.placeholder(tf.float32)
# model()Faire un modèle
model = model(x_image, keep_prob)
# loss()Pour calculer la perte
loss = loss(labels_placeholder, model)
# training()Pour former et ajuster les paramètres du modèle d'apprentissage
train_step = training(FLAGS.learning_rate, loss)
#Calcul de la précision
accuracy = accuracy(model, labels_placeholder)
#Prêt à économiser
saver = tf.train.Saver()
#Créer une session(Les calculs TensorFlow doivent être effectués dans une session absolue)
sess = tf.Session()
#Initialisation variable(Initialiser après le démarrage de la session)
sess.run(tf.global_variables_initializer())
#Paramètres d'affichage du TensorBoard(Déclaratif du Tensor Board?)
summary_step = tf.summary.merge_all()
# train_Spécifiez le chemin pour sortir le journal TensorBoard avec dir
summary_writer = tf.summary.FileWriter(FLAGS.train_dir, sess.graph)
#En fait max_Exécuter l'entraînement autant de fois que l'étape
for step in range(FLAGS.max_steps):
for i in range(len(train_image)/FLAGS.batch_size):
# batch_Exécution de la formation pour les images de taille
batch = FLAGS.batch_size*i
# feed_Spécifiez les données à mettre dans l'espace réservé avec dict
sess.run(
train_step,
feed_dict={
images_placeholder: train_image[batch:batch+FLAGS.batch_size],
labels_placeholder: train_label[batch:batch+FLAGS.batch_size],
keep_prob: 0.5
}
)
#Calculez la précision après chaque étape
train_accuracy = sess.run(
accuracy,
feed_dict={
images_placeholder: train_image,
labels_placeholder: train_label,
keep_prob: 1.0
}
)
print "step %d, training accuracy %g"%(step, train_accuracy)
#Ajouter une valeur à afficher sur le TensorBoard après chaque étape
summary_str = sess.run(
summary_step,
feed_dict={
images_placeholder: train_image,
labels_placeholder: train_label,
keep_prob: 1.0
}
)
summary_writer.add_summary(summary_str, step)
#Afficher la précision des données de test après l'entraînement
print "test accuracy %g"%sess.run(
accuracy,
feed_dict={
images_placeholder: test_image,
labels_placeholder: test_label,
keep_prob: 1.0
}
)
#Former les données et enregistrer le modèle final
# "model.ckpt"Est le nom du fichier de sortie
save_path = saver.save(sess, "model.ckpt")
Before
def weight_variable(shape):
initial = tf.truncated_normal(shape, stddev=0.1)
return tf.Variable(initial)
def bias_variable(shape):
initial = tf.constant(0.1, shape=shape)
return tf.Variable(initial)
def conv2d(x, W):
return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')
def max_pool_2x2(x):
return tf.nn.max_pool(x, ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1], padding='SAME')
After
with slim.arg_scope(
[slim.conv2d, slim.fully_connected],
activation_fn=tf.nn.relu,
weights_initializer=tf.truncated_normal_initializer(stddev=0.1),
biases_initializer=tf.constant_initializer(0.1)
):
with slim.arg_scope([slim.max_pool2d], padding='SAME'):
Before
W_conv1 = weight_variable([5, 5, 3, 32])
b_conv1 = bias_variable([32])
conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)
After
conv1 = slim.conv2d(x_image, 32, [5, 5])
Before
pool1 = max_pool_2x2(conv1)
After
pool1 = slim.max_pool2d(conv1, [2, 2])
Before
W_conv2 = weight_variable([5, 5, 32, 64])
b_conv2 = bias_variable([64])
conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
After
conv2 = slim.conv2d(pool1, 64, [5, 5])
Before
pool2 = max_pool_2x2(conv2)
After
pool2 = slim.max_pool2d(conv2, [2, 2])
Before
W_fc1 = weight_variable([7*7*64, 1024])
b_fc1 = bias_variable([1024])
pool2_flat = tf.reshape(pool2, [-1, 7*7*64])
fc1 = tf.nn.relu(tf.matmul(pool2_flat, W_fc1) + b_fc1)
After
pool2_flat = slim.flatten(pool2)
fc1 = slim.fully_connected(pool2_flat, 1024)
Before
dropout = tf.nn.dropout(fc1, keep_prob)
After
dropout = slim.dropout(fc1, keep_prob)
Before
W_fc2 = weight_variable([1024, NUM_CLASSES])
b_fc2 = bias_variable([NUM_CLASSES])
y_conv = tf.nn.softmax(tf.matmul(dropout, W_fc2) + b_fc2)
After
y_conv = slim.fully_connected(dropout, NUM_CLASSES, activation_fn=None)
y_conv = tf.nn.softmax(y_conv)
――Il semble un peu plus mince, mais cela peut être efficace en ce qui concerne la classe SSD. TCela ressemble plus à un puzzle qu'à une compréhension du remplacement. ――Il semblait que d'autres choses pouvaient être remplacées, mais comme diverses erreurs et valeurs calculées étaient cassées, je ne les ai conservées qu'à l'intérieur du modèle. «Je sens que c'était une ressource paku, mais c'est devenu un peu la mienne.
Recommended Posts