C'est très facile à lire et les commentaires sont soigneusement écrits, donc même moi, un débutant en Python, pouvais comprendre ce que je faisais.
main.py
#!/usr/local/bin/python
# -*- coding: utf-8 -*-
import sys
import cv2
import random
import numpy as np
import tensorflow as tf
import tensorflow.python.platform
#Nombre d'étiquettes d'identification(Cette fois Kyo:0,Kaoru: 1,Shinya: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', '/workspace/dir/train/data.txt', 'File name of train data')
#Vérification des données de test
flags.DEFINE_string('test', '/workspace/dir/test/data.txt', 'File name of train data')
#Dossier dans lequel les données sont placées
flags.DEFINE_string('train_dir', /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
####
###Ajouter le traitement du modèle de formation ici
####
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():
#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("float", 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("float", shape=(None, NUM_CLASSES))
#Tensor temporaire pour mettre le taux d'abandon
keep_prob = tf.placeholder("float")
# inference()Faire un modèle
logits = inference(images_placeholder, keep_prob)
# loss()Pour calculer la perte
loss_value = loss(logits, labels_placeholder)
# training()Pour former et ajuster les paramètres du modèle d'apprentissage
train_op = training(loss_value, FLAGS.learning_rate)
#Calcul de la précision
acc = accuracy(logits, 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_op = 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_op, 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(acc, 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_op, 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(acc, 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, "model2.ckpt")