Melhores práticas para a tubulação de entrada de alto desempenho usando apenas tf.data API (sem feed_dict)

votos
1

O funcionário TensorFlow Performance Guide afirma o seguinte:

Enquanto que alimentam dados usando um feed_dict oferece um elevado grau de flexibilidade, em geral feed_dict não fornece uma solução escalável. Se apenas uma única GPU é usado, a diferença entre a API tf.data e desempenho feed_dict pode ser insignificante. Nossa recomendação é evitar o uso feed_dict para todos, mas triviais exemplos. Em particular, evitar a utilização de feed_dict com grandes entradas.

No entanto, evitar o uso de feed_dict inteiramente parece ser impossível. Considere a seguinte configuração com conjuntos de dados trem, validação e teste.

ds = tf.data.Dataset
n_files = 1000 # total number of tfrecord files
split = int(.67 * n_files)
files = ds.zip((ds.range(n_files),ds.list_files(train/part-r-*)))
train_files = files.filter(lambda a, b: a < split).map(lambda a,b: b)
validation_files = files.filter(lambda a, b: a >= split).map(lambda a,b: b)
test_files = ds.list_files(test/part-r-*)

Um método comum para analisar os conjuntos de dados pode parecer com o seguinte:

def setup_dataset(self, file_ds, mode=train):

   data = file_ds.apply(tf.contrib.data.parallel_interleave(
       tf.data.TFRecordDataset,
       cycle_length=4,
       sloppy=True,
       buffer_output_elements=self.batch_size * 8,
       prefetch_input_elements=self.batch_size * 8
   ))

   if mode == train:
       data = data.map(self.train_data_parser)
   else:
       data = data.map(self.test_data_parser)

   return data

Então, em vez de alimentar as características individuais através de um feed_dict em session.run(), você criaria um iterador reutilizável com qualquer Iterator.from_structure()ou Iterator.from_string_handle(). Vou mostrar um exemplo com o primeiro, mas você tiver o mesmo problema de qualquer maneira.

train = self.setup_dataset(train_files)
self.ops[template_iterator] = tf.data.Iterator.from_structure(train.output_types, train.output_shapes)
self.ops[next_batch] = self.ops[template_iterator].get_next(name=next_batch)
self.ops[train_init] = self.ops[template_iterator].make_initializer(train)

validation = self.setup_dataset(validation_files)
self.ops[validation_init] = self.ops[template_iterator].make_initializer(validation)

Isso tudo funciona muito bem, mas o que é que eu vou fazer com o conjunto de dados de teste? O conjunto de dados de teste não irá conter o recurso (s) rótulo e, portanto, não estão em conformidade com as mesmas output_types e output_shapes como o trem e validação conjuntos de dados.

Eu realmente gostaria de restaurar a partir de um SavedModel e inicializar o conjunto de dados de teste em vez de servir o modelo através de uma API.

Qual é o truque que eu estou faltando para incorporar conjunto de dados de teste durante a inferência?

Publicado 20/09/2018 em 04:19
fonte usuário
Em outras línguas...                            


1 respostas

votos
0

Eu tenho os meus conjuntos de dados e iterators configurado para treinamento e inferência como este:

# Train dataset
images_train = tf.placeholder(tf.float32, train_images.shape)
labels_train = tf.placeholder(tf.float32, train_masks.shape)
dataset_train = tf.data.Dataset.from_tensor_slices({"images": images_train, "masks": labels_train})
dataset_train = dataset_train.batch(MINIBATCH)
dataset_train = dataset_train.map(lambda x: map_helper(x, augmentation), num_parallel_calls=8)
dataset_train = dataset_train.shuffle(buffer_size=10000)

iterator_train = tf.data.Iterator.from_structure(dataset_train.output_types, dataset_train.output_shapes)
training_init_op = iterator_train.make_initializer(dataset_train)
batch_train = iterator_train.get_next()

# Inference dataset
images_infer = tf.placeholder(tf.float32, shape=[None] + list(valid_images.shape[1:]))
labels_infer = tf.placeholder(tf.float32, shape=[None] + list(valid_masks.shape[1:]))
dataset_infer = tf.data.Dataset.from_tensor_slices({"images": images_infer, "masks": labels_infer})
dataset_infer = dataset_infer.batch(MINIBATCH)

iterator_infer = tf.data.Iterator.from_structure(dataset_infer.output_types, dataset_infer.output_shapes)
infer_init_op = iterator_infer.make_initializer(dataset_infer)
batch_infer = iterator_infer.get_next()

Treinamento

Inicializar o iterador para o treinamento usando training_init_op

sess.run(training_init_op, feed_dict={images_train: train_images, labels_train: train_masks})

Validação

Inicializar o iterador inferência para validação usando infer_init_op

sess.run(infer_init_op, feed_dict={images_infer: images_val, labels_infer: masks_val})

Teste

Inicializar o iteração inferência para testar a utilização infer_init_op. Isto é um pouco hacky, mas eu criar uma matriz com zeros, onde os rótulos iria e usar o mesmo iterador I utilizado para validação

sess.run(infer_init_op, feed_dict={images_infer: images_test, labels_infer: np.zeros(images_test.shape)})

Alternativamente, você pode criar 3 diferentes conjuntos de dados / iterators para trem / validação / teste

Respondeu 20/09/2018 em 09:33
fonte usuário

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more