TensorFlow Pour apprendre d'un grand nombre d'images ... (Problème non résolu) → 12/18 Résolu

introduction

J'ai regardé mes articles jusqu'à la dernière fois, mais c'est très difficile à voir ... Je dois inventer petit à petit une manière d'écrire. Salut, c'est ikki. Preferred Networks, que j'ai vu à l'exposition de robots l'autre jour, l'a développé en collaboration avec FANUC. " Le blog sur Learning from 0 for bulk robots with deep learning »a été mis à jour. Ou plutôt, il était déjà posté lorsque je l'ai posté la dernière fois. .. .. J'écoutais l'histoire à l'atelier, et j'ai été surpris d'apprendre que ce robot a été fabriqué en 3 mois. M. Nishikawa a dit: "Cela aurait pris trois ans pour une personne ordinaire (rires)", mais je n'ai pas la capacité de le faire même si cela prend trois ans.

Donc, l'introduction est devenue longue, mais cette fois, à la suite de l'article précédent, il s'agit du problème de "Out of GPU Memory". ..

problème

Des conseils de Reo Aoki et MATS à l'article précédent, j'ai pu créer un programme qui apprend les images et les reconnaît sans lancer d'erreurs, mais le nombre d'images pouvant être alimentées est petit et ce n'est pas assez bon. La précision de la reconnaissance n'est pas bonne. Dois-je concevoir une image (ensemble de données) à former? Je pense aussi, mais si possible, j'aimerais le résoudre dans le cadre du programme. À l'avenir, je souhaite créer des données d'entraînement sans générer d'erreurs, quel que soit le nombre d'images consommées! Je pense. (Bien qu'il y ait une limite à "combien")

programme

Le programme actuel est le suivant. Cette fois également, je me référerai à identifier la société de production de l'anime Yuruyuri avec le journal d'activité kivantium TensorFlow. Merci beaucoup.

#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
import cv2
import numpy as np
import tensorflow as tf
import tensorflow.python.platform

NUM_CLASSES = 2
IMAGE_SIZE = 28
IMAGE_PIXELS = IMAGE_SIZE*IMAGE_SIZE*3

flags = tf.app.flags
FLAGS = flags.FLAGS
flags.DEFINE_string('save_model', 'models/model.ckpt', 'File name of model data')
flags.DEFINE_string('train', 'training/train_.txt', 'File name of train data')
flags.DEFINE_string('test', 'training/test_.txt', 'File name of test data')
flags.DEFINE_string('train_dir', '/tmp/pict_data', 'Directory to put the training data.')
flags.DEFINE_integer('max_steps', 200, 'Number of steps to run trainer.')
flags.DEFINE_integer('batch_size', 128, 'Batch size'
                     'Must divide evenly into the dataset sizes.')
flags.DEFINE_float('learning_rate', 1e-4, 'Initial learning rate.')

def inference(images_placeholder, keep_prob):
    ####################################################################
    #Fonctions qui créent des modèles prédictifs
    #argument: 
    #  images_placeholder:Espace réservé pour l'image
    #  keep_prob:espace réservé pour le taux d'abandon
    #Valeur de retour:
    #  y_conv:Probabilité de chaque classe(Quelque chose comme)
    ####################################################################

    #Écart type de poids 0.Initialisé 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.Initialisé 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 convolutive
    def conv2d(x, W):
      return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')

    #Créer une couche de pooling
    def max_pool_2x2(x):
      return tf.nn.max_pool(x, ksize=[1, 2, 2, 1],
                            strides=[1, 2, 2, 1], padding='SAME')
    
    #Transformez l'entrée en 28x28x3
    x_images = tf.reshape(images_placeholder, [-1, IMAGE_SIZE, IMAGE_SIZE, 3])

    #Création de la couche de convolution 1
    with tf.name_scope('conv1') as scope:
        W_conv1 = weight_variable([5, 5, 3, 32])
        b_conv1 = bias_variable([32])
        h_conv1 = tf.nn.relu(conv2d(x_images, W_conv1) + b_conv1)

    #Création de la couche de pooling 1
    with tf.name_scope('pool1') as scope:
        h_pool1 = max_pool_2x2(h_conv1)
    
    #Création de la couche de convolution 2
    with tf.name_scope('conv2') as scope:
        W_conv2 = weight_variable([5, 5, 32, 64])
        b_conv2 = bias_variable([64])
        h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)

    #Création du pooling layer 2
    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])
        h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])
        h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)
        #paramètres d'abandon
        h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)

    #Création de la couche 2 entièrement connectée
    with tf.name_scope('fc2') as scope:
        W_fc2 = weight_variable([1024, NUM_CLASSES])
        b_fc2 = bias_variable([NUM_CLASSES])

    #Normalisation par fonction softmax
    with tf.name_scope('softmax') as scope:
        y_conv=tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)

    #Renvoie quelque chose comme la probabilité de chaque étiquette
    return y_conv

def loss(logits, labels):
    ####################################################################
    #Fonction pour calculer la perte
    #argument:
    #  logits:Tenseur logit, float - [batch_size, NUM_CLASSES]
    #  labels:Tenseur d'étiquette, int32 - [batch_size, NUM_CLASSES]
    #Valeur de retour:
    #  cross_entropy:Tenseur d'entropie croisée, float
    ####################################################################

    #Calcul de l'entropie croisée
    cross_entropy = -tf.reduce_sum(labels*tf.log(logits))
    #Spécifiez pour afficher dans TensorBoard
    tf.scalar_summary("cross_entropy", cross_entropy)
    return cross_entropy

def training(loss, learning_rate):
    ####################################################################
    #Fonctions qui définissent les opérations d'entraînement
    #argument:
    #  loss:Tenseur de perte, loss()Résultat de
    #  learning_rate:Coefficient d'apprentissage
    #Valeur de retour:
    #  train_step:Op de formation
    ####################################################################

    train_step = tf.train.AdamOptimizer(learning_rate).minimize(loss)
    return train_step

def accuracy(logits, labels):
    ####################################################################
    #Taux de réponse correct(accuracy)Fonction à calculer
    #argument: 
    #  logits: inference()Résultat de
    #  labels:Tenseur d'étiquette, int32 - [batch_size, NUM_CLASSES]
    #Valeur de retour:
    #  accuracy:Taux de réponse correct(float)
    ####################################################################
    correct_prediction = tf.equal(tf.argmax(logits, 1), tf.argmax(labels, 1))
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
    tf.scalar_summary("accuracy", accuracy)
    return accuracy

if __name__ == '__main__':
    #Fichier ouvert
    with open(FLAGS.train, 'r') as f: # train.txt
        train_image = []
        train_label = []
        for line in f:
            line = line.rstrip()
            l = line.split()
            img = cv2.imread(l[0])
            img = cv2.resize(img, (IMAGE_SIZE, IMAGE_SIZE))
            train_image.append(img.flatten().astype(np.float32)/255.0)
            tmp = np.zeros(NUM_CLASSES)
            tmp[int(l[1])] = 1
            train_label.append(tmp)
        train_image = np.asarray(train_image)
        train_label = np.asarray(train_label)
        print len(train_image)

    with open(FLAGS.test, 'r') as f: # test.txt
        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)
    
    with tf.Graph().as_default():
        images_placeholder = tf.placeholder("float", shape=(None, IMAGE_PIXELS))
        labels_placeholder = tf.placeholder("float", shape=(None, NUM_CLASSES))
        keep_prob = tf.placeholder("float")

        logits = inference(images_placeholder, keep_prob)
        loss_value = loss(logits, labels_placeholder)
        train_op = training(loss_value, FLAGS.learning_rate)
        acc = accuracy(logits, labels_placeholder)

        #Prêt à économiser
        saver = tf.train.Saver()
        sess = tf.Session()
        sess.run(tf.initialize_all_variables())
        #Définition de la valeur à afficher sur TensorBoard
        summary_op = tf.merge_all_summaries()
        summary_writer = tf.train.SummaryWriter(FLAGS.train_dir, sess.graph_def)
        
        for step in range(FLAGS.max_steps):
            for i in range(len(train_image)/FLAGS.batch_size):
                batch = FLAGS.batch_size*i
                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})

            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)

            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)

    print "test accuracy %g"%sess.run(acc, feed_dict={
        images_placeholder: test_image,
        labels_placeholder: test_label,
        keep_prob: 1.0})

    #Enregistrez le modèle final
    save_path = saver.save(sess, FLAGS.save_model)

Quant au contenu du programme ・ Apprendre en lisant 2 classes d'images de train.txt et test.txt ・ La taille de l'image varie, mais elle a été redimensionnée à 28 * 28 par redimensionnement. -Output le résultat appris dans un fichier appelé model.ckpt "GeForce GTX TITAN X 12GB" est utilisé pour le GPU.

J'ai également vu un thread que ce problème est un problème d'allocateur de mémoire et peut être résolu en mettant à jour TensorFlow vers la dernière version, mais cela ne l'a pas résolu après tout. ・ ・ ・

Comment puis-je alimenter 20 000 ou 30 000 images? Nous continuerons d'enquêter. .. ..

** Probablement résolu! !! ** → TensorFlow Pour apprendre d'un grand nombre d'images ... ~ (presque) solution ~

Recommended Posts

TensorFlow Pour apprendre d'un grand nombre d'images ... (Problème non résolu) → 12/18 Résolu
TensorFlow Pour apprendre d'un grand nombre d'images ... ~ (presque) solution ~
Téléchargez un grand nombre d'images sur Wordpress
Apprenez à gonfler des images à partir du code TensorFlow
Je souhaite résoudre le problème de fuite de mémoire lors de la sortie d'un grand nombre d'images avec Matplotlib
Convertissez un grand nombre de fichiers PDF en fichiers texte à l'aide de pdfminer
Let Code Day6 commençant à zéro "1342. Nombre d'étapes pour réduire un nombre à zéro"
One-liner qui crée un grand nombre de fichiers de test à la fois sous Linux
Organisez un grand nombre de fichiers dans des dossiers
Un outil pour suivre les affiches avec un grand nombre de likes sur instagram [25 minutes à 1 seconde]
Créer un ensemble de données d'images à utiliser pour la formation
Accélérez un grand nombre de requêtes simples dans MySQL
Je veux détecter des images de chats d'Instagram
Installation de TensorFlow, une bibliothèque d'apprentissage automatique de Google
[Python] Générer de manière aléatoire un grand nombre de noms de personne en anglais
J'ai essayé de trouver la tendance du nombre de navires dans la baie de Tokyo à partir d'images satellites.
Je veux démarrer beaucoup de processus à partir de python
Comment augmenter le nombre d'images de jeux de données d'apprentissage automatique
Scrapy-Redis est recommandé pour l'exploration d'un grand nombre de domaines
Comment obtenir une liste de liens à partir d'une page de wikipedia
[Django] Que faire quand il y a de nombreux champs dans le modèle que vous souhaitez créer
Création d'un modèle séquentiel Tensorflow avec une image originale ajoutée à MNIST
L'exécution d'un grand nombre de Python3 Executor.submit peut consommer beaucoup de mémoire.
À partir d'un livre que les programmeurs peuvent apprendre ... (Python): examen des tableaux
Comment créer une grande quantité de données de test dans MySQL? ??
Exécutez Systems Manager à partir de Lambda pour obtenir une sauvegarde d'EC2
D'un livre que les pensées du programmeur peuvent être apprises: résumez les parties de petits problèmes
[Version compatible TensorFlow 2.x] Comment entraîner une grande quantité de données à l'aide de TFRecord et DataSet dans TensorFlow (Keras)
Une histoire sur la création d'un programme qui augmentera le nombre d'abonnés Instagram de 0 à 700 en une semaine