Pourquoi le réseau convolutif utilise-t-il toutes les 64 images pour l'entraînement?

Question

Je suis à la recherche d'un code de here pour Python 3.5 + tensorflow + TFLearn:

# -*- coding: utf-8 -*- 

""" Convolutional Neural Network for MNIST dataset classification task. 

References: 
    Y. LeCun, L. Bottou, Y. Bengio, and P. Haffner. "Gradient-based 
    learning applied to document recognition." Proceedings of the IEEE, 
    86(11):2278-2324, November 1998. 

Links: 
    [MNIST Dataset] http://yann.lecun.com/exdb/mnist/ 

""" 

from __future__ import division, print_function, absolute_import 

import tflearn 
from tflearn.layers.core import input_data, dropout, fully_connected 
from tflearn.layers.conv import conv_2d, max_pool_2d 
from tflearn.layers.normalization import local_response_normalization 
from tflearn.layers.estimator import regression 

# Data loading and preprocessing 
import tflearn.datasets.mnist as mnist 
X, Y, testX, testY = mnist.load_data(one_hot=True) 
X = X.reshape([-1, 28, 28, 1]) 
testX = testX.reshape([-1, 28, 28, 1]) 

# Building convolutional network 
network = input_data(shape=[None, 28, 28, 1], name='input') 
network = conv_2d(network, 32, 3, activation='relu', regularizer="L2") 
network = max_pool_2d(network, 2) 
network = local_response_normalization(network) 
network = conv_2d(network, 64, 3, activation='relu', regularizer="L2") 
network = max_pool_2d(network, 2) 
network = local_response_normalization(network) 
network = fully_connected(network, 128, activation='tanh') 
network = dropout(network, 0.8) 
network = fully_connected(network, 256, activation='tanh') 
network = dropout(network, 0.8) 
network = fully_connected(network, 10, activation='softmax') 
network = regression(network, optimizer='adam', learning_rate=0.01, 
        loss='categorical_crossentropy', name='target') 

# Training 
model = tflearn.DNN(network, tensorboard_verbose=0) 
model.fit({'input': X}, {'target': Y}, n_epoch=20, 
      validation_set=({'input': testX}, {'target': testY}), 
      snapshot_step=100, show_metric=True, run_id='convnet_mnist') 

Ok, ça marche. Mais il n'utilise que toutes les 64 images de l'ensemble pendant l'apprentissage. Pourquoi cela arrive-t-il? Que faire si j'ai un petit jeu et que le réseau doit utiliser chaque première image?

Exemple de message de formation

Training Step: 1 | time: 2.416s 
| Adam | epoch: 001 | loss: 0.00000 -- iter: 064/55000 
Training Step: 2 | total loss: 0.24470 | time: 4.621s 
| Adam | epoch: 001 | loss: 0.24470 -- iter: 128/55000 
Training Step: 3 | total loss: 0.10852 | time: 6.876s 
| Adam | epoch: 001 | loss: 0.10852 -- iter: 192/55000 
Training Step: 4 | total loss: 0.20421 | time: 9.129s 
| Adam | epoch: 001 | loss: 0.20421 -- iter: 256/55000 

Answer 1

Il est non seulement en utilisant tous les 64e image, il se charge des lots de 64 images. C'est pourquoi vous voyez l'iter augmenter de 64 à chaque fois, car il a traité 64 images par étape d'entraînement. Jetez un oeil à la documentation pour la couche de régression http://tflearn.org/layers/estimator/, ici vous pouvez définir la taille du lot.

Answer 2

Je l'ai fait par moi-même. Ce paramètre est régi par taille_taille dans modèle.fit. Par défaut, il est 64. donc, d'utiliser toutes les première image que vous avez besoin de réécrire la dernière chaîne de la façon suivante:

model.fit({'input': X}, {'target': Y}, n_epoch=20, 
      validation_set=({'input': testX}, {'target': testY}), 
      snapshot_step=100, batch_size=1, 
      show_metric=True,run_id='convnet_mnist')