diff --git a/bob/learn/tensorflow/analyzers/ExperimentAnalizer.py b/bob/learn/tensorflow/analyzers/ExperimentAnalizer.py index 56ca885025b41c8c0689700775dfaebeba92e922..c66cc36920ee8b17e596507627a720edb508768b 100644 --- a/bob/learn/tensorflow/analyzers/ExperimentAnalizer.py +++ b/bob/learn/tensorflow/analyzers/ExperimentAnalizer.py @@ -2,7 +2,6 @@ # vim: set fileencoding=utf-8 : # @author: Tiago de Freitas Pereira # @date: Tue 09 Aug 2016 15:33 CEST - """ Neural net work error rates analizer """ @@ -25,7 +24,8 @@ class ExperimentAnalizer: """ - def __init__(self, convergence_threshold=0.01, convergence_reference='eer'): + def __init__(self, convergence_threshold=0.01, + convergence_reference='eer'): """ Use the CNN as feature extractor for a n-class classification @@ -76,8 +76,10 @@ class ExperimentAnalizer: # Creating models models = [] for i in range(len(base_data_shuffler.possible_labels)): - indexes_model = numpy.where(enroll_labels == data_shuffler.possible_labels[i])[0] - models.append(numpy.mean(enroll_features[indexes_model, :], axis=0)) + indexes_model = numpy.where( + enroll_labels == data_shuffler.possible_labels[i])[0] + models.append( + numpy.mean(enroll_features[indexes_model, :], axis=0)) # Probing positive_scores = numpy.zeros(shape=0) @@ -87,16 +89,23 @@ class ExperimentAnalizer: # Positive scoring indexes = probe_labels == base_data_shuffler.possible_labels[i] positive_data = probe_features[indexes, :] - p = [cosine(models[i], positive_data[j]) for j in range(positive_data.shape[0])] + p = [ + cosine(models[i], positive_data[j]) + for j in range(positive_data.shape[0]) + ] positive_scores = numpy.hstack((positive_scores, p)) # negative scoring indexes = probe_labels != base_data_shuffler.possible_labels[i] negative_data = probe_features[indexes, :] - n = [cosine(models[i], negative_data[j]) for j in range(negative_data.shape[0])] + n = [ + cosine(models[i], negative_data[j]) + for j in range(negative_data.shape[0]) + ] negative_scores = numpy.hstack((negative_scores, n)) - return self.__compute_tensorflow_summary((-1)*negative_scores, (-1) * positive_scores) + return self.__compute_tensorflow_summary((-1) * negative_scores, + (-1) * positive_scores) def __compute_tensorflow_summary(self, negative_scores, positive_scores): """ @@ -119,27 +128,38 @@ class ExperimentAnalizer: # Compute EER threshold = bob.measure.eer_threshold(negative_scores, positive_scores) - far, frr = bob.measure.farfrr(negative_scores, positive_scores, threshold) + far, frr = bob.measure.farfrr(negative_scores, positive_scores, + threshold) eer = (far + frr) / 2. - summaries.append(summary_pb2.Summary.Value(tag="EER", simple_value=eer)) + summaries.append( + summary_pb2.Summary.Value(tag="EER", simple_value=eer)) self.eer.append(eer) # Computing FAR 10 - threshold = bob.measure.far_threshold(negative_scores, positive_scores, far_value=0.1) - far, frr = bob.measure.farfrr(negative_scores, positive_scores, threshold) - summaries.append(summary_pb2.Summary.Value(tag="FAR 10", simple_value=frr)) + threshold = bob.measure.far_threshold( + negative_scores, positive_scores, far_value=0.1) + far, frr = bob.measure.farfrr(negative_scores, positive_scores, + threshold) + summaries.append( + summary_pb2.Summary.Value(tag="FAR 10", simple_value=frr)) self.far10.append(frr) # Computing FAR 100 - threshold = bob.measure.far_threshold(negative_scores, positive_scores, far_value=0.01) - far, frr = bob.measure.farfrr(negative_scores, positive_scores, threshold) - summaries.append(summary_pb2.Summary.Value(tag="FAR 100", simple_value=frr)) + threshold = bob.measure.far_threshold( + negative_scores, positive_scores, far_value=0.01) + far, frr = bob.measure.farfrr(negative_scores, positive_scores, + threshold) + summaries.append( + summary_pb2.Summary.Value(tag="FAR 100", simple_value=frr)) self.far100.append(frr) # Computing FAR 1000 - threshold = bob.measure.far_threshold(negative_scores, positive_scores, far_value=0.001) - far, frr = bob.measure.farfrr(negative_scores, positive_scores, threshold) - summaries.append(summary_pb2.Summary.Value(tag="FAR 1000", simple_value=frr)) + threshold = bob.measure.far_threshold( + negative_scores, positive_scores, far_value=0.001) + far, frr = bob.measure.farfrr(negative_scores, positive_scores, + threshold) + summaries.append( + summary_pb2.Summary.Value(tag="FAR 1000", simple_value=frr)) self.far1000.append(frr) - return summary_pb2.Summary(value=summaries) \ No newline at end of file + return summary_pb2.Summary(value=summaries) diff --git a/bob/learn/tensorflow/analyzers/SoftmaxAnalizer.py b/bob/learn/tensorflow/analyzers/SoftmaxAnalizer.py index 838c9efe4f0b58291015548fcfc7439a8553ca5c..6b5dbe9a0e2d9909d8af10f425e3194f0a6e39e0 100644 --- a/bob/learn/tensorflow/analyzers/SoftmaxAnalizer.py +++ b/bob/learn/tensorflow/analyzers/SoftmaxAnalizer.py @@ -2,7 +2,6 @@ # vim: set fileencoding=utf-8 : # @author: Tiago de Freitas Pereira # @date: Tue 09 Aug 2016 15:33 CEST - """ Neural net work error rates analizer """ @@ -24,8 +23,15 @@ class SoftmaxAnalizer(object): def __call__(self, data_shuffler, network, session): data, labels = data_shuffler.get_batch() - predictions = numpy.argmax(session.run(network.inference_graph, feed_dict={network.inference_placeholder: data[:]}), 1) - accuracy = 100. * numpy.sum(predictions == labels) / predictions.shape[0] + predictions = numpy.argmax( + session.run( + network.inference_graph, + feed_dict={ + network.inference_placeholder: data[:] + }), 1) + accuracy = 100. * numpy.sum( + predictions == labels) / predictions.shape[0] - summaries = [(summary_pb2.Summary.Value(tag="accuracy_validation", simple_value=float(accuracy)))] + summaries = [(summary_pb2.Summary.Value( + tag="accuracy_validation", simple_value=float(accuracy)))] return summary_pb2.Summary(value=summaries) diff --git a/bob/learn/tensorflow/analyzers/__init__.py b/bob/learn/tensorflow/analyzers/__init__.py index d7511241693fd0a134de6c0d54b761cc25510de4..13ad021cddeb089e26a92359357707364fc8068b 100644 --- a/bob/learn/tensorflow/analyzers/__init__.py +++ b/bob/learn/tensorflow/analyzers/__init__.py @@ -4,7 +4,7 @@ from .SoftmaxAnalizer import SoftmaxAnalizer # gets sphinx autodoc done right - don't remove it def __appropriate__(*args): - """Says object was actually declared here, an not on the import module. + """Says object was actually declared here, an not on the import module. Parameters: @@ -14,11 +14,12 @@ def __appropriate__(*args): ` """ - for obj in args: obj.__module__ = __name__ + for obj in args: + obj.__module__ = __name__ + __appropriate__( ExperimentAnalizer, SoftmaxAnalizer, - ) +) __all__ = [_ for _ in dir() if not _.startswith('_')] - diff --git a/bob/learn/tensorflow/dataset/__init__.py b/bob/learn/tensorflow/dataset/__init__.py index ed35e7e829e8f595cb62768653f03f626cc1b3c2..683244b0094d2de65eed67121a747cbf719fb2a0 100644 --- a/bob/learn/tensorflow/dataset/__init__.py +++ b/bob/learn/tensorflow/dataset/__init__.py @@ -3,20 +3,22 @@ import numpy import os import bob.io.base -DEFAULT_FEATURE = {'data': tf.FixedLenFeature([], tf.string), - 'label': tf.FixedLenFeature([], tf.int64), - 'key': tf.FixedLenFeature([], tf.string)} +DEFAULT_FEATURE = { + 'data': tf.FixedLenFeature([], tf.string), + 'label': tf.FixedLenFeature([], tf.int64), + 'key': tf.FixedLenFeature([], tf.string) +} def from_hdf5file_to_tensor(filename): import bob.io.image data = bob.io.image.to_matplotlib(bob.io.base.load(filename)) - - #reshaping to ndim == 3 + + #reshaping to ndim == 3 if data.ndim == 2: data = numpy.reshape(data, (data.shape[0], data.shape[1], 1)) data = data.astype("float32") - + return data @@ -27,14 +29,16 @@ def from_filename_to_tensor(filename, extension=None): If the file extension is something that tensorflow understands (.jpg, .bmp, .tif,...), it uses the `tf.image.decode_image` otherwise it uses `bob.io.base.load` """ - + if extension == "hdf5": return tf.py_func(from_hdf5file_to_tensor, [filename], [tf.float32]) else: - return tf.cast(tf.image.decode_image(tf.read_file(filename)), tf.float32) + return tf.cast( + tf.image.decode_image(tf.read_file(filename)), tf.float32) -def append_image_augmentation(image, gray_scale=False, +def append_image_augmentation(image, + gray_scale=False, output_shape=None, random_flip=False, random_brightness=False, @@ -73,8 +77,8 @@ def append_image_augmentation(image, gray_scale=False, if output_shape is not None: assert len(output_shape) == 2 - image = tf.image.resize_image_with_crop_or_pad( - image, output_shape[0], output_shape[1]) + image = tf.image.resize_image_with_crop_or_pad(image, output_shape[0], + output_shape[1]) if random_flip: image = tf.image.random_flip_left_right(image) @@ -137,18 +141,20 @@ def triplets_random_generator(input_data, input_labels): input_labels = numpy.array(input_labels) total_samples = input_data.shape[0] - indexes_per_labels = arrange_indexes_by_label( - input_labels, possible_labels) + indexes_per_labels = arrange_indexes_by_label(input_labels, + possible_labels) # searching for random triplets offset_class = 0 for i in range(total_samples): - anchor_sample = input_data[indexes_per_labels[possible_labels[offset_class]][numpy.random.randint( - len(indexes_per_labels[possible_labels[offset_class]]))], ...] + anchor_sample = input_data[indexes_per_labels[possible_labels[ + offset_class]][numpy.random.randint( + len(indexes_per_labels[possible_labels[offset_class]]))], ...] - positive_sample = input_data[indexes_per_labels[possible_labels[offset_class]][numpy.random.randint( - len(indexes_per_labels[possible_labels[offset_class]]))], ...] + positive_sample = input_data[indexes_per_labels[possible_labels[ + offset_class]][numpy.random.randint( + len(indexes_per_labels[possible_labels[offset_class]]))], ...] # Changing the class offset_class += 1 @@ -156,8 +162,9 @@ def triplets_random_generator(input_data, input_labels): if offset_class == len(possible_labels): offset_class = 0 - negative_sample = input_data[indexes_per_labels[possible_labels[offset_class]][numpy.random.randint( - len(indexes_per_labels[possible_labels[offset_class]]))], ...] + negative_sample = input_data[indexes_per_labels[possible_labels[ + offset_class]][numpy.random.randint( + len(indexes_per_labels[possible_labels[offset_class]]))], ...] append(str(anchor_sample), str(positive_sample), str(negative_sample)) # yield anchor, positive, negative @@ -199,8 +206,8 @@ def siamease_pairs_generator(input_data, input_labels): # for l in possible_labels: # indexes_per_labels[l] = numpy.where(input_labels == l)[0] # numpy.random.shuffle(indexes_per_labels[l]) - indexes_per_labels = arrange_indexes_by_label( - input_labels, possible_labels) + indexes_per_labels = arrange_indexes_by_label(input_labels, + possible_labels) left_possible_indexes = numpy.random.choice( possible_labels, total_samples, replace=True) @@ -215,10 +222,10 @@ def siamease_pairs_generator(input_data, input_labels): class_index = left_possible_indexes[i] # Now selecting the samples for the pair - left = input_data[indexes_per_labels[class_index][numpy.random.randint( - len(indexes_per_labels[class_index]))]] - right = input_data[indexes_per_labels[class_index][numpy.random.randint( - len(indexes_per_labels[class_index]))]] + left = input_data[indexes_per_labels[class_index][ + numpy.random.randint(len(indexes_per_labels[class_index]))]] + right = input_data[indexes_per_labels[class_index][ + numpy.random.randint(len(indexes_per_labels[class_index]))]] append(left, right, 0) # yield left, right, 0 else: @@ -237,10 +244,12 @@ def siamease_pairs_generator(input_data, input_labels): if j < total_samples: # Now selecting the samples for the pair - left = input_data[indexes_per_labels[class_index[0]][numpy.random.randint( - len(indexes_per_labels[class_index[0]]))]] - right = input_data[indexes_per_labels[class_index[1]][numpy.random.randint( - len(indexes_per_labels[class_index[1]]))]] + left = input_data[indexes_per_labels[class_index[0]][ + numpy.random.randint( + len(indexes_per_labels[class_index[0]]))]] + right = input_data[indexes_per_labels[class_index[1]][ + numpy.random.randint( + len(indexes_per_labels[class_index[1]]))]] append(left, right, 1) genuine = not genuine @@ -274,9 +283,8 @@ def blocks_tensorflow(images, block_size): # extract image patches for each color space: output = [] for i in range(3): - blocks = tf.extract_image_patches( - images[:, :, :, i:i + 1], block_size, block_size, [1, 1, 1, 1], - "VALID") + blocks = tf.extract_image_patches(images[:, :, :, i:i + 1], block_size, + block_size, [1, 1, 1, 1], "VALID") if i == 0: n_blocks = int(numpy.prod(blocks.shape[1:3])) blocks = tf.reshape(blocks, output_size) diff --git a/bob/learn/tensorflow/dataset/bio.py b/bob/learn/tensorflow/dataset/bio.py index 427b5e182b70de680a61f681762bf7e7eded6877..70b7ba024cfb36ec9e4e58f570b9dbdd07880b8e 100644 --- a/bob/learn/tensorflow/dataset/bio.py +++ b/bob/learn/tensorflow/dataset/bio.py @@ -40,17 +40,23 @@ class BioGenerator(object): The shapes of the returned samples. """ - def __init__(self, database, biofiles, load_data=None, - biofile_to_label=None, multiple_samples=False, **kwargs): + def __init__(self, + database, + biofiles, + load_data=None, + biofile_to_label=None, + multiple_samples=False, + **kwargs): super(BioGenerator, self).__init__(**kwargs) if load_data is None: + def load_data(database, biofile): - data = read_original_data( - biofile, - database.original_directory, - database.original_extension) + data = read_original_data(biofile, database.original_directory, + database.original_extension) return data + if biofile_to_label is None: + def biofile_to_label(biofile): return -1 @@ -71,8 +77,8 @@ class BioGenerator(object): data = six.next(data) data = tf.convert_to_tensor(data) self._output_types = (data.dtype, tf.int64, tf.string) - self._output_shapes = ( - data.shape, tf.TensorShape([]), tf.TensorShape([])) + self._output_shapes = (data.shape, tf.TensorShape([]), + tf.TensorShape([])) logger.info("Initializing a dataset with %d files and %s types " "and %s shapes", len(self.biofiles), self.output_types, @@ -107,8 +113,8 @@ class BioGenerator(object): (data, label, key) : tuple A tuple containing the data, label, and the key. """ - for f, label, key in six.moves.zip( - self.biofiles, self.labels, self.keys): + for f, label, key in six.moves.zip(self.biofiles, self.labels, + self.keys): data = self.load_data(self.database, f) # labels if self.multiple_samples: diff --git a/bob/learn/tensorflow/dataset/image.py b/bob/learn/tensorflow/dataset/image.py index 241be4342ff6ca2e738f2f2ce6a010de3eda55ab..b3de35f43e22b20832a5087646cf439a1bb6cd22 100644 --- a/bob/learn/tensorflow/dataset/image.py +++ b/bob/learn/tensorflow/dataset/image.py @@ -7,16 +7,21 @@ from functools import partial from . import append_image_augmentation, from_filename_to_tensor -def shuffle_data_and_labels_image_augmentation(filenames, labels, data_shape, data_type, - batch_size, epochs=None, buffer_size=10**3, - gray_scale=False, - output_shape=None, - random_flip=False, - random_brightness=False, - random_contrast=False, - random_saturation=False, - per_image_normalization=True, - extension=None): +def shuffle_data_and_labels_image_augmentation(filenames, + labels, + data_shape, + data_type, + batch_size, + epochs=None, + buffer_size=10**3, + gray_scale=False, + output_shape=None, + random_flip=False, + random_brightness=False, + random_contrast=False, + random_saturation=False, + per_image_normalization=True, + extension=None): """ Dump random batches from a list of image paths and labels: @@ -71,28 +76,33 @@ def shuffle_data_and_labels_image_augmentation(filenames, labels, data_shape, da extension: If None, will load files using `tf.image.decode..` if set to `hdf5`, will load with `bob.io.base.load` - """ + """ + + dataset = create_dataset_from_path_augmentation( + filenames, + labels, + data_shape, + data_type, + gray_scale=gray_scale, + output_shape=output_shape, + random_flip=random_flip, + random_brightness=random_brightness, + random_contrast=random_contrast, + random_saturation=random_saturation, + per_image_normalization=per_image_normalization, + extension=extension) - dataset = create_dataset_from_path_augmentation(filenames, labels, data_shape, - data_type, - gray_scale=gray_scale, - output_shape=output_shape, - random_flip=random_flip, - random_brightness=random_brightness, - random_contrast=random_contrast, - random_saturation=random_saturation, - per_image_normalization=per_image_normalization, - extension=extension) - dataset = dataset.shuffle(buffer_size).batch(batch_size).repeat(epochs) data, labels = dataset.make_one_shot_iterator().get_next() return data, labels -def create_dataset_from_path_augmentation(filenames, labels, - data_shape, data_type, - gray_scale=False, +def create_dataset_from_path_augmentation(filenames, + labels, + data_shape, + data_type, + gray_scale=False, output_shape=None, random_flip=False, random_brightness=False, @@ -120,26 +130,30 @@ def create_dataset_from_path_augmentation(filenames, labels, feature: """ - - parser = partial(image_augmentation_parser, - data_shape=data_shape, - data_type=data_type, - gray_scale=gray_scale, - output_shape=output_shape, - random_flip=random_flip, - random_brightness=random_brightness, - random_contrast=random_contrast, - random_saturation=random_saturation, - per_image_normalization=per_image_normalization, - extension=extension) + + parser = partial( + image_augmentation_parser, + data_shape=data_shape, + data_type=data_type, + gray_scale=gray_scale, + output_shape=output_shape, + random_flip=random_flip, + random_brightness=random_brightness, + random_contrast=random_contrast, + random_saturation=random_saturation, + per_image_normalization=per_image_normalization, + extension=extension) dataset = tf.contrib.data.Dataset.from_tensor_slices((filenames, labels)) dataset = dataset.map(parser) return dataset -def image_augmentation_parser(filename, label, data_shape, data_type, - gray_scale=False, +def image_augmentation_parser(filename, + label, + data_shape, + data_type, + gray_scale=False, output_shape=None, random_flip=False, random_brightness=False, @@ -147,30 +161,30 @@ def image_augmentation_parser(filename, label, data_shape, data_type, random_saturation=False, per_image_normalization=True, extension=None): - """ Parses a single tf.Example into image and label tensors. """ - + # Convert the image data from string back to the numbers image = from_filename_to_tensor(filename, extension=extension) # Reshape image data into the original shape image = tf.reshape(image, data_shape) - + #Applying image augmentation - image = append_image_augmentation(image, gray_scale=gray_scale, - output_shape=output_shape, - random_flip=random_flip, - random_brightness=random_brightness, - random_contrast=random_contrast, - random_saturation=random_saturation, - per_image_normalization=per_image_normalization) - + image = append_image_augmentation( + image, + gray_scale=gray_scale, + output_shape=output_shape, + random_flip=random_flip, + random_brightness=random_brightness, + random_contrast=random_contrast, + random_saturation=random_saturation, + per_image_normalization=per_image_normalization) + label = tf.cast(label, tf.int64) features = dict() features['data'] = image features['key'] = filename return features, label - diff --git a/bob/learn/tensorflow/dataset/siamese_image.py b/bob/learn/tensorflow/dataset/siamese_image.py index 30c610f0e6129f148da46a40852724a682804142..9d3c4fc117017f220356025cf19b1229568939a1 100644 --- a/bob/learn/tensorflow/dataset/siamese_image.py +++ b/bob/learn/tensorflow/dataset/siamese_image.py @@ -7,16 +7,21 @@ from functools import partial from . import append_image_augmentation, siamease_pairs_generator, from_filename_to_tensor -def shuffle_data_and_labels_image_augmentation(filenames, labels, data_shape, data_type, - batch_size, epochs=None, buffer_size=10**3, - gray_scale=False, - output_shape=None, - random_flip=False, - random_brightness=False, - random_contrast=False, - random_saturation=False, - per_image_normalization=True, - extension=None): +def shuffle_data_and_labels_image_augmentation(filenames, + labels, + data_shape, + data_type, + batch_size, + epochs=None, + buffer_size=10**3, + gray_scale=False, + output_shape=None, + random_flip=False, + random_brightness=False, + random_contrast=False, + random_saturation=False, + per_image_normalization=True, + extension=None): """ Dump random batches for siamese networks from a list of image paths and labels: @@ -76,27 +81,32 @@ def shuffle_data_and_labels_image_augmentation(filenames, labels, data_shape, da extension: If None, will load files using `tf.image.decode..` if set to `hdf5`, will load with `bob.io.base.load` - """ + """ - dataset = create_dataset_from_path_augmentation(filenames, labels, data_shape, - data_type, - gray_scale=gray_scale, - output_shape=output_shape, - random_flip=random_flip, - random_brightness=random_brightness, - random_contrast=random_contrast, - random_saturation=random_saturation, - per_image_normalization=per_image_normalization, - extension=extension) + dataset = create_dataset_from_path_augmentation( + filenames, + labels, + data_shape, + data_type, + gray_scale=gray_scale, + output_shape=output_shape, + random_flip=random_flip, + random_brightness=random_brightness, + random_contrast=random_contrast, + random_saturation=random_saturation, + per_image_normalization=per_image_normalization, + extension=extension) dataset = dataset.shuffle(buffer_size).batch(batch_size).repeat(epochs) data, labels = dataset.make_one_shot_iterator().get_next() return data, labels -def create_dataset_from_path_augmentation(filenames, labels, - data_shape, data_type, - gray_scale=False, +def create_dataset_from_path_augmentation(filenames, + labels, + data_shape, + data_type, + gray_scale=False, output_shape=None, random_flip=False, random_brightness=False, @@ -155,27 +165,34 @@ def create_dataset_from_path_augmentation(filenames, labels, If None, will load files using `tf.image.decode..` if set to `hdf5`, will load with `bob.io.base.load` """ - - parser = partial(image_augmentation_parser, - data_shape=data_shape, - data_type=data_type, - gray_scale=gray_scale, - output_shape=output_shape, - random_flip=random_flip, - random_brightness=random_brightness, - random_contrast=random_contrast, - random_saturation=random_saturation, - per_image_normalization=per_image_normalization, - extension=extension) - - left_data, right_data, siamese_labels = siamease_pairs_generator(filenames, labels) - dataset = tf.contrib.data.Dataset.from_tensor_slices((left_data, right_data, siamese_labels)) + + parser = partial( + image_augmentation_parser, + data_shape=data_shape, + data_type=data_type, + gray_scale=gray_scale, + output_shape=output_shape, + random_flip=random_flip, + random_brightness=random_brightness, + random_contrast=random_contrast, + random_saturation=random_saturation, + per_image_normalization=per_image_normalization, + extension=extension) + + left_data, right_data, siamese_labels = siamease_pairs_generator( + filenames, labels) + dataset = tf.contrib.data.Dataset.from_tensor_slices( + (left_data, right_data, siamese_labels)) dataset = dataset.map(parser) return dataset -def image_augmentation_parser(filename_left, filename_right, label, data_shape, data_type, - gray_scale=False, +def image_augmentation_parser(filename_left, + filename_right, + label, + data_shape, + data_type, + gray_scale=False, output_shape=None, random_flip=False, random_brightness=False, @@ -183,11 +200,10 @@ def image_augmentation_parser(filename_left, filename_right, label, data_shape, random_saturation=False, per_image_normalization=True, extension=None): - """ Parses a single tf.Example into image and label tensors. """ - + # Convert the image data from string back to the numbers image_left = from_filename_to_tensor(filename_left, extension=extension) image_right = from_filename_to_tensor(filename_right, extension=extension) @@ -195,28 +211,31 @@ def image_augmentation_parser(filename_left, filename_right, label, data_shape, # Reshape image data into the original shape image_left = tf.reshape(image_left, data_shape) image_right = tf.reshape(image_right, data_shape) - + #Applying image augmentation - image_left = append_image_augmentation(image_left, gray_scale=gray_scale, - output_shape=output_shape, - random_flip=random_flip, - random_brightness=random_brightness, - random_contrast=random_contrast, - random_saturation=random_saturation, - per_image_normalization=per_image_normalization) - - image_right = append_image_augmentation(image_right, gray_scale=gray_scale, - output_shape=output_shape, - random_flip=random_flip, - random_brightness=random_brightness, - random_contrast=random_contrast, - random_saturation=random_saturation, - per_image_normalization=per_image_normalization) + image_left = append_image_augmentation( + image_left, + gray_scale=gray_scale, + output_shape=output_shape, + random_flip=random_flip, + random_brightness=random_brightness, + random_contrast=random_contrast, + random_saturation=random_saturation, + per_image_normalization=per_image_normalization) + + image_right = append_image_augmentation( + image_right, + gray_scale=gray_scale, + output_shape=output_shape, + random_flip=random_flip, + random_brightness=random_brightness, + random_contrast=random_contrast, + random_saturation=random_saturation, + per_image_normalization=per_image_normalization) image = dict() - image['left'] = image_left + image['left'] = image_left image['right'] = image_right label = tf.cast(label, tf.int64) return image, label - diff --git a/bob/learn/tensorflow/dataset/tfrecords.py b/bob/learn/tensorflow/dataset/tfrecords.py index faa0938a23db82957339149dcf914ce270a1208e..2c6aea41ae48f7d3f53d67c406df7ba397c0b006 100644 --- a/bob/learn/tensorflow/dataset/tfrecords.py +++ b/bob/learn/tensorflow/dataset/tfrecords.py @@ -20,7 +20,10 @@ def example_parser(serialized_example, feature, data_shape, data_type): return image, label, key -def image_augmentation_parser(serialized_example, feature, data_shape, data_type, +def image_augmentation_parser(serialized_example, + feature, + data_shape, + data_type, gray_scale=False, output_shape=None, random_flip=False, @@ -41,22 +44,26 @@ def image_augmentation_parser(serialized_example, feature, data_shape, data_type image = tf.reshape(image, data_shape) # Applying image augmentation - image = append_image_augmentation(image, gray_scale=gray_scale, - output_shape=output_shape, - random_flip=random_flip, - random_brightness=random_brightness, - random_contrast=random_contrast, - random_saturation=random_saturation, - per_image_normalization=per_image_normalization) + image = append_image_augmentation( + image, + gray_scale=gray_scale, + output_shape=output_shape, + random_flip=random_flip, + random_brightness=random_brightness, + random_contrast=random_contrast, + random_saturation=random_saturation, + per_image_normalization=per_image_normalization) # Cast label data into int64 label = tf.cast(features['label'], tf.int64) key = tf.cast(features['key'], tf.string) - + return image, label, key -def read_and_decode(filename_queue, data_shape, data_type=tf.float32, +def read_and_decode(filename_queue, + data_shape, + data_type=tf.float32, feature=None): """ Simples parse possible for a tfrecord. @@ -71,7 +78,9 @@ def read_and_decode(filename_queue, data_shape, data_type=tf.float32, return example_parser(serialized_example, feature, data_shape, data_type) -def create_dataset_from_records(tfrecord_filenames, data_shape, data_type, +def create_dataset_from_records(tfrecord_filenames, + data_shape, + data_type, feature=None): """ Create dataset from a list of tf-record files @@ -94,21 +103,27 @@ def create_dataset_from_records(tfrecord_filenames, data_shape, data_type, if feature is None: feature = DEFAULT_FEATURE dataset = tf.contrib.data.TFRecordDataset(tfrecord_filenames) - parser = partial(example_parser, feature=feature, data_shape=data_shape, - data_type=data_type) + parser = partial( + example_parser, + feature=feature, + data_shape=data_shape, + data_type=data_type) dataset = dataset.map(parser) return dataset -def create_dataset_from_records_with_augmentation(tfrecord_filenames, data_shape, data_type, - feature=None, - gray_scale=False, - output_shape=None, - random_flip=False, - random_brightness=False, - random_contrast=False, - random_saturation=False, - per_image_normalization=True): +def create_dataset_from_records_with_augmentation( + tfrecord_filenames, + data_shape, + data_type, + feature=None, + gray_scale=False, + output_shape=None, + random_flip=False, + random_brightness=False, + random_contrast=False, + random_saturation=False, + per_image_normalization=True): """ Create dataset from a list of tf-record files @@ -130,21 +145,28 @@ def create_dataset_from_records_with_augmentation(tfrecord_filenames, data_shape if feature is None: feature = DEFAULT_FEATURE dataset = tf.contrib.data.TFRecordDataset(tfrecord_filenames) - parser = partial(image_augmentation_parser, feature=feature, data_shape=data_shape, - data_type=data_type, - gray_scale=gray_scale, - output_shape=output_shape, - random_flip=random_flip, - random_brightness=random_brightness, - random_contrast=random_contrast, - random_saturation=random_saturation, - per_image_normalization=per_image_normalization) + parser = partial( + image_augmentation_parser, + feature=feature, + data_shape=data_shape, + data_type=data_type, + gray_scale=gray_scale, + output_shape=output_shape, + random_flip=random_flip, + random_brightness=random_brightness, + random_contrast=random_contrast, + random_saturation=random_saturation, + per_image_normalization=per_image_normalization) dataset = dataset.map(parser) return dataset -def shuffle_data_and_labels_image_augmentation(tfrecord_filenames, data_shape, data_type, - batch_size, epochs=None, buffer_size=10**3, +def shuffle_data_and_labels_image_augmentation(tfrecord_filenames, + data_shape, + data_type, + batch_size, + epochs=None, + buffer_size=10**3, gray_scale=False, output_shape=None, random_flip=False, @@ -198,29 +220,35 @@ def shuffle_data_and_labels_image_augmentation(tfrecord_filenames, data_shape, d """ - dataset = create_dataset_from_records_with_augmentation(tfrecord_filenames, data_shape, - data_type, - gray_scale=gray_scale, - output_shape=output_shape, - random_flip=random_flip, - random_brightness=random_brightness, - random_contrast=random_contrast, - random_saturation=random_saturation, - per_image_normalization=per_image_normalization) + dataset = create_dataset_from_records_with_augmentation( + tfrecord_filenames, + data_shape, + data_type, + gray_scale=gray_scale, + output_shape=output_shape, + random_flip=random_flip, + random_brightness=random_brightness, + random_contrast=random_contrast, + random_saturation=random_saturation, + per_image_normalization=per_image_normalization) dataset = dataset.shuffle(buffer_size).batch(batch_size).repeat(epochs) data, labels, key = dataset.make_one_shot_iterator().get_next() - + features = dict() features['data'] = data features['key'] = key - + return features, labels -def shuffle_data_and_labels(tfrecord_filenames, data_shape, data_type, - batch_size, epochs=None, buffer_size=10**3): +def shuffle_data_and_labels(tfrecord_filenames, + data_shape, + data_type, + batch_size, + epochs=None, + buffer_size=10**3): """ Dump random batches from a list of tf-record files @@ -254,12 +282,15 @@ def shuffle_data_and_labels(tfrecord_filenames, data_shape, data_type, features = dict() features['data'] = data features['key'] = key - + return features, labels -def batch_data_and_labels(tfrecord_filenames, data_shape, data_type, - batch_size, epochs=1): +def batch_data_and_labels(tfrecord_filenames, + data_shape, + data_type, + batch_size, + epochs=1): """ Dump in order batches from a list of tf-record files @@ -289,12 +320,15 @@ def batch_data_and_labels(tfrecord_filenames, data_shape, data_type, features = dict() features['data'] = data features['key'] = key - + return features, labels - - -def batch_data_and_labels_image_augmentation(tfrecord_filenames, data_shape, data_type, - batch_size, epochs=1, + + +def batch_data_and_labels_image_augmentation(tfrecord_filenames, + data_shape, + data_type, + batch_size, + epochs=1, gray_scale=False, output_shape=None, random_flip=False, @@ -323,23 +357,24 @@ def batch_data_and_labels_image_augmentation(tfrecord_filenames, data_shape, dat Number of epochs to be batched """ - - dataset = create_dataset_from_records_with_augmentation(tfrecord_filenames, data_shape, - data_type, - gray_scale=gray_scale, - output_shape=output_shape, - random_flip=random_flip, - random_brightness=random_brightness, - random_contrast=random_contrast, - random_saturation=random_saturation, - per_image_normalization=per_image_normalization) - + + dataset = create_dataset_from_records_with_augmentation( + tfrecord_filenames, + data_shape, + data_type, + gray_scale=gray_scale, + output_shape=output_shape, + random_flip=random_flip, + random_brightness=random_brightness, + random_contrast=random_contrast, + random_saturation=random_saturation, + per_image_normalization=per_image_normalization) + dataset = dataset.batch(batch_size).repeat(epochs) data, labels, key = dataset.make_one_shot_iterator().get_next() features = dict() features['data'] = data features['key'] = key - - return features, labels + return features, labels diff --git a/bob/learn/tensorflow/dataset/triplet_image.py b/bob/learn/tensorflow/dataset/triplet_image.py index 1cbff96086f0b968ce152e0501ccd6709e3cf39d..11907fb53d471b8784082c279327eb719797e01a 100644 --- a/bob/learn/tensorflow/dataset/triplet_image.py +++ b/bob/learn/tensorflow/dataset/triplet_image.py @@ -7,8 +7,13 @@ from functools import partial from . import append_image_augmentation, triplets_random_generator, from_filename_to_tensor -def shuffle_data_and_labels_image_augmentation(filenames, labels, data_shape, data_type, - batch_size, epochs=None, buffer_size=10**3, +def shuffle_data_and_labels_image_augmentation(filenames, + labels, + data_shape, + data_type, + batch_size, + epochs=None, + buffer_size=10**3, gray_scale=False, output_shape=None, random_flip=False, @@ -75,18 +80,21 @@ def shuffle_data_and_labels_image_augmentation(filenames, labels, data_shape, da extension: If None, will load files using `tf.image.decode..` if set to `hdf5`, will load with `bob.io.base.load` - """ - - dataset = create_dataset_from_path_augmentation(filenames, labels, data_shape, - data_type, - gray_scale=gray_scale, - output_shape=output_shape, - random_flip=random_flip, - random_brightness=random_brightness, - random_contrast=random_contrast, - random_saturation=random_saturation, - per_image_normalization=per_image_normalization, - extension=extension) + """ + + dataset = create_dataset_from_path_augmentation( + filenames, + labels, + data_shape, + data_type, + gray_scale=gray_scale, + output_shape=output_shape, + random_flip=random_flip, + random_brightness=random_brightness, + random_contrast=random_contrast, + random_saturation=random_saturation, + per_image_normalization=per_image_normalization, + extension=extension) dataset = dataset.shuffle(buffer_size).batch(batch_size).repeat(epochs) #dataset = dataset.batch(buffer_size).batch(batch_size).repeat(epochs) @@ -95,9 +103,11 @@ def shuffle_data_and_labels_image_augmentation(filenames, labels, data_shape, da return data -def create_dataset_from_path_augmentation(filenames, labels, - data_shape, data_type=tf.float32, - gray_scale=False, +def create_dataset_from_path_augmentation(filenames, + labels, + data_shape, + data_type=tf.float32, + gray_scale=False, output_shape=None, random_flip=False, random_brightness=False, @@ -125,28 +135,35 @@ def create_dataset_from_path_augmentation(filenames, labels, feature: """ - - parser = partial(image_augmentation_parser, - data_shape=data_shape, - data_type=data_type, - gray_scale=gray_scale, - output_shape=output_shape, - random_flip=random_flip, - random_brightness=random_brightness, - random_contrast=random_contrast, - random_saturation=random_saturation, - per_image_normalization=per_image_normalization, - extension=extension) - - anchor_data, positive_data, negative_data = triplets_random_generator(filenames, labels) - - dataset = tf.contrib.data.Dataset.from_tensor_slices((anchor_data, positive_data, negative_data)) + + parser = partial( + image_augmentation_parser, + data_shape=data_shape, + data_type=data_type, + gray_scale=gray_scale, + output_shape=output_shape, + random_flip=random_flip, + random_brightness=random_brightness, + random_contrast=random_contrast, + random_saturation=random_saturation, + per_image_normalization=per_image_normalization, + extension=extension) + + anchor_data, positive_data, negative_data = triplets_random_generator( + filenames, labels) + + dataset = tf.contrib.data.Dataset.from_tensor_slices( + (anchor_data, positive_data, negative_data)) dataset = dataset.map(parser) return dataset -def image_augmentation_parser(anchor, positive, negative, data_shape, data_type=tf.float32, - gray_scale=False, +def image_augmentation_parser(anchor, + positive, + negative, + data_shape, + data_type=tf.float32, + gray_scale=False, output_shape=None, random_flip=False, random_brightness=False, @@ -154,13 +171,13 @@ def image_augmentation_parser(anchor, positive, negative, data_shape, data_type= random_saturation=False, per_image_normalization=True, extension=None): - """ Parses a single tf.Example into image and label tensors. """ triplet = dict() - for n, v in zip(['anchor', 'positive', 'negative'], [anchor, positive, negative]): + for n, v in zip(['anchor', 'positive', 'negative'], + [anchor, positive, negative]): # Convert the image data from string back to the numbers image = from_filename_to_tensor(v, extension=extension) @@ -169,13 +186,15 @@ def image_augmentation_parser(anchor, positive, negative, data_shape, data_type= image = tf.reshape(image, data_shape) # Applying image augmentation - image = append_image_augmentation(image, gray_scale=gray_scale, - output_shape=output_shape, - random_flip=random_flip, - random_brightness=random_brightness, - random_contrast=random_contrast, - random_saturation=random_saturation, - per_image_normalization=per_image_normalization) + image = append_image_augmentation( + image, + gray_scale=gray_scale, + output_shape=output_shape, + random_flip=random_flip, + random_brightness=random_brightness, + random_contrast=random_contrast, + random_saturation=random_saturation, + per_image_normalization=per_image_normalization) triplet[n] = image diff --git a/bob/learn/tensorflow/datashuffler/Base.py b/bob/learn/tensorflow/datashuffler/Base.py index 1fb271d6cd129e5ed4293ad6d550462e1812fb8c..57f79ac58cfc8651fae101135db7b795c6429ecf 100644 --- a/bob/learn/tensorflow/datashuffler/Base.py +++ b/bob/learn/tensorflow/datashuffler/Base.py @@ -1,7 +1,7 @@ #!/usr/bin/env python # vim: set fileencoding=utf-8 : # @author: Tiago de Freitas Pereira -# @date: Wed 11 May 2016 09:39:36 CEST +# @date: Wed 11 May 2016 09:39:36 CEST import numpy import tensorflow as tf @@ -48,7 +48,9 @@ class Base(object): """ - def __init__(self, data, labels, + def __init__(self, + data, + labels, input_shape=[None, 28, 28, 1], input_dtype="float32", batch_size=32, @@ -106,18 +108,23 @@ class Base(object): """ with tf.name_scope("Input"): - self.data_ph = tf.placeholder(tf.float32, shape=self.input_shape, name="data") - self.label_ph = tf.placeholder(tf.int64, shape=[None], name="label") + self.data_ph = tf.placeholder( + tf.float32, shape=self.input_shape, name="data") + self.label_ph = tf.placeholder( + tf.int64, shape=[None], name="label") # If prefetch, setup the queue to feed data if self.prefetch: - queue = tf.FIFOQueue(capacity=self.prefetch_capacity, - dtypes=[tf.float32, tf.int64], - shapes=[self.input_shape[1:], []]) + queue = tf.FIFOQueue( + capacity=self.prefetch_capacity, + dtypes=[tf.float32, tf.int64], + shapes=[self.input_shape[1:], []]) # Fetching the place holders from the queue - self.enqueue_op = queue.enqueue_many([self.data_ph, self.label_ph]) - self.data_ph_from_queue, self.label_ph_from_queue = queue.dequeue_many(self.batch_size) + self.enqueue_op = queue.enqueue_many( + [self.data_ph, self.label_ph]) + self.data_ph_from_queue, self.label_ph_from_queue = queue.dequeue_many( + self.batch_size) else: self.data_ph_from_queue = self.data_ph @@ -130,7 +137,9 @@ class Base(object): """ if not element in ["data", "label"]: - raise ValueError("Value '{0}' invalid. Options available are {1}".format(element, self.placeholder_options)) + raise ValueError( + "Value '{0}' invalid. Options available are {1}".format( + element, self.placeholder_options)) # If None, create the placeholders from scratch if self.data_ph is None: @@ -148,13 +157,13 @@ class Base(object): else: return self.label_ph - def bob2skimage(self, bob_image): """ Convert bob color image to the skcit image """ - skimage = numpy.zeros(shape=(bob_image.shape[1], bob_image.shape[2], bob_image.shape[0])) + skimage = numpy.zeros( + shape=(bob_image.shape[1], bob_image.shape[2], bob_image.shape[0])) for i in range(bob_image.shape[0]): skimage[:, :, i] = bob_image[i, :, :] @@ -166,7 +175,8 @@ class Base(object): Convert bob color image to the skcit image """ - bob_image = numpy.zeros(shape=(sk_image.shape[2], sk_image.shape[0], sk_image.shape[1])) + bob_image = numpy.zeros( + shape=(sk_image.shape[2], sk_image.shape[0], sk_image.shape[1])) for i in range(bob_image.shape[0]): bob_image[i, :, :] = sk_image[:, :, i] # Copying red @@ -198,11 +208,11 @@ class Base(object): # TODO: LAME SOLUTION #if data.shape[0] != 3: # GRAY SCALE IMAGES IN A RGB DATABASE # step_data = numpy.zeros(shape=(3, data.shape[0], data.shape[1])) - #step_data = numpy.zeros(shape=(3, data.shape[0], data.shape[1])) - #step_data[0, ...] = data[:, :, 0] - #step_data[1, ...] = data[:, :, 0] - #step_data[2, ...] = data[:, :, 0] - #data = step_data + #step_data = numpy.zeros(shape=(3, data.shape[0], data.shape[1])) + #step_data[0, ...] = data[:, :, 0] + #step_data[1, ...] = data[:, :, 0] + #step_data[2, ...] = data[:, :, 0] + #data = step_data #dst = numpy.zeros(shape=(self.bob_shape)) #bob.ip.base.scale(data, dst) @@ -227,8 +237,7 @@ class Base(object): result = [] for k in range(size): if use_list: - result.append( - [x[k] for x in data_holder]) + result.append([x[k] for x in data_holder]) else: dt = data_holder[0][k] if type(dt) in [int, bool]: @@ -239,7 +248,8 @@ class Base(object): try: tp = dt.dtype except: - raise TypeError("Unsupported type to batch: {}".format(type(dt))) + raise TypeError("Unsupported type to batch: {}".format( + type(dt))) try: result.append( numpy.asarray([x[k] for x in data_holder], dtype=tp)) @@ -271,7 +281,7 @@ class Base(object): try: for i in range(self.batch_size): data = six.next(self.batch_generator) - + holder.append(data) if len(holder) == self.batch_size: return self._aggregate_batch(holder, False) @@ -279,7 +289,7 @@ class Base(object): except StopIteration: self.batch_generator = None self.epoch += 1 - + # If we have left data in the epoch, return if len(holder) > 0: return self._aggregate_batch(holder, False) @@ -288,4 +298,3 @@ class Base(object): data = six.next(self.batch_generator) holder.append(data) return self._aggregate_batch(holder, False) - diff --git a/bob/learn/tensorflow/datashuffler/Disk.py b/bob/learn/tensorflow/datashuffler/Disk.py index 4c81a1d9065802f5cf15bfef98ceef04413fa012..4700f799efcce5a8d4ffec91058ad50b7de11311 100644 --- a/bob/learn/tensorflow/datashuffler/Disk.py +++ b/bob/learn/tensorflow/datashuffler/Disk.py @@ -1,7 +1,7 @@ #!/usr/bin/env python # vim: set fileencoding=utf-8 : # @author: Tiago de Freitas Pereira -# @date: Wed 11 May 2016 09:39:36 CEST +# @date: Wed 11 May 2016 09:39:36 CEST import numpy import bob.io.base @@ -14,7 +14,6 @@ logger = bob.core.log.setup("bob.learn.tensorflow") class Disk(Base): - """ This datashuffler deal with databases that are stored in the disk. The data is loaded on the fly,. @@ -46,7 +45,9 @@ class Disk(Base): The algorithm used for feature scaling. Look :py:class:`bob.learn.tensorflow.datashuffler.ScaleFactor`, :py:class:`bob.learn.tensorflow.datashuffler.Linear` and :py:class:`bob.learn.tensorflow.datashuffler.MeanOffset` """ - def __init__(self, data, labels, + def __init__(self, + data, + labels, input_shape, input_dtype="float32", batch_size=1, @@ -55,8 +56,7 @@ class Disk(Base): normalizer=None, prefetch=False, prefetch_capacity=10, - prefetch_threads=5 - ): + prefetch_threads=5): if isinstance(data, list): data = numpy.array(data) @@ -75,8 +75,7 @@ class Disk(Base): normalizer=normalizer, prefetch=prefetch, prefetch_capacity=prefetch_capacity, - prefetch_threads=prefetch_threads - ) + prefetch_threads=prefetch_threads) # Seting the seed numpy.random.seed(seed) @@ -90,7 +89,7 @@ class Disk(Base): if self.data_augmentation is not None: d = self.data_augmentation(d) - if d.shape[0] != 3 and self.input_shape[2] != 3: # GRAY SCALE IMAGE + if d.shape[0] != 3 and self.input_shape[2] != 3: # GRAY SCALE IMAGE data = numpy.zeros(shape=(d.shape[0], d.shape[1], 1)) data[:, :, 0] = d data = self.rescale(data) @@ -100,7 +99,8 @@ class Disk(Base): # Checking NaN if numpy.sum(numpy.isnan(data)) > 0: - logger.warning("######### Sample {0} has noise #########".format(file_name)) + logger.warning( + "######### Sample {0} has noise #########".format(file_name)) return data diff --git a/bob/learn/tensorflow/datashuffler/DiskAudio.py b/bob/learn/tensorflow/datashuffler/DiskAudio.py index 471f13ba5a4ccdcdaeb3d24f03beda2cfcd756e0..c2843d6990f9e62598ddbda506c69378173fcccc 100644 --- a/bob/learn/tensorflow/datashuffler/DiskAudio.py +++ b/bob/learn/tensorflow/datashuffler/DiskAudio.py @@ -14,7 +14,9 @@ logger.propagate = False class DiskAudio(Base): - def __init__(self, data, labels, + def __init__(self, + data, + labels, input_shape, input_dtype="float32", batch_size=1, @@ -23,9 +25,7 @@ class DiskAudio(Base): context_size=20, win_length_ms=10, rate=16000, - out_file="" - ): - + out_file=""): """ This datashuffler deals with speech databases that are stored in the disk. The data is loaded and preprocessed on the fly. @@ -50,8 +50,7 @@ class DiskAudio(Base): input_dtype=input_dtype, batch_size=batch_size, seed=seed, - data_augmentation=data_augmentation - ) + data_augmentation=data_augmentation) # Seting the seed numpy.random.seed(seed) @@ -59,6 +58,8 @@ class DiskAudio(Base): self.frames_storage = [] # a similar queue for the corresponding labels self.labels_storage = [] + + # if self.out_file != "": # bob.io.base.create_directories_safe(os.path.dirname(self.out_file)) # f = open(self.out_file, "w") @@ -85,7 +86,8 @@ class DiskAudio(Base): while len(self.frames_storage) < self.batch_size: if f is not None: f.write("%s\n" % self.data[indexes[i]]) - frames, labels = self.extract_frames_from_file(self.data[indexes[i]], self.labels[indexes[i]]) + frames, labels = self.extract_frames_from_file( + self.data[indexes[i]], self.labels[indexes[i]]) self.frames_storage.extend(frames) self.labels_storage.extend(labels) i += 1 @@ -99,7 +101,10 @@ class DiskAudio(Base): selected_data = numpy.reshape(selected_data, (self.batch_size, -1, 1)) if f is not None: f.close() - return [selected_data.astype("float32"), selected_labels.astype("int64")] + return [ + selected_data.astype("float32"), + selected_labels.astype("int64") + ] def extract_frames_from_file(self, filename, label): rate, wav_signal = self.load_from_file(filename) @@ -108,14 +113,17 @@ class DiskAudio(Base): def extract_frames_from_wav(self, wav_signal, label): m_total_length = len(wav_signal) - m_num_win = int(m_total_length / self.m_win_length) # discard the tail of the signal + m_num_win = int(m_total_length / + self.m_win_length) # discard the tail of the signal # normalize the signal first wav_signal -= numpy.mean(wav_signal) wav_signal /= numpy.std(wav_signal) # make sure the array is divided into equal chunks - windows = numpy.split(wav_signal[:int(self.m_win_length) * int(m_num_win)], int(m_num_win)) + windows = numpy.split( + wav_signal[:int(self.m_win_length) * int(m_num_win)], + int(m_num_win)) final_frames = [] final_labels = [label] * m_num_win @@ -127,11 +135,18 @@ class DiskAudio(Base): # copy the first frame necessary number of times if i < self.context_size: left_context = numpy.tile(windows[0], self.context_size - i) - final_frames.append(numpy.append(left_context, windows[:i + self.context_size + 1])) + final_frames.append( + numpy.append(left_context, + windows[:i + self.context_size + 1])) elif (i + self.context_size) > (m_num_win - 1): - right_context = numpy.tile(windows[-1], i + self.context_size - m_num_win + 1) - final_frames.append(numpy.append(windows[i - self.context_size:], right_context)) + right_context = numpy.tile( + windows[-1], i + self.context_size - m_num_win + 1) + final_frames.append( + numpy.append(windows[i - self.context_size:], + right_context)) else: - final_frames.append(numpy.ravel(windows[i - self.context_size:i + self.context_size + 1])) + final_frames.append( + numpy.ravel(windows[i - self.context_size: + i + self.context_size + 1])) return final_frames, final_labels diff --git a/bob/learn/tensorflow/datashuffler/ImageAugmentation.py b/bob/learn/tensorflow/datashuffler/ImageAugmentation.py index dfe6c940643b41442e9678a75d61fc3407e1d659..c06942c019837b0bd6a80564a0a60d85f2b9d3e6 100644 --- a/bob/learn/tensorflow/datashuffler/ImageAugmentation.py +++ b/bob/learn/tensorflow/datashuffler/ImageAugmentation.py @@ -18,8 +18,8 @@ def add_gaussian_blur(image, seed=10): sigma = possible_sigmas[numpy.random.randint(len(possible_sigmas))] radius = possible_radii[numpy.random.randint(len(possible_radii))] - gaussian_filter = bob.ip.base.Gaussian(sigma=(sigma, sigma), - radius=(radius, radius)) + gaussian_filter = bob.ip.base.Gaussian( + sigma=(sigma, sigma), radius=(radius, radius)) return gaussian_filter(image) @@ -53,12 +53,11 @@ def compute_salt_and_peper(image, level): r = numpy.random.rand(*image.shape) # 0 noise - indexes_0 = r <= (level/0.5) + indexes_0 = r <= (level / 0.5) image[indexes_0] = 0.0 # 255 noise - indexes_255 = (1 - level / 2) <= r; + indexes_255 = (1 - level / 2) <= r image[indexes_255] = 255.0 return image - diff --git a/bob/learn/tensorflow/datashuffler/Memory.py b/bob/learn/tensorflow/datashuffler/Memory.py index b96c3a82ca2e5a059407f5d9be380380565dfe2d..ada07aa205dc9bb6eb7545cdbeb1fd13b6b64d5c 100644 --- a/bob/learn/tensorflow/datashuffler/Memory.py +++ b/bob/learn/tensorflow/datashuffler/Memory.py @@ -1,7 +1,7 @@ #!/usr/bin/env python # vim: set fileencoding=utf-8 : # @author: Tiago de Freitas Pereira -# @date: Wed 11 May 2016 09:39:36 CEST +# @date: Wed 11 May 2016 09:39:36 CEST import numpy from .Base import Base @@ -9,7 +9,6 @@ import tensorflow as tf class Memory(Base): - """ This datashuffler deal with memory databases that are stored in a :py:class`numpy.array` @@ -40,7 +39,9 @@ class Memory(Base): The algorithm used for feature scaling. Look :py:class:`bob.learn.tensorflow.datashuffler.ScaleFactor`, :py:class:`bob.learn.tensorflow.datashuffler.Linear` and :py:class:`bob.learn.tensorflow.datashuffler.MeanOffset` """ - def __init__(self, data, labels, + def __init__(self, + data, + labels, input_shape, input_dtype="float32", batch_size=1, @@ -49,8 +50,7 @@ class Memory(Base): normalizer=None, prefetch=False, prefetch_capacity=10, - prefetch_threads=5 - ): + prefetch_threads=5): super(Memory, self).__init__( data=data, @@ -63,8 +63,7 @@ class Memory(Base): normalizer=normalizer, prefetch=prefetch, prefetch_capacity=prefetch_capacity, - prefetch_threads=prefetch_threads - ) + prefetch_threads=prefetch_threads) # Seting the seed numpy.random.seed(seed) self.data = self.data.astype(input_dtype) diff --git a/bob/learn/tensorflow/datashuffler/Normalizer.py b/bob/learn/tensorflow/datashuffler/Normalizer.py index 79098e61863fecbf7c25fb4037f3582fae7aec88..cbf91529335c69c50b5982ce4e984bc8dc15a258 100644 --- a/bob/learn/tensorflow/datashuffler/Normalizer.py +++ b/bob/learn/tensorflow/datashuffler/Normalizer.py @@ -4,6 +4,7 @@ import numpy + def scale_factor(x, scale_factor=0.00390625): """ Normalize a sample by a scale factor @@ -21,10 +22,10 @@ def mean_offset(x, mean_offset): return x + def per_image_standarization(x): - + mean = numpy.mean(x) std = numpy.std(x) - return (x-mean)/max(std, 1/numpy.sqrt(numpy.prod(x.shape))) - + return (x - mean) / max(std, 1 / numpy.sqrt(numpy.prod(x.shape))) diff --git a/bob/learn/tensorflow/datashuffler/OnlineSampling.py b/bob/learn/tensorflow/datashuffler/OnlineSampling.py index 125c181ffbfa54a0570e3091d5152570092eac83..75cfff87950365370e29b6e4bfc68db1d46d8a8a 100644 --- a/bob/learn/tensorflow/datashuffler/OnlineSampling.py +++ b/bob/learn/tensorflow/datashuffler/OnlineSampling.py @@ -1,7 +1,7 @@ #!/usr/bin/env python # vim: set fileencoding=utf-8 : # @author: Tiago de Freitas Pereira -# @date: Wed 11 May 2016 09:39:36 CEST +# @date: Wed 11 May 2016 09:39:36 CEST import tensorflow as tf from .Base import Base @@ -42,14 +42,18 @@ class OnlineSampling(object): if self.feature_placeholder is None: shape = tuple([None] + list(data.shape[1:])) - self.feature_placeholder = tf.placeholder(tf.float32, shape=shape, name="feature") - embbeding = self.feature_extractor.compute_graph(self.feature_placeholder, self.feature_extractor.default_feature_layer) + self.feature_placeholder = tf.placeholder( + tf.float32, shape=shape, name="feature") + embbeding = self.feature_extractor.compute_graph( + self.feature_placeholder, + self.feature_extractor.default_feature_layer) - self.graph = tf.nn.l2_normalize(embbeding, 1, 1e-10, name='embeddings') + self.graph = tf.nn.l2_normalize( + embbeding, 1, 1e-10, name='embeddings') #if self.feature_placeholder.get_shape().as_list() != list(data.shape): - #tf.reshape(self.feature_placeholder, tf.pack([data.shape])) - #self.feature_placeholder.set_shape(data.shape) + #tf.reshape(self.feature_placeholder, tf.pack([data.shape])) + #self.feature_placeholder.set_shape(data.shape) feed_dict = {self.feature_placeholder: data} return self.session.run([self.graph], feed_dict=feed_dict)[0] diff --git a/bob/learn/tensorflow/datashuffler/Siamese.py b/bob/learn/tensorflow/datashuffler/Siamese.py index 33ba50227f8e08e8c6ec6b3381f1f6d5c3c9b975..cac100398800e760e31c891a199eab6e2ad6300f 100644 --- a/bob/learn/tensorflow/datashuffler/Siamese.py +++ b/bob/learn/tensorflow/datashuffler/Siamese.py @@ -1,7 +1,7 @@ #!/usr/bin/env python # vim: set fileencoding=utf-8 : # @author: Tiago de Freitas Pereira -# @date: Wed 11 May 2016 09:39:36 CEST +# @date: Wed 11 May 2016 09:39:36 CEST import numpy from .Base import Base @@ -32,22 +32,30 @@ class Siamese(Base): """ with tf.name_scope("Input"): self.data_ph = dict() - self.data_ph['left'] = tf.placeholder(tf.float32, shape=self.input_shape, name="left") - self.data_ph['right'] = tf.placeholder(tf.float32, shape=self.input_shape, name="right") - self.label_ph = tf.placeholder(tf.int64, shape=[None], name="label") + self.data_ph['left'] = tf.placeholder( + tf.float32, shape=self.input_shape, name="left") + self.data_ph['right'] = tf.placeholder( + tf.float32, shape=self.input_shape, name="right") + self.label_ph = tf.placeholder( + tf.int64, shape=[None], name="label") if self.prefetch: - queue = tf.FIFOQueue(capacity=self.prefetch_capacity, - dtypes=[tf.float32, tf.float32, tf.int64], - shapes=[self.input_shape[1:], self.input_shape[1:], []]) + queue = tf.FIFOQueue( + capacity=self.prefetch_capacity, + dtypes=[tf.float32, tf.float32, tf.int64], + shapes=[self.input_shape[1:], self.input_shape[1:], []]) self.data_ph_from_queue = dict() self.data_ph_from_queue['left'] = None self.data_ph_from_queue['right'] = None # Fetching the place holders from the queue - self.enqueue_op = queue.enqueue_many([self.data_ph['left'], self.data_ph['right'], self.label_ph]) - self.data_ph_from_queue['left'], self.data_ph_from_queue['right'], self.label_ph_from_queue = queue.dequeue_many(self.batch_size) + self.enqueue_op = queue.enqueue_many([ + self.data_ph['left'], self.data_ph['right'], self.label_ph + ]) + self.data_ph_from_queue['left'], self.data_ph_from_queue[ + 'right'], self.label_ph_from_queue = queue.dequeue_many( + self.batch_size) else: self.data_ph_from_queue = dict() @@ -66,8 +74,10 @@ class Siamese(Base): indexes_per_labels[l] = numpy.where(input_labels == l)[0] numpy.random.shuffle(indexes_per_labels[l]) - left_possible_indexes = numpy.random.choice(self.possible_labels, input_data.shape[0], replace=True) - right_possible_indexes = numpy.random.choice(self.possible_labels, input_data.shape[0], replace=True) + left_possible_indexes = numpy.random.choice( + self.possible_labels, input_data.shape[0], replace=True) + right_possible_indexes = numpy.random.choice( + self.possible_labels, input_data.shape[0], replace=True) genuine = True @@ -78,8 +88,12 @@ class Siamese(Base): class_index = left_possible_indexes[i] # Now selecting the samples for the pair - left = input_data[indexes_per_labels[class_index][numpy.random.randint(len(indexes_per_labels[class_index]))]] - right = input_data[indexes_per_labels[class_index][numpy.random.randint(len(indexes_per_labels[class_index]))]] + left = input_data[indexes_per_labels[class_index] + [numpy.random.randint( + len(indexes_per_labels[class_index]))]] + right = input_data[indexes_per_labels[class_index] + [numpy.random.randint( + len(indexes_per_labels[class_index]))]] yield left, right, 0 @@ -98,8 +112,12 @@ class Siamese(Base): j += 1 # Now selecting the samples for the pair - left = input_data[indexes_per_labels[class_index[0]][numpy.random.randint(len(indexes_per_labels[class_index[0]]))]] - right = input_data[indexes_per_labels[class_index[1]][numpy.random.randint(len(indexes_per_labels[class_index[1]]))]] + left = input_data[indexes_per_labels[class_index[0]][ + numpy.random.randint( + len(indexes_per_labels[class_index[0]]))]] + right = input_data[indexes_per_labels[class_index[1]][ + numpy.random.randint( + len(indexes_per_labels[class_index[1]]))]] yield left, right, 1 diff --git a/bob/learn/tensorflow/datashuffler/SiameseDisk.py b/bob/learn/tensorflow/datashuffler/SiameseDisk.py index cb77d79502b1acc28f2df0b159f551aed026e1df..a85c66a2abbbaec113e6f3af22a4623685dbc087 100644 --- a/bob/learn/tensorflow/datashuffler/SiameseDisk.py +++ b/bob/learn/tensorflow/datashuffler/SiameseDisk.py @@ -1,7 +1,7 @@ #!/usr/bin/env python # vim: set fileencoding=utf-8 : # @author: Tiago de Freitas Pereira -# @date: Wed 11 May 2016 09:39:36 CEST +# @date: Wed 11 May 2016 09:39:36 CEST import numpy import bob.core @@ -44,7 +44,10 @@ class SiameseDisk(Siamese, Disk): The algorithm used for feature scaling. Look :py:class:`bob.learn.tensorflow.datashuffler.ScaleFactor`, :py:class:`bob.learn.tensorflow.datashuffler.Linear` and :py:class:`bob.learn.tensorflow.datashuffler.MeanOffset` """ - def __init__(self, data, labels, + + def __init__(self, + data, + labels, input_shape, input_dtype="float32", batch_size=1, @@ -53,8 +56,7 @@ class SiameseDisk(Siamese, Disk): normalizer=None, prefetch=False, prefetch_capacity=10, - prefetch_threads=5 - ): + prefetch_threads=5): if isinstance(data, list): data = numpy.array(data) @@ -73,8 +75,7 @@ class SiameseDisk(Siamese, Disk): normalizer=normalizer, prefetch=prefetch, prefetch_capacity=prefetch_capacity, - prefetch_threads=prefetch_threads - ) + prefetch_threads=prefetch_threads) # Seting the seed numpy.random.seed(seed) @@ -100,13 +101,16 @@ class SiameseDisk(Siamese, Disk): # Applying the data augmentation if self.data_augmentation is not None: - d = self.bob2skimage(self.data_augmentation(self.skimage2bob(left))) + d = self.bob2skimage( + self.data_augmentation(self.skimage2bob(left))) left = d - d = self.bob2skimage(self.data_augmentation(self.skimage2bob(right))) + d = self.bob2skimage( + self.data_augmentation(self.skimage2bob(right))) right = d left = self.normalize_sample(left) right = self.normalize_sample(right) - yield left.astype(self.input_dtype), right.astype(self.input_dtype), label + yield left.astype(self.input_dtype), right.astype( + self.input_dtype), label diff --git a/bob/learn/tensorflow/datashuffler/SiameseMemory.py b/bob/learn/tensorflow/datashuffler/SiameseMemory.py index 93dbdbcbba768db32e168bd4daacccb63ba94c4e..967b7413173d28560f784dda280829dc571b4913 100644 --- a/bob/learn/tensorflow/datashuffler/SiameseMemory.py +++ b/bob/learn/tensorflow/datashuffler/SiameseMemory.py @@ -1,7 +1,7 @@ #!/usr/bin/env python # vim: set fileencoding=utf-8 : # @author: Tiago de Freitas Pereira -# @date: Wed 11 May 2016 09:39:36 CEST +# @date: Wed 11 May 2016 09:39:36 CEST import numpy import six @@ -43,7 +43,9 @@ class SiameseMemory(Siamese, Memory): """ - def __init__(self, data, labels, + def __init__(self, + data, + labels, input_shape=[None, 28, 28, 1], input_dtype="float32", batch_size=32, @@ -52,8 +54,7 @@ class SiameseMemory(Siamese, Memory): normalizer=None, prefetch=False, prefetch_capacity=50, - prefetch_threads=10 - ): + prefetch_threads=10): super(SiameseMemory, self).__init__( data=data, @@ -66,8 +67,7 @@ class SiameseMemory(Siamese, Memory): normalizer=normalizer, prefetch=prefetch, prefetch_capacity=prefetch_capacity, - prefetch_threads=prefetch_threads - ) + prefetch_threads=prefetch_threads) # Seting the seed numpy.random.seed(seed) self.data = self.data.astype(input_dtype) @@ -89,13 +89,16 @@ class SiameseMemory(Siamese, Memory): # Applying the data augmentation if self.data_augmentation is not None: - d = self.bob2skimage(self.data_augmentation(self.skimage2bob(left))) + d = self.bob2skimage( + self.data_augmentation(self.skimage2bob(left))) left = d - d = self.bob2skimage(self.data_augmentation(self.skimage2bob(right))) + d = self.bob2skimage( + self.data_augmentation(self.skimage2bob(right))) right = d left = self.normalize_sample(left) right = self.normalize_sample(right) - yield left.astype(self.input_dtype), right.astype(self.input_dtype), label + yield left.astype(self.input_dtype), right.astype( + self.input_dtype), label diff --git a/bob/learn/tensorflow/datashuffler/TFRecord.py b/bob/learn/tensorflow/datashuffler/TFRecord.py index a25f15d7c5ff203275b9bf754e3407e213c12aa4..b03d69403e675d83edda8ff6f151c6202a90ce89 100644 --- a/bob/learn/tensorflow/datashuffler/TFRecord.py +++ b/bob/learn/tensorflow/datashuffler/TFRecord.py @@ -22,13 +22,15 @@ class TFRecord(object): prefetch_capacity: Capacity of the bucket for prefetching prefetch_threads: Number of threads in the prefetching """ - def __init__(self,filename_queue, - input_shape=[None, 28, 28, 1], - input_dtype=tf.float32, - batch_size=32, - seed=10, - prefetch_capacity=1000, - prefetch_threads=5): + + def __init__(self, + filename_queue, + input_shape=[None, 28, 28, 1], + input_dtype=tf.float32, + batch_size=32, + seed=10, + prefetch_capacity=1000, + prefetch_threads=5): # Setting the seed for the pseudo random number generator self.seed = seed @@ -51,14 +53,15 @@ class TFRecord(object): self.data_ph = None self.label_ph = None - def __call__(self, element, from_queue=False): """ Return the necessary placeholder """ if not element in ["data", "label"]: - raise ValueError("Value '{0}' invalid. Options available are {1}".format(element, self.placeholder_options)) + raise ValueError( + "Value '{0}' invalid. Options available are {1}".format( + element, self.placeholder_options)) # If None, create the placeholders from scratch if self.data_ph is None: @@ -69,23 +72,24 @@ class TFRecord(object): else: return self.label_ph - def __load_features(self): """ Load features from queue """ - feature = {'train/data': tf.FixedLenFeature([], tf.string), - 'train/label': tf.FixedLenFeature([], tf.int64)} + feature = { + 'train/data': tf.FixedLenFeature([], tf.string), + 'train/label': tf.FixedLenFeature([], tf.int64) + } # Define a reader and read the next record reader = tf.TFRecordReader() _, serialized_example = reader.read(self.filename_queue) - # Decode the record read by the reader - features = tf.parse_single_example(serialized_example, features=feature) + features = tf.parse_single_example( + serialized_example, features=feature) # Convert the image data from string back to the numbers image = tf.decode_raw(features['train/data'], self.input_dtype) @@ -98,23 +102,22 @@ class TFRecord(object): return image, label - def create_placeholders(self): """ Create placeholder data from features. """ image, label = self.__load_features() - - data_ph, label_ph = tf.train.shuffle_batch([image, label], batch_size=self.batch_size, - capacity=self.prefetch_capacity, num_threads=self.prefetch_threads, - min_after_dequeue=1, name="shuffle_batch") - + data_ph, label_ph = tf.train.shuffle_batch( + [image, label], + batch_size=self.batch_size, + capacity=self.prefetch_capacity, + num_threads=self.prefetch_threads, + min_after_dequeue=1, + name="shuffle_batch") self.data_ph = data_ph self.label_ph = label_ph - def get_batch(self): pass - diff --git a/bob/learn/tensorflow/datashuffler/TFRecordImage.py b/bob/learn/tensorflow/datashuffler/TFRecordImage.py index 3f66b23bdac16915503c24ecf0344f4fc5324448..6aae5de0a9e3d638b714203f1d3aed5a05e46793 100644 --- a/bob/learn/tensorflow/datashuffler/TFRecordImage.py +++ b/bob/learn/tensorflow/datashuffler/TFRecordImage.py @@ -9,6 +9,7 @@ import bob.ip.base import numpy from .TFRecord import TFRecord + class TFRecordImage(TFRecord): """ Datashuffler that wraps the batching using tfrecords. @@ -32,28 +33,29 @@ class TFRecordImage(TFRecord): gray_scale: Convert the output to gray scale """ - def __init__(self,filename_queue, - input_shape=[None, 28, 28, 1], - output_shape=[None, 28, 28, 1], - input_dtype=tf.uint8, - batch_size=32, - seed=10, - prefetch_capacity=1000, - prefetch_threads=5, - shuffle=True, - normalization=False, - random_flip=True, - random_crop=True, - gray_scale=False - ): - - super(TFRecord, self).__init__(filename_queue=filename_queue, - input_shape=input_shape, - input_dtype=input_dtype, - batch_size=batch_size, - seed=seed, - prefetch_capacity=prefetch_capacity, - prefetch_threads=prefetch_threads) + def __init__(self, + filename_queue, + input_shape=[None, 28, 28, 1], + output_shape=[None, 28, 28, 1], + input_dtype=tf.uint8, + batch_size=32, + seed=10, + prefetch_capacity=1000, + prefetch_threads=5, + shuffle=True, + normalization=False, + random_flip=True, + random_crop=True, + gray_scale=False): + + super(TFRecord, self).__init__( + filename_queue=filename_queue, + input_shape=input_shape, + input_dtype=input_dtype, + batch_size=batch_size, + seed=seed, + prefetch_capacity=prefetch_capacity, + prefetch_threads=prefetch_threads) # Preparing the output self.output_shape = output_shape @@ -63,7 +65,6 @@ class TFRecordImage(TFRecord): self.random_flip = random_flip self.gray_scale = gray_scale - def create_placeholders(self): """ Reimplementation @@ -79,7 +80,8 @@ class TFRecordImage(TFRecord): self.output_shape[3] = 1 if self.random_crop: - image = tf.image.resize_image_with_crop_or_pad(image, self.output_shape[1], self.output_shape[2]) + image = tf.image.resize_image_with_crop_or_pad( + image, self.output_shape[1], self.output_shape[2]) if self.random_flip: image = tf.image.random_flip_left_right(image) @@ -90,16 +92,21 @@ class TFRecordImage(TFRecord): image.set_shape(tuple(self.output_shape[1:])) - if self.shuffle: - data_ph, label_ph = tf.train.shuffle_batch([image, label], batch_size=self.batch_size, - capacity=self.prefetch_capacity, num_threads=self.prefetch_threads, - min_after_dequeue=self.prefetch_capacity//2, name="shuffle_batch") + data_ph, label_ph = tf.train.shuffle_batch( + [image, label], + batch_size=self.batch_size, + capacity=self.prefetch_capacity, + num_threads=self.prefetch_threads, + min_after_dequeue=self.prefetch_capacity // 2, + name="shuffle_batch") else: - data_ph, label_ph = tf.train.batch([image, label], batch_size=self.batch_size, - capacity=self.prefetch_capacity, num_threads=self.prefetch_threads, name="batch") - + data_ph, label_ph = tf.train.batch( + [image, label], + batch_size=self.batch_size, + capacity=self.prefetch_capacity, + num_threads=self.prefetch_threads, + name="batch") self.data_ph = data_ph self.label_ph = label_ph - diff --git a/bob/learn/tensorflow/datashuffler/Triplet.py b/bob/learn/tensorflow/datashuffler/Triplet.py index 16f72c5efd8b43c46530a10b2adaf0e6f5ab685c..3a7ed0789960ad2d6b80418666735a0e105efdc3 100644 --- a/bob/learn/tensorflow/datashuffler/Triplet.py +++ b/bob/learn/tensorflow/datashuffler/Triplet.py @@ -1,7 +1,7 @@ #!/usr/bin/env python # vim: set fileencoding=utf-8 : # @author: Tiago de Freitas Pereira -# @date: Wed 11 May 2016 09:39:36 CEST +# @date: Wed 11 May 2016 09:39:36 CEST import numpy from .Base import Base @@ -31,14 +31,21 @@ class Triplet(Base): """ with tf.name_scope("Input"): self.data_ph = dict() - self.data_ph['anchor'] = tf.placeholder(tf.float32, shape=self.input_shape, name="anchor") - self.data_ph['positive'] = tf.placeholder(tf.float32, shape=self.input_shape, name="positive") - self.data_ph['negative'] = tf.placeholder(tf.float32, shape=self.input_shape, name="negative") + self.data_ph['anchor'] = tf.placeholder( + tf.float32, shape=self.input_shape, name="anchor") + self.data_ph['positive'] = tf.placeholder( + tf.float32, shape=self.input_shape, name="positive") + self.data_ph['negative'] = tf.placeholder( + tf.float32, shape=self.input_shape, name="negative") if self.prefetch: - queue = tf.FIFOQueue(capacity=self.prefetch_capacity, - dtypes=[tf.float32, tf.float32, tf.float32], - shapes=[self.input_shape[1:], self.input_shape[1:], self.input_shape[1:]]) + queue = tf.FIFOQueue( + capacity=self.prefetch_capacity, + dtypes=[tf.float32, tf.float32, tf.float32], + shapes=[ + self.input_shape[1:], self.input_shape[1:], + self.input_shape[1:] + ]) self.data_ph_from_queue = dict() self.data_ph_from_queue['anchor'] = None @@ -46,8 +53,13 @@ class Triplet(Base): self.data_ph_from_queue['negative'] = None # Fetching the place holders from the queue - self.enqueue_op = queue.enqueue_many([self.data_ph['anchor'], self.data_ph['positive'], self.data_ph['negative']]) - self.data_ph_from_queue['anchor'], self.data_ph_from_queue['positive'], self.data_ph_from_queue['negative'] = queue.dequeue_many(self.batch_size) + self.enqueue_op = queue.enqueue_many([ + self.data_ph['anchor'], self.data_ph['positive'], + self.data_ph['negative'] + ]) + self.data_ph_from_queue['anchor'], self.data_ph_from_queue[ + 'positive'], self.data_ph_from_queue[ + 'negative'] = queue.dequeue_many(self.batch_size) else: self.data_ph_from_queue = dict() @@ -68,9 +80,15 @@ class Triplet(Base): for i in range(input_data.shape[0]): - anchor = input_data[indexes_per_labels[self.possible_labels[offset_class]][numpy.random.randint(len(indexes_per_labels[self.possible_labels[offset_class]]))], ...] + anchor = input_data[indexes_per_labels[self.possible_labels[ + offset_class]][numpy.random.randint( + len(indexes_per_labels[self.possible_labels[ + offset_class]]))], ...] - positive = input_data[indexes_per_labels[self.possible_labels[offset_class]][numpy.random.randint(len(indexes_per_labels[self.possible_labels[offset_class]]))], ...] + positive = input_data[indexes_per_labels[self.possible_labels[ + offset_class]][numpy.random.randint( + len(indexes_per_labels[self.possible_labels[ + offset_class]]))], ...] # Changing the class offset_class += 1 @@ -78,13 +96,17 @@ class Triplet(Base): if offset_class == len(self.possible_labels): offset_class = 0 - negative = input_data[indexes_per_labels[self.possible_labels[offset_class]][numpy.random.randint(len(indexes_per_labels[self.possible_labels[offset_class]]))], ...] + negative = input_data[indexes_per_labels[self.possible_labels[ + offset_class]][numpy.random.randint( + len(indexes_per_labels[self.possible_labels[ + offset_class]]))], ...] yield anchor, positive, negative def get_one_triplet(self, input_data, input_labels): # Getting a pair of clients - index = numpy.random.choice(len(self.possible_labels), 2, replace=False) + index = numpy.random.choice( + len(self.possible_labels), 2, replace=False) index[0] = self.possible_labels[index[0]] index[1] = self.possible_labels[index[1]] diff --git a/bob/learn/tensorflow/datashuffler/TripletDisk.py b/bob/learn/tensorflow/datashuffler/TripletDisk.py index a3174a1f657e3a9ff252112500f67c333740a56f..6cf6adc040d3b06d4d87a3c00f170e5224917b76 100644 --- a/bob/learn/tensorflow/datashuffler/TripletDisk.py +++ b/bob/learn/tensorflow/datashuffler/TripletDisk.py @@ -1,7 +1,7 @@ #!/usr/bin/env python # vim: set fileencoding=utf-8 : # @author: Tiago de Freitas Pereira -# @date: Wed 11 May 2016 09:39:36 CEST +# @date: Wed 11 May 2016 09:39:36 CEST import numpy import bob.io.base @@ -50,7 +50,9 @@ class TripletDisk(Triplet, Disk): """ - def __init__(self, data, labels, + def __init__(self, + data, + labels, input_shape, input_dtype="float32", batch_size=1, @@ -59,8 +61,7 @@ class TripletDisk(Triplet, Disk): normalizer=None, prefetch=False, prefetch_capacity=50, - prefetch_threads=10 - ): + prefetch_threads=10): if isinstance(data, list): data = numpy.array(data) @@ -78,8 +79,7 @@ class TripletDisk(Triplet, Disk): normalizer=normalizer, prefetch=prefetch, prefetch_capacity=prefetch_capacity, - prefetch_threads=prefetch_threads - ) + prefetch_threads=prefetch_threads) # Seting the seed numpy.random.seed(seed) @@ -100,7 +100,8 @@ class TripletDisk(Triplet, Disk): for i in range(self.data.shape[0]): - anchor_filename, positive_filename, negative_filename = six.next(triplets) + anchor_filename, positive_filename, negative_filename = six.next( + triplets) anchor = self.load_from_file(str(anchor_filename)) positive = self.load_from_file(str(positive_filename)) @@ -108,14 +109,17 @@ class TripletDisk(Triplet, Disk): # Applying the data augmentation if self.data_augmentation is not None: - d = self.bob2skimage(self.data_augmentation(self.skimage2bob(anchor))) - anchor = d + d = self.bob2skimage( + self.data_augmentation(self.skimage2bob(anchor))) + anchor = d - d = self.bob2skimage(self.data_augmentation(self.skimage2bob(positive))) - positive = d + d = self.bob2skimage( + self.data_augmentation(self.skimage2bob(positive))) + positive = d - d = self.bob2skimage(self.data_augmentation(self.skimage2bob(negative))) - negative = d + d = self.bob2skimage( + self.data_augmentation(self.skimage2bob(negative))) + negative = d # Scaling anchor = self.normalize_sample(anchor).astype(self.input_dtype) diff --git a/bob/learn/tensorflow/datashuffler/TripletMemory.py b/bob/learn/tensorflow/datashuffler/TripletMemory.py index 89e4cdc2a5fb4f9d05cd782050e66e189a9a509f..dbadfc39496d733b4758172e37e956e0f9807f0c 100644 --- a/bob/learn/tensorflow/datashuffler/TripletMemory.py +++ b/bob/learn/tensorflow/datashuffler/TripletMemory.py @@ -1,7 +1,7 @@ #!/usr/bin/env python # vim: set fileencoding=utf-8 : # @author: Tiago de Freitas Pereira -# @date: Wed 11 May 2016 09:39:36 CEST +# @date: Wed 11 May 2016 09:39:36 CEST import numpy import tensorflow as tf @@ -43,7 +43,9 @@ class TripletMemory(Triplet, Memory): """ - def __init__(self, data, labels, + def __init__(self, + data, + labels, input_shape=[None, 28, 28, 1], input_dtype="float32", batch_size=1, @@ -52,8 +54,7 @@ class TripletMemory(Triplet, Memory): normalizer=None, prefetch=False, prefetch_capacity=50, - prefetch_threads=10 - ): + prefetch_threads=10): super(TripletMemory, self).__init__( data=data, @@ -66,8 +67,7 @@ class TripletMemory(Triplet, Memory): normalizer=normalizer, prefetch=prefetch, prefetch_capacity=prefetch_capacity, - prefetch_threads=prefetch_threads - ) + prefetch_threads=prefetch_threads) # Seting the seed numpy.random.seed(seed) @@ -91,14 +91,17 @@ class TripletMemory(Triplet, Memory): # Applying the data augmentation if self.data_augmentation is not None: - d = self.bob2skimage(self.data_augmentation(self.skimage2bob(anchor))) - anchor = d + d = self.bob2skimage( + self.data_augmentation(self.skimage2bob(anchor))) + anchor = d - d = self.bob2skimage(self.data_augmentation(self.skimage2bob(positive))) - positive = d + d = self.bob2skimage( + self.data_augmentation(self.skimage2bob(positive))) + positive = d - d = self.bob2skimage(self.data_augmentation(self.skimage2bob(negative))) - negative = d + d = self.bob2skimage( + self.data_augmentation(self.skimage2bob(negative))) + negative = d # Scaling anchor = self.normalize_sample(anchor).astype(self.input_dtype) diff --git a/bob/learn/tensorflow/datashuffler/TripletWithFastSelectionDisk.py b/bob/learn/tensorflow/datashuffler/TripletWithFastSelectionDisk.py index fd6d8976c2dfe01b34b91260d9cf0f5f516ba7aa..dd81254a3c9069d1676ea8cd2757ed937ea4fd9a 100644 --- a/bob/learn/tensorflow/datashuffler/TripletWithFastSelectionDisk.py +++ b/bob/learn/tensorflow/datashuffler/TripletWithFastSelectionDisk.py @@ -1,7 +1,7 @@ #!/usr/bin/env python # vim: set fileencoding=utf-8 : # @author: Tiago de Freitas Pereira -# @date: Wed 11 May 2016 09:39:36 CEST +# @date: Wed 11 May 2016 09:39:36 CEST import numpy import tensorflow as tf @@ -59,7 +59,9 @@ class TripletWithFastSelectionDisk(Triplet, Disk, OnlineSampling): The algorithm used for feature scaling. Look :py:class:`bob.learn.tensorflow.datashuffler.ScaleFactor`, :py:class:`bob.learn.tensorflow.datashuffler.Linear` and :py:class:`bob.learn.tensorflow.datashuffler.MeanOffset` """ - def __init__(self, data, labels, + def __init__(self, + data, + labels, input_shape, input_dtype="float32", batch_size=1, @@ -76,8 +78,7 @@ class TripletWithFastSelectionDisk(Triplet, Disk, OnlineSampling): batch_size=batch_size, seed=seed, data_augmentation=data_augmentation, - normalizer=normalizer - ) + normalizer=normalizer) self.clear_variables() # Seting the seed numpy.random.seed(seed) @@ -105,10 +106,14 @@ class TripletWithFastSelectionDisk(Triplet, Disk, OnlineSampling): sample_n = numpy.zeros(shape=shape, dtype=self.input_dtype) for i in range(shape[0]): - file_name_a, file_name_p, file_name_n = self.get_one_triplet(self.data, self.labels) - sample_a[i, ...] = self.normalize_sample(self.load_from_file(str(file_name_a))) - sample_p[i, ...] = self.normalize_sample(self.load_from_file(str(file_name_p))) - sample_n[i, ...] = self.normalize_sample(self.load_from_file(str(file_name_n))) + file_name_a, file_name_p, file_name_n = self.get_one_triplet( + self.data, self.labels) + sample_a[i, ...] = self.normalize_sample( + self.load_from_file(str(file_name_a))) + sample_p[i, ...] = self.normalize_sample( + self.load_from_file(str(file_name_p))) + sample_n[i, ...] = self.normalize_sample( + self.load_from_file(str(file_name_n))) return [sample_a, sample_p, sample_n] @@ -127,12 +132,17 @@ class TripletWithFastSelectionDisk(Triplet, Disk, OnlineSampling): return self.get_random_batch() # Selecting the classes used in the selection - indexes = numpy.random.choice(len(self.possible_labels), self.total_identities, replace=False) - samples_per_identity = int(numpy.ceil(self.batch_size/float(self.total_identities))) - anchor_labels = numpy.ones(samples_per_identity) * self.possible_labels[indexes[0]] + indexes = numpy.random.choice( + len(self.possible_labels), self.total_identities, replace=False) + samples_per_identity = int( + numpy.ceil(self.batch_size / float(self.total_identities))) + anchor_labels = numpy.ones( + samples_per_identity) * self.possible_labels[indexes[0]] for i in range(1, self.total_identities): - anchor_labels = numpy.hstack((anchor_labels, numpy.ones(samples_per_identity) * self.possible_labels[indexes[i]])) + anchor_labels = numpy.hstack((anchor_labels, + numpy.ones(samples_per_identity) * + self.possible_labels[indexes[i]])) anchor_labels = anchor_labels[0:self.batch_size] samples_a = numpy.zeros(shape=self.shape, dtype=self.input_dtype) @@ -143,8 +153,10 @@ class TripletWithFastSelectionDisk(Triplet, Disk, OnlineSampling): embedding_a = self.project(samples_a) # Getting the positives - samples_p, embedding_p, d_anchor_positive = self.get_positives(anchor_labels, embedding_a) - samples_n = self.get_negative(anchor_labels, embedding_a, d_anchor_positive) + samples_p, embedding_p, d_anchor_positive = self.get_positives( + anchor_labels, embedding_a) + samples_n = self.get_negative(anchor_labels, embedding_a, + d_anchor_positive) return samples_a, samples_p, samples_n @@ -174,14 +186,16 @@ class TripletWithFastSelectionDisk(Triplet, Disk, OnlineSampling): indexes = numpy.where(self.labels == l)[0] numpy.random.shuffle(indexes) file_name = self.data[indexes[0], ...] - samples_p[i, ...] = self.normalize_sample(self.load_from_file(str(file_name))) + samples_p[i, ...] = self.normalize_sample( + self.load_from_file(str(file_name))) embedding_p = self.project(samples_p) # Computing the distances d_anchor_positive = [] for i in range(self.shape[0]): - d_anchor_positive.append(euclidean(embedding_a[i, :], embedding_p[i, :])) + d_anchor_positive.append( + euclidean(embedding_a[i, :], embedding_p[i, :])) return samples_p, embedding_p, d_anchor_positive @@ -194,7 +208,7 @@ class TripletWithFastSelectionDisk(Triplet, Disk, OnlineSampling): indexes = range(len(self.labels)) numpy.random.shuffle(indexes) - negative_samples_search = self.batch_size*self.batch_increase_factor + negative_samples_search = self.batch_size * self.batch_increase_factor # Limiting to the batch size, otherwise the number of comparisons will explode indexes = indexes[0:negative_samples_search] @@ -205,26 +219,32 @@ class TripletWithFastSelectionDisk(Triplet, Disk, OnlineSampling): samples_n = numpy.zeros(shape=self.shape, dtype=self.input_dtype) for i in range(shape[0]): file_name = self.data[indexes[i], ...] - temp_samples_n[i, ...] = self.normalize_sample(self.load_from_file(str(file_name))) + temp_samples_n[i, ...] = self.normalize_sample( + self.load_from_file(str(file_name))) # Computing all the embeddings embedding_temp_n = self.project(temp_samples_n) # Computing the distances - d_anchor_negative = cdist(embedding_a, embedding_temp_n, metric='euclidean') + d_anchor_negative = cdist( + embedding_a, embedding_temp_n, metric='euclidean') # Selecting the negative samples for i in range(self.shape[0]): label = anchor_labels[i] - possible_candidates = [d if d > d_anchor_positive[i] else numpy.inf for d in d_anchor_negative[i]] - + possible_candidates = [ + d if d > d_anchor_positive[i] else numpy.inf + for d in d_anchor_negative[i] + ] + for j in numpy.argsort(possible_candidates): # Checking if they don't have the same label if self.labels[indexes[j]] != label: samples_n[i, ...] = temp_samples_n[j, ...] if numpy.isinf(possible_candidates[j]): - logger.info("SEMI-HARD negative not found, took the first one") + logger.info( + "SEMI-HARD negative not found, took the first one") break return samples_n diff --git a/bob/learn/tensorflow/datashuffler/TripletWithSelectionDisk.py b/bob/learn/tensorflow/datashuffler/TripletWithSelectionDisk.py index 14cfe60f406c955210b8dd4636b7f8a5b7115e26..ada3f42cefca6d5c89b67c078aa0dcae7f4652fb 100644 --- a/bob/learn/tensorflow/datashuffler/TripletWithSelectionDisk.py +++ b/bob/learn/tensorflow/datashuffler/TripletWithSelectionDisk.py @@ -1,7 +1,7 @@ #!/usr/bin/env python # vim: set fileencoding=utf-8 : # @author: Tiago de Freitas Pereira -# @date: Wed 11 May 2016 09:39:36 CEST +# @date: Wed 11 May 2016 09:39:36 CEST import numpy import tensorflow as tf @@ -48,7 +48,9 @@ class TripletWithSelectionDisk(Triplet, Disk, OnlineSampling): """ - def __init__(self, data, labels, + def __init__(self, + data, + labels, input_shape, input_dtype="float32", batch_size=1, @@ -65,8 +67,7 @@ class TripletWithSelectionDisk(Triplet, Disk, OnlineSampling): batch_size=batch_size, seed=seed, data_augmentation=data_augmentation, - normalizer=normalizer - ) + normalizer=normalizer) self.clear_variables() # Seting the seed numpy.random.seed(seed) @@ -91,10 +92,14 @@ class TripletWithSelectionDisk(Triplet, Disk, OnlineSampling): sample_n = numpy.zeros(shape=shape, dtype=self.input_dtype) for i in range(shape[0]): - file_name_a, file_name_p, file_name_n = self.get_one_triplet(self.data, self.labels) - sample_a[i, ...] = self.normalize_sample(self.load_from_file(str(file_name_a))) - sample_p[i, ...] = self.normalize_sample(self.load_from_file(str(file_name_p))) - sample_n[i, ...] = self.normalize_sample(self.load_from_file(str(file_name_n))) + file_name_a, file_name_p, file_name_n = self.get_one_triplet( + self.data, self.labels) + sample_a[i, ...] = self.normalize_sample( + self.load_from_file(str(file_name_a))) + sample_p[i, ...] = self.normalize_sample( + self.load_from_file(str(file_name_p))) + sample_n[i, ...] = self.normalize_sample( + self.load_from_file(str(file_name_n))) return [sample_a, sample_p, sample_n] @@ -113,12 +118,17 @@ class TripletWithSelectionDisk(Triplet, Disk, OnlineSampling): return self.get_random_batch() # Selecting the classes used in the selection - indexes = numpy.random.choice(len(self.possible_labels), self.total_identities, replace=False) - samples_per_identity = numpy.ceil(self.batch_size/float(self.total_identities)) - anchor_labels = numpy.ones(samples_per_identity) * self.possible_labels[indexes[0]] + indexes = numpy.random.choice( + len(self.possible_labels), self.total_identities, replace=False) + samples_per_identity = numpy.ceil( + self.batch_size / float(self.total_identities)) + anchor_labels = numpy.ones( + samples_per_identity) * self.possible_labels[indexes[0]] for i in range(1, self.total_identities): - anchor_labels = numpy.hstack((anchor_labels,numpy.ones(samples_per_identity) * self.possible_labels[indexes[i]])) + anchor_labels = numpy.hstack((anchor_labels, + numpy.ones(samples_per_identity) * + self.possible_labels[indexes[i]])) anchor_labels = anchor_labels[0:self.batch_size] data_a = numpy.zeros(shape=self.shape, dtype=self.input_dtype) @@ -137,9 +147,11 @@ class TripletWithSelectionDisk(Triplet, Disk, OnlineSampling): label = anchor_labels[i] #anchor = self.get_anchor(label) #logger.info("********* Positives") - positive, distance_anchor_positive = self.get_positive(label, features_a[i]) + positive, distance_anchor_positive = self.get_positive( + label, features_a[i]) #logger.info("********* Negatives") - negative = self.get_negative(label, features_a[i], distance_anchor_positive) + negative = self.get_negative(label, features_a[i], + distance_anchor_positive) #logger.info("********* Appending") @@ -180,14 +192,16 @@ class TripletWithSelectionDisk(Triplet, Disk, OnlineSampling): numpy.random.shuffle(indexes) indexes = indexes[ - 0:self.batch_size] # Limiting to the batch size, otherwise the number of comparisons will explode + 0:self. + batch_size] # Limiting to the batch size, otherwise the number of comparisons will explode distances = [] shape = tuple([len(indexes)] + list(self.shape[1:])) sample_p = numpy.zeros(shape=shape, dtype=self.input_dtype) for i in range(shape[0]): file_name = self.data[indexes[i], ...] - sample_p[i, ...] = self.normalize_sample(self.load_from_file(str(file_name))) + sample_p[i, ...] = self.normalize_sample( + self.load_from_file(str(file_name))) embedding_p = self.project(sample_p) @@ -210,13 +224,15 @@ class TripletWithSelectionDisk(Triplet, Disk, OnlineSampling): indexes = numpy.where(self.labels != label)[0] numpy.random.shuffle(indexes) indexes = indexes[ - 0:self.batch_size*3] # Limiting to the batch size, otherwise the number of comparisons will explode + 0:self.batch_size * + 3] # Limiting to the batch size, otherwise the number of comparisons will explode shape = tuple([len(indexes)] + list(self.shape[1:])) sample_n = numpy.zeros(shape=shape, dtype=self.input_dtype) for i in range(shape[0]): file_name = self.data[indexes[i], ...] - sample_n[i, ...] = self.normalize_sample(self.load_from_file(str(file_name))) + sample_n[i, ...] = self.normalize_sample( + self.load_from_file(str(file_name))) embedding_n = self.project(sample_n) diff --git a/bob/learn/tensorflow/datashuffler/TripletWithSelectionMemory.py b/bob/learn/tensorflow/datashuffler/TripletWithSelectionMemory.py index ab98c936a133a17e1d440eb40e74e1b686a54f2e..35686fc52e0370090f2bb45ae2a1a299d21ea112 100644 --- a/bob/learn/tensorflow/datashuffler/TripletWithSelectionMemory.py +++ b/bob/learn/tensorflow/datashuffler/TripletWithSelectionMemory.py @@ -1,7 +1,7 @@ #!/usr/bin/env python # vim: set fileencoding=utf-8 : # @author: Tiago de Freitas Pereira -# @date: Wed 11 May 2016 09:39:36 CEST +# @date: Wed 11 May 2016 09:39:36 CEST import numpy import tensorflow as tf @@ -60,7 +60,9 @@ class TripletWithSelectionMemory(Triplet, Memory, OnlineSampling): """ - def __init__(self, data, labels, + def __init__(self, + data, + labels, input_shape, input_dtype="float32", batch_size=1, @@ -77,8 +79,7 @@ class TripletWithSelectionMemory(Triplet, Memory, OnlineSampling): batch_size=batch_size, seed=seed, data_augmentation=data_augmentation, - normalizer=normalizer - ) + normalizer=normalizer) self.clear_variables() # Seting the seed numpy.random.seed(seed) @@ -101,12 +102,17 @@ class TripletWithSelectionMemory(Triplet, Memory, OnlineSampling): shape = [self.batch_size] + list(self.input_shape[1:]) # Selecting the classes used in the selection - indexes = numpy.random.choice(len(self.possible_labels), self.total_identities, replace=False) - samples_per_identity = numpy.ceil(self.batch_size/float(self.total_identities)) - anchor_labels = numpy.ones(samples_per_identity) * self.possible_labels[indexes[0]] + indexes = numpy.random.choice( + len(self.possible_labels), self.total_identities, replace=False) + samples_per_identity = numpy.ceil( + self.batch_size / float(self.total_identities)) + anchor_labels = numpy.ones( + samples_per_identity) * self.possible_labels[indexes[0]] for i in range(1, self.total_identities): - anchor_labels = numpy.hstack((anchor_labels,numpy.ones(samples_per_identity) * self.possible_labels[indexes[i]])) + anchor_labels = numpy.hstack((anchor_labels, + numpy.ones(samples_per_identity) * + self.possible_labels[indexes[i]])) anchor_labels = anchor_labels[0:self.batch_size] samples_a = numpy.zeros(shape=shape, dtype=self.input_dtype) @@ -117,8 +123,10 @@ class TripletWithSelectionMemory(Triplet, Memory, OnlineSampling): embedding_a = self.project(samples_a) # Getting the positives - samples_p, embedding_p, d_anchor_positive = self.get_positives(anchor_labels, embedding_a) - samples_n = self.get_negative(anchor_labels, embedding_a, d_anchor_positive) + samples_p, embedding_p, d_anchor_positive = self.get_positives( + anchor_labels, embedding_a) + samples_n = self.get_negative(anchor_labels, embedding_a, + d_anchor_positive) return samples_a, samples_p, samples_n @@ -144,14 +152,16 @@ class TripletWithSelectionMemory(Triplet, Memory, OnlineSampling): l = anchor_labels[i] indexes = numpy.where(self.labels == l)[0] numpy.random.shuffle(indexes) - samples_p[i, ...] = self.normalize_sample(self.data[indexes[0], ...]) + samples_p[i, ...] = self.normalize_sample( + self.data[indexes[0], ...]) embedding_p = self.project(samples_p) # Computing the distances d_anchor_positive = [] for i in range(shape[0]): - d_anchor_positive.append(euclidean(embedding_a[i, :], embedding_p[i, :])) + d_anchor_positive.append( + euclidean(embedding_a[i, :], embedding_p[i, :])) return samples_p, embedding_p, d_anchor_positive @@ -175,18 +185,23 @@ class TripletWithSelectionMemory(Triplet, Memory, OnlineSampling): temp_samples_n = numpy.zeros(shape=shape, dtype='float32') samples_n = numpy.zeros(shape=shape, dtype='float32') for i in range(shape[0]): - temp_samples_n[i, ...] = self.normalize_sample(self.data[indexes[i], ...]) + temp_samples_n[i, ...] = self.normalize_sample( + self.data[indexes[i], ...]) # Computing all the embeddings embedding_temp_n = self.project(temp_samples_n) # Computing the distances - d_anchor_negative = cdist(embedding_a, embedding_temp_n, metric='euclidean') + d_anchor_negative = cdist( + embedding_a, embedding_temp_n, metric='euclidean') # Selecting the negative samples for i in range(shape[0]): label = anchor_labels[i] - possible_candidates = [d if d > d_anchor_positive[i] else numpy.inf for d in d_anchor_negative[i]] + possible_candidates = [ + d if d > d_anchor_positive[i] else numpy.inf + for d in d_anchor_negative[i] + ] for j in numpy.argsort(possible_candidates): @@ -194,7 +209,8 @@ class TripletWithSelectionMemory(Triplet, Memory, OnlineSampling): if self.labels[indexes[j]] != label: samples_n[i, ...] = temp_samples_n[j, ...] if numpy.isinf(possible_candidates[j]): - logger.info("SEMI-HARD negative not found, took the first one") + logger.info( + "SEMI-HARD negative not found, took the first one") break return samples_n diff --git a/bob/learn/tensorflow/datashuffler/__init__.py b/bob/learn/tensorflow/datashuffler/__init__.py index b2a6d14d8c063eae7f52308ed08f3f8aaefde9b8..e6f6acb8e9266b83c7e22b6814ecdf738eb42230 100644 --- a/bob/learn/tensorflow/datashuffler/__init__.py +++ b/bob/learn/tensorflow/datashuffler/__init__.py @@ -24,7 +24,7 @@ from .TFRecordImage import TFRecordImage # gets sphinx autodoc done right - don't remove it def __appropriate__(*args): - """Says object was actually declared here, an not on the import module. + """Says object was actually declared here, an not on the import module. Parameters: @@ -34,25 +34,13 @@ def __appropriate__(*args): ` """ - for obj in args: obj.__module__ = __name__ - -__appropriate__( - Base, - Siamese, - Triplet, - Memory, - Disk, - OnlineSampling, - SiameseMemory, - TripletMemory, - TripletWithSelectionMemory, - TripletWithFastSelectionDisk, - SiameseDisk, - TripletDisk, - TripletWithSelectionDisk, - scale_factor, mean_offset, per_image_standarization, - DiskAudio, - TFRecord, - TFRecordImage - ) + for obj in args: + obj.__module__ = __name__ + + +__appropriate__(Base, Siamese, Triplet, Memory, Disk, OnlineSampling, + SiameseMemory, TripletMemory, TripletWithSelectionMemory, + TripletWithFastSelectionDisk, SiameseDisk, TripletDisk, + TripletWithSelectionDisk, scale_factor, mean_offset, + per_image_standarization, DiskAudio, TFRecord, TFRecordImage) __all__ = [_ for _ in dir() if not _.startswith('_')] diff --git a/bob/learn/tensorflow/estimators/Logits.py b/bob/learn/tensorflow/estimators/Logits.py index 738aabae82e840069df0aeb4d8e13cadbff1cd2d..d2b566d9d3e2966aa0aec1141e02347520b14f78 100755 --- a/bob/learn/tensorflow/estimators/Logits.py +++ b/bob/learn/tensorflow/estimators/Logits.py @@ -92,8 +92,7 @@ class Logits(estimator.Estimator): model_dir="", validation_batch_size=None, params=None, - extra_checkpoint=None - ): + extra_checkpoint=None): self.architecture = architecture self.optimizer = optimizer @@ -115,21 +114,26 @@ class Logits(estimator.Estimator): # Building the training graph # Checking if we have some variables/scope that we may want to shut down - trainable_variables = get_trainable_variables(self.extra_checkpoint) - prelogits = self.architecture(data, mode=mode, trainable_variables=trainable_variables)[0] + trainable_variables = get_trainable_variables( + self.extra_checkpoint) + prelogits = self.architecture( + data, mode=mode, + trainable_variables=trainable_variables)[0] logits = append_logits(prelogits, n_classes) # Compute Loss (for both TRAIN and EVAL modes) self.loss = self.loss_op(logits, labels) if self.extra_checkpoint is not None: - tf.contrib.framework.init_from_checkpoint(self.extra_checkpoint["checkpoint_path"], - self.extra_checkpoint["scopes"]) + tf.contrib.framework.init_from_checkpoint( + self.extra_checkpoint["checkpoint_path"], + self.extra_checkpoint["scopes"]) global_step = tf.train.get_or_create_global_step() - train_op = self.optimizer.minimize(self.loss, global_step=global_step) - return tf.estimator.EstimatorSpec(mode=mode, loss=self.loss, - train_op=train_op) + train_op = self.optimizer.minimize( + self.loss, global_step=global_step) + return tf.estimator.EstimatorSpec( + mode=mode, loss=self.loss, train_op=train_op) # Building the training graph for PREDICTION OR VALIDATION prelogits = self.architecture(data, mode=mode)[0] @@ -154,33 +158,40 @@ class Logits(estimator.Estimator): } if mode == tf.estimator.ModeKeys.PREDICT: - return tf.estimator.EstimatorSpec(mode=mode, - predictions=predictions) + return tf.estimator.EstimatorSpec( + mode=mode, predictions=predictions) # IF Validation self.loss = self.loss_op(logits, labels) if self.embedding_validation: predictions_op = predict_using_tensors( - predictions["embeddings"], labels, + predictions["embeddings"], + labels, num=validation_batch_size) - eval_metric_ops = {"accuracy": tf.metrics.accuracy( - labels=labels, predictions=predictions_op)} + eval_metric_ops = { + "accuracy": + tf.metrics.accuracy( + labels=labels, predictions=predictions_op) + } return tf.estimator.EstimatorSpec( mode=mode, loss=self.loss, eval_metric_ops=eval_metric_ops) else: # Add evaluation metrics (for EVAL mode) eval_metric_ops = { - "accuracy": tf.metrics.accuracy( - labels=labels, predictions=predictions["classes"])} + "accuracy": + tf.metrics.accuracy( + labels=labels, predictions=predictions["classes"]) + } return tf.estimator.EstimatorSpec( mode=mode, loss=self.loss, eval_metric_ops=eval_metric_ops) - super(Logits, self).__init__(model_fn=_model_fn, - model_dir=model_dir, - params=params, - config=config) + super(Logits, self).__init__( + model_fn=_model_fn, + model_dir=model_dir, + params=params, + config=config) class LogitsCenterLoss(estimator.Estimator): @@ -242,19 +253,20 @@ class LogitsCenterLoss(estimator.Estimator): """ - def __init__(self, - architecture=None, - optimizer=None, - config=None, - n_classes=0, - embedding_validation=False, - model_dir="", - alpha=0.9, - factor=0.01, - validation_batch_size=None, - params=None, - extra_checkpoint=None, - ): + def __init__( + self, + architecture=None, + optimizer=None, + config=None, + n_classes=0, + embedding_validation=False, + model_dir="", + alpha=0.9, + factor=0.01, + validation_batch_size=None, + params=None, + extra_checkpoint=None, + ): self.architecture = architecture self.optimizer = optimizer @@ -288,26 +300,36 @@ class LogitsCenterLoss(estimator.Estimator): # Building the training graph # Checking if we have some variables/scope that we may want to shut down - trainable_variables = get_trainable_variables(self.extra_checkpoint) - prelogits = self.architecture(data, mode=mode, trainable_variables=trainable_variables)[0] + trainable_variables = get_trainable_variables( + self.extra_checkpoint) + prelogits = self.architecture( + data, mode=mode, + trainable_variables=trainable_variables)[0] logits = append_logits(prelogits, n_classes) # Compute Loss (for TRAIN mode) - loss_dict = mean_cross_entropy_center_loss(logits, prelogits, labels, self.n_classes, - alpha=self.alpha, factor=self.factor) + loss_dict = mean_cross_entropy_center_loss( + logits, + prelogits, + labels, + self.n_classes, + alpha=self.alpha, + factor=self.factor) self.loss = loss_dict['loss'] centers = loss_dict['centers'] if self.extra_checkpoint is not None: - tf.contrib.framework.init_from_checkpoint(self.extra_checkpoint["checkpoint_path"], - self.extra_checkpoint["scopes"]) + tf.contrib.framework.init_from_checkpoint( + self.extra_checkpoint["checkpoint_path"], + self.extra_checkpoint["scopes"]) global_step = tf.train.get_or_create_global_step() - train_op = tf.group(self.optimizer.minimize(self.loss, global_step=global_step), - centers) - return tf.estimator.EstimatorSpec(mode=mode, loss=self.loss, - train_op=train_op) + train_op = tf.group( + self.optimizer.minimize( + self.loss, global_step=global_step), centers) + return tf.estimator.EstimatorSpec( + mode=mode, loss=self.loss, train_op=train_op) # Building the training graph for PREDICTION OR VALIDATION prelogits = self.architecture(data, mode=mode)[0] @@ -326,33 +348,47 @@ class LogitsCenterLoss(estimator.Estimator): "classes": tf.argmax(input=logits, axis=1), # Add `softmax_tensor` to the graph. It is used for PREDICT and by the # `logging_hook`. - "probabilities": tf.nn.softmax(logits, name="softmax_tensor"), + "probabilities": tf.nn.softmax( + logits, name="softmax_tensor"), "key": key, } if mode == tf.estimator.ModeKeys.PREDICT: - return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions) + return tf.estimator.EstimatorSpec( + mode=mode, predictions=predictions) # IF Validation - loss_dict = mean_cross_entropy_center_loss(logits, prelogits, labels, self.n_classes, - alpha=self.alpha, factor=self.factor) + loss_dict = mean_cross_entropy_center_loss( + logits, + prelogits, + labels, + self.n_classes, + alpha=self.alpha, + factor=self.factor) self.loss = loss_dict['loss'] if self.embedding_validation: predictions_op = predict_using_tensors( - predictions["embeddings"], labels, num=validation_batch_size) - eval_metric_ops = {"accuracy": tf.metrics.accuracy( - labels=labels, predictions=predictions_op)} - return tf.estimator.EstimatorSpec(mode=mode, loss=self.loss, eval_metric_ops=eval_metric_ops) + predictions["embeddings"], + labels, + num=validation_batch_size) + eval_metric_ops = { + "accuracy": + tf.metrics.accuracy( + labels=labels, predictions=predictions_op) + } + return tf.estimator.EstimatorSpec( + mode=mode, loss=self.loss, eval_metric_ops=eval_metric_ops) else: # Add evaluation metrics (for EVAL mode) eval_metric_ops = { - "accuracy": tf.metrics.accuracy( - labels=labels, predictions=predictions["classes"])} + "accuracy": + tf.metrics.accuracy( + labels=labels, predictions=predictions["classes"]) + } return tf.estimator.EstimatorSpec( mode=mode, loss=self.loss, eval_metric_ops=eval_metric_ops) - super(LogitsCenterLoss, self).__init__(model_fn=_model_fn, - model_dir=model_dir, - config=config) + super(LogitsCenterLoss, self).__init__( + model_fn=_model_fn, model_dir=model_dir, config=config) diff --git a/bob/learn/tensorflow/estimators/Siamese.py b/bob/learn/tensorflow/estimators/Siamese.py index 7796bca5a87464ebe6ac7f59350a1eacbca3cbf9..c33a47ff0bec92e90d269f29a2ef3d1559f98830 100755 --- a/bob/learn/tensorflow/estimators/Siamese.py +++ b/bob/learn/tensorflow/estimators/Siamese.py @@ -89,8 +89,7 @@ class Siamese(estimator.Estimator): model_dir="", validation_batch_size=None, params=None, - extra_checkpoint=None - ): + extra_checkpoint=None): self.architecture = architecture self.optimizer = optimizer @@ -99,10 +98,13 @@ class Siamese(estimator.Estimator): self.extra_checkpoint = extra_checkpoint if self.architecture is None: - raise ValueError("Please specify a function to build the architecture !!") + raise ValueError( + "Please specify a function to build the architecture !!") if self.optimizer is None: - raise ValueError("Please specify a optimizer (https://www.tensorflow.org/api_guides/python/train) !!") + raise ValueError( + "Please specify a optimizer (https://www.tensorflow.org/api_guides/python/train) !!" + ) if self.loss_op is None: raise ValueError("Please specify a function to build the loss !!") @@ -112,30 +114,41 @@ class Siamese(estimator.Estimator): # Building one graph, by default everything is trainable # The input function needs to have dictionary pair with the `left` and `right` keys - if 'left' not in features.keys() or 'right' not in features.keys(): + if 'left' not in features.keys( + ) or 'right' not in features.keys(): raise ValueError( - "The input function needs to contain a dictionary with the keys `left` and `right` ") + "The input function needs to contain a dictionary with the keys `left` and `right` " + ) # Building one graph - trainable_variables = get_trainable_variables(self.extra_checkpoint) - prelogits_left, end_points_left = self.architecture(features['left'], mode=mode, - trainable_variables=trainable_variables) - prelogits_right, end_points_right = self.architecture(features['right'], reuse=True, mode=mode, - trainable_variables=trainable_variables) + trainable_variables = get_trainable_variables( + self.extra_checkpoint) + prelogits_left, end_points_left = self.architecture( + features['left'], + mode=mode, + trainable_variables=trainable_variables) + prelogits_right, end_points_right = self.architecture( + features['right'], + reuse=True, + mode=mode, + trainable_variables=trainable_variables) if self.extra_checkpoint is not None: - tf.contrib.framework.init_from_checkpoint(self.extra_checkpoint["checkpoint_path"], - self.extra_checkpoint["scopes"]) + tf.contrib.framework.init_from_checkpoint( + self.extra_checkpoint["checkpoint_path"], + self.extra_checkpoint["scopes"]) # Compute Loss (for both TRAIN and EVAL modes) - self.loss = self.loss_op(prelogits_left, prelogits_right, labels) + self.loss = self.loss_op(prelogits_left, prelogits_right, + labels) # Configure the Training Op (for TRAIN mode) global_step = tf.train.get_or_create_global_step() - train_op = self.optimizer.minimize(self.loss, global_step=global_step) + train_op = self.optimizer.minimize( + self.loss, global_step=global_step) - return tf.estimator.EstimatorSpec(mode=mode, loss=self.loss, - train_op=train_op) + return tf.estimator.EstimatorSpec( + mode=mode, loss=self.loss, train_op=train_op) check_features(features) data = features['data'] @@ -146,14 +159,23 @@ class Siamese(estimator.Estimator): predictions = {"embeddings": embeddings} if mode == tf.estimator.ModeKeys.PREDICT: - return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions) - - predictions_op = predict_using_tensors(predictions["embeddings"], labels, num=validation_batch_size) - eval_metric_ops = {"accuracy": tf.metrics.accuracy(labels=labels, predictions=predictions_op)} - - return tf.estimator.EstimatorSpec(mode=mode, loss=tf.reduce_mean(1), eval_metric_ops=eval_metric_ops) - - super(Siamese, self).__init__(model_fn=_model_fn, - model_dir=model_dir, - params=params, - config=config) + return tf.estimator.EstimatorSpec( + mode=mode, predictions=predictions) + + predictions_op = predict_using_tensors( + predictions["embeddings"], labels, num=validation_batch_size) + eval_metric_ops = { + "accuracy": + tf.metrics.accuracy(labels=labels, predictions=predictions_op) + } + + return tf.estimator.EstimatorSpec( + mode=mode, + loss=tf.reduce_mean(1), + eval_metric_ops=eval_metric_ops) + + super(Siamese, self).__init__( + model_fn=_model_fn, + model_dir=model_dir, + params=params, + config=config) diff --git a/bob/learn/tensorflow/estimators/Triplet.py b/bob/learn/tensorflow/estimators/Triplet.py index 80ec1bd66f322567ae91e68a9dda27a310f0e405..c22098e5252af7d4836fe02f958bb5e426f5ce84 100644 --- a/bob/learn/tensorflow/estimators/Triplet.py +++ b/bob/learn/tensorflow/estimators/Triplet.py @@ -81,8 +81,7 @@ class Triplet(estimator.Estimator): loss_op=triplet_loss, model_dir="", validation_batch_size=None, - extra_checkpoint=None - ): + extra_checkpoint=None): self.architecture = architecture self.optimizer = optimizer @@ -91,10 +90,13 @@ class Triplet(estimator.Estimator): self.extra_checkpoint = extra_checkpoint if self.architecture is None: - raise ValueError("Please specify a function to build the architecture !!") + raise ValueError( + "Please specify a function to build the architecture !!") if self.optimizer is None: - raise ValueError("Please specify a optimizer (https://www.tensorflow.org/api_guides/python/train) !!") + raise ValueError( + "Please specify a optimizer (https://www.tensorflow.org/api_guides/python/train) !!" + ) if self.loss_op is None: raise ValueError("Please specify a function to build the loss !!") @@ -107,29 +109,42 @@ class Triplet(estimator.Estimator): if 'anchor' not in features.keys() or \ 'positive' not in features.keys() or \ 'negative' not in features.keys(): - raise ValueError("The input function needs to contain a dictionary with the " - "keys `anchor`, `positive` and `negative` ") + raise ValueError( + "The input function needs to contain a dictionary with the " + "keys `anchor`, `positive` and `negative` ") # Building one graph - trainable_variables = get_trainable_variables(self.extra_checkpoint) - prelogits_anchor = self.architecture(features['anchor'], mode=mode, - trainable_variables=trainable_variables)[0] - prelogits_positive = self.architecture(features['positive'], reuse=True, mode=mode, - trainable_variables=trainable_variables)[0] - prelogits_negative = self.architecture(features['negative'], reuse=True, mode=mode, - trainable_variables=trainable_variables)[0] + trainable_variables = get_trainable_variables( + self.extra_checkpoint) + prelogits_anchor = self.architecture( + features['anchor'], + mode=mode, + trainable_variables=trainable_variables)[0] + prelogits_positive = self.architecture( + features['positive'], + reuse=True, + mode=mode, + trainable_variables=trainable_variables)[0] + prelogits_negative = self.architecture( + features['negative'], + reuse=True, + mode=mode, + trainable_variables=trainable_variables)[0] if self.extra_checkpoint is not None: - tf.contrib.framework.init_from_checkpoint(self.extra_checkpoint["checkpoint_path"], - self.extra_checkpoint["scopes"]) + tf.contrib.framework.init_from_checkpoint( + self.extra_checkpoint["checkpoint_path"], + self.extra_checkpoint["scopes"]) # Compute Loss (for both TRAIN and EVAL modes) - self.loss = self.loss_op(prelogits_anchor, prelogits_positive, prelogits_negative) + self.loss = self.loss_op(prelogits_anchor, prelogits_positive, + prelogits_negative) # Configure the Training Op (for TRAIN mode) global_step = tf.train.get_or_create_global_step() - train_op = self.optimizer.minimize(self.loss, global_step=global_step) - return tf.estimator.EstimatorSpec(mode=mode, loss=self.loss, - train_op=train_op) + train_op = self.optimizer.minimize( + self.loss, global_step=global_step) + return tf.estimator.EstimatorSpec( + mode=mode, loss=self.loss, train_op=train_op) check_features(features) data = features['data'] @@ -140,13 +155,20 @@ class Triplet(estimator.Estimator): predictions = {"embeddings": embeddings} if mode == tf.estimator.ModeKeys.PREDICT: - return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions) - - predictions_op = predict_using_tensors(predictions["embeddings"], labels, num=validation_batch_size) - eval_metric_ops = {"accuracy": tf.metrics.accuracy(labels=labels, predictions=predictions_op)} - - return tf.estimator.EstimatorSpec(mode=mode, loss=tf.reduce_mean(1), eval_metric_ops=eval_metric_ops) - - super(Triplet, self).__init__(model_fn=_model_fn, - model_dir=model_dir, - config=config) + return tf.estimator.EstimatorSpec( + mode=mode, predictions=predictions) + + predictions_op = predict_using_tensors( + predictions["embeddings"], labels, num=validation_batch_size) + eval_metric_ops = { + "accuracy": + tf.metrics.accuracy(labels=labels, predictions=predictions_op) + } + + return tf.estimator.EstimatorSpec( + mode=mode, + loss=tf.reduce_mean(1), + eval_metric_ops=eval_metric_ops) + + super(Triplet, self).__init__( + model_fn=_model_fn, model_dir=model_dir, config=config) diff --git a/bob/learn/tensorflow/estimators/__init__.py b/bob/learn/tensorflow/estimators/__init__.py index d70ad87a7ace58a0a687890fe74837ae3d8737d0..59f0b905c79a50f3d81bf5fabb88551043a15a39 100644 --- a/bob/learn/tensorflow/estimators/__init__.py +++ b/bob/learn/tensorflow/estimators/__init__.py @@ -7,7 +7,9 @@ import tensorflow as tf def check_features(features): if not 'data' in features.keys() or not 'key' in features.keys(): - raise ValueError("The input function needs to contain a dictionary with the keys `data` and `key` ") + raise ValueError( + "The input function needs to contain a dictionary with the keys `data` and `key` " + ) return True @@ -46,7 +48,7 @@ from .Triplet import Triplet # gets sphinx autodoc done right - don't remove it def __appropriate__(*args): - """Says object was actually declared here, an not on the import module. + """Says object was actually declared here, an not on the import module. Parameters: @@ -56,14 +58,9 @@ def __appropriate__(*args): ` """ - for obj in args: obj.__module__ = __name__ - -__appropriate__( - Logits, - LogitsCenterLoss, - Siamese, - Triplet - ) -__all__ = [_ for _ in dir() if not _.startswith('_')] + for obj in args: + obj.__module__ = __name__ +__appropriate__(Logits, LogitsCenterLoss, Siamese, Triplet) +__all__ = [_ for _ in dir() if not _.startswith('_')] diff --git a/bob/learn/tensorflow/examples/mnist/mnist_config.py b/bob/learn/tensorflow/examples/mnist/mnist_config.py index 9991e218e4bf454d28fadc2e1c3d6eaa52c89067..fbed1f5f5972742967c752372e5ec04e132ec860 100644 --- a/bob/learn/tensorflow/examples/mnist/mnist_config.py +++ b/bob/learn/tensorflow/examples/mnist/mnist_config.py @@ -126,8 +126,8 @@ def mnist_model(inputs, mode): # First max pooling layer with a 2x2 filter and stride of 2 # Input Tensor Shape: [batch_size, 28, 28, 32] # Output Tensor Shape: [batch_size, 14, 14, 32] - pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2, - data_format=data_format) + pool1 = tf.layers.max_pooling2d( + inputs=conv1, pool_size=[2, 2], strides=2, data_format=data_format) # Convolutional Layer #2 # Computes 64 features using a 5x5 filter. @@ -146,8 +146,8 @@ def mnist_model(inputs, mode): # Second max pooling layer with a 2x2 filter and stride of 2 # Input Tensor Shape: [batch_size, 14, 14, 64] # Output Tensor Shape: [batch_size, 7, 7, 64] - pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2, - data_format=data_format) + pool2 = tf.layers.max_pooling2d( + inputs=conv2, pool_size=[2, 2], strides=2, data_format=data_format) # Flatten tensor into a batch of vectors # Input Tensor Shape: [batch_size, 7, 7, 64] @@ -158,8 +158,8 @@ def mnist_model(inputs, mode): # Densely connected layer with 1024 neurons # Input Tensor Shape: [batch_size, 7 * 7 * 64] # Output Tensor Shape: [batch_size, 1024] - dense = tf.layers.dense(inputs=pool2_flat, units=1024, - activation=tf.nn.relu) + dense = tf.layers.dense( + inputs=pool2_flat, units=1024, activation=tf.nn.relu) # Add dropout operation; 0.6 probability that element will be kept dropout = tf.layers.dropout( @@ -192,8 +192,8 @@ def model_fn(features, labels=None, mode=tf.estimator.ModeKeys.TRAIN): # Configure the training op if mode == tf.estimator.ModeKeys.TRAIN: optimizer = tf.train.AdamOptimizer(learning_rate=1e-4) - train_op = optimizer.minimize( - loss, tf.train.get_or_create_global_step()) + train_op = optimizer.minimize(loss, + tf.train.get_or_create_global_step()) else: train_op = None @@ -215,9 +215,8 @@ def model_fn(features, labels=None, mode=tf.estimator.ModeKeys.TRAIN): eval_metric_ops=metrics) -estimator = tf.estimator.Estimator(model_fn=model_fn, model_dir=model_dir, - params=None, config=run_config) - +estimator = tf.estimator.Estimator( + model_fn=model_fn, model_dir=model_dir, params=None, config=run_config) output = train_tfrecords[0] db = Database() diff --git a/bob/learn/tensorflow/examples/mnist/tfrecords.py b/bob/learn/tensorflow/examples/mnist/tfrecords.py index 657d5c97f992b05b35d54b70877c4e5b2594ca29..2a4eb216d7e4275ee339a961a1667c6705086bda 100644 --- a/bob/learn/tensorflow/examples/mnist/tfrecords.py +++ b/bob/learn/tensorflow/examples/mnist/tfrecords.py @@ -27,8 +27,8 @@ CLIENT_IDS = dict(zip(CLIENT_IDS, range(len(CLIENT_IDS)))) def file_to_label(f): return CLIENT_IDS[str(f.client_id)] -# Optional objects: +# Optional objects: # The groups that you want to create tfrecords for. It should be a list of # 'world' ('train' in bob.pad.base), 'dev', and 'eval' values. [default: @@ -41,6 +41,7 @@ reader = Preprocessor().read_data reader = Extractor().read_feature # or from bob.bio.base.utils import load as reader + # or a reader that casts images to uint8: diff --git a/bob/learn/tensorflow/layers/Conv1D.py b/bob/learn/tensorflow/layers/Conv1D.py index f9fccc51b3f72ba8fb345ca73c66b5bb40abd520..7c8f167ef5c41f27fa76e3528a65aaa9ef33c5f8 100644 --- a/bob/learn/tensorflow/layers/Conv1D.py +++ b/bob/learn/tensorflow/layers/Conv1D.py @@ -6,12 +6,12 @@ import tensorflow as tf from .Layer import Layer + #from bob.learn.tensorflow.initialization import Xavier #from bob.learn.tensorflow.initialization import Constant class Conv1D(Layer): - """ 1D Convolution **Parameters** @@ -45,23 +45,27 @@ class Conv1D(Layer): """ - def __init__(self, name, activation=None, + def __init__(self, + name, + activation=None, kernel_size=300, filters=20, stride=100, - weights_initialization=tf.contrib.layers.xavier_initializer(uniform=False, dtype=tf.float32, seed=10), + weights_initialization=tf.contrib.layers.xavier_initializer( + uniform=False, dtype=tf.float32, seed=10), init_value=None, - bias_initialization=tf.contrib.layers.xavier_initializer(uniform=False, dtype=tf.float32, seed=10), + bias_initialization=tf.contrib.layers.xavier_initializer( + uniform=False, dtype=tf.float32, seed=10), batch_norm=False, - use_gpu=False - ): - super(Conv1D, self).__init__(name=name, - activation=activation, - weights_initialization=weights_initialization, - bias_initialization=bias_initialization, - batch_norm=batch_norm, - use_gpu=use_gpu, - ) + use_gpu=False): + super(Conv1D, self).__init__( + name=name, + activation=activation, + weights_initialization=weights_initialization, + bias_initialization=bias_initialization, + batch_norm=batch_norm, + use_gpu=use_gpu, + ) self.kernel_size = kernel_size self.filters = filters self.W = None @@ -74,29 +78,32 @@ class Conv1D(Layer): # TODO: Do an assert here if len(input_layer.get_shape().as_list()) != 3: - raise ValueError("The input as a convolutional layer must have 3 dimensions, " - "but {0} were provided".format(len(input_layer.get_shape().as_list()))) + raise ValueError( + "The input as a convolutional layer must have 3 dimensions, " + "but {0} were provided".format( + len(input_layer.get_shape().as_list()))) n_channels = input_layer.get_shape().as_list()[2] if self.W is None: if self.init_value is None: self.init_value = self.kernel_size * n_channels - self.W = self.weights_initialization(shape=[self.kernel_size, n_channels, self.filters], - name="w_" + str(self.name), - scope="w_" + str(self.name), - init_value=self.init_value - ) - - self.b = self.bias_initialization(shape=[self.filters], - name="b_" + str(self.name) + "bias", - scope="b_" + str(self.name), - init_value=self.init_value - ) + self.W = self.weights_initialization( + shape=[self.kernel_size, n_channels, self.filters], + name="w_" + str(self.name), + scope="w_" + str(self.name), + init_value=self.init_value) + + self.b = self.bias_initialization( + shape=[self.filters], + name="b_" + str(self.name) + "bias", + scope="b_" + str(self.name), + init_value=self.init_value) def get_graph(self, training_phase=True): with tf.name_scope(str(self.name)): - conv1d = tf.nn.conv1d(self.input_layer, self.W, stride=self.stride, padding='VALID') + conv1d = tf.nn.conv1d( + self.input_layer, self.W, stride=self.stride, padding='VALID') if self.batch_norm: conv1d = self.batch_normalize(conv1d, training_phase) diff --git a/bob/learn/tensorflow/layers/Layer.py b/bob/learn/tensorflow/layers/Layer.py index d6e1c241d44a9952e35c84808cfe89ba7679aa09..cd5dc9910d26ccb05f8f59c8a43b4a3b3d258c27 100644 --- a/bob/learn/tensorflow/layers/Layer.py +++ b/bob/learn/tensorflow/layers/Layer.py @@ -7,7 +7,6 @@ import tensorflow as tf class Layer(object): - """ Layer base class @@ -33,10 +32,13 @@ class Layer(object): """ - def __init__(self, name, + def __init__(self, + name, activation=None, - weights_initialization=tf.contrib.layers.xavier_initializer(uniform=False, dtype=tf.float32, seed=10), - bias_initialization=tf.contrib.layers.xavier_initializer(uniform=False, dtype=tf.float32, seed=10), + weights_initialization=tf.contrib.layers.xavier_initializer( + uniform=False, dtype=tf.float32, seed=10), + bias_initialization=tf.contrib.layers.xavier_initializer( + uniform=False, dtype=tf.float32, seed=10), batch_norm=False, use_gpu=False): @@ -56,10 +58,12 @@ class Layer(object): self.batch_var = None def create_variables(self, input_layer): - NotImplementedError("Please implement this function in derived classes") + NotImplementedError( + "Please implement this function in derived classes") def get_graph(self, training_phase=True): - NotImplementedError("Please implement this function in derived classes") + NotImplementedError( + "Please implement this function in derived classes") def variable_exist(self, var): return var in [v.name.split("/")[0] for v in tf.global_variables()] @@ -80,41 +84,49 @@ class Layer(object): reuse = self.variable_exist(name) #if reuse: - #import ipdb; ipdb.set_trace(); + #import ipdb; ipdb.set_trace(); with tf.variable_scope(name, reuse=reuse): phase_train = tf.convert_to_tensor(phase_train, dtype=tf.bool) n_out = int(x.get_shape()[-1]) - self.beta = tf.get_variable(name + '_beta', - initializer=tf.constant(0.0, shape=[n_out], dtype=x.dtype), - trainable=True, - dtype=x.dtype) + self.beta = tf.get_variable( + name + '_beta', + initializer=tf.constant(0.0, shape=[n_out], dtype=x.dtype), + trainable=True, + dtype=x.dtype) - self.gamma = tf.get_variable(name + '_gamma', - initializer=tf.constant(1.0, shape=[n_out], dtype=x.dtype), - trainable=True, - dtype=x.dtype) + self.gamma = tf.get_variable( + name + '_gamma', + initializer=tf.constant(1.0, shape=[n_out], dtype=x.dtype), + trainable=True, + dtype=x.dtype) if len(x.get_shape()) == 2: - self.batch_mean, self.batch_var = tf.nn.moments(x, [0], name='moments_{0}'.format(name)) + self.batch_mean, self.batch_var = tf.nn.moments( + x, [0], name='moments_{0}'.format(name)) else: - self.batch_mean, self.batch_var = tf.nn.moments(x, range(len(x.get_shape())-1), name='moments_{0}'.format(name)) + self.batch_mean, self.batch_var = tf.nn.moments( + x, + range(len(x.get_shape()) - 1), + name='moments_{0}'.format(name)) ema = tf.train.ExponentialMovingAverage(decay=0.9) def mean_var_with_update(): ema_apply_op = ema.apply([self.batch_mean, self.batch_var]) with tf.control_dependencies([ema_apply_op]): - return tf.identity(self.batch_mean), tf.identity(self.batch_var) + return tf.identity(self.batch_mean), tf.identity( + self.batch_var) mean, var = control_flow_ops.cond(phase_train, mean_var_with_update, lambda: (ema.average(self.batch_mean), ema.average(self.batch_var)), name=name + "mean_var") - normed = tf.nn.batch_normalization(x, mean, var, self.beta, self.gamma, 1e-3) + normed = tf.nn.batch_normalization(x, mean, var, self.beta, + self.gamma, 1e-3) return normed def get_varible_by_name(self, var): diff --git a/bob/learn/tensorflow/layers/Maxout.py b/bob/learn/tensorflow/layers/Maxout.py index ba77c154ae15909c3f78155f50be04b94f16461c..d1abd0e5f27a1135e03d6e93ac1a6c3a34ff3319 100644 --- a/bob/learn/tensorflow/layers/Maxout.py +++ b/bob/learn/tensorflow/layers/Maxout.py @@ -3,11 +3,8 @@ # @author: Tiago de Freitas Pereira # @date: Fri 04 Aug 2017 14:14:22 CEST - ## MAXOUT IMPLEMENTED FOR TENSORFLOW - - from tensorflow.python.framework import ops from tensorflow.python.ops import math_ops from tensorflow.python.ops import gen_array_ops @@ -20,7 +17,6 @@ def maxout(inputs, num_units, axis=-1, name=None): class MaxOut(base.Layer): - """ Adds a maxout op from @@ -44,13 +40,8 @@ class MaxOut(base.Layer): name: Optional scope for name_scope. """ - def __init__(self, - num_units, - axis=-1, - name=None, - **kwargs): - super(MaxOut, self).__init__( - name=name, trainable=False, **kwargs) + def __init__(self, num_units, axis=-1, name=None, **kwargs): + super(MaxOut, self).__init__(name=name, trainable=False, **kwargs) self.axis = axis self.num_units = num_units @@ -63,8 +54,8 @@ class MaxOut(base.Layer): num_channels = shape[self.axis] if num_channels % self.num_units: raise ValueError('number of features({}) is not ' - 'a multiple of num_units({})' - .format(num_channels, self.num_units)) + 'a multiple of num_units({})'.format( + num_channels, self.num_units)) shape[self.axis] = -1 shape += [num_channels // self.num_units] @@ -73,10 +64,10 @@ class MaxOut(base.Layer): if shape[i] is None: shape[i] = gen_array_ops.shape(inputs)[i] - outputs = math_ops.reduce_max(gen_array_ops.reshape(inputs, shape), -1, keep_dims=False) + outputs = math_ops.reduce_max( + gen_array_ops.reshape(inputs, shape), -1, keep_dims=False) shape = outputs.get_shape().as_list() shape[self.axis] = self.num_units outputs.set_shape(shape) return outputs - diff --git a/bob/learn/tensorflow/layers/__init__.py b/bob/learn/tensorflow/layers/__init__.py index 3940286b8d18ffa31ce0a0b59c8bd50a99a985bf..b9aef36bba3db085ecceaa3359f2fe312edae005 100644 --- a/bob/learn/tensorflow/layers/__init__.py +++ b/bob/learn/tensorflow/layers/__init__.py @@ -5,7 +5,7 @@ from .Maxout import maxout, maxout # gets sphinx autodoc done right - don't remove it def __appropriate__(*args): - """Says object was actually declared here, an not on the import module. + """Says object was actually declared here, an not on the import module. **Parameters** @@ -15,13 +15,9 @@ def __appropriate__(*args): ` """ - for obj in args: obj.__module__ = __name__ + for obj in args: + obj.__module__ = __name__ -__appropriate__( - Layer, - Conv1D, - maxout, - Maxout - ) -__all__ = [_ for _ in dir() if not _.startswith('_')] +__appropriate__(Layer, Conv1D, maxout, Maxout) +__all__ = [_ for _ in dir() if not _.startswith('_')] diff --git a/bob/learn/tensorflow/loss/BaseLoss.py b/bob/learn/tensorflow/loss/BaseLoss.py index a49a0e1378b0382c12d959c1fcb14aa8bb344491..4dc7f583fcf57d29b5b25ed55cd48a9c91b04aab 100644 --- a/bob/learn/tensorflow/loss/BaseLoss.py +++ b/bob/learn/tensorflow/loss/BaseLoss.py @@ -23,17 +23,26 @@ def mean_cross_entropy_loss(logits, labels, add_regularization_losses=True): with tf.variable_scope('cross_entropy_loss'): - loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits( - logits=logits, labels=labels), name=tf.GraphKeys.LOSSES) - + loss = tf.reduce_mean( + tf.nn.sparse_softmax_cross_entropy_with_logits( + logits=logits, labels=labels), + name=tf.GraphKeys.LOSSES) + if add_regularization_losses: - regularization_losses = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES) - return tf.add_n([loss] + regularization_losses, name=tf.GraphKeys.LOSSES) + regularization_losses = tf.get_collection( + tf.GraphKeys.REGULARIZATION_LOSSES) + return tf.add_n( + [loss] + regularization_losses, name=tf.GraphKeys.LOSSES) else: return loss - -def mean_cross_entropy_center_loss(logits, prelogits, labels, n_classes, alpha=0.9, factor=0.01): + +def mean_cross_entropy_center_loss(logits, + prelogits, + labels, + n_classes, + alpha=0.9, + factor=0.01): """ Implementation of the CrossEntropy + Center Loss from the paper "A Discriminative Feature Learning Approach for Deep Face Recognition"(http://ydwen.github.io/papers/WenECCV16.pdf) @@ -49,30 +58,38 @@ def mean_cross_entropy_center_loss(logits, prelogits, labels, n_classes, alpha=0 """ # Cross entropy with tf.variable_scope('cross_entropy_loss'): - loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits( - logits=logits, labels=labels), name=tf.GraphKeys.LOSSES) - + loss = tf.reduce_mean( + tf.nn.sparse_softmax_cross_entropy_with_logits( + logits=logits, labels=labels), + name=tf.GraphKeys.LOSSES) + tf.summary.scalar('cross_entropy_loss', loss) - # Appending center loss + # Appending center loss with tf.variable_scope('center_loss'): n_features = prelogits.get_shape()[1] - - centers = tf.get_variable('centers', [n_classes, n_features], dtype=tf.float32, - initializer=tf.constant_initializer(0), trainable=False) - + + centers = tf.get_variable( + 'centers', [n_classes, n_features], + dtype=tf.float32, + initializer=tf.constant_initializer(0), + trainable=False) + #label = tf.reshape(labels, [-1]) centers_batch = tf.gather(centers, labels) diff = (1 - alpha) * (centers_batch - prelogits) centers = tf.scatter_sub(centers, labels, diff) - center_loss = tf.reduce_mean(tf.square(prelogits - centers_batch)) - tf.add_to_collection(tf.GraphKeys.REGULARIZATION_LOSSES, center_loss * factor) + center_loss = tf.reduce_mean(tf.square(prelogits - centers_batch)) + tf.add_to_collection(tf.GraphKeys.REGULARIZATION_LOSSES, + center_loss * factor) tf.summary.scalar('center_loss', center_loss) # Adding the regularizers in the loss with tf.variable_scope('total_loss'): - regularization_losses = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES) - total_loss = tf.add_n([loss] + regularization_losses, name=tf.GraphKeys.LOSSES) + regularization_losses = tf.get_collection( + tf.GraphKeys.REGULARIZATION_LOSSES) + total_loss = tf.add_n( + [loss] + regularization_losses, name=tf.GraphKeys.LOSSES) tf.summary.scalar('total_loss', total_loss) loss = dict() @@ -80,4 +97,3 @@ def mean_cross_entropy_center_loss(logits, prelogits, labels, n_classes, alpha=0 loss['centers'] = centers return loss - diff --git a/bob/learn/tensorflow/loss/ContrastiveLoss.py b/bob/learn/tensorflow/loss/ContrastiveLoss.py index 4dbc250e133751d4ff48388aeb0875d16ca18011..f72cbd8ae2312cdf39e5e4a3c9d375ac833318fc 100644 --- a/bob/learn/tensorflow/loss/ContrastiveLoss.py +++ b/bob/learn/tensorflow/loss/ContrastiveLoss.py @@ -9,7 +9,10 @@ import tensorflow as tf from bob.learn.tensorflow.utils import compute_euclidean_distance -def contrastive_loss(left_embedding, right_embedding, labels, contrastive_margin=2.0): +def contrastive_loss(left_embedding, + right_embedding, + labels, + contrastive_margin=2.0): """ Compute the contrastive loss as in @@ -38,26 +41,30 @@ def contrastive_loss(left_embedding, right_embedding, labels, contrastive_margin with tf.name_scope("contrastive_loss"): labels = tf.to_float(labels) - + left_embedding = tf.nn.l2_normalize(left_embedding, 1) - right_embedding = tf.nn.l2_normalize(right_embedding, 1) + right_embedding = tf.nn.l2_normalize(right_embedding, 1) d = compute_euclidean_distance(left_embedding, right_embedding) - + with tf.name_scope("within_class"): - one = tf.constant(1.0) - within_class = tf.multiply(one - labels, tf.square(d)) # (1-Y)*(d^2) - within_class_loss = tf.reduce_mean(within_class, name=tf.GraphKeys.LOSSES) + one = tf.constant(1.0) + within_class = tf.multiply(one - labels, + tf.square(d)) # (1-Y)*(d^2) + within_class_loss = tf.reduce_mean( + within_class, name=tf.GraphKeys.LOSSES) with tf.name_scope("between_class"): max_part = tf.square(tf.maximum(contrastive_margin - d, 0)) - between_class = tf.multiply(labels, max_part) # (Y) * max((margin - d)^2, 0) - between_class_loss = tf.reduce_mean(between_class, name=tf.GraphKeys.LOSSES) + between_class = tf.multiply( + labels, max_part) # (Y) * max((margin - d)^2, 0) + between_class_loss = tf.reduce_mean( + between_class, name=tf.GraphKeys.LOSSES) with tf.name_scope("total_loss"): - loss = 0.5 * (within_class + between_class) - loss = tf.reduce_mean(loss, name=tf.GraphKeys.LOSSES) - + loss = 0.5 * (within_class + between_class) + loss = tf.reduce_mean(loss, name=tf.GraphKeys.LOSSES) + tf.summary.scalar('loss', loss) tf.summary.scalar('between_class', between_class_loss) tf.summary.scalar('within_class', within_class_loss) @@ -65,7 +72,10 @@ def contrastive_loss(left_embedding, right_embedding, labels, contrastive_margin return loss -def contrastive_loss_deprecated(left_embedding, right_embedding, labels, contrastive_margin=1.0): +def contrastive_loss_deprecated(left_embedding, + right_embedding, + labels, + contrastive_margin=1.0): """ Compute the contrastive loss as in @@ -91,24 +101,26 @@ def contrastive_loss_deprecated(left_embedding, right_embedding, labels, contras with tf.name_scope("contrastive_loss"): labels = tf.to_float(labels) - + left_embedding = tf.nn.l2_normalize(left_embedding, 1) - right_embedding = tf.nn.l2_normalize(right_embedding, 1) + right_embedding = tf.nn.l2_normalize(right_embedding, 1) one = tf.constant(1.0) d = compute_euclidean_distance(left_embedding, right_embedding) within_class = tf.multiply(one - labels, tf.square(d)) # (1-Y)*(d^2) - + max_part = tf.square(tf.maximum(contrastive_margin - d, 0)) - between_class = tf.multiply(labels, max_part) # (Y) * max((margin - d)^2, 0) + between_class = tf.multiply(labels, + max_part) # (Y) * max((margin - d)^2, 0) - loss = 0.5 * (within_class + between_class) + loss = 0.5 * (within_class + between_class) loss_dict = dict() loss_dict['loss'] = tf.reduce_mean(loss, name=tf.GraphKeys.LOSSES) - loss_dict['between_class'] = tf.reduce_mean(between_class, name=tf.GraphKeys.LOSSES) - loss_dict['within_class'] = tf.reduce_mean(within_class, name=tf.GraphKeys.LOSSES) + loss_dict['between_class'] = tf.reduce_mean( + between_class, name=tf.GraphKeys.LOSSES) + loss_dict['within_class'] = tf.reduce_mean( + within_class, name=tf.GraphKeys.LOSSES) return loss_dict - diff --git a/bob/learn/tensorflow/loss/NegLogLoss.py b/bob/learn/tensorflow/loss/NegLogLoss.py index b4da1601b5977143d62cadd6fd853bf3a41fc100..96ef7c963f0c85b983c9c7fa853905ff69f6c383 100644 --- a/bob/learn/tensorflow/loss/NegLogLoss.py +++ b/bob/learn/tensorflow/loss/NegLogLoss.py @@ -25,12 +25,16 @@ class NegLogLoss(BaseLoss): rank = len(shape) flat_params = tf.reshape(params, [-1]) if rank > 2: - indices_unpacked = tf.unstack(tf.transpose(indices, [rank - 1] + range(0, rank - 1), name)) + indices_unpacked = tf.unstack( + tf.transpose(indices, [rank - 1] + range(0, rank - 1), name)) elif rank == 2: indices_unpacked = tf.unstack(indices) else: indices_unpacked = indices - flat_indices = [i * rank + indices_unpacked[i] for i in range(0, len(indices_unpacked))] + flat_indices = [ + i * rank + indices_unpacked[i] + for i in range(0, len(indices_unpacked)) + ] return tf.gather(flat_params, flat_indices, name=name) def __call__(self, graph, label): diff --git a/bob/learn/tensorflow/loss/TripletLoss.py b/bob/learn/tensorflow/loss/TripletLoss.py index 1c788cbc837be4ad46db7d81aaef6540b46ebe86..fe59cbb96fdd1050d4f94c99205b9bfdf0c69b48 100644 --- a/bob/learn/tensorflow/loss/TripletLoss.py +++ b/bob/learn/tensorflow/loss/TripletLoss.py @@ -9,7 +9,10 @@ import tensorflow as tf from bob.learn.tensorflow.utils import compute_euclidean_distance -def triplet_loss(anchor_embedding, positive_embedding, negative_embedding, margin=5.0): +def triplet_loss(anchor_embedding, + positive_embedding, + negative_embedding, + margin=5.0): """ Compute the triplet loss as in @@ -37,15 +40,21 @@ def triplet_loss(anchor_embedding, positive_embedding, negative_embedding, margi with tf.name_scope("triplet_loss"): # Normalize - anchor_embedding = tf.nn.l2_normalize(anchor_embedding, 1, 1e-10, name="anchor") - positive_embedding = tf.nn.l2_normalize(positive_embedding, 1, 1e-10, name="positive") - negative_embedding = tf.nn.l2_normalize(negative_embedding, 1, 1e-10, name="negative") - - d_positive = tf.reduce_sum(tf.square(tf.subtract(anchor_embedding, positive_embedding)), 1) - d_negative = tf.reduce_sum(tf.square(tf.subtract(anchor_embedding, negative_embedding)), 1) + anchor_embedding = tf.nn.l2_normalize( + anchor_embedding, 1, 1e-10, name="anchor") + positive_embedding = tf.nn.l2_normalize( + positive_embedding, 1, 1e-10, name="positive") + negative_embedding = tf.nn.l2_normalize( + negative_embedding, 1, 1e-10, name="negative") + + d_positive = tf.reduce_sum( + tf.square(tf.subtract(anchor_embedding, positive_embedding)), 1) + d_negative = tf.reduce_sum( + tf.square(tf.subtract(anchor_embedding, negative_embedding)), 1) basic_loss = tf.add(tf.subtract(d_positive, d_negative), margin) - loss = tf.reduce_mean(tf.maximum(basic_loss, 0.0), 0, name=tf.GraphKeys.LOSSES) + loss = tf.reduce_mean( + tf.maximum(basic_loss, 0.0), 0, name=tf.GraphKeys.LOSSES) between_class_loss = tf.reduce_mean(d_negative) within_class_loss = tf.reduce_mean(d_positive) @@ -56,7 +65,10 @@ def triplet_loss(anchor_embedding, positive_embedding, negative_embedding, margi return loss -def triplet_loss_deprecated(anchor_embedding, positive_embedding, negative_embedding, margin=5.0): +def triplet_loss_deprecated(anchor_embedding, + positive_embedding, + negative_embedding, + margin=5.0): """ Compute the triplet loss as in @@ -84,15 +96,21 @@ def triplet_loss_deprecated(anchor_embedding, positive_embedding, negative_embed with tf.name_scope("triplet_loss"): # Normalize - anchor_embedding = tf.nn.l2_normalize(anchor_embedding, 1, 1e-10, name="anchor") - positive_embedding = tf.nn.l2_normalize(positive_embedding, 1, 1e-10, name="positive") - negative_embedding = tf.nn.l2_normalize(negative_embedding, 1, 1e-10, name="negative") - - d_positive = tf.reduce_sum(tf.square(tf.subtract(anchor_embedding, positive_embedding)), 1) - d_negative = tf.reduce_sum(tf.square(tf.subtract(anchor_embedding, negative_embedding)), 1) + anchor_embedding = tf.nn.l2_normalize( + anchor_embedding, 1, 1e-10, name="anchor") + positive_embedding = tf.nn.l2_normalize( + positive_embedding, 1, 1e-10, name="positive") + negative_embedding = tf.nn.l2_normalize( + negative_embedding, 1, 1e-10, name="negative") + + d_positive = tf.reduce_sum( + tf.square(tf.subtract(anchor_embedding, positive_embedding)), 1) + d_negative = tf.reduce_sum( + tf.square(tf.subtract(anchor_embedding, negative_embedding)), 1) basic_loss = tf.add(tf.subtract(d_positive, d_negative), margin) - loss = tf.reduce_mean(tf.maximum(basic_loss, 0.0), 0, name=tf.GraphKeys.LOSSES) + loss = tf.reduce_mean( + tf.maximum(basic_loss, 0.0), 0, name=tf.GraphKeys.LOSSES) loss_dict = dict() loss_dict['loss'] = loss @@ -102,13 +120,17 @@ def triplet_loss_deprecated(anchor_embedding, positive_embedding, negative_embed return loss_dict -def triplet_fisher_loss(anchor_embedding, positive_embedding, negative_embedding): +def triplet_fisher_loss(anchor_embedding, positive_embedding, + negative_embedding): with tf.name_scope("triplet_loss"): # Normalize - anchor_embedding = tf.nn.l2_normalize(anchor_embedding, 1, 1e-10, name="anchor") - positive_embedding = tf.nn.l2_normalize(positive_embedding, 1, 1e-10, name="positive") - negative_embedding = tf.nn.l2_normalize(negative_embedding, 1, 1e-10, name="negative") + anchor_embedding = tf.nn.l2_normalize( + anchor_embedding, 1, 1e-10, name="anchor") + positive_embedding = tf.nn.l2_normalize( + positive_embedding, 1, 1e-10, name="positive") + negative_embedding = tf.nn.l2_normalize( + negative_embedding, 1, 1e-10, name="negative") average_class = tf.reduce_mean(anchor_embedding, 0) average_total = tf.div(tf.add(tf.reduce_mean(anchor_embedding, axis=0),\ @@ -125,11 +147,15 @@ def triplet_fisher_loss(anchor_embedding, positive_embedding, negative_embedding positive = s[0] negative = s[1] - buffer_sw = tf.reshape(tf.subtract(positive, average_class), shape=(dim, 1)) - buffer_sw = tf.matmul(buffer_sw, tf.reshape(buffer_sw, shape=(1, dim))) + buffer_sw = tf.reshape( + tf.subtract(positive, average_class), shape=(dim, 1)) + buffer_sw = tf.matmul(buffer_sw, + tf.reshape(buffer_sw, shape=(1, dim))) - buffer_sb = tf.reshape(tf.subtract(negative, average_total), shape=(dim, 1)) - buffer_sb = tf.matmul(buffer_sb, tf.reshape(buffer_sb, shape=(1, dim))) + buffer_sb = tf.reshape( + tf.subtract(negative, average_total), shape=(dim, 1)) + buffer_sb = tf.matmul(buffer_sb, + tf.reshape(buffer_sb, shape=(1, dim))) if Sw is None: Sw = buffer_sw @@ -144,9 +170,12 @@ def triplet_fisher_loss(anchor_embedding, positive_embedding, negative_embedding loss = tf.trace(tf.div(Sw, Sb), name=tf.GraphKeys.LOSSES) return loss, tf.trace(Sb), tf.trace(Sw) - - -def triplet_average_loss(anchor_embedding, positive_embedding, negative_embedding, margin=5.0): + + +def triplet_average_loss(anchor_embedding, + positive_embedding, + negative_embedding, + margin=5.0): """ Compute the triplet loss as in @@ -174,28 +203,38 @@ def triplet_average_loss(anchor_embedding, positive_embedding, negative_embeddin with tf.name_scope("triplet_loss"): # Normalize - anchor_embedding = tf.nn.l2_normalize(anchor_embedding, 1, 1e-10, name="anchor") - positive_embedding = tf.nn.l2_normalize(positive_embedding, 1, 1e-10, name="positive") - negative_embedding = tf.nn.l2_normalize(negative_embedding, 1, 1e-10, name="negative") + anchor_embedding = tf.nn.l2_normalize( + anchor_embedding, 1, 1e-10, name="anchor") + positive_embedding = tf.nn.l2_normalize( + positive_embedding, 1, 1e-10, name="positive") + negative_embedding = tf.nn.l2_normalize( + negative_embedding, 1, 1e-10, name="negative") anchor_mean = tf.reduce_mean(anchor_embedding, 0) - d_positive = tf.reduce_sum(tf.square(tf.subtract(anchor_mean, positive_embedding)), 1) - d_negative = tf.reduce_sum(tf.square(tf.subtract(anchor_mean, negative_embedding)), 1) + d_positive = tf.reduce_sum( + tf.square(tf.subtract(anchor_mean, positive_embedding)), 1) + d_negative = tf.reduce_sum( + tf.square(tf.subtract(anchor_mean, negative_embedding)), 1) basic_loss = tf.add(tf.subtract(d_positive, d_negative), margin) - loss = tf.reduce_mean(tf.maximum(basic_loss, 0.0), 0, name=tf.GraphKeys.LOSSES) + loss = tf.reduce_mean( + tf.maximum(basic_loss, 0.0), 0, name=tf.GraphKeys.LOSSES) - return loss, tf.reduce_mean(d_negative), tf.reduce_mean(d_positive) + return loss, tf.reduce_mean(d_negative), tf.reduce_mean(d_positive) -def triplet_fisher_loss(anchor_embedding, positive_embedding, negative_embedding): +def triplet_fisher_loss(anchor_embedding, positive_embedding, + negative_embedding): with tf.name_scope("triplet_loss"): # Normalize - anchor_embedding = tf.nn.l2_normalize(anchor_embedding, 1, 1e-10, name="anchor") - positive_embedding = tf.nn.l2_normalize(positive_embedding, 1, 1e-10, name="positive") - negative_embedding = tf.nn.l2_normalize(negative_embedding, 1, 1e-10, name="negative") + anchor_embedding = tf.nn.l2_normalize( + anchor_embedding, 1, 1e-10, name="anchor") + positive_embedding = tf.nn.l2_normalize( + positive_embedding, 1, 1e-10, name="positive") + negative_embedding = tf.nn.l2_normalize( + negative_embedding, 1, 1e-10, name="negative") average_class = tf.reduce_mean(anchor_embedding, 0) average_total = tf.div(tf.add(tf.reduce_mean(anchor_embedding, axis=0),\ @@ -212,11 +251,15 @@ def triplet_fisher_loss(anchor_embedding, positive_embedding, negative_embedding positive = s[0] negative = s[1] - buffer_sw = tf.reshape(tf.subtract(positive, average_class), shape=(dim, 1)) - buffer_sw = tf.matmul(buffer_sw, tf.reshape(buffer_sw, shape=(1, dim))) + buffer_sw = tf.reshape( + tf.subtract(positive, average_class), shape=(dim, 1)) + buffer_sw = tf.matmul(buffer_sw, + tf.reshape(buffer_sw, shape=(1, dim))) - buffer_sb = tf.reshape(tf.subtract(negative, average_total), shape=(dim, 1)) - buffer_sb = tf.matmul(buffer_sb, tf.reshape(buffer_sb, shape=(1, dim))) + buffer_sb = tf.reshape( + tf.subtract(negative, average_total), shape=(dim, 1)) + buffer_sb = tf.matmul(buffer_sb, + tf.reshape(buffer_sb, shape=(1, dim))) if Sw is None: Sw = buffer_sw @@ -231,4 +274,3 @@ def triplet_fisher_loss(anchor_embedding, positive_embedding, negative_embedding loss = tf.trace(tf.div(Sw, Sb), name=tf.GraphKeys.LOSSES) return loss, tf.trace(Sb), tf.trace(Sw) - diff --git a/bob/learn/tensorflow/loss/__init__.py b/bob/learn/tensorflow/loss/__init__.py index 94b4f281328d39549cf06b42839fb82f09c115b0..a9bea3f05bc719a462ed7d8f79419f504d2fcef3 100644 --- a/bob/learn/tensorflow/loss/__init__.py +++ b/bob/learn/tensorflow/loss/__init__.py @@ -1,12 +1,13 @@ from .BaseLoss import mean_cross_entropy_loss, mean_cross_entropy_center_loss from .ContrastiveLoss import contrastive_loss, contrastive_loss_deprecated from .TripletLoss import triplet_loss, triplet_average_loss, triplet_fisher_loss, triplet_loss_deprecated + #from .NegLogLoss import NegLogLoss # gets sphinx autodoc done right - don't remove it def __appropriate__(*args): - """Says object was actually declared here, an not on the import module. + """Says object was actually declared here, an not on the import module. Parameters: @@ -16,14 +17,11 @@ def __appropriate__(*args): ` """ - for obj in args: obj.__module__ = __name__ - -__appropriate__( - mean_cross_entropy_loss, mean_cross_entropy_center_loss, - contrastive_loss, - triplet_loss, triplet_average_loss, triplet_fisher_loss - ) -__all__ = [_ for _ in dir() if not _.startswith('_')] - + for obj in args: + obj.__module__ = __name__ +__appropriate__(mean_cross_entropy_loss, mean_cross_entropy_center_loss, + contrastive_loss, triplet_loss, triplet_average_loss, + triplet_fisher_loss) +__all__ = [_ for _ in dir() if not _.startswith('_')] diff --git a/bob/learn/tensorflow/network/Chopra.py b/bob/learn/tensorflow/network/Chopra.py index 2a4328f919d89d6f12fda6272e0ce08530072194..a3242e40b3a925cdd5a4a4a228beb1c4726003d6 100644 --- a/bob/learn/tensorflow/network/Chopra.py +++ b/bob/learn/tensorflow/network/Chopra.py @@ -4,19 +4,19 @@ import tensorflow as tf -def chopra(inputs, conv1_kernel_size=[7, 7], - conv1_output=15, - pooling1_size=[2, 2], - - - conv2_kernel_size=[6, 6], - conv2_output=45, - - pooling2_size=[4, 3], - fc1_output=250, - seed=10, - reuse=False,): +def chopra( + inputs, + conv1_kernel_size=[7, 7], + conv1_output=15, + pooling1_size=[2, 2], + conv2_kernel_size=[6, 6], + conv2_output=45, + pooling2_size=[4, 3], + fc1_output=250, + seed=10, + reuse=False, +): """Class that creates the architecture presented in the paper: Chopra, Sumit, Raia Hadsell, and Yann LeCun. "Learning a similarity metric discriminatively, with application to @@ -63,36 +63,47 @@ def chopra(inputs, conv1_kernel_size=[7, 7], slim = tf.contrib.slim end_points = dict() - - initializer = tf.contrib.layers.xavier_initializer(uniform=False, dtype=tf.float32, seed=seed) - - graph = slim.conv2d(inputs, conv1_output, conv1_kernel_size, activation_fn=tf.nn.relu, - stride=1, - weights_initializer=initializer, - scope='conv1', - reuse=reuse) + + initializer = tf.contrib.layers.xavier_initializer( + uniform=False, dtype=tf.float32, seed=seed) + + graph = slim.conv2d( + inputs, + conv1_output, + conv1_kernel_size, + activation_fn=tf.nn.relu, + stride=1, + weights_initializer=initializer, + scope='conv1', + reuse=reuse) end_points['conv1'] = graph - + graph = slim.max_pool2d(graph, pooling1_size, scope='pool1') end_points['pool1'] = graph - graph = slim.conv2d(graph, conv2_output, conv2_kernel_size, activation_fn=tf.nn.relu, - stride=1, - weights_initializer=initializer, - scope='conv2', reuse=reuse) + graph = slim.conv2d( + graph, + conv2_output, + conv2_kernel_size, + activation_fn=tf.nn.relu, + stride=1, + weights_initializer=initializer, + scope='conv2', + reuse=reuse) end_points['conv2'] = graph graph = slim.max_pool2d(graph, pooling2_size, scope='pool2') - end_points['pool2'] = graph + end_points['pool2'] = graph graph = slim.flatten(graph, scope='flatten1') - end_points['flatten1'] = graph - - graph = slim.fully_connected(graph, fc1_output, - weights_initializer=initializer, - activation_fn=None, - scope='fc1', - reuse=reuse) - end_points['fc1'] = graph - - return graph, end_points + end_points['flatten1'] = graph + graph = slim.fully_connected( + graph, + fc1_output, + weights_initializer=initializer, + activation_fn=None, + scope='fc1', + reuse=reuse) + end_points['fc1'] = graph + + return graph, end_points diff --git a/bob/learn/tensorflow/network/Dummy.py b/bob/learn/tensorflow/network/Dummy.py index 374f2aede6d19358d191677922497b60d72abd4f..917f30863a6fffafe6b590b44bdc8d4a785da587 100644 --- a/bob/learn/tensorflow/network/Dummy.py +++ b/bob/learn/tensorflow/network/Dummy.py @@ -6,7 +6,11 @@ import tensorflow as tf from .utils import is_trainable -def dummy(inputs, reuse=False, mode=tf.estimator.ModeKeys.TRAIN, trainable_variables=None, **kwargs): +def dummy(inputs, + reuse=False, + mode=tf.estimator.ModeKeys.TRAIN, + trainable_variables=None, + **kwargs): """ Create all the necessary variables for this CNN @@ -24,31 +28,37 @@ def dummy(inputs, reuse=False, mode=tf.estimator.ModeKeys.TRAIN, trainable_varia slim = tf.contrib.slim end_points = dict() - + # Here is my choice to shutdown the whole scope trainable = is_trainable("Dummy", trainable_variables) with tf.variable_scope('Dummy', reuse=reuse): - + initializer = tf.contrib.layers.xavier_initializer() name = 'conv1' - graph = slim.conv2d(inputs, 10, [3, 3], activation_fn=tf.nn.relu, stride=1, scope=name, - weights_initializer=initializer, - trainable=trainable) + graph = slim.conv2d( + inputs, + 10, [3, 3], + activation_fn=tf.nn.relu, + stride=1, + scope=name, + weights_initializer=initializer, + trainable=trainable) end_points[name] = graph - - graph = slim.max_pool2d(graph, [4, 4], scope='pool1') + + graph = slim.max_pool2d(graph, [4, 4], scope='pool1') end_points['pool1'] = graph - + graph = slim.flatten(graph, scope='flatten1') - end_points['flatten1'] = graph + end_points['flatten1'] = graph name = 'fc1' - graph = slim.fully_connected(graph, 50, - weights_initializer=initializer, - activation_fn=None, - scope=name, - trainable=trainable) + graph = slim.fully_connected( + graph, + 50, + weights_initializer=initializer, + activation_fn=None, + scope=name, + trainable=trainable) end_points[name] = graph return graph, end_points - diff --git a/bob/learn/tensorflow/network/Embedding.py b/bob/learn/tensorflow/network/Embedding.py index b34d196437904541366631eb3359c78d7ceec961..4695a91745f74a03f32d23c82ced771b50156d81 100644 --- a/bob/learn/tensorflow/network/Embedding.py +++ b/bob/learn/tensorflow/network/Embedding.py @@ -1,8 +1,7 @@ #!/usr/bin/env python # vim: set fileencoding=utf-8 : # @author: Tiago de Freitas Pereira -# @date: Wed 11 May 2016 09:39:36 CEST - +# @date: Wed 11 May 2016 09:39:36 CEST import tensorflow as tf from bob.learn.tensorflow.utils.session import Session @@ -19,6 +18,7 @@ class Embedding(object): graph: Embedding graph """ + def __init__(self, inputs, graph, normalizer=None): self.inputs = inputs self.graph = graph diff --git a/bob/learn/tensorflow/network/InceptionResnetV1.py b/bob/learn/tensorflow/network/InceptionResnetV1.py index f5b238275b460bfb9cd7a69c3bbc215381561cb4..3ff4259dc1690201cdefbdccac8af39a2557f47f 100644 --- a/bob/learn/tensorflow/network/InceptionResnetV1.py +++ b/bob/learn/tensorflow/network/InceptionResnetV1.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================== - """Contains the definition of the Inception Resnet V1 architecture. As described in http://arxiv.org/abs/1602.07261. Inception-v4, Inception-ResNet and the Impact of Residual Connections @@ -28,21 +27,58 @@ import tensorflow.contrib.slim as slim # Inception-Renset-A -def block35(net, scale=1.0, activation_fn=tf.nn.relu, scope=None, reuse=None, trainable_variables=True): +def block35(net, + scale=1.0, + activation_fn=tf.nn.relu, + scope=None, + reuse=None, + trainable_variables=True): """Builds the 35x35 resnet block.""" with tf.variable_scope(scope, 'Block35', [net], reuse=reuse): with tf.variable_scope('Branch_0'): - tower_conv = slim.conv2d(net, 32, 1, scope='Conv2d_1x1', trainable=trainable_variables) + tower_conv = slim.conv2d( + net, 32, 1, scope='Conv2d_1x1', trainable=trainable_variables) with tf.variable_scope('Branch_1'): - tower_conv1_0 = slim.conv2d(net, 32, 1, scope='Conv2d_0a_1x1', trainable=trainable_variables) - tower_conv1_1 = slim.conv2d(tower_conv1_0, 32, 3, scope='Conv2d_0b_3x3', trainable=trainable_variables) + tower_conv1_0 = slim.conv2d( + net, + 32, + 1, + scope='Conv2d_0a_1x1', + trainable=trainable_variables) + tower_conv1_1 = slim.conv2d( + tower_conv1_0, + 32, + 3, + scope='Conv2d_0b_3x3', + trainable=trainable_variables) with tf.variable_scope('Branch_2'): - tower_conv2_0 = slim.conv2d(net, 32, 1, scope='Conv2d_0a_1x1', trainable=trainable_variables) - tower_conv2_1 = slim.conv2d(tower_conv2_0, 32, 3, scope='Conv2d_0b_3x3', trainable=trainable_variables) - tower_conv2_2 = slim.conv2d(tower_conv2_1, 32, 3, scope='Conv2d_0c_3x3', trainable=trainable_variables) + tower_conv2_0 = slim.conv2d( + net, + 32, + 1, + scope='Conv2d_0a_1x1', + trainable=trainable_variables) + tower_conv2_1 = slim.conv2d( + tower_conv2_0, + 32, + 3, + scope='Conv2d_0b_3x3', + trainable=trainable_variables) + tower_conv2_2 = slim.conv2d( + tower_conv2_1, + 32, + 3, + scope='Conv2d_0c_3x3', + trainable=trainable_variables) mixed = tf.concat([tower_conv, tower_conv1_1, tower_conv2_2], 3) - up = slim.conv2d(mixed, net.get_shape()[3], 1, normalizer_fn=None, - activation_fn=None, scope='Conv2d_1x1', trainable=trainable_variables) + up = slim.conv2d( + mixed, + net.get_shape()[3], + 1, + normalizer_fn=None, + activation_fn=None, + scope='Conv2d_1x1', + trainable=trainable_variables) net += scale * up if activation_fn: net = activation_fn(net) @@ -50,20 +86,43 @@ def block35(net, scale=1.0, activation_fn=tf.nn.relu, scope=None, reuse=None, tr # Inception-Renset-B -def block17(net, scale=1.0, activation_fn=tf.nn.relu, scope=None, reuse=None, trainable_variables=True): +def block17(net, + scale=1.0, + activation_fn=tf.nn.relu, + scope=None, + reuse=None, + trainable_variables=True): """Builds the 17x17 resnet block.""" with tf.variable_scope(scope, 'Block17', [net], reuse=reuse): with tf.variable_scope('Branch_0'): - tower_conv = slim.conv2d(net, 128, 1, scope='Conv2d_1x1', trainable=trainable_variables) + tower_conv = slim.conv2d( + net, 128, 1, scope='Conv2d_1x1', trainable=trainable_variables) with tf.variable_scope('Branch_1'): - tower_conv1_0 = slim.conv2d(net, 128, 1, scope='Conv2d_0a_1x1', trainable=trainable_variables) - tower_conv1_1 = slim.conv2d(tower_conv1_0, 128, [1, 7], - scope='Conv2d_0b_1x7', trainable=trainable_variables) - tower_conv1_2 = slim.conv2d(tower_conv1_1, 128, [7, 1], - scope='Conv2d_0c_7x1', trainable=trainable_variables) + tower_conv1_0 = slim.conv2d( + net, + 128, + 1, + scope='Conv2d_0a_1x1', + trainable=trainable_variables) + tower_conv1_1 = slim.conv2d( + tower_conv1_0, + 128, [1, 7], + scope='Conv2d_0b_1x7', + trainable=trainable_variables) + tower_conv1_2 = slim.conv2d( + tower_conv1_1, + 128, [7, 1], + scope='Conv2d_0c_7x1', + trainable=trainable_variables) mixed = tf.concat([tower_conv, tower_conv1_2], 3) - up = slim.conv2d(mixed, net.get_shape()[3], 1, normalizer_fn=None, - activation_fn=None, scope='Conv2d_1x1', trainable=trainable_variables) + up = slim.conv2d( + mixed, + net.get_shape()[3], + 1, + normalizer_fn=None, + activation_fn=None, + scope='Conv2d_1x1', + trainable=trainable_variables) net += scale * up if activation_fn: net = activation_fn(net) @@ -71,20 +130,43 @@ def block17(net, scale=1.0, activation_fn=tf.nn.relu, scope=None, reuse=None, tr # Inception-Resnet-C -def block8(net, scale=1.0, activation_fn=tf.nn.relu, scope=None, reuse=None, trainable_variables=True): +def block8(net, + scale=1.0, + activation_fn=tf.nn.relu, + scope=None, + reuse=None, + trainable_variables=True): """Builds the 8x8 resnet block.""" with tf.variable_scope(scope, 'Block8', [net], reuse=reuse): with tf.variable_scope('Branch_0'): - tower_conv = slim.conv2d(net, 192, 1, scope='Conv2d_1x1', trainable=trainable_variables) + tower_conv = slim.conv2d( + net, 192, 1, scope='Conv2d_1x1', trainable=trainable_variables) with tf.variable_scope('Branch_1'): - tower_conv1_0 = slim.conv2d(net, 192, 1, scope='Conv2d_0a_1x1', trainable=trainable_variables) - tower_conv1_1 = slim.conv2d(tower_conv1_0, 192, [1, 3], - scope='Conv2d_0b_1x3', trainable=trainable_variables) - tower_conv1_2 = slim.conv2d(tower_conv1_1, 192, [3, 1], - scope='Conv2d_0c_3x1', trainable=trainable_variables) + tower_conv1_0 = slim.conv2d( + net, + 192, + 1, + scope='Conv2d_0a_1x1', + trainable=trainable_variables) + tower_conv1_1 = slim.conv2d( + tower_conv1_0, + 192, [1, 3], + scope='Conv2d_0b_1x3', + trainable=trainable_variables) + tower_conv1_2 = slim.conv2d( + tower_conv1_1, + 192, [3, 1], + scope='Conv2d_0c_3x1', + trainable=trainable_variables) mixed = tf.concat([tower_conv, tower_conv1_2], 3) - up = slim.conv2d(mixed, net.get_shape()[3], 1, normalizer_fn=None, - activation_fn=None, scope='Conv2d_1x1', trainable=trainable_variables) + up = slim.conv2d( + mixed, + net.get_shape()[3], + 1, + normalizer_fn=None, + activation_fn=None, + scope='Conv2d_1x1', + trainable=trainable_variables) net += scale * up if activation_fn: net = activation_fn(net) @@ -93,47 +175,92 @@ def block8(net, scale=1.0, activation_fn=tf.nn.relu, scope=None, reuse=None, tra def reduction_a(net, k, l, m, n, trainable_variables=True, reuse=None): with tf.variable_scope('Branch_0', reuse=reuse): - tower_conv = slim.conv2d(net, n, 3, stride=2, padding='VALID', - scope='Conv2d_1a_3x3', trainable=trainable_variables) + tower_conv = slim.conv2d( + net, + n, + 3, + stride=2, + padding='VALID', + scope='Conv2d_1a_3x3', + trainable=trainable_variables) with tf.variable_scope('Branch_1', reuse=reuse): - tower_conv1_0 = slim.conv2d(net, k, 1, scope='Conv2d_0a_1x1', trainable=trainable_variables) - tower_conv1_1 = slim.conv2d(tower_conv1_0, l, 3, - scope='Conv2d_0b_3x3', trainable=trainable_variables) - tower_conv1_2 = slim.conv2d(tower_conv1_1, m, 3, - stride=2, padding='VALID', - scope='Conv2d_1a_3x3', trainable=trainable_variables) + tower_conv1_0 = slim.conv2d( + net, k, 1, scope='Conv2d_0a_1x1', trainable=trainable_variables) + tower_conv1_1 = slim.conv2d( + tower_conv1_0, + l, + 3, + scope='Conv2d_0b_3x3', + trainable=trainable_variables) + tower_conv1_2 = slim.conv2d( + tower_conv1_1, + m, + 3, + stride=2, + padding='VALID', + scope='Conv2d_1a_3x3', + trainable=trainable_variables) with tf.variable_scope('Branch_2', reuse=reuse): - tower_pool = slim.max_pool2d(net, 3, stride=2, padding='VALID', - scope='MaxPool_1a_3x3') + tower_pool = slim.max_pool2d( + net, 3, stride=2, padding='VALID', scope='MaxPool_1a_3x3') net = tf.concat([tower_conv, tower_conv1_2, tower_pool], 3) return net def reduction_b(net, reuse=None, trainable_variables=True): with tf.variable_scope('Branch_0', reuse=reuse): - tower_conv = slim.conv2d(net, 256, 1, scope='Conv2d_0a_1x1', trainable=trainable_variables) - tower_conv_1 = slim.conv2d(tower_conv, 384, 3, stride=2, - padding='VALID', scope='Conv2d_1a_3x3', trainable=trainable_variables) + tower_conv = slim.conv2d( + net, 256, 1, scope='Conv2d_0a_1x1', trainable=trainable_variables) + tower_conv_1 = slim.conv2d( + tower_conv, + 384, + 3, + stride=2, + padding='VALID', + scope='Conv2d_1a_3x3', + trainable=trainable_variables) with tf.variable_scope('Branch_1', reuse=reuse): - tower_conv1 = slim.conv2d(net, 256, 1, scope='Conv2d_0a_1x1', trainable=trainable_variables) - tower_conv1_1 = slim.conv2d(tower_conv1, 256, 3, stride=2, - padding='VALID', scope='Conv2d_1a_3x3', trainable=trainable_variables) + tower_conv1 = slim.conv2d( + net, 256, 1, scope='Conv2d_0a_1x1', trainable=trainable_variables) + tower_conv1_1 = slim.conv2d( + tower_conv1, + 256, + 3, + stride=2, + padding='VALID', + scope='Conv2d_1a_3x3', + trainable=trainable_variables) with tf.variable_scope('Branch_2', reuse=reuse): - tower_conv2 = slim.conv2d(net, 256, 1, scope='Conv2d_0a_1x1', trainable=trainable_variables) - tower_conv2_1 = slim.conv2d(tower_conv2, 256, 3, - scope='Conv2d_0b_3x3', trainable=trainable_variables) - tower_conv2_2 = slim.conv2d(tower_conv2_1, 256, 3, stride=2, - padding='VALID', scope='Conv2d_1a_3x3', trainable=trainable_variables) + tower_conv2 = slim.conv2d( + net, 256, 1, scope='Conv2d_0a_1x1', trainable=trainable_variables) + tower_conv2_1 = slim.conv2d( + tower_conv2, + 256, + 3, + scope='Conv2d_0b_3x3', + trainable=trainable_variables) + tower_conv2_2 = slim.conv2d( + tower_conv2_1, + 256, + 3, + stride=2, + padding='VALID', + scope='Conv2d_1a_3x3', + trainable=trainable_variables) with tf.variable_scope('Branch_3', reuse=reuse): - tower_pool = slim.max_pool2d(net, 3, stride=2, padding='VALID', - scope='MaxPool_1a_3x3') - net = tf.concat([tower_conv_1, tower_conv1_1, - tower_conv2_2, tower_pool], 3) + tower_pool = slim.max_pool2d( + net, 3, stride=2, padding='VALID', scope='MaxPool_1a_3x3') + net = tf.concat([tower_conv_1, tower_conv1_1, tower_conv2_2, tower_pool], + 3) return net -def inference(images, keep_probability, phase_train=True, - bottleneck_layer_size=128, weight_decay=0.0, reuse=None): +def inference(images, + keep_probability, + phase_train=True, + bottleneck_layer_size=128, + weight_decay=0.0, + reuse=None): batch_norm_params = { # Decay for the moving averages. 'decay': 0.995, @@ -142,27 +269,31 @@ def inference(images, keep_probability, phase_train=True, # force in-place updates of mean and variance estimates 'updates_collections': None, # Moving averages ends up in the trainable variables collection - 'variables_collections': [ tf.GraphKeys.TRAINABLE_VARIABLES ], + 'variables_collections': [tf.GraphKeys.TRAINABLE_VARIABLES], } - - with slim.arg_scope([slim.conv2d, slim.fully_connected], - weights_initializer=tf.truncated_normal_initializer(stddev=0.1), - weights_regularizer=slim.l2_regularizer(weight_decay), - normalizer_fn=slim.batch_norm, - normalizer_params=batch_norm_params): - return inception_resnet_v1(images, is_training=phase_train, - dropout_keep_prob=keep_probability, - bottleneck_layer_size=bottleneck_layer_size, - reuse=reuse) + + with slim.arg_scope( + [slim.conv2d, slim.fully_connected], + weights_initializer=tf.truncated_normal_initializer(stddev=0.1), + weights_regularizer=slim.l2_regularizer(weight_decay), + normalizer_fn=slim.batch_norm, + normalizer_params=batch_norm_params): + return inception_resnet_v1( + images, + is_training=phase_train, + dropout_keep_prob=keep_probability, + bottleneck_layer_size=bottleneck_layer_size, + reuse=reuse) def inception_resnet_v1(inputs, dropout_keep_prob=0.8, bottleneck_layer_size=128, - reuse=None, + reuse=None, scope='InceptionResnetV1', mode=tf.estimator.ModeKeys.TRAIN, - trainable_variables=True, **kwargs): + trainable_variables=True, + **kwargs): """ Creates the Inception Resnet V1 model. @@ -182,80 +313,157 @@ def inception_resnet_v1(inputs, Optional variable_scope. """ end_points = {} - + with tf.variable_scope(scope, 'InceptionResnetV1', [inputs], reuse=reuse): - with slim.arg_scope([slim.batch_norm, slim.dropout], - is_training=(mode == tf.estimator.ModeKeys.TRAIN)): - with slim.arg_scope([slim.conv2d, slim.max_pool2d, slim.avg_pool2d], - stride=1, padding='SAME'): - + with slim.arg_scope( + [slim.batch_norm, slim.dropout], + is_training=(mode == tf.estimator.ModeKeys.TRAIN)): + with slim.arg_scope( + [slim.conv2d, slim.max_pool2d, slim.avg_pool2d], + stride=1, + padding='SAME'): + # 149 x 149 x 32 - net = slim.conv2d(inputs, 32, 3, stride=2, padding='VALID', - scope='Conv2d_1a_3x3', trainable=trainable_variables) + net = slim.conv2d( + inputs, + 32, + 3, + stride=2, + padding='VALID', + scope='Conv2d_1a_3x3', + trainable=trainable_variables) end_points['Conv2d_1a_3x3'] = net # 147 x 147 x 32 - net = slim.conv2d(net, 32, 3, padding='VALID', - scope='Conv2d_2a_3x3', trainable=trainable_variables) + net = slim.conv2d( + net, + 32, + 3, + padding='VALID', + scope='Conv2d_2a_3x3', + trainable=trainable_variables) end_points['Conv2d_2a_3x3'] = net # 147 x 147 x 64 - net = slim.conv2d(net, 64, 3, scope='Conv2d_2b_3x3', trainable=trainable_variables) + net = slim.conv2d( + net, + 64, + 3, + scope='Conv2d_2b_3x3', + trainable=trainable_variables) end_points['Conv2d_2b_3x3'] = net # 73 x 73 x 64 - net = slim.max_pool2d(net, 3, stride=2, padding='VALID', - scope='MaxPool_3a_3x3') + net = slim.max_pool2d( + net, 3, stride=2, padding='VALID', scope='MaxPool_3a_3x3') end_points['MaxPool_3a_3x3'] = net # 73 x 73 x 80 - net = slim.conv2d(net, 80, 1, padding='VALID', - scope='Conv2d_3b_1x1', trainable=trainable_variables) + net = slim.conv2d( + net, + 80, + 1, + padding='VALID', + scope='Conv2d_3b_1x1', + trainable=trainable_variables) end_points['Conv2d_3b_1x1'] = net # 71 x 71 x 192 - net = slim.conv2d(net, 192, 3, padding='VALID', - scope='Conv2d_4a_3x3', trainable=trainable_variables) + net = slim.conv2d( + net, + 192, + 3, + padding='VALID', + scope='Conv2d_4a_3x3', + trainable=trainable_variables) end_points['Conv2d_4a_3x3'] = net # 35 x 35 x 256 - net = slim.conv2d(net, 256, 3, stride=2, padding='VALID', - scope='Conv2d_4b_3x3', trainable=trainable_variables) + net = slim.conv2d( + net, + 256, + 3, + stride=2, + padding='VALID', + scope='Conv2d_4b_3x3', + trainable=trainable_variables) end_points['Conv2d_4b_3x3'] = net - + # 5 x Inception-resnet-A - net = slim.repeat(net, 5, block35, scale=0.17, trainable_variables=trainable_variables, reuse=reuse) + net = slim.repeat( + net, + 5, + block35, + scale=0.17, + trainable_variables=trainable_variables, + reuse=reuse) end_points['Mixed_5a'] = net - + # Reduction-A with tf.variable_scope('Mixed_6a'): - net = reduction_a(net, 192, 192, 256, 384, trainable_variables=trainable_variables, reuse=reuse) + net = reduction_a( + net, + 192, + 192, + 256, + 384, + trainable_variables=trainable_variables, + reuse=reuse) end_points['Mixed_6a'] = net - + # 10 x Inception-Resnet-B - net = slim.repeat(net, 10, block17, scale=0.10, trainable_variables=trainable_variables, reuse=reuse) + net = slim.repeat( + net, + 10, + block17, + scale=0.10, + trainable_variables=trainable_variables, + reuse=reuse) end_points['Mixed_6b'] = net - + # Reduction-B with tf.variable_scope('Mixed_7a'): - net = reduction_b(net, trainable_variables=trainable_variables, reuse=reuse) + net = reduction_b( + net, + trainable_variables=trainable_variables, + reuse=reuse) end_points['Mixed_7a'] = net - + # 5 x Inception-Resnet-C - net = slim.repeat(net, 5, block8, scale=0.20, trainable_variables=trainable_variables, reuse=reuse) + net = slim.repeat( + net, + 5, + block8, + scale=0.20, + trainable_variables=trainable_variables, + reuse=reuse) end_points['Mixed_8a'] = net - - net = block8(net, activation_fn=None, trainable_variables=trainable_variables, reuse=reuse) + + net = block8( + net, + activation_fn=None, + trainable_variables=trainable_variables, + reuse=reuse) end_points['Mixed_8b'] = net - + with tf.variable_scope('Logits'): end_points['PrePool'] = net #pylint: disable=no-member - net = slim.avg_pool2d(net, net.get_shape()[1:3], padding='VALID', - scope='AvgPool_1a_8x8') + net = slim.avg_pool2d( + net, + net.get_shape()[1:3], + padding='VALID', + scope='AvgPool_1a_8x8') net = slim.flatten(net) - - net = slim.dropout(net, dropout_keep_prob, is_training=(mode == tf.estimator.ModeKeys.TRAIN), - scope='Dropout') - + + net = slim.dropout( + net, + dropout_keep_prob, + is_training=(mode == tf.estimator.ModeKeys.TRAIN), + scope='Dropout') + end_points['PreLogitsFlatten'] = net - - net = slim.fully_connected(net, bottleneck_layer_size, activation_fn=None, - scope='Bottleneck', - reuse=reuse, trainable=trainable_variables) - + + net = slim.fully_connected( + net, + bottleneck_layer_size, + activation_fn=None, + scope='Bottleneck', + reuse=reuse, + trainable=trainable_variables) + return net, end_points diff --git a/bob/learn/tensorflow/network/InceptionResnetV2.py b/bob/learn/tensorflow/network/InceptionResnetV2.py index b2427a07b2b6a09f3371252ac32cf7bda593ce64..aa5ea67f86de8b8e597465b79baf85ef3d06a482 100644 --- a/bob/learn/tensorflow/network/InceptionResnetV2.py +++ b/bob/learn/tensorflow/network/InceptionResnetV2.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================== - """Contains the definition of the Inception Resnet V2 architecture. As described in http://arxiv.org/abs/1602.07261. Inception-v4, Inception-ResNet and the Impact of Residual Connections @@ -29,24 +28,69 @@ from .utils import is_trainable # Inception-Renset-A -def block35(net, scale=1.0, activation_fn=tf.nn.relu, scope=None, reuse=None, trainable_variables=True): +def block35(net, + scale=1.0, + activation_fn=tf.nn.relu, + scope=None, + reuse=None, + trainable_variables=True): """Builds the 35x35 resnet block.""" with tf.variable_scope(scope, 'Block35', [net]): with tf.variable_scope('Branch_0'): - tower_conv = slim.conv2d(net, 32, 1, scope='Conv2d_1x1', trainable=trainable_variables, reuse=reuse) + tower_conv = slim.conv2d( + net, + 32, + 1, + scope='Conv2d_1x1', + trainable=trainable_variables, + reuse=reuse) with tf.variable_scope('Branch_1'): - tower_conv1_0 = slim.conv2d(net, 32, 1, scope='Conv2d_0a_1x1', trainable=trainable_variables, reuse=reuse) - tower_conv1_1 = slim.conv2d(tower_conv1_0, 32, 3, scope='Conv2d_0b_3x3', trainable=trainable_variables, - reuse=reuse) + tower_conv1_0 = slim.conv2d( + net, + 32, + 1, + scope='Conv2d_0a_1x1', + trainable=trainable_variables, + reuse=reuse) + tower_conv1_1 = slim.conv2d( + tower_conv1_0, + 32, + 3, + scope='Conv2d_0b_3x3', + trainable=trainable_variables, + reuse=reuse) with tf.variable_scope('Branch_2'): - tower_conv2_0 = slim.conv2d(net, 32, 1, scope='Conv2d_0a_1x1', trainable=trainable_variables, reuse=reuse) - tower_conv2_1 = slim.conv2d(tower_conv2_0, 48, 3, scope='Conv2d_0b_3x3', trainable=trainable_variables, - reuse=reuse) - tower_conv2_2 = slim.conv2d(tower_conv2_1, 64, 3, scope='Conv2d_0c_3x3', trainable=trainable_variables, - reuse=reuse) + tower_conv2_0 = slim.conv2d( + net, + 32, + 1, + scope='Conv2d_0a_1x1', + trainable=trainable_variables, + reuse=reuse) + tower_conv2_1 = slim.conv2d( + tower_conv2_0, + 48, + 3, + scope='Conv2d_0b_3x3', + trainable=trainable_variables, + reuse=reuse) + tower_conv2_2 = slim.conv2d( + tower_conv2_1, + 64, + 3, + scope='Conv2d_0c_3x3', + trainable=trainable_variables, + reuse=reuse) mixed = tf.concat([tower_conv, tower_conv1_1, tower_conv2_2], 3) - up = slim.conv2d(mixed, net.get_shape()[3], 1, normalizer_fn=None, - activation_fn=None, scope='Conv2d_1x1', trainable=trainable_variables, reuse=reuse) + up = slim.conv2d( + mixed, + net.get_shape()[3], + 1, + normalizer_fn=None, + activation_fn=None, + scope='Conv2d_1x1', + trainable=trainable_variables, + reuse=reuse) net += scale * up if activation_fn: net = activation_fn(net) @@ -54,20 +98,52 @@ def block35(net, scale=1.0, activation_fn=tf.nn.relu, scope=None, reuse=None, tr # Inception-Renset-B -def block17(net, scale=1.0, activation_fn=tf.nn.relu, scope=None, reuse=None, trainable_variables=True): +def block17(net, + scale=1.0, + activation_fn=tf.nn.relu, + scope=None, + reuse=None, + trainable_variables=True): """Builds the 17x17 resnet block.""" with tf.variable_scope(scope, 'Block17', [net]): with tf.variable_scope('Branch_0'): - tower_conv = slim.conv2d(net, 192, 1, scope='Conv2d_1x1', trainable=trainable_variables, reuse=reuse) + tower_conv = slim.conv2d( + net, + 192, + 1, + scope='Conv2d_1x1', + trainable=trainable_variables, + reuse=reuse) with tf.variable_scope('Branch_1'): - tower_conv1_0 = slim.conv2d(net, 128, 1, scope='Conv2d_0a_1x1', trainable=trainable_variables, reuse=reuse) - tower_conv1_1 = slim.conv2d(tower_conv1_0, 160, [1, 7], - scope='Conv2d_0b_1x7', trainable=trainable_variables, reuse=reuse) - tower_conv1_2 = slim.conv2d(tower_conv1_1, 192, [7, 1], - scope='Conv2d_0c_7x1', trainable=trainable_variables, reuse=reuse) + tower_conv1_0 = slim.conv2d( + net, + 128, + 1, + scope='Conv2d_0a_1x1', + trainable=trainable_variables, + reuse=reuse) + tower_conv1_1 = slim.conv2d( + tower_conv1_0, + 160, [1, 7], + scope='Conv2d_0b_1x7', + trainable=trainable_variables, + reuse=reuse) + tower_conv1_2 = slim.conv2d( + tower_conv1_1, + 192, [7, 1], + scope='Conv2d_0c_7x1', + trainable=trainable_variables, + reuse=reuse) mixed = tf.concat([tower_conv, tower_conv1_2], 3) - up = slim.conv2d(mixed, net.get_shape()[3], 1, normalizer_fn=None, - activation_fn=None, scope='Conv2d_1x1', trainable=trainable_variables, reuse=reuse) + up = slim.conv2d( + mixed, + net.get_shape()[3], + 1, + normalizer_fn=None, + activation_fn=None, + scope='Conv2d_1x1', + trainable=trainable_variables, + reuse=reuse) net += scale * up if activation_fn: net = activation_fn(net) @@ -75,28 +151,63 @@ def block17(net, scale=1.0, activation_fn=tf.nn.relu, scope=None, reuse=None, tr # Inception-Resnet-C -def block8(net, scale=1.0, activation_fn=tf.nn.relu, scope=None, reuse=None, trainable_variables=True): +def block8(net, + scale=1.0, + activation_fn=tf.nn.relu, + scope=None, + reuse=None, + trainable_variables=True): """Builds the 8x8 resnet block.""" with tf.variable_scope(scope, 'Block8', [net]): with tf.variable_scope('Branch_0'): - tower_conv = slim.conv2d(net, 192, 1, scope='Conv2d_1x1', trainable=trainable_variables, reuse=reuse) + tower_conv = slim.conv2d( + net, + 192, + 1, + scope='Conv2d_1x1', + trainable=trainable_variables, + reuse=reuse) with tf.variable_scope('Branch_1'): - tower_conv1_0 = slim.conv2d(net, 192, 1, scope='Conv2d_0a_1x1', trainable=trainable_variables, reuse=reuse) - tower_conv1_1 = slim.conv2d(tower_conv1_0, 224, [1, 3], - scope='Conv2d_0b_1x3', trainable=trainable_variables, reuse=reuse) - tower_conv1_2 = slim.conv2d(tower_conv1_1, 256, [3, 1], - scope='Conv2d_0c_3x1', trainable=trainable_variables, reuse=reuse) + tower_conv1_0 = slim.conv2d( + net, + 192, + 1, + scope='Conv2d_0a_1x1', + trainable=trainable_variables, + reuse=reuse) + tower_conv1_1 = slim.conv2d( + tower_conv1_0, + 224, [1, 3], + scope='Conv2d_0b_1x3', + trainable=trainable_variables, + reuse=reuse) + tower_conv1_2 = slim.conv2d( + tower_conv1_1, + 256, [3, 1], + scope='Conv2d_0c_3x1', + trainable=trainable_variables, + reuse=reuse) mixed = tf.concat([tower_conv, tower_conv1_2], 3) - up = slim.conv2d(mixed, net.get_shape()[3], 1, normalizer_fn=None, - activation_fn=None, scope='Conv2d_1x1', trainable=trainable_variables, reuse=reuse) + up = slim.conv2d( + mixed, + net.get_shape()[3], + 1, + normalizer_fn=None, + activation_fn=None, + scope='Conv2d_1x1', + trainable=trainable_variables, + reuse=reuse) net += scale * up if activation_fn: net = activation_fn(net) return net -def inference(images, keep_probability, - bottleneck_layer_size=128, weight_decay=0.0, reuse=None): +def inference(images, + keep_probability, + bottleneck_layer_size=128, + weight_decay=0.0, + reuse=None): batch_norm_params = { # Decay for the moving averages. 'decay': 0.995, @@ -107,14 +218,18 @@ def inference(images, keep_probability, # Moving averages ends up in the trainable variables collection 'variables_collections': [tf.GraphKeys.TRAINABLE_VARIABLES], } - with slim.arg_scope([slim.conv2d, slim.fully_connected], - weights_initializer=tf.truncated_normal_initializer(stddev=0.1), - weights_regularizer=slim.l2_regularizer(weight_decay), - normalizer_fn=slim.batch_norm, - normalizer_params=batch_norm_params): - return inception_resnet_v2(images, mode=tf.estimator.ModeKeys.PREDICT, - dropout_keep_prob=keep_probability, - bottleneck_layer_size=bottleneck_layer_size, reuse=reuse) + with slim.arg_scope( + [slim.conv2d, slim.fully_connected], + weights_initializer=tf.truncated_normal_initializer(stddev=0.1), + weights_regularizer=slim.l2_regularizer(weight_decay), + normalizer_fn=slim.batch_norm, + normalizer_params=batch_norm_params): + return inception_resnet_v2( + images, + mode=tf.estimator.ModeKeys.PREDICT, + dropout_keep_prob=keep_probability, + bottleneck_layer_size=bottleneck_layer_size, + reuse=reuse) def inception_resnet_v2(inputs, @@ -152,52 +267,81 @@ def inception_resnet_v2(inputs, """ end_points = {} with tf.variable_scope(scope, 'InceptionResnetV2', [inputs], reuse=reuse): - with slim.arg_scope([slim.batch_norm, slim.dropout], - is_training=(mode == tf.estimator.ModeKeys.TRAIN)): - with slim.arg_scope([slim.conv2d, slim.max_pool2d, slim.avg_pool2d], - stride=1, padding='SAME'): + with slim.arg_scope( + [slim.batch_norm, slim.dropout], + is_training=(mode == tf.estimator.ModeKeys.TRAIN)): + with slim.arg_scope( + [slim.conv2d, slim.max_pool2d, slim.avg_pool2d], + stride=1, + padding='SAME'): # 149 x 149 x 32 name = "Conv2d_1a_3x3" trainable = is_trainable(name, trainable_variables) - net = slim.conv2d(inputs, 32, 3, stride=2, padding='VALID', - scope=name, trainable=trainable, reuse=reuse) + net = slim.conv2d( + inputs, + 32, + 3, + stride=2, + padding='VALID', + scope=name, + trainable=trainable, + reuse=reuse) end_points[name] = net # 147 x 147 x 32 name = "Conv2d_2a_3x3" trainable = is_trainable(name, trainable_variables) - net = slim.conv2d(net, 32, 3, padding='VALID', - scope=name, trainable=trainable, reuse=reuse) + net = slim.conv2d( + net, + 32, + 3, + padding='VALID', + scope=name, + trainable=trainable, + reuse=reuse) end_points[name] = net # 147 x 147 x 64 name = "Conv2d_2b_3x3" trainable = is_trainable(name, trainable_variables) - net = slim.conv2d(net, 64, 3, scope=name, trainable=trainable, reuse=reuse) + net = slim.conv2d( + net, 64, 3, scope=name, trainable=trainable, reuse=reuse) end_points[name] = net # 73 x 73 x 64 - net = slim.max_pool2d(net, 3, stride=2, padding='VALID', - scope='MaxPool_3a_3x3') + net = slim.max_pool2d( + net, 3, stride=2, padding='VALID', scope='MaxPool_3a_3x3') end_points['MaxPool_3a_3x3'] = net # 73 x 73 x 80 name = "Conv2d_3b_1x1" trainable = is_trainable(name, trainable_variables) - net = slim.conv2d(net, 80, 1, padding='VALID', - scope=name, trainable=trainable, reuse=reuse) + net = slim.conv2d( + net, + 80, + 1, + padding='VALID', + scope=name, + trainable=trainable, + reuse=reuse) end_points[name] = net # 71 x 71 x 192 name = "Conv2d_4a_3x3" trainable = is_trainable(name, trainable_variables) - net = slim.conv2d(net, 192, 3, padding='VALID', - scope=name, trainable=trainable, reuse=reuse) + net = slim.conv2d( + net, + 192, + 3, + padding='VALID', + scope=name, + trainable=trainable, + reuse=reuse) end_points[name] = net # 35 x 35 x 192 - net = slim.max_pool2d(net, 3, stride=2, padding='VALID', - scope='MaxPool_5a_3x3') + net = slim.max_pool2d( + net, 3, stride=2, padding='VALID', scope='MaxPool_5a_3x3') end_points['MaxPool_5a_3x3'] = net # 35 x 35 x 320 @@ -205,49 +349,125 @@ def inception_resnet_v2(inputs, trainable = is_trainable(name, trainable_variables) with tf.variable_scope(name): with tf.variable_scope('Branch_0'): - tower_conv = slim.conv2d(net, 96, 1, scope='Conv2d_1x1', trainable=trainable, reuse=reuse) + tower_conv = slim.conv2d( + net, + 96, + 1, + scope='Conv2d_1x1', + trainable=trainable, + reuse=reuse) with tf.variable_scope('Branch_1'): - tower_conv1_0 = slim.conv2d(net, 48, 1, scope='Conv2d_0a_1x1', trainable=trainable, reuse=reuse) - tower_conv1_1 = slim.conv2d(tower_conv1_0, 64, 5, - scope='Conv2d_0b_5x5', trainable=trainable, reuse=reuse) + tower_conv1_0 = slim.conv2d( + net, + 48, + 1, + scope='Conv2d_0a_1x1', + trainable=trainable, + reuse=reuse) + tower_conv1_1 = slim.conv2d( + tower_conv1_0, + 64, + 5, + scope='Conv2d_0b_5x5', + trainable=trainable, + reuse=reuse) with tf.variable_scope('Branch_2'): - tower_conv2_0 = slim.conv2d(net, 64, 1, scope='Conv2d_0a_1x1', trainable=trainable, reuse=reuse) - tower_conv2_1 = slim.conv2d(tower_conv2_0, 96, 3, - scope='Conv2d_0b_3x3', trainable=trainable, reuse=reuse) - tower_conv2_2 = slim.conv2d(tower_conv2_1, 96, 3, - scope='Conv2d_0c_3x3', trainable=trainable, reuse=reuse) + tower_conv2_0 = slim.conv2d( + net, + 64, + 1, + scope='Conv2d_0a_1x1', + trainable=trainable, + reuse=reuse) + tower_conv2_1 = slim.conv2d( + tower_conv2_0, + 96, + 3, + scope='Conv2d_0b_3x3', + trainable=trainable, + reuse=reuse) + tower_conv2_2 = slim.conv2d( + tower_conv2_1, + 96, + 3, + scope='Conv2d_0c_3x3', + trainable=trainable, + reuse=reuse) with tf.variable_scope('Branch_3'): - tower_pool = slim.avg_pool2d(net, 3, stride=1, padding='SAME', - scope='AvgPool_0a_3x3') - tower_pool_1 = slim.conv2d(tower_pool, 64, 1, - scope='Conv2d_0b_1x1', trainable=trainable, reuse=reuse) - net = tf.concat([tower_conv, tower_conv1_1, - tower_conv2_2, tower_pool_1], 3) + tower_pool = slim.avg_pool2d( + net, + 3, + stride=1, + padding='SAME', + scope='AvgPool_0a_3x3') + tower_pool_1 = slim.conv2d( + tower_pool, + 64, + 1, + scope='Conv2d_0b_1x1', + trainable=trainable, + reuse=reuse) + net = tf.concat([ + tower_conv, tower_conv1_1, tower_conv2_2, tower_pool_1 + ], 3) end_points[name] = net # BLOCK 35 name = "Block35" trainable = is_trainable(name, trainable_variables) - net = slim.repeat(net, 10, block35, scale=0.17, trainable_variables=trainable, reuse=reuse) + net = slim.repeat( + net, + 10, + block35, + scale=0.17, + trainable_variables=trainable, + reuse=reuse) # 17 x 17 x 1024 name = "Mixed_6a" trainable = is_trainable(name, trainable_variables) with tf.variable_scope(name): with tf.variable_scope('Branch_0'): - tower_conv = slim.conv2d(net, 384, 3, stride=2, padding='VALID', - scope='Conv2d_1a_3x3', trainable=trainable, reuse=reuse) + tower_conv = slim.conv2d( + net, + 384, + 3, + stride=2, + padding='VALID', + scope='Conv2d_1a_3x3', + trainable=trainable, + reuse=reuse) with tf.variable_scope('Branch_1'): - tower_conv1_0 = slim.conv2d(net, 256, 1, scope='Conv2d_0a_1x1', trainable=trainable, - reuse=reuse) - tower_conv1_1 = slim.conv2d(tower_conv1_0, 256, 3, - scope='Conv2d_0b_3x3', trainable=trainable, reuse=reuse) - tower_conv1_2 = slim.conv2d(tower_conv1_1, 384, 3, - stride=2, padding='VALID', - scope='Conv2d_1a_3x3', trainable=trainable, reuse=reuse) + tower_conv1_0 = slim.conv2d( + net, + 256, + 1, + scope='Conv2d_0a_1x1', + trainable=trainable, + reuse=reuse) + tower_conv1_1 = slim.conv2d( + tower_conv1_0, + 256, + 3, + scope='Conv2d_0b_3x3', + trainable=trainable, + reuse=reuse) + tower_conv1_2 = slim.conv2d( + tower_conv1_1, + 384, + 3, + stride=2, + padding='VALID', + scope='Conv2d_1a_3x3', + trainable=trainable, + reuse=reuse) with tf.variable_scope('Branch_2'): - tower_pool = slim.max_pool2d(net, 3, stride=2, padding='VALID', - scope='MaxPool_1a_3x3') + tower_pool = slim.max_pool2d( + net, + 3, + stride=2, + padding='VALID', + scope='MaxPool_1a_3x3') net = tf.concat([tower_conv, tower_conv1_2, tower_pool], 3) end_points[name] = net @@ -255,62 +475,132 @@ def inception_resnet_v2(inputs, # BLOCK 17 name = "Block17" trainable = is_trainable(name, trainable_variables) - net = slim.repeat(net, 20, block17, scale=0.10, trainable_variables=trainable, reuse=reuse) + net = slim.repeat( + net, + 20, + block17, + scale=0.10, + trainable_variables=trainable, + reuse=reuse) name = "Mixed_7a" trainable = is_trainable(name, trainable_variables) with tf.variable_scope(name): with tf.variable_scope('Branch_0'): - tower_conv = slim.conv2d(net, 256, 1, scope='Conv2d_0a_1x1', trainable=trainable, reuse=reuse) - tower_conv_1 = slim.conv2d(tower_conv, 384, 3, stride=2, - padding='VALID', scope='Conv2d_1a_3x3', trainable=trainable, - reuse=reuse) + tower_conv = slim.conv2d( + net, + 256, + 1, + scope='Conv2d_0a_1x1', + trainable=trainable, + reuse=reuse) + tower_conv_1 = slim.conv2d( + tower_conv, + 384, + 3, + stride=2, + padding='VALID', + scope='Conv2d_1a_3x3', + trainable=trainable, + reuse=reuse) with tf.variable_scope('Branch_1'): - tower_conv1 = slim.conv2d(net, 256, 1, scope='Conv2d_0a_1x1', trainable=trainable, reuse=reuse) - tower_conv1_1 = slim.conv2d(tower_conv1, 288, 3, stride=2, - padding='VALID', scope='Conv2d_1a_3x3', trainable=trainable, - reuse=reuse) + tower_conv1 = slim.conv2d( + net, + 256, + 1, + scope='Conv2d_0a_1x1', + trainable=trainable, + reuse=reuse) + tower_conv1_1 = slim.conv2d( + tower_conv1, + 288, + 3, + stride=2, + padding='VALID', + scope='Conv2d_1a_3x3', + trainable=trainable, + reuse=reuse) with tf.variable_scope('Branch_2'): - tower_conv2 = slim.conv2d(net, 256, 1, scope='Conv2d_0a_1x1', trainable=trainable, reuse=reuse) - tower_conv2_1 = slim.conv2d(tower_conv2, 288, 3, - scope='Conv2d_0b_3x3', trainable=trainable, reuse=reuse) - tower_conv2_2 = slim.conv2d(tower_conv2_1, 320, 3, stride=2, - padding='VALID', scope='Conv2d_1a_3x3', trainable=trainable, - reuse=reuse) + tower_conv2 = slim.conv2d( + net, + 256, + 1, + scope='Conv2d_0a_1x1', + trainable=trainable, + reuse=reuse) + tower_conv2_1 = slim.conv2d( + tower_conv2, + 288, + 3, + scope='Conv2d_0b_3x3', + trainable=trainable, + reuse=reuse) + tower_conv2_2 = slim.conv2d( + tower_conv2_1, + 320, + 3, + stride=2, + padding='VALID', + scope='Conv2d_1a_3x3', + trainable=trainable, + reuse=reuse) with tf.variable_scope('Branch_3'): - tower_pool = slim.max_pool2d(net, 3, stride=2, padding='VALID', - scope='MaxPool_1a_3x3') - net = tf.concat([tower_conv_1, tower_conv1_1, - tower_conv2_2, tower_pool], 3) + tower_pool = slim.max_pool2d( + net, + 3, + stride=2, + padding='VALID', + scope='MaxPool_1a_3x3') + net = tf.concat([ + tower_conv_1, tower_conv1_1, tower_conv2_2, tower_pool + ], 3) end_points[name] = net # Block 8 name = "Block8" trainable = is_trainable(name, trainable_variables) - net = slim.repeat(net, 9, block8, scale=0.20, trainable_variables=trainable, reuse=reuse) - net = block8(net, activation_fn=None, trainable_variables=trainable, reuse=reuse) + net = slim.repeat( + net, + 9, + block8, + scale=0.20, + trainable_variables=trainable, + reuse=reuse) + net = block8( + net, + activation_fn=None, + trainable_variables=trainable, + reuse=reuse) name = "Conv2d_7b_1x1" trainable = is_trainable(name, trainable_variables) - net = slim.conv2d(net, 1536, 1, scope=name, trainable=trainable, reuse=reuse) + net = slim.conv2d( + net, 1536, 1, scope=name, trainable=trainable, reuse=reuse) end_points[name] = net with tf.variable_scope('Logits'): end_points['PrePool'] = net # pylint: disable=no-member - net = slim.avg_pool2d(net, net.get_shape()[1:3], padding='VALID', - scope='AvgPool_1a_8x8') + net = slim.avg_pool2d( + net, + net.get_shape()[1:3], + padding='VALID', + scope='AvgPool_1a_8x8') net = slim.flatten(net) - net = slim.dropout(net, dropout_keep_prob, - scope='Dropout') + net = slim.dropout(net, dropout_keep_prob, scope='Dropout') end_points['PreLogitsFlatten'] = net name = "Bottleneck" trainable = is_trainable(name, trainable_variables) - net = slim.fully_connected(net, bottleneck_layer_size, activation_fn=None, - scope=name, reuse=reuse, trainable=trainable) + net = slim.fully_connected( + net, + bottleneck_layer_size, + activation_fn=None, + scope=name, + reuse=reuse, + trainable=trainable) end_points[name] = net return net, end_points diff --git a/bob/learn/tensorflow/network/LightCNN9.py b/bob/learn/tensorflow/network/LightCNN9.py index 451a5cfd32aa96ce68edcc110a81c74ba128c16f..6d102ca22129e4703aeec66b03dedea086de0e28 100644 --- a/bob/learn/tensorflow/network/LightCNN9.py +++ b/bob/learn/tensorflow/network/LightCNN9.py @@ -7,7 +7,11 @@ from bob.learn.tensorflow.layers import maxout from .utils import is_trainable -def light_cnn9(inputs, seed=10, reuse=False, trainable_variables=None, **kwargs): +def light_cnn9(inputs, + seed=10, + reuse=False, + trainable_variables=None, + **kwargs): """Creates the graph for the Light CNN-9 in Wu, Xiang, et al. "A light CNN for deep face representation with noisy labels." arXiv preprint arXiv:1511.02683 (2015). @@ -15,141 +19,155 @@ def light_cnn9(inputs, seed=10, reuse=False, trainable_variables=None, **kwargs) slim = tf.contrib.slim with tf.variable_scope('LightCNN9', reuse=reuse): - initializer = tf.contrib.layers.xavier_initializer(uniform=False, dtype=tf.float32, seed=seed) + initializer = tf.contrib.layers.xavier_initializer( + uniform=False, dtype=tf.float32, seed=seed) end_points = dict() name = "Conv1" trainable = is_trainable(name, trainable_variables) - graph = slim.conv2d(inputs, 96, [5, 5], activation_fn=tf.nn.relu, - stride=1, - weights_initializer=initializer, - scope=name, - trainable=trainable, - reuse=reuse) + graph = slim.conv2d( + inputs, + 96, [5, 5], + activation_fn=tf.nn.relu, + stride=1, + weights_initializer=initializer, + scope=name, + trainable=trainable, + reuse=reuse) end_points[name] = graph - graph = maxout(graph, - num_units=48, - name='Maxout1') + graph = maxout(graph, num_units=48, name='Maxout1') - graph = slim.max_pool2d(graph, [2, 2], stride=2, padding="SAME", scope='Pool1') + graph = slim.max_pool2d( + graph, [2, 2], stride=2, padding="SAME", scope='Pool1') #### name = "Conv2a" trainable = is_trainable(name, trainable_variables) - graph = slim.conv2d(graph, 96, [1, 1], activation_fn=tf.nn.relu, - stride=1, - weights_initializer=initializer, - scope=name, - trainable=trainable, - reuse=reuse) - - graph = maxout(graph, - num_units=48, - name='Maxout2a') + graph = slim.conv2d( + graph, + 96, [1, 1], + activation_fn=tf.nn.relu, + stride=1, + weights_initializer=initializer, + scope=name, + trainable=trainable, + reuse=reuse) + + graph = maxout(graph, num_units=48, name='Maxout2a') name = "Conv2" trainable = is_trainable(name, trainable_variables) - graph = slim.conv2d(graph, 192, [3, 3], activation_fn=tf.nn.relu, - stride=1, - weights_initializer=initializer, - scope=name, - trainable=trainable, - reuse=reuse) + graph = slim.conv2d( + graph, + 192, [3, 3], + activation_fn=tf.nn.relu, + stride=1, + weights_initializer=initializer, + scope=name, + trainable=trainable, + reuse=reuse) end_points[name] = graph - graph = maxout(graph, - num_units=96, - name='Maxout2') + graph = maxout(graph, num_units=96, name='Maxout2') - graph = slim.max_pool2d(graph, [2, 2], stride=2, padding="SAME", scope='Pool2') + graph = slim.max_pool2d( + graph, [2, 2], stride=2, padding="SAME", scope='Pool2') ##### name = "Conv3a" trainable = is_trainable(name, trainable_variables) - graph = slim.conv2d(graph, 192, [1, 1], activation_fn=tf.nn.relu, - stride=1, - weights_initializer=initializer, - scope=name, - trainable=trainable, - reuse=reuse) - - graph = maxout(graph, - num_units=96, - name='Maxout3a') + graph = slim.conv2d( + graph, + 192, [1, 1], + activation_fn=tf.nn.relu, + stride=1, + weights_initializer=initializer, + scope=name, + trainable=trainable, + reuse=reuse) + + graph = maxout(graph, num_units=96, name='Maxout3a') name = "Conv3" trainable = is_trainable(name, trainable_variables) - graph = slim.conv2d(graph, 384, [3, 3], activation_fn=tf.nn.relu, - stride=1, - weights_initializer=initializer, - scope=name, - trainable=trainable, - reuse=reuse) + graph = slim.conv2d( + graph, + 384, [3, 3], + activation_fn=tf.nn.relu, + stride=1, + weights_initializer=initializer, + scope=name, + trainable=trainable, + reuse=reuse) end_points[name] = graph - graph = maxout(graph, - num_units=192, - name='Maxout3') + graph = maxout(graph, num_units=192, name='Maxout3') - graph = slim.max_pool2d(graph, [2, 2], stride=2, padding="SAME", scope='Pool3') + graph = slim.max_pool2d( + graph, [2, 2], stride=2, padding="SAME", scope='Pool3') ##### name = "Conv4a" trainable = is_trainable(name, trainable_variables) - graph = slim.conv2d(graph, 384, [1, 1], activation_fn=tf.nn.relu, - stride=1, - weights_initializer=initializer, - scope=name, - trainable=trainable, - reuse=reuse) - - graph = maxout(graph, - num_units=192, - name='Maxout4a') + graph = slim.conv2d( + graph, + 384, [1, 1], + activation_fn=tf.nn.relu, + stride=1, + weights_initializer=initializer, + scope=name, + trainable=trainable, + reuse=reuse) + + graph = maxout(graph, num_units=192, name='Maxout4a') name = "Conv4" trainable = is_trainable(name, trainable_variables) - graph = slim.conv2d(graph, 256, [3, 3], activation_fn=tf.nn.relu, - stride=1, - weights_initializer=initializer, - scope=name, - trainable=trainable, - reuse=reuse) + graph = slim.conv2d( + graph, + 256, [3, 3], + activation_fn=tf.nn.relu, + stride=1, + weights_initializer=initializer, + scope=name, + trainable=trainable, + reuse=reuse) end_points[name] = graph - graph = maxout(graph, - num_units=128, - name='Maxout4') + graph = maxout(graph, num_units=128, name='Maxout4') ##### name = "Conv5a" trainable = is_trainable(name, trainable_variables) - graph = slim.conv2d(graph, 256, [1, 1], activation_fn=tf.nn.relu, - stride=1, - weights_initializer=initializer, - scope=name, - trainable=trainable, - reuse=reuse) - - graph = maxout(graph, - num_units=128, - name='Maxout5a') + graph = slim.conv2d( + graph, + 256, [1, 1], + activation_fn=tf.nn.relu, + stride=1, + weights_initializer=initializer, + scope=name, + trainable=trainable, + reuse=reuse) + + graph = maxout(graph, num_units=128, name='Maxout5a') name = "Conv5" trainable = is_trainable(name, trainable_variables) - graph = slim.conv2d(graph, 256, [3, 3], activation_fn=tf.nn.relu, - stride=1, - weights_initializer=initializer, - scope=name, - trainable=trainable, - reuse=reuse) + graph = slim.conv2d( + graph, + 256, [3, 3], + activation_fn=tf.nn.relu, + stride=1, + weights_initializer=initializer, + scope=name, + trainable=trainable, + reuse=reuse) end_points[name] = graph - graph = maxout(graph, - num_units=128, - name='Maxout5') + graph = maxout(graph, num_units=128, name='Maxout5') - graph = slim.max_pool2d(graph, [2, 2], stride=2, padding="SAME", scope='Pool4') + graph = slim.max_pool2d( + graph, [2, 2], stride=2, padding="SAME", scope='Pool4') graph = slim.flatten(graph, scope='flatten1') end_points['flatten1'] = graph @@ -158,12 +176,14 @@ def light_cnn9(inputs, seed=10, reuse=False, trainable_variables=None, **kwargs) name = "fc1" trainable = is_trainable(name, trainable_variables) - prelogits = slim.fully_connected(graph, 512, - weights_initializer=initializer, - activation_fn=tf.nn.relu, - scope=name, - trainable=trainable, - reuse=reuse) + prelogits = slim.fully_connected( + graph, + 512, + weights_initializer=initializer, + activation_fn=tf.nn.relu, + scope=name, + trainable=trainable, + reuse=reuse) end_points['fc1'] = prelogits return prelogits, end_points diff --git a/bob/learn/tensorflow/network/MLP.py b/bob/learn/tensorflow/network/MLP.py index 0f48e8602d0b811e5dd4469c241f84ac5aa076cc..1af525f12bba51beefa9a781e97e2b65d1969483 100644 --- a/bob/learn/tensorflow/network/MLP.py +++ b/bob/learn/tensorflow/network/MLP.py @@ -5,7 +5,13 @@ import tensorflow as tf -def mlp(inputs, output_shape, hidden_layers=[10], hidden_activation=tf.nn.tanh, output_activation=None, seed=10, **kwargs): +def mlp(inputs, + output_shape, + hidden_layers=[10], + hidden_activation=tf.nn.tanh, + output_activation=None, + seed=10, + **kwargs): """An MLP is a representation of a Multi-Layer Perceptron. This implementation is feed-forward and fully-connected. @@ -30,20 +36,25 @@ def mlp(inputs, output_shape, hidden_layers=[10], hidden_activation=tf.nn.tanh, """ slim = tf.contrib.slim - initializer = tf.contrib.layers.xavier_initializer(uniform=False, dtype=tf.float32, seed=seed) + initializer = tf.contrib.layers.xavier_initializer( + uniform=False, dtype=tf.float32, seed=seed) graph = inputs for i in range(len(hidden_layers)): weights = hidden_layers[i] - graph = slim.fully_connected(graph, weights, - weights_initializer=initializer, - activation_fn=hidden_activation, - scope='fc_{0}'.format(i)) - - graph = slim.fully_connected(graph, output_shape, - weights_initializer=initializer, - activation_fn=output_activation, - scope='fc_output') + graph = slim.fully_connected( + graph, + weights, + weights_initializer=initializer, + activation_fn=hidden_activation, + scope='fc_{0}'.format(i)) + + graph = slim.fully_connected( + graph, + output_shape, + weights_initializer=initializer, + activation_fn=output_activation, + scope='fc_output') return graph diff --git a/bob/learn/tensorflow/network/SimpleCNN.py b/bob/learn/tensorflow/network/SimpleCNN.py index 37edbf65b33c522b9ccdcddd8c7959f4ee19f514..e1f279e02c506c068aa0498d277f0d9b718cfe5e 100644 --- a/bob/learn/tensorflow/network/SimpleCNN.py +++ b/bob/learn/tensorflow/network/SimpleCNN.py @@ -20,8 +20,8 @@ def base_architecture(input_layer, mode, kernerl_size, data_format, **kwargs): # Pooling Layer #1 # First max pooling layer with a 2x2 filter and stride of 2 - pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], - strides=2, data_format=data_format) + pool1 = tf.layers.max_pooling2d( + inputs=conv1, pool_size=[2, 2], strides=2, data_format=data_format) endpoints['pool1'] = pool1 # Convolutional Layer #2 @@ -38,8 +38,8 @@ def base_architecture(input_layer, mode, kernerl_size, data_format, **kwargs): # Pooling Layer #2 # Second max pooling layer with a 2x2 filter and stride of 2 - pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], - strides=2, data_format=data_format) + pool2 = tf.layers.max_pooling2d( + inputs=conv2, pool_size=[2, 2], strides=2, data_format=data_format) endpoints['pool2'] = pool2 # Flatten tensor into a batch of vectors @@ -55,21 +55,24 @@ def base_architecture(input_layer, mode, kernerl_size, data_format, **kwargs): # Add dropout operation; 0.6 probability that element will be kept dropout = tf.layers.dropout( - inputs=dense, rate=0.4, - training=mode == tf.estimator.ModeKeys.TRAIN) + inputs=dense, rate=0.4, training=mode == tf.estimator.ModeKeys.TRAIN) endpoints['dropout'] = dropout return dropout, endpoints -def architecture(input_layer, mode=tf.estimator.ModeKeys.TRAIN, - kernerl_size=(3, 3), n_classes=2, - data_format='channels_last', reuse=False, **kwargs): +def architecture(input_layer, + mode=tf.estimator.ModeKeys.TRAIN, + kernerl_size=(3, 3), + n_classes=2, + data_format='channels_last', + reuse=False, + **kwargs): with tf.variable_scope('SimpleCNN', reuse=reuse): - dropout, endpoints = base_architecture( - input_layer, mode, kernerl_size, data_format) + dropout, endpoints = base_architecture(input_layer, mode, kernerl_size, + data_format) # Logits layer # Input Tensor Shape: [batch_size, 1024] # Output Tensor Shape: [batch_size, n_classes] @@ -108,8 +111,7 @@ def model_fn(features, labels, mode, params=None, config=None): return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions) # Calculate Loss (for both TRAIN and EVAL modes) - loss = tf.losses.sparse_softmax_cross_entropy( - logits=logits, labels=labels) + loss = tf.losses.sparse_softmax_cross_entropy(logits=logits, labels=labels) accuracy = tf.metrics.accuracy( labels=labels, predictions=predictions["classes"]) metrics = {'accuracy': accuracy} diff --git a/bob/learn/tensorflow/network/__init__.py b/bob/learn/tensorflow/network/__init__.py index 3226aa31d2fd87ca5d7f6011d3502e62431fde56..7d4656089bdd850cdea103b33a64ac2266081839 100644 --- a/bob/learn/tensorflow/network/__init__.py +++ b/bob/learn/tensorflow/network/__init__.py @@ -30,6 +30,6 @@ __appropriate__( dummy, Embedding, mlp, - ) +) __all__ = [_ for _ in dir() if not _.startswith('_')] diff --git a/bob/learn/tensorflow/network/utils.py b/bob/learn/tensorflow/network/utils.py index f7abea4450874f5dece8db254c681d63132dac7f..5b32ed123aaaccae3ac124b215d926643d9cc8df 100644 --- a/bob/learn/tensorflow/network/utils.py +++ b/bob/learn/tensorflow/network/utils.py @@ -6,16 +6,22 @@ import tensorflow as tf import tensorflow.contrib.slim as slim -def append_logits(graph, n_classes, reuse=False, l2_regularizer=0.001, +def append_logits(graph, + n_classes, + reuse=False, + l2_regularizer=0.001, weights_std=0.1): return slim.fully_connected( - graph, n_classes, activation_fn=None, + graph, + n_classes, + activation_fn=None, weights_initializer=tf.truncated_normal_initializer( stddev=weights_std), weights_regularizer=slim.l2_regularizer(l2_regularizer), - scope='Logits', reuse=reuse) - - + scope='Logits', + reuse=reuse) + + def is_trainable(name, trainable_variables): """ Check if a variable is trainable or not diff --git a/bob/learn/tensorflow/script/__init__.py b/bob/learn/tensorflow/script/__init__.py index 735af4304a149a6149921e72d2a7dcad54e5c29c..b156cdd2398fd5af2b88db8279fd84c85b767b36 100644 --- a/bob/learn/tensorflow/script/__init__.py +++ b/bob/learn/tensorflow/script/__init__.py @@ -1,3 +1,2 @@ # gets sphinx autodoc done right - don't remove it __all__ = [_ for _ in dir() if not _.startswith('_')] - diff --git a/bob/learn/tensorflow/script/compute_statistics.py b/bob/learn/tensorflow/script/compute_statistics.py index 9b38c130d41719d0f62492f29fb3e5b0fec5bf2a..c3a9998215c533447489f155d28709957106a10e 100644 --- a/bob/learn/tensorflow/script/compute_statistics.py +++ b/bob/learn/tensorflow/script/compute_statistics.py @@ -1,9 +1,7 @@ #!/usr/bin/env python # vim: set fileencoding=utf-8 : # @author: Tiago de Freitas Pereira -# @date: Wed 11 May 2016 09:39:36 CEST - - +# @date: Wed 11 May 2016 09:39:36 CEST """ Script that computes statistics for image @@ -21,6 +19,7 @@ import os import numpy import bob.io.image + def process_images(base_path, extension, shape): files = os.listdir(base_path) diff --git a/bob/learn/tensorflow/script/db_to_tfrecords.py b/bob/learn/tensorflow/script/db_to_tfrecords.py index aa0e3b1edb46926d2d8e9a0ff55d0f06f8fe9c73..4a05fa7738c8669f51ba7c092d90d0f2e90cf9b9 100644 --- a/bob/learn/tensorflow/script/db_to_tfrecords.py +++ b/bob/learn/tensorflow/script/db_to_tfrecords.py @@ -1,5 +1,4 @@ #!/usr/bin/env python - """Converts Bio and PAD datasets to TFRecords file formats. Usage: @@ -110,9 +109,11 @@ def int64_feature(value): def write_a_sample(writer, data, label, key, feature=None): if feature is None: - feature = {'data': bytes_feature(data.tostring()), - 'label': int64_feature(label), - 'key': bytes_feature(key)} + feature = { + 'data': bytes_feature(data.tostring()), + 'label': int64_feature(label), + 'key': bytes_feature(key) + } example = tf.train.Example(features=tf.train.Features(feature=feature)) writer.write(example.SerializeToString()) @@ -130,14 +131,13 @@ def main(argv=None): config = read_config_file(config_files) # optional arguments - verbosity = get_from_config_or_commandline( - config, 'verbose', args, defaults) - allow_failures = get_from_config_or_commandline( - config, 'allow_failures', args, defaults) + verbosity = get_from_config_or_commandline(config, 'verbose', args, + defaults) + allow_failures = get_from_config_or_commandline(config, 'allow_failures', + args, defaults) multiple_samples = get_from_config_or_commandline( config, 'multiple_samples', args, defaults) - shuffle = get_from_config_or_commandline( - config, 'shuffle', args, defaults) + shuffle = get_from_config_or_commandline(config, 'shuffle', args, defaults) # Sets-up logging set_verbosity_level(logger, verbosity) @@ -145,8 +145,8 @@ def main(argv=None): # required arguments samples = config.samples reader = config.reader - output = get_from_config_or_commandline( - config, 'output', args, defaults, False) + output = get_from_config_or_commandline(config, 'output', args, defaults, + False) if not output.endswith(".tfrecords"): output += ".tfrecords" diff --git a/bob/learn/tensorflow/script/eval_generic.py b/bob/learn/tensorflow/script/eval_generic.py index 06304fe254ae3c8efe88d9de96f73d5b2936980a..aaeefce130d94829e56d6fbf1ee0322923b576de 100644 --- a/bob/learn/tensorflow/script/eval_generic.py +++ b/bob/learn/tensorflow/script/eval_generic.py @@ -1,5 +1,4 @@ #!/usr/bin/env python - """Evaluates networks trained with tf.train.MonitoredTrainingSession Usage: @@ -106,8 +105,8 @@ def main(argv=None): print(str_evaluations) sys.stdout.flush() with open(evaluated_file, 'a') as f: - f.write('{} {}\n'.format( - evaluations['global_step'], str_evaluations)) + f.write('{} {}\n'.format(evaluations['global_step'], + str_evaluations)) if run_once: break time.sleep(eval_interval_secs) diff --git a/bob/learn/tensorflow/script/load_and_debug.py b/bob/learn/tensorflow/script/load_and_debug.py index 757f7776ae8756f06508cc3e1e1c77c08a91bda3..91fd6d73fb53bf0b764e6e9cad39e88488dcefbf 100644 --- a/bob/learn/tensorflow/script/load_and_debug.py +++ b/bob/learn/tensorflow/script/load_and_debug.py @@ -1,8 +1,6 @@ #!/usr/bin/env python # vim: set fileencoding=utf-8 : # @author: Tiago de Freitas Pereira - - """ Load and debug tensorflow models @@ -36,11 +34,13 @@ def main(): logger.info("Directory already exists, trying to get the last checkpoint") - trainer = config.Trainer(config.train_data_shuffler, - iterations=0, - analizer=None, - temp_dir=output_dir) + trainer = config.Trainer( + config.train_data_shuffler, + iterations=0, + analizer=None, + temp_dir=output_dir) trainer.create_network_from_file(output_dir) - import ipdb; ipdb.set_trace(); - - debug=True + import ipdb + ipdb.set_trace() + + debug = True diff --git a/bob/learn/tensorflow/script/predict_bio.py b/bob/learn/tensorflow/script/predict_bio.py index c648e44fefed6c655c68b3dc69a008c6f28f027b..7f1f8916836faf137115bf22cce1401b50070303 100644 --- a/bob/learn/tensorflow/script/predict_bio.py +++ b/bob/learn/tensorflow/script/predict_bio.py @@ -1,5 +1,4 @@ #!/usr/bin/env python - """Saves predictions or embeddings of tf.estimators. This script works with bob.bio.base databases. To use it see the configuration details below. This script works with tensorflow 1.4 and above. @@ -169,18 +168,17 @@ def main(argv=None): config = read_config_file(config_files) # optional arguments - verbosity = get_from_config_or_commandline( - config, 'verbose', args, defaults) - predict_keys = get_from_config_or_commandline( - config, 'predict_keys', args, defaults) - checkpoint_path = get_from_config_or_commandline( - config, 'checkpoint_path', args, defaults) + verbosity = get_from_config_or_commandline(config, 'verbose', args, + defaults) + predict_keys = get_from_config_or_commandline(config, 'predict_keys', args, + defaults) + checkpoint_path = get_from_config_or_commandline(config, 'checkpoint_path', + args, defaults) multiple_samples = get_from_config_or_commandline( config, 'multiple_samples', args, defaults) number_of_parallel_jobs = get_from_config_or_commandline( config, 'number_of_parallel_jobs', args, defaults) - force = get_from_config_or_commandline( - config, 'force', args, defaults) + force = get_from_config_or_commandline(config, 'force', args, defaults) hooks = getattr(config, 'hooks', None) load_data = getattr(config, 'load_data', None) @@ -192,8 +190,8 @@ def main(argv=None): database = config.database biofiles = config.biofiles bio_predict_input_fn = config.bio_predict_input_fn - output_dir = get_from_config_or_commandline( - config, 'output_dir', args, defaults, False) + output_dir = get_from_config_or_commandline(config, 'output_dir', args, + defaults, False) assert len(biofiles), "biofiles are empty!" @@ -216,11 +214,13 @@ def main(argv=None): return generator = BioGenerator( - database, biofiles, load_data=load_data, + database, + biofiles, + load_data=load_data, multiple_samples=multiple_samples) - predict_input_fn = bio_predict_input_fn( - generator, generator.output_types, generator.output_shapes) + predict_input_fn = bio_predict_input_fn(generator, generator.output_types, + generator.output_shapes) if checkpoint_path: logger.info("Restoring the model from %s", checkpoint_path) diff --git a/bob/learn/tensorflow/script/predict_generic.py b/bob/learn/tensorflow/script/predict_generic.py index be11dec7f487ef9143f333b20d56171c69d38598..a2322c897971cca2b73f760c9b497f8fe1eb736e 100644 --- a/bob/learn/tensorflow/script/predict_generic.py +++ b/bob/learn/tensorflow/script/predict_generic.py @@ -1,5 +1,4 @@ #!/usr/bin/env python - """Returns predictions of networks trained with tf.train.MonitoredTrainingSession @@ -78,12 +77,12 @@ def main(argv=None): config = read_config_file(config_files) # optional arguments - verbosity = get_from_config_or_commandline( - config, 'verbose', args, defaults) - predict_keys = get_from_config_or_commandline( - config, 'predict_keys', args, defaults) - checkpoint_path = get_from_config_or_commandline( - config, 'checkpoint_path', args, defaults) + verbosity = get_from_config_or_commandline(config, 'verbose', args, + defaults) + predict_keys = get_from_config_or_commandline(config, 'predict_keys', args, + defaults) + checkpoint_path = get_from_config_or_commandline(config, 'checkpoint_path', + args, defaults) hooks = getattr(config, 'hooks', None) # Sets-up logging @@ -92,8 +91,8 @@ def main(argv=None): # required arguments estimator = config.estimator predict_input_fn = config.predict_input_fn - output_dir = get_from_config_or_commandline( - config, 'output_dir', args, defaults, False) + output_dir = get_from_config_or_commandline(config, 'output_dir', args, + defaults, False) predictions = estimator.predict( predict_input_fn, diff --git a/bob/learn/tensorflow/script/train.py b/bob/learn/tensorflow/script/train.py index 0c20262ef6552f61c32639084f675d1f20ac9de0..04be12d614e2479758c13e8382559dd62200b133 100644 --- a/bob/learn/tensorflow/script/train.py +++ b/bob/learn/tensorflow/script/train.py @@ -2,7 +2,6 @@ # vim: set fileencoding=utf-8 : # @author: Tiago de Freitas Pereira # @date: Wed 04 Jan 2017 18:00:36 CET - """ Train a Neural network using bob.learn.tensorflow @@ -43,7 +42,7 @@ def dump_commandline(): def main(): args = docopt(__doc__, version='Train Neural Net') - + output_dir = str(args['--output-dir']) iterations = int(args['--iterations']) @@ -59,13 +58,21 @@ def main(): command = dump_commandline() dependencies = [] total_jobs = [] - - kwargs = {"env": ["LD_LIBRARY_PATH=/idiap/user/tpereira/cuda/cuda-8.0/lib64:/idiap/user/tpereira/cuda/cudnn-8.0-linux-x64-v5.1/lib64:/idiap/user/tpereira/cuda/cuda-8.0/bin"]} - + + kwargs = { + "env": [ + "LD_LIBRARY_PATH=/idiap/user/tpereira/cuda/cuda-8.0/lib64:/idiap/user/tpereira/cuda/cudnn-8.0-linux-x64-v5.1/lib64:/idiap/user/tpereira/cuda/cuda-8.0/bin" + ] + } + for i in range(jobs): - job_id = job_manager.submit(command, queue=queue, dependencies=dependencies, - name=job_name + "{0}".format(i), **kwargs) - + job_id = job_manager.submit( + command, + queue=queue, + dependencies=dependencies, + name=job_name + "{0}".format(i), + **kwargs) + dependencies = [job_id] total_jobs.append(job_id) @@ -73,7 +80,7 @@ def main(): return True config = imp.load_source('config', args['']) - + # Cleaning all variables in case you are loading the checkpoint tf.reset_default_graph() if os.path.exists(output_dir) else None @@ -81,7 +88,7 @@ def main(): validate_with_embeddings = False if hasattr(config, 'validate_with_embeddings'): validate_with_embeddings = config.validate_with_embeddings - + # Run validation with embeddings validation_data_shuffler = None if hasattr(config, 'validation_data_shuffler'): @@ -91,15 +98,16 @@ def main(): if hasattr(config, 'prelogits'): prelogits = config.prelogits - - trainer = config.Trainer(config.train_data_shuffler, - validation_data_shuffler=validation_data_shuffler, - validate_with_embeddings=validate_with_embeddings, - iterations=iterations, - analizer=None, - temp_dir=output_dir) + trainer = config.Trainer( + config.train_data_shuffler, + validation_data_shuffler=validation_data_shuffler, + validate_with_embeddings=validate_with_embeddings, + iterations=iterations, + analizer=None, + temp_dir=output_dir) if os.path.exists(output_dir): - logger.info("Directory already exists, trying to get the last checkpoint") + logger.info( + "Directory already exists, trying to get the last checkpoint") trainer.create_network_from_file(output_dir) else: @@ -112,28 +120,33 @@ def main(): train_graph = config.logits if hasattr(config, 'validation_graph'): validation_graph = config.validation_graph - + else: # Preparing the architecture input_pl = config.train_data_shuffler("data", from_queue=False) - if isinstance(trainer, bob.learn.tensorflow.trainers.SiameseTrainer): + if isinstance(trainer, + bob.learn.tensorflow.trainers.SiameseTrainer): train_graph = dict() train_graph['left'] = config.architecture(input_pl['left']) - train_graph['right'] = config.architecture(input_pl['right'], reuse=True) + train_graph['right'] = config.architecture( + input_pl['right'], reuse=True) - elif isinstance(trainer, bob.learn.tensorflow.trainers.TripletTrainer): + elif isinstance(trainer, + bob.learn.tensorflow.trainers.TripletTrainer): train_graph = dict() train_graph['anchor'] = config.architecture(input_pl['anchor']) - train_graph['positive'] = config.architecture(input_pl['positive'], reuse=True) - train_graph['negative'] = config.architecture(input_pl['negative'], reuse=True) + train_graph['positive'] = config.architecture( + input_pl['positive'], reuse=True) + train_graph['negative'] = config.architecture( + input_pl['negative'], reuse=True) else: train_graph = config.architecture(input_pl) - trainer.create_network_from_scratch(train_graph, - validation_graph=validation_graph, - loss=config.loss, - learning_rate=config.learning_rate, - optimizer=config.optimizer, - prelogits=prelogits) + trainer.create_network_from_scratch( + train_graph, + validation_graph=validation_graph, + loss=config.loss, + learning_rate=config.learning_rate, + optimizer=config.optimizer, + prelogits=prelogits) trainer.train() - diff --git a/bob/learn/tensorflow/script/train_and_evaluate.py b/bob/learn/tensorflow/script/train_and_evaluate.py index 534f4d6bf41f0df0022558509bf1d4c977a7b6ff..015577b805e5aad07b69930f0aba737f8ab88c96 100644 --- a/bob/learn/tensorflow/script/train_and_evaluate.py +++ b/bob/learn/tensorflow/script/train_and_evaluate.py @@ -1,5 +1,4 @@ #!/usr/bin/env python - """Trains and evaluates a network using Tensorflow estimators. This script calls the estimator.train_and_evaluate function. Please see: https://www.tensorflow.org/api_docs/python/tf/estimator/train_and_evaluate @@ -46,31 +45,31 @@ logger = setup(__name__) def main(argv=None): - from docopt import docopt - import os - import sys - docs = __doc__ % {'prog': os.path.basename(sys.argv[0])} - version = pkg_resources.require('bob.learn.tensorflow')[0].version - defaults = docopt(docs, argv=[""]) - args = docopt(docs, argv=argv, version=version) - config_files = args[''] - config = read_config_file(config_files) + from docopt import docopt + import os + import sys + docs = __doc__ % {'prog': os.path.basename(sys.argv[0])} + version = pkg_resources.require('bob.learn.tensorflow')[0].version + defaults = docopt(docs, argv=[""]) + args = docopt(docs, argv=argv, version=version) + config_files = args[''] + config = read_config_file(config_files) - # optional arguments - verbosity = get_from_config_or_commandline( - config, 'verbose', args, defaults) + # optional arguments + verbosity = get_from_config_or_commandline(config, 'verbose', args, + defaults) - # Sets-up logging - set_verbosity_level(logger, verbosity) + # Sets-up logging + set_verbosity_level(logger, verbosity) - # required arguments - estimator = config.estimator - train_spec = config.train_spec - eval_spec = config.eval_spec + # required arguments + estimator = config.estimator + train_spec = config.train_spec + eval_spec = config.eval_spec - # Train and evaluate - tf.estimator.train_and_evaluate(estimator, train_spec, eval_spec) + # Train and evaluate + tf.estimator.train_and_evaluate(estimator, train_spec, eval_spec) if __name__ == '__main__': - main() + main() diff --git a/bob/learn/tensorflow/script/train_generic.py b/bob/learn/tensorflow/script/train_generic.py index 1ac36673c62b34f46303ca54b158246480adde8a..c096dedf753e96ed0df52dfd33e46b5204b5d9ee 100644 --- a/bob/learn/tensorflow/script/train_generic.py +++ b/bob/learn/tensorflow/script/train_generic.py @@ -1,5 +1,4 @@ #!/usr/bin/env python - """Trains networks using Tensorflow estimators. Usage: @@ -55,16 +54,15 @@ def main(argv=None): defaults = docopt(docs, argv=[""]) args = docopt(docs, argv=argv, version=version) config_files = args[''] - + config = read_config_file(config_files) # optional arguments - verbosity = get_from_config_or_commandline( - config, 'verbose', args, defaults) - max_steps = get_from_config_or_commandline( - config, 'max_steps', args, defaults) - steps = get_from_config_or_commandline( - config, 'steps', args, defaults) + verbosity = get_from_config_or_commandline(config, 'verbose', args, + defaults) + max_steps = get_from_config_or_commandline(config, 'max_steps', args, + defaults) + steps = get_from_config_or_commandline(config, 'steps', args, defaults) hooks = getattr(config, 'hooks', None) # Sets-up logging @@ -75,8 +73,8 @@ def main(argv=None): train_input_fn = config.train_input_fn # Train - estimator.train(input_fn=train_input_fn, hooks=hooks, steps=steps, - max_steps=max_steps) + estimator.train( + input_fn=train_input_fn, hooks=hooks, steps=steps, max_steps=max_steps) if __name__ == '__main__': diff --git a/bob/learn/tensorflow/test/data/dummy_verify_config.py b/bob/learn/tensorflow/test/data/dummy_verify_config.py index d2b26163331ea2c8767fa8730723c33f270f435b..08279834a8e4692f846fe7770f344220ba3e29d5 100644 --- a/bob/learn/tensorflow/test/data/dummy_verify_config.py +++ b/bob/learn/tensorflow/test/data/dummy_verify_config.py @@ -18,8 +18,8 @@ def file_to_label(f): def reader(biofile): - data = read_original_data( - biofile, database.original_directory, database.original_extension) + data = read_original_data(biofile, database.original_directory, + database.original_extension) label = file_to_label(biofile) key = str(biofile.path).encode("utf-8") return (data, label, key) diff --git a/bob/learn/tensorflow/test/data/mnist_estimator.py b/bob/learn/tensorflow/test/data/mnist_estimator.py index fd028d9f1f9745c953cbd9abdb10d44c18703ca0..224e974c2d8dc9627fd38e0a8fead61318f3b425 100644 --- a/bob/learn/tensorflow/test/data/mnist_estimator.py +++ b/bob/learn/tensorflow/test/data/mnist_estimator.py @@ -1,4 +1,3 @@ import tensorflow as tf data = tf.feature_column.numeric_column('data', shape=[784]) -estimator = tf.estimator.LinearClassifier( - feature_columns=[data], n_classes=10) +estimator = tf.estimator.LinearClassifier(feature_columns=[data], n_classes=10) diff --git a/bob/learn/tensorflow/test/data/mnist_input_fn.py b/bob/learn/tensorflow/test/data/mnist_input_fn.py index 828e42974347cd239c520e6c0245c7477ea35719..75eb39c548b7d854dde6c55c10bd115392626003 100644 --- a/bob/learn/tensorflow/test/data/mnist_input_fn.py +++ b/bob/learn/tensorflow/test/data/mnist_input_fn.py @@ -15,7 +15,8 @@ def input_fn(mode): shuffle = True data, labels = database.data(groups=groups) return tf.estimator.inputs.numpy_input_fn( - x={"data": data.astype('float32'), 'key': labels.astype('float32')}, + x={"data": data.astype('float32'), + 'key': labels.astype('float32')}, y=labels.astype('int32'), batch_size=128, num_epochs=num_epochs, diff --git a/bob/learn/tensorflow/test/data/train_scripts/siamese.py b/bob/learn/tensorflow/test/data/train_scripts/siamese.py index d8b0de1f7148775e56251ee498f524f253dec4b1..3658e71f5103b4a4f7e8f7603dcf51413165edca 100644 --- a/bob/learn/tensorflow/test/data/train_scripts/siamese.py +++ b/bob/learn/tensorflow/test/data/train_scripts/siamese.py @@ -16,10 +16,12 @@ train_data, train_labels, validation_data, validation_labels = \ load_mnist() train_data = numpy.reshape(train_data, (train_data.shape[0], 28, 28, 1)) -train_data_shuffler = SiameseMemory(train_data, train_labels, - input_shape=INPUT_SHAPE, - batch_size=BATCH_SIZE, - normalizer=ScaleFactor()) +train_data_shuffler = SiameseMemory( + train_data, + train_labels, + input_shape=INPUT_SHAPE, + batch_size=BATCH_SIZE, + normalizer=ScaleFactor()) ### ARCHITECTURE ### architecture = Chopra(seed=SEED, n_classes=10) diff --git a/bob/learn/tensorflow/test/data/train_scripts/softmax.py b/bob/learn/tensorflow/test/data/train_scripts/softmax.py index 94daceef1c06175c30a02b88660b428599c7d20e..ed48ececfe66b19d7d5d83dbed6166de0d75f90e 100644 --- a/bob/learn/tensorflow/test/data/train_scripts/softmax.py +++ b/bob/learn/tensorflow/test/data/train_scripts/softmax.py @@ -11,15 +11,16 @@ INPUT_SHAPE = [None, 28, 28, 1] SEED = 10 USE_GPU = False - ### PREPARING DATASHUFFLER ### train_data, train_labels, validation_data, validation_labels = load_mnist() train_data = numpy.reshape(train_data, (train_data.shape[0], 28, 28, 1)) -train_data_shuffler = Memory(train_data, train_labels, - input_shape=INPUT_SHAPE, - batch_size=BATCH_SIZE, - normalizer=ScaleFactor()) +train_data_shuffler = Memory( + train_data, + train_labels, + input_shape=INPUT_SHAPE, + batch_size=BATCH_SIZE, + normalizer=ScaleFactor()) ### ARCHITECTURE ### architecture = chopra(seed=SEED, n_classes=10) @@ -30,11 +31,8 @@ loss = MeanSoftMaxLoss() ### LEARNING RATE ### learning_rate = constant(base_learning_rate=0.01) - ### SOLVER ### optimizer = tf.train.GradientDescentOptimizer(learning_rate) ### Trainer ### trainer = Trainer - - diff --git a/bob/learn/tensorflow/test/data/train_scripts/triplet.py b/bob/learn/tensorflow/test/data/train_scripts/triplet.py index 3ef79480b829eff8c9e2c027e1cf0a425e3342f2..35908c8e305eb64359f183d3fd74afee541a8a01 100644 --- a/bob/learn/tensorflow/test/data/train_scripts/triplet.py +++ b/bob/learn/tensorflow/test/data/train_scripts/triplet.py @@ -16,9 +16,8 @@ train_data, train_labels, validation_data, validation_labels = \ load_mnist() train_data = numpy.reshape(train_data, (train_data.shape[0], 28, 28, 1)) -train_data_shuffler = TripletMemory(train_data, train_labels, - input_shape=INPUT_SHAPE, - batch_size=BATCH_SIZE) +train_data_shuffler = TripletMemory( + train_data, train_labels, input_shape=INPUT_SHAPE, batch_size=BATCH_SIZE) ### ARCHITECTURE ### architecture = Chopra(seed=SEED, n_classes=10) @@ -26,14 +25,11 @@ architecture = Chopra(seed=SEED, n_classes=10) ### LOSS ### loss = TripletLoss(margin=4.) - ### LEARNING RATE ### learning_rate = constant(base_learning_rate=0.01) - ### SOLVER ### optimizer = tf.train.GradientDescentOptimizer(learning_rate) - ### Trainer ### trainer = Trainer diff --git a/bob/learn/tensorflow/test/test_cnn.py b/bob/learn/tensorflow/test/test_cnn.py index aef4b92cd0464f4e59b28309d35eac7f31cf2be6..b34dd39e41ff208e72e9ec524f65a48fdd64748b 100644 --- a/bob/learn/tensorflow/test/test_cnn.py +++ b/bob/learn/tensorflow/test/test_cnn.py @@ -12,14 +12,12 @@ from bob.learn.tensorflow.test.test_cnn_scratch import validate_network from bob.learn.tensorflow.network import Embedding, light_cnn9 from bob.learn.tensorflow.network.utils import append_logits - from bob.learn.tensorflow.utils import load_mnist import tensorflow as tf import bob.io.base import shutil from scipy.spatial.distance import cosine import bob.measure - """ Some unit tests for the datashuffler """ @@ -30,6 +28,7 @@ iterations = 200 seed = 10 numpy.random.seed(seed) + def dummy_experiment(data_s, embedding): """ Create a dummy experiment and return the EER @@ -50,7 +49,8 @@ def dummy_experiment(data_s, embedding): # Creating models models = [] for i in range(len(data_shuffler.possible_labels)): - indexes_model = numpy.where(enroll_labels == data_shuffler.possible_labels[i])[0] + indexes_model = numpy.where( + enroll_labels == data_shuffler.possible_labels[i])[0] models.append(numpy.mean(enroll_features[indexes_model, :], axis=0)) # Probing @@ -61,17 +61,25 @@ def dummy_experiment(data_s, embedding): # Positive scoring indexes = probe_labels == data_shuffler.possible_labels[i] positive_data = probe_features[indexes, :] - p = [cosine(models[i], positive_data[j]) for j in range(positive_data.shape[0])] + p = [ + cosine(models[i], positive_data[j]) + for j in range(positive_data.shape[0]) + ] positive_scores = numpy.hstack((positive_scores, p)) # negative scoring indexes = probe_labels != data_shuffler.possible_labels[i] negative_data = probe_features[indexes, :] - n = [cosine(models[i], negative_data[j]) for j in range(negative_data.shape[0])] + n = [ + cosine(models[i], negative_data[j]) + for j in range(negative_data.shape[0]) + ] negative_scores = numpy.hstack((negative_scores, n)) - threshold = bob.measure.eer_threshold((-1) * negative_scores, (-1) * positive_scores) - far, frr = bob.measure.farfrr((-1) * negative_scores, (-1) * positive_scores, threshold) + threshold = bob.measure.eer_threshold((-1) * negative_scores, + (-1) * positive_scores) + far, frr = bob.measure.farfrr((-1) * negative_scores, + (-1) * positive_scores, threshold) return (far + frr) / 2. @@ -83,12 +91,15 @@ def test_cnn_trainer(): train_data, train_labels, validation_data, validation_labels = load_mnist() # * 0.00390625 train_data = numpy.reshape(train_data, (train_data.shape[0], 28, 28, 1)) - validation_data = numpy.reshape(validation_data, (validation_data.shape[0], 28, 28, 1)) + validation_data = numpy.reshape(validation_data, + (validation_data.shape[0], 28, 28, 1)) # Creating datashufflers - train_data_shuffler = Memory(train_data, train_labels, - input_shape=[None, 28, 28, 1], - batch_size=batch_size) + train_data_shuffler = Memory( + train_data, + train_labels, + input_shape=[None, 28, 28, 1], + batch_size=batch_size) directory = "./temp/cnn" @@ -96,29 +107,31 @@ def test_cnn_trainer(): inputs = train_data_shuffler("data", from_queue=True) labels = train_data_shuffler("label", from_queue=True) logits = append_logits(dummy(inputs)[0], n_classes=10) - + # Loss for the softmax loss = mean_cross_entropy_loss(logits, labels) - + embedding = Embedding(inputs, logits) # One graph trainer - trainer = Trainer(train_data_shuffler, - iterations=iterations, - analizer=None, - temp_dir=directory - ) - learning_rate=constant(0.1, name="regular_lr") - trainer.create_network_from_scratch(graph=logits, - loss=loss, - learning_rate=learning_rate, - optimizer=tf.train.GradientDescentOptimizer(learning_rate), - ) + trainer = Trainer( + train_data_shuffler, + iterations=iterations, + analizer=None, + temp_dir=directory) + learning_rate = constant(0.1, name="regular_lr") + trainer.create_network_from_scratch( + graph=logits, + loss=loss, + learning_rate=learning_rate, + optimizer=tf.train.GradientDescentOptimizer(learning_rate), + ) trainer.train() #trainer.train(validation_data_shuffler) - # Using embedding to compute the accuracy - accuracy = validate_network(embedding, validation_data, validation_labels, normalizer=None) + # Using embedding to compute the accuracy + accuracy = validate_network( + embedding, validation_data, validation_labels, normalizer=None) # At least 20% of accuracy assert accuracy > 20. @@ -126,7 +139,7 @@ def test_cnn_trainer(): del trainer del logits tf.reset_default_graph() - assert len(tf.global_variables())==0 + assert len(tf.global_variables()) == 0 def test_lightcnn_trainer(): @@ -134,18 +147,26 @@ def test_lightcnn_trainer(): # generating fake data train_data = numpy.random.normal(0, 0.2, size=(100, 128, 128, 1)) - train_data = numpy.vstack((train_data, numpy.random.normal(2, 0.2, size=(100, 128, 128, 1)))) - train_labels = numpy.hstack((numpy.zeros(100), numpy.ones(100))).astype("uint64") - + train_data = numpy.vstack((train_data, + numpy.random.normal( + 2, 0.2, size=(100, 128, 128, 1)))) + train_labels = numpy.hstack((numpy.zeros(100), + numpy.ones(100))).astype("uint64") + validation_data = numpy.random.normal(0, 0.2, size=(100, 128, 128, 1)) - validation_data = numpy.vstack((validation_data, numpy.random.normal(2, 0.2, size=(100, 128, 128, 1)))) - validation_labels = numpy.hstack((numpy.zeros(100), numpy.ones(100))).astype("uint64") + validation_data = numpy.vstack((validation_data, + numpy.random.normal( + 2, 0.2, size=(100, 128, 128, 1)))) + validation_labels = numpy.hstack((numpy.zeros(100), + numpy.ones(100))).astype("uint64") # Creating datashufflers - train_data_shuffler = Memory(train_data, train_labels, - input_shape=[None, 128, 128, 1], - batch_size=batch_size, - normalizer=scale_factor) + train_data_shuffler = Memory( + train_data, + train_labels, + input_shape=[None, 128, 128, 1], + batch_size=batch_size, + normalizer=scale_factor) directory = "./temp/cnn" @@ -154,35 +175,38 @@ def test_lightcnn_trainer(): labels = train_data_shuffler("label", from_queue=True) prelogits = light_cnn9(inputs)[0] logits = append_logits(prelogits, n_classes=10) - - embedding = Embedding(train_data_shuffler("data", from_queue=False), logits) - + + embedding = Embedding( + train_data_shuffler("data", from_queue=False), logits) + # Loss for the softmax loss = mean_cross_entropy_loss(logits, labels) - # One graph trainer - trainer = Trainer(train_data_shuffler, - iterations=4, - analizer=None, - temp_dir=directory - ) - trainer.create_network_from_scratch(graph=logits, - loss=loss, - learning_rate=constant(0.001, name="regular_lr"), - optimizer=tf.train.GradientDescentOptimizer(0.001), - ) + trainer = Trainer( + train_data_shuffler, iterations=4, analizer=None, temp_dir=directory) + trainer.create_network_from_scratch( + graph=logits, + loss=loss, + learning_rate=constant(0.001, name="regular_lr"), + optimizer=tf.train.GradientDescentOptimizer(0.001), + ) trainer.train() #trainer.train(validation_data_shuffler) # Using embedding to compute the accuracy - accuracy = validate_network(embedding, validation_data, validation_labels, input_shape=[None, 128, 128, 1], normalizer=scale_factor) + accuracy = validate_network( + embedding, + validation_data, + validation_labels, + input_shape=[None, 128, 128, 1], + normalizer=scale_factor) assert True shutil.rmtree(directory) del trainer del logits tf.reset_default_graph() - assert len(tf.global_variables())==0 + assert len(tf.global_variables()) == 0 def test_siamesecnn_trainer(): @@ -190,15 +214,20 @@ def test_siamesecnn_trainer(): train_data, train_labels, validation_data, validation_labels = load_mnist() train_data = numpy.reshape(train_data, (train_data.shape[0], 28, 28, 1)) - validation_data = numpy.reshape(validation_data, (validation_data.shape[0], 28, 28, 1)) + validation_data = numpy.reshape(validation_data, + (validation_data.shape[0], 28, 28, 1)) # Creating datashufflers - train_data_shuffler = SiameseMemory(train_data, train_labels, - input_shape=[None, 28, 28, 1], - batch_size=batch_size) - validation_data_shuffler = SiameseMemory(validation_data, validation_labels, - input_shape=[None, 28, 28, 1], - batch_size=validation_batch_size) + train_data_shuffler = SiameseMemory( + train_data, + train_labels, + input_shape=[None, 28, 28, 1], + batch_size=batch_size) + validation_data_shuffler = SiameseMemory( + validation_data, + validation_labels, + input_shape=[None, 28, 28, 1], + batch_size=validation_batch_size) directory = "./temp/siamesecnn" # Building the graph @@ -209,27 +238,32 @@ def test_siamesecnn_trainer(): graph['right'] = dummy(inputs['right'], reuse=True)[0] # Loss for the Siamese - loss = contrastive_loss_deprecated(graph['left'], graph['right'], labels, contrastive_margin=4.) - - trainer = SiameseTrainer(train_data_shuffler, - iterations=iterations, - analizer=None, - temp_dir=directory) - - trainer.create_network_from_scratch(graph=graph, - loss=loss, - learning_rate=constant(0.01, name="regular_lr"), - optimizer=tf.train.GradientDescentOptimizer(0.01),) - + loss = contrastive_loss_deprecated( + graph['left'], graph['right'], labels, contrastive_margin=4.) + + trainer = SiameseTrainer( + train_data_shuffler, + iterations=iterations, + analizer=None, + temp_dir=directory) + + trainer.create_network_from_scratch( + graph=graph, + loss=loss, + learning_rate=constant(0.01, name="regular_lr"), + optimizer=tf.train.GradientDescentOptimizer(0.01), + ) + trainer.train() - embedding = Embedding(train_data_shuffler("data", from_queue=False)['left'], graph['left']) + embedding = Embedding( + train_data_shuffler("data", from_queue=False)['left'], graph['left']) eer = dummy_experiment(validation_data_shuffler, embedding) assert eer < 0.15 shutil.rmtree(directory) del trainer # Just to clean tf.variables tf.reset_default_graph() - assert len(tf.global_variables())==0 + assert len(tf.global_variables()) == 0 def test_tripletcnn_trainer(): @@ -237,15 +271,20 @@ def test_tripletcnn_trainer(): train_data, train_labels, validation_data, validation_labels = load_mnist() train_data = numpy.reshape(train_data, (train_data.shape[0], 28, 28, 1)) - validation_data = numpy.reshape(validation_data, (validation_data.shape[0], 28, 28, 1)) + validation_data = numpy.reshape(validation_data, + (validation_data.shape[0], 28, 28, 1)) # Creating datashufflers - train_data_shuffler = TripletMemory(train_data, train_labels, - input_shape=[None, 28, 28, 1], - batch_size=batch_size) - validation_data_shuffler = TripletMemory(validation_data, validation_labels, - input_shape=[None, 28, 28, 1], - batch_size=validation_batch_size) + train_data_shuffler = TripletMemory( + train_data, + train_labels, + input_shape=[None, 28, 28, 1], + batch_size=batch_size) + validation_data_shuffler = TripletMemory( + validation_data, + validation_labels, + input_shape=[None, 28, 28, 1], + batch_size=validation_batch_size) directory = "./temp/tripletcnn" @@ -256,25 +295,29 @@ def test_tripletcnn_trainer(): graph['positive'] = dummy(inputs['positive'], reuse=True)[0] graph['negative'] = dummy(inputs['negative'], reuse=True)[0] - loss = triplet_loss_deprecated(graph['anchor'], graph['positive'], graph['negative']) + loss = triplet_loss_deprecated(graph['anchor'], graph['positive'], + graph['negative']) # One graph trainer - trainer = TripletTrainer(train_data_shuffler, - iterations=iterations, - analizer=None, - temp_dir=directory - ) - trainer.create_network_from_scratch(graph=graph, - loss=loss, - learning_rate=constant(0.1, name="regular_lr"), - optimizer=tf.train.GradientDescentOptimizer(0.1),) + trainer = TripletTrainer( + train_data_shuffler, + iterations=iterations, + analizer=None, + temp_dir=directory) + trainer.create_network_from_scratch( + graph=graph, + loss=loss, + learning_rate=constant(0.1, name="regular_lr"), + optimizer=tf.train.GradientDescentOptimizer(0.1), + ) trainer.train() - embedding = Embedding(train_data_shuffler("data", from_queue=False)['anchor'], graph['anchor']) + embedding = Embedding( + train_data_shuffler("data", from_queue=False)['anchor'], + graph['anchor']) eer = dummy_experiment(validation_data_shuffler, embedding) assert eer < 0.25 shutil.rmtree(directory) del trainer # Just to clean tf.variables tf.reset_default_graph() - assert len(tf.global_variables())==0 - + assert len(tf.global_variables()) == 0 diff --git a/bob/learn/tensorflow/test/test_cnn_other_losses.py b/bob/learn/tensorflow/test/test_cnn_other_losses.py index a7e4a5068ac1d9c4bfa364c4cdc440417b1ab791..30384a6b6639c83a92f1fef615760e762a8c070e 100644 --- a/bob/learn/tensorflow/test/test_cnn_other_losses.py +++ b/bob/learn/tensorflow/test/test_cnn_other_losses.py @@ -12,7 +12,6 @@ from bob.learn.tensorflow.network.utils import append_logits import tensorflow as tf import shutil import os - """ Some unit tests that create networks on the fly """ @@ -35,15 +34,27 @@ def scratch_network_embeding_example(train_data_shuffler, reuse=False): # Creating a random network initializer = tf.contrib.layers.xavier_initializer(seed=seed) - graph = slim.conv2d(inputs, 10, [3, 3], activation_fn=tf.nn.relu, stride=1, scope='conv1', - weights_initializer=initializer, reuse=reuse) + graph = slim.conv2d( + inputs, + 10, [3, 3], + activation_fn=tf.nn.relu, + stride=1, + scope='conv1', + weights_initializer=initializer, + reuse=reuse) graph = slim.max_pool2d(graph, [4, 4], scope='pool1') graph = slim.flatten(graph, scope='flatten1') - prelogits = slim.fully_connected(graph, 30, activation_fn=None, scope='fc1', - weights_initializer=initializer, reuse=reuse) + prelogits = slim.fully_connected( + graph, + 30, + activation_fn=None, + scope='fc1', + weights_initializer=initializer, + reuse=reuse) return prelogits + def test_center_loss_tfrecord_embedding_validation(): tf.reset_default_graph() @@ -64,96 +75,103 @@ def test_center_loss_tfrecord_embedding_validation(): for i in range(6000): img = data[i] img_raw = img.tostring() - - feature = {'train/data': _bytes_feature(img_raw), - 'train/label': _int64_feature(labels[i]) - } - - example = tf.train.Example(features=tf.train.Features(feature=feature)) + + feature = { + 'train/data': _bytes_feature(img_raw), + 'train/label': _int64_feature(labels[i]) + } + + example = tf.train.Example( + features=tf.train.Features(feature=feature)) writer.write(example.SerializeToString()) writer.close() - + tf.reset_default_graph() - + # Creating the tf record - tfrecords_filename = "mnist_train.tfrecords" + tfrecords_filename = "mnist_train.tfrecords" create_tf_record(tfrecords_filename, train_data, train_labels) - filename_queue = tf.train.string_input_producer([tfrecords_filename], num_epochs=55, name="input") - - tfrecords_filename_val = "mnist_validation.tfrecords" - create_tf_record(tfrecords_filename_val, validation_data, validation_labels) - filename_queue_val = tf.train.string_input_producer([tfrecords_filename_val], num_epochs=55, name="input_validation") + filename_queue = tf.train.string_input_producer( + [tfrecords_filename], num_epochs=55, name="input") + tfrecords_filename_val = "mnist_validation.tfrecords" + create_tf_record(tfrecords_filename_val, validation_data, + validation_labels) + filename_queue_val = tf.train.string_input_producer( + [tfrecords_filename_val], num_epochs=55, name="input_validation") # Creating the CNN using the TFRecord as input - train_data_shuffler = TFRecord(filename_queue=filename_queue, - batch_size=batch_size) + train_data_shuffler = TFRecord( + filename_queue=filename_queue, batch_size=batch_size) + + validation_data_shuffler = TFRecord( + filename_queue=filename_queue_val, batch_size=2000) - validation_data_shuffler = TFRecord(filename_queue=filename_queue_val, - batch_size=2000) - prelogits = scratch_network_embeding_example(train_data_shuffler) logits = append_logits(prelogits, n_classes=10) - validation_graph = tf.nn.l2_normalize(scratch_network_embeding_example(validation_data_shuffler, reuse=True), 1) + validation_graph = tf.nn.l2_normalize( + scratch_network_embeding_example(validation_data_shuffler, reuse=True), + 1) labels = train_data_shuffler("label", from_queue=False) - + # Setting the placeholders # Loss for the softmax - loss = mean_cross_entropy_center_loss(logits, prelogits, labels, n_classes=10, factor=0.1) + loss = mean_cross_entropy_center_loss( + logits, prelogits, labels, n_classes=10, factor=0.1) # One graph trainer - trainer = Trainer(train_data_shuffler, - validation_data_shuffler=validation_data_shuffler, - validate_with_embeddings=True, - iterations=iterations, #It is supper fast - analizer=None, - temp_dir=directory) + trainer = Trainer( + train_data_shuffler, + validation_data_shuffler=validation_data_shuffler, + validate_with_embeddings=True, + iterations=iterations, #It is supper fast + analizer=None, + temp_dir=directory) learning_rate = constant(0.01, name="regular_lr") - trainer.create_network_from_scratch(graph=logits, - validation_graph=validation_graph, - loss=loss, - learning_rate=learning_rate, - optimizer=tf.train.GradientDescentOptimizer(learning_rate), - prelogits=prelogits - ) + trainer.create_network_from_scratch( + graph=logits, + validation_graph=validation_graph, + loss=loss, + learning_rate=learning_rate, + optimizer=tf.train.GradientDescentOptimizer(learning_rate), + prelogits=prelogits) trainer.train() - + assert True tf.reset_default_graph() del trainer - assert len(tf.global_variables())==0 + assert len(tf.global_variables()) == 0 del train_data_shuffler del validation_data_shuffler ##### 2 Continuing the training - + # Creating the CNN using the TFRecord as input - train_data_shuffler = TFRecord(filename_queue=filename_queue, - batch_size=batch_size) + train_data_shuffler = TFRecord( + filename_queue=filename_queue, batch_size=batch_size) + + validation_data_shuffler = TFRecord( + filename_queue=filename_queue_val, batch_size=2000) - validation_data_shuffler = TFRecord(filename_queue=filename_queue_val, - batch_size=2000) - # One graph trainer - trainer = Trainer(train_data_shuffler, - validation_data_shuffler=validation_data_shuffler, - validate_with_embeddings=True, - iterations=2, #It is supper fast - analizer=None, - temp_dir=directory) + trainer = Trainer( + train_data_shuffler, + validation_data_shuffler=validation_data_shuffler, + validate_with_embeddings=True, + iterations=2, #It is supper fast + analizer=None, + temp_dir=directory) trainer.create_network_from_file(directory) trainer.train() - + os.remove(tfrecords_filename) - os.remove(tfrecords_filename_val) + os.remove(tfrecords_filename_val) tf.reset_default_graph() shutil.rmtree(directory) - assert len(tf.global_variables())==0 - - + assert len(tf.global_variables()) == 0 diff --git a/bob/learn/tensorflow/test/test_cnn_prefetch.py b/bob/learn/tensorflow/test/test_cnn_prefetch.py index ad73378d599b5428c88ccd3b073347198c370942..d8891da1e4bcff0911601bcefad8bef2e2a1c163 100644 --- a/bob/learn/tensorflow/test/test_cnn_prefetch.py +++ b/bob/learn/tensorflow/test/test_cnn_prefetch.py @@ -19,7 +19,6 @@ import shutil from scipy.spatial.distance import cosine import bob.measure from .test_cnn import dummy_experiment - """ Some unit tests for the datashuffler """ @@ -36,38 +35,43 @@ def test_cnn_trainer(): # Loading data train_data, train_labels, validation_data, validation_labels = load_mnist() train_data = numpy.reshape(train_data, (train_data.shape[0], 28, 28, 1)) - validation_data = numpy.reshape(validation_data, (validation_data.shape[0], 28, 28, 1)) + validation_data = numpy.reshape(validation_data, + (validation_data.shape[0], 28, 28, 1)) # Creating datashufflers - train_data_shuffler = Memory(train_data, train_labels, - input_shape=[None, 28, 28, 1], - batch_size=batch_size, - prefetch=True, - prefetch_threads=1) + train_data_shuffler = Memory( + train_data, + train_labels, + input_shape=[None, 28, 28, 1], + batch_size=batch_size, + prefetch=True, + prefetch_threads=1) directory = "./temp/cnn" # Preparing the graph inputs = train_data_shuffler("data", from_queue=True) labels = train_data_shuffler("label", from_queue=True) - prelogits,_ = chopra(inputs, seed=seed) + prelogits, _ = chopra(inputs, seed=seed) logits = append_logits(prelogits, n_classes=10) - embedding = Embedding(train_data_shuffler("data", from_queue=False), logits) + embedding = Embedding( + train_data_shuffler("data", from_queue=False), logits) # Loss for the softmax loss = mean_cross_entropy_loss(logits, labels) # One graph trainer - trainer = Trainer(train_data_shuffler, - iterations=iterations, - analizer=None, - temp_dir=directory - ) - trainer.create_network_from_scratch(graph=logits, - loss=loss, - learning_rate=constant(0.01, name="regular_lr"), - optimizer=tf.train.GradientDescentOptimizer(0.01), - ) + trainer = Trainer( + train_data_shuffler, + iterations=iterations, + analizer=None, + temp_dir=directory) + trainer.create_network_from_scratch( + graph=logits, + loss=loss, + learning_rate=constant(0.01, name="regular_lr"), + optimizer=tf.train.GradientDescentOptimizer(0.01), + ) trainer.train() # Using embedding to compute the accuracy @@ -80,11 +84,10 @@ def test_cnn_trainer(): del trainer del embedding tf.reset_default_graph() - assert len(tf.global_variables())==0 + assert len(tf.global_variables()) == 0 def test_siamesecnn_trainer(): - """ tf.reset_default_graph() @@ -140,6 +143,7 @@ def test_siamesecnn_trainer(): """ assert True + def test_tripletcnn_trainer(): """ tf.reset_default_graph() diff --git a/bob/learn/tensorflow/test/test_cnn_pretrained_model.py b/bob/learn/tensorflow/test/test_cnn_pretrained_model.py index 1124ceb1bffa1c69eb7409b3caa64e041b886e8c..b62f3c757e3cb1b71fca70a8a92e783f7c123ff2 100644 --- a/bob/learn/tensorflow/test/test_cnn_pretrained_model.py +++ b/bob/learn/tensorflow/test/test_cnn_pretrained_model.py @@ -14,10 +14,8 @@ from bob.learn.tensorflow.network import Embedding from .test_cnn import dummy_experiment from .test_cnn_scratch import validate_network - import tensorflow as tf import shutil - """ Some unit tests that create networks on the fly and load variables """ @@ -33,18 +31,26 @@ def scratch_network(input_pl, reuse=False): slim = tf.contrib.slim with tf.device("/cpu:0"): - initializer = tf.contrib.layers.xavier_initializer(uniform=False, dtype=tf.float32, seed=10) - - scratch = slim.conv2d(input_pl, 16, [3, 3], activation_fn=tf.nn.relu, - stride=1, - weights_initializer=initializer, - scope='conv1', reuse=reuse) + initializer = tf.contrib.layers.xavier_initializer( + uniform=False, dtype=tf.float32, seed=10) + + scratch = slim.conv2d( + input_pl, + 16, [3, 3], + activation_fn=tf.nn.relu, + stride=1, + weights_initializer=initializer, + scope='conv1', + reuse=reuse) scratch = slim.max_pool2d(scratch, kernel_size=[2, 2], scope='pool1') scratch = slim.flatten(scratch, scope='flatten1') - scratch = slim.fully_connected(scratch, 10, - weights_initializer=initializer, - activation_fn=None, - scope='fc1', reuse=reuse) + scratch = slim.fully_connected( + scratch, + 10, + weights_initializer=initializer, + activation_fn=None, + scope='fc1', + reuse=reuse) return scratch @@ -56,34 +62,40 @@ def test_cnn_pretrained(): train_data, train_labels, validation_data, validation_labels = load_mnist() train_data = numpy.reshape(train_data, (train_data.shape[0], 28, 28, 1)) - # Creating datashufflers - train_data_shuffler = Memory(train_data, train_labels, - input_shape=[None, 28, 28, 1], - batch_size=batch_size) - validation_data = numpy.reshape(validation_data, (validation_data.shape[0], 28, 28, 1)) + # Creating datashufflers + train_data_shuffler = Memory( + train_data, + train_labels, + input_shape=[None, 28, 28, 1], + batch_size=batch_size) + validation_data = numpy.reshape(validation_data, + (validation_data.shape[0], 28, 28, 1)) directory = "./temp/cnn" # Creating a random network inputs = train_data_shuffler("data", from_queue=True) labels = train_data_shuffler("label", from_queue=True) logits = scratch_network(inputs) - embedding = Embedding(train_data_shuffler("data", from_queue=False), logits) + embedding = Embedding( + train_data_shuffler("data", from_queue=False), logits) # Loss for the softmax loss = mean_cross_entropy_loss(logits, labels) # One graph trainer - trainer = Trainer(train_data_shuffler, - iterations=iterations, - analizer=None, - temp_dir=directory) - trainer.create_network_from_scratch(graph=logits, - loss=loss, - learning_rate=constant(0.1, name="regular_lr"), - optimizer=tf.train.GradientDescentOptimizer(0.1)) + trainer = Trainer( + train_data_shuffler, + iterations=iterations, + analizer=None, + temp_dir=directory) + trainer.create_network_from_scratch( + graph=logits, + loss=loss, + learning_rate=constant(0.1, name="regular_lr"), + optimizer=tf.train.GradientDescentOptimizer(0.1)) trainer.train() - accuracy = validate_network(embedding, validation_data, validation_labels, normalizer=None) - + accuracy = validate_network( + embedding, validation_data, validation_labels, normalizer=None) assert accuracy > 20 tf.reset_default_graph() @@ -94,21 +106,22 @@ def test_cnn_pretrained(): del embedding # One graph trainer - trainer = Trainer(train_data_shuffler, - iterations=iterations, - analizer=None, - temp_dir=directory - ) + trainer = Trainer( + train_data_shuffler, + iterations=iterations, + analizer=None, + temp_dir=directory) trainer.create_network_from_file(os.path.join(directory, "model.ckp.meta")) trainer.train() embedding = Embedding(trainer.data_ph, trainer.graph) - accuracy = validate_network(embedding, validation_data, validation_labels, normalizer=None) + accuracy = validate_network( + embedding, validation_data, validation_labels, normalizer=None) assert accuracy > 50 shutil.rmtree(directory) del trainer tf.reset_default_graph() - assert len(tf.global_variables())==0 + assert len(tf.global_variables()) == 0 def test_triplet_cnn_pretrained(): @@ -118,14 +131,19 @@ def test_triplet_cnn_pretrained(): train_data = numpy.reshape(train_data, (train_data.shape[0], 28, 28, 1)) # Creating datashufflers - train_data_shuffler = TripletMemory(train_data, train_labels, - input_shape=[None, 28, 28, 1], - batch_size=batch_size) - validation_data = numpy.reshape(validation_data, (validation_data.shape[0], 28, 28, 1)) - - validation_data_shuffler = TripletMemory(validation_data, validation_labels, - input_shape=[None, 28, 28, 1], - batch_size=validation_batch_size) + train_data_shuffler = TripletMemory( + train_data, + train_labels, + input_shape=[None, 28, 28, 1], + batch_size=batch_size) + validation_data = numpy.reshape(validation_data, + (validation_data.shape[0], 28, 28, 1)) + + validation_data_shuffler = TripletMemory( + validation_data, + validation_labels, + input_shape=[None, 28, 28, 1], + batch_size=validation_batch_size) directory = "./temp/cnn" @@ -137,18 +155,21 @@ def test_triplet_cnn_pretrained(): graph['negative'] = scratch_network(inputs['negative'], reuse=True) # Loss for the softmax - loss = triplet_loss_deprecated(graph['anchor'], graph['positive'], graph['negative'], margin=4.) + loss = triplet_loss_deprecated( + graph['anchor'], graph['positive'], graph['negative'], margin=4.) # One graph trainer - trainer = TripletTrainer(train_data_shuffler, - iterations=iterations, - analizer=None, - temp_dir=directory) - - trainer.create_network_from_scratch(graph=graph, - loss=loss, - learning_rate=constant(0.01, name="regular_lr"), - optimizer=tf.train.GradientDescentOptimizer(0.01)) + trainer = TripletTrainer( + train_data_shuffler, + iterations=iterations, + analizer=None, + temp_dir=directory) + + trainer.create_network_from_scratch( + graph=graph, + loss=loss, + learning_rate=constant(0.01, name="regular_lr"), + optimizer=tf.train.GradientDescentOptimizer(0.01)) trainer.train() # Testing embedding = Embedding(trainer.data_ph['anchor'], trainer.graph['anchor']) @@ -162,10 +183,11 @@ def test_triplet_cnn_pretrained(): del trainer # Training the network using a pre trained model - trainer = TripletTrainer(train_data_shuffler, - iterations=iterations*2, - analizer=None, - temp_dir=directory) + trainer = TripletTrainer( + train_data_shuffler, + iterations=iterations * 2, + analizer=None, + temp_dir=directory) trainer.create_network_from_file(os.path.join(directory, "model.ckp.meta")) trainer.train() @@ -179,7 +201,7 @@ def test_triplet_cnn_pretrained(): del trainer tf.reset_default_graph() - assert len(tf.global_variables())==0 + assert len(tf.global_variables()) == 0 def test_siamese_cnn_pretrained(): @@ -190,14 +212,19 @@ def test_siamese_cnn_pretrained(): train_data = numpy.reshape(train_data, (train_data.shape[0], 28, 28, 1)) # Creating datashufflers - train_data_shuffler = SiameseMemory(train_data, train_labels, - input_shape=[None, 28, 28, 1], - batch_size=batch_size) - validation_data = numpy.reshape(validation_data, (validation_data.shape[0], 28, 28, 1)) - - validation_data_shuffler = SiameseMemory(validation_data, validation_labels, - input_shape=[None, 28, 28, 1], - batch_size=validation_batch_size) + train_data_shuffler = SiameseMemory( + train_data, + train_labels, + input_shape=[None, 28, 28, 1], + batch_size=batch_size) + validation_data = numpy.reshape(validation_data, + (validation_data.shape[0], 28, 28, 1)) + + validation_data_shuffler = SiameseMemory( + validation_data, + validation_labels, + input_shape=[None, 28, 28, 1], + batch_size=validation_batch_size) directory = "./temp/cnn" # Creating graph @@ -208,17 +235,20 @@ def test_siamese_cnn_pretrained(): graph['right'] = scratch_network(inputs['right'], reuse=True) # Loss for the softmax - loss = contrastive_loss_deprecated(graph['left'], graph['right'], labels, contrastive_margin=4.) + loss = contrastive_loss_deprecated( + graph['left'], graph['right'], labels, contrastive_margin=4.) # One graph trainer - trainer = SiameseTrainer(train_data_shuffler, - iterations=iterations, - analizer=None, - temp_dir=directory) - - trainer.create_network_from_scratch(graph=graph, - loss=loss, - learning_rate=constant(0.01, name="regular_lr"), - optimizer=tf.train.GradientDescentOptimizer(0.01)) + trainer = SiameseTrainer( + train_data_shuffler, + iterations=iterations, + analizer=None, + temp_dir=directory) + + trainer.create_network_from_scratch( + graph=graph, + loss=loss, + learning_rate=constant(0.01, name="regular_lr"), + optimizer=tf.train.GradientDescentOptimizer(0.01)) trainer.train() # Testing @@ -231,10 +261,11 @@ def test_siamese_cnn_pretrained(): del loss del trainer - trainer = SiameseTrainer(train_data_shuffler, - iterations=iterations, - analizer=None, - temp_dir=directory) + trainer = SiameseTrainer( + train_data_shuffler, + iterations=iterations, + analizer=None, + temp_dir=directory) trainer.create_network_from_file(os.path.join(directory, "model.ckp.meta")) trainer.train() @@ -248,5 +279,4 @@ def test_siamese_cnn_pretrained(): del trainer tf.reset_default_graph() - assert len(tf.global_variables())==0 - + assert len(tf.global_variables()) == 0 diff --git a/bob/learn/tensorflow/test/test_cnn_scratch.py b/bob/learn/tensorflow/test/test_cnn_scratch.py index edc60426e34198f9a6e2a48f2e59a0c7aec12d65..3e8ab27d809f713cbdc5e8650d85c5fb07e2a1df 100644 --- a/bob/learn/tensorflow/test/test_cnn_scratch.py +++ b/bob/learn/tensorflow/test/test_cnn_scratch.py @@ -12,7 +12,6 @@ from bob.learn.tensorflow.utils import load_mnist import tensorflow as tf import shutil import os - """ Some unit tests that create networks on the fly """ @@ -35,17 +34,30 @@ def scratch_network(train_data_shuffler, reuse=False): # Creating a random network initializer = tf.contrib.layers.xavier_initializer(seed=seed) - graph = slim.conv2d(inputs, 10, [3, 3], activation_fn=tf.nn.relu, stride=1, scope='conv1', - weights_initializer=initializer, reuse=reuse) + graph = slim.conv2d( + inputs, + 10, [3, 3], + activation_fn=tf.nn.relu, + stride=1, + scope='conv1', + weights_initializer=initializer, + reuse=reuse) graph = slim.max_pool2d(graph, [4, 4], scope='pool1') graph = slim.flatten(graph, scope='flatten1') - graph = slim.fully_connected(graph, 10, activation_fn=None, scope='fc1', - weights_initializer=initializer, reuse=reuse) + graph = slim.fully_connected( + graph, + 10, + activation_fn=None, + scope='fc1', + weights_initializer=initializer, + reuse=reuse) return graph -def scratch_network_embeding_example(train_data_shuffler, reuse=False, get_embedding=False): +def scratch_network_embeding_example(train_data_shuffler, + reuse=False, + get_embedding=False): if isinstance(train_data_shuffler, tf.Tensor): inputs = train_data_shuffler @@ -54,34 +66,55 @@ def scratch_network_embeding_example(train_data_shuffler, reuse=False, get_embed # Creating a random network initializer = tf.contrib.layers.xavier_initializer(seed=seed) - graph = slim.conv2d(inputs, 10, [3, 3], activation_fn=tf.nn.relu, stride=1, scope='conv1', - weights_initializer=initializer, reuse=reuse) + graph = slim.conv2d( + inputs, + 10, [3, 3], + activation_fn=tf.nn.relu, + stride=1, + scope='conv1', + weights_initializer=initializer, + reuse=reuse) graph = slim.max_pool2d(graph, [4, 4], scope='pool1') graph = slim.flatten(graph, scope='flatten1') - graph = slim.fully_connected(graph, 30, activation_fn=None, scope='fc1', - weights_initializer=initializer, reuse=reuse) + graph = slim.fully_connected( + graph, + 30, + activation_fn=None, + scope='fc1', + weights_initializer=initializer, + reuse=reuse) if get_embedding: graph = tf.nn.l2_normalize(graph, dim=1, name="embedding") else: - graph = slim.fully_connected(graph, 10, activation_fn=None, scope='logits', - weights_initializer=initializer, reuse=reuse) - - return graph - + graph = slim.fully_connected( + graph, + 10, + activation_fn=None, + scope='logits', + weights_initializer=initializer, + reuse=reuse) + return graph -def validate_network(embedding, validation_data, validation_labels, input_shape=[None, 28, 28, 1], normalizer=scale_factor): +def validate_network(embedding, + validation_data, + validation_labels, + input_shape=[None, 28, 28, 1], + normalizer=scale_factor): # Testing - validation_data_shuffler = Memory(validation_data, validation_labels, - input_shape=input_shape, - batch_size=validation_batch_size, - normalizer=normalizer) + validation_data_shuffler = Memory( + validation_data, + validation_labels, + input_shape=input_shape, + batch_size=validation_batch_size, + normalizer=normalizer) [data, labels] = validation_data_shuffler.get_batch() predictions = embedding(data) - accuracy = 100. * numpy.sum(numpy.argmax(predictions, axis=1) == labels) / predictions.shape[0] + accuracy = 100. * numpy.sum( + numpy.argmax(predictions, axis=1) == labels) / predictions.shape[0] return accuracy @@ -93,11 +126,14 @@ def test_cnn_trainer_scratch(): train_data = numpy.reshape(train_data, (train_data.shape[0], 28, 28, 1)) # Creating datashufflers - train_data_shuffler = Memory(train_data, train_labels, - input_shape=[None, 28, 28, 1], - batch_size=batch_size) + train_data_shuffler = Memory( + train_data, + train_labels, + input_shape=[None, 28, 28, 1], + batch_size=batch_size) - validation_data = numpy.reshape(validation_data, (validation_data.shape[0], 28, 28, 1)) + validation_data = numpy.reshape(validation_data, + (validation_data.shape[0], 28, 28, 1)) # Create scratch network logits = scratch_network(train_data_shuffler) @@ -105,27 +141,31 @@ def test_cnn_trainer_scratch(): loss = mean_cross_entropy_loss(logits, labels) # Setting the placeholders - embedding = Embedding(train_data_shuffler("data", from_queue=False), logits) + embedding = Embedding( + train_data_shuffler("data", from_queue=False), logits) # One graph trainer - trainer = Trainer(train_data_shuffler, - iterations=iterations, - analizer=None, - temp_dir=directory) - - trainer.create_network_from_scratch(graph=logits, - loss=loss, - learning_rate=constant(0.01, name="regular_lr"), - optimizer=tf.train.GradientDescentOptimizer(0.01), - ) + trainer = Trainer( + train_data_shuffler, + iterations=iterations, + analizer=None, + temp_dir=directory) + + trainer.create_network_from_scratch( + graph=logits, + loss=loss, + learning_rate=constant(0.01, name="regular_lr"), + optimizer=tf.train.GradientDescentOptimizer(0.01), + ) trainer.train() - accuracy = validate_network(embedding, validation_data, validation_labels, normalizer=None) + accuracy = validate_network( + embedding, validation_data, validation_labels, normalizer=None) assert accuracy > 20 shutil.rmtree(directory) del trainer - tf.reset_default_graph() - assert len(tf.global_variables())==0 + tf.reset_default_graph() + assert len(tf.global_variables()) == 0 def test_cnn_tfrecord(): @@ -148,70 +188,78 @@ def test_cnn_tfrecord(): for i in range(6000): img = data[i] img_raw = img.tostring() - - feature = {'train/data': _bytes_feature(img_raw), - 'train/label': _int64_feature(labels[i]) - } - - example = tf.train.Example(features=tf.train.Features(feature=feature)) + + feature = { + 'train/data': _bytes_feature(img_raw), + 'train/label': _int64_feature(labels[i]) + } + + example = tf.train.Example( + features=tf.train.Features(feature=feature)) writer.write(example.SerializeToString()) writer.close() tf.reset_default_graph() - + # Creating the tf record - tfrecords_filename = "mnist_train.tfrecords" + tfrecords_filename = "mnist_train.tfrecords" create_tf_record(tfrecords_filename, train_data, train_labels) - filename_queue = tf.train.string_input_producer([tfrecords_filename], num_epochs=15, name="input") - + filename_queue = tf.train.string_input_producer( + [tfrecords_filename], num_epochs=15, name="input") + tfrecords_filename_val = "mnist_validation.tfrecords" - create_tf_record(tfrecords_filename_val, validation_data, validation_labels) - filename_queue_val = tf.train.string_input_producer([tfrecords_filename_val], num_epochs=15, name="input_validation") + create_tf_record(tfrecords_filename_val, validation_data, + validation_labels) + filename_queue_val = tf.train.string_input_producer( + [tfrecords_filename_val], num_epochs=15, name="input_validation") # Creating the CNN using the TFRecord as input - train_data_shuffler = TFRecord(filename_queue=filename_queue, - batch_size=batch_size) + train_data_shuffler = TFRecord( + filename_queue=filename_queue, batch_size=batch_size) + + validation_data_shuffler = TFRecord( + filename_queue=filename_queue_val, batch_size=2000) - validation_data_shuffler = TFRecord(filename_queue=filename_queue_val, - batch_size=2000) - logits = scratch_network(train_data_shuffler) labels = train_data_shuffler("label", from_queue=False) validation_logits = scratch_network(validation_data_shuffler, reuse=True) validation_labels = validation_data_shuffler("label", from_queue=False) - + # Setting the placeholders # Loss for the softmax loss = mean_cross_entropy_loss(logits, labels) - validation_loss = mean_cross_entropy_loss(validation_logits, validation_labels) + validation_loss = mean_cross_entropy_loss(validation_logits, + validation_labels) # One graph trainer - - trainer = Trainer(train_data_shuffler, - validation_data_shuffler=validation_data_shuffler, - iterations=iterations, #It is supper fast - analizer=None, - temp_dir=directory) + + trainer = Trainer( + train_data_shuffler, + validation_data_shuffler=validation_data_shuffler, + iterations=iterations, #It is supper fast + analizer=None, + temp_dir=directory) learning_rate = constant(0.01, name="regular_lr") - trainer.create_network_from_scratch(graph=logits, - validation_graph=validation_logits, - loss=loss, - validation_loss=validation_loss, - learning_rate=learning_rate, - optimizer=tf.train.GradientDescentOptimizer(learning_rate), - ) - + trainer.create_network_from_scratch( + graph=logits, + validation_graph=validation_logits, + loss=loss, + validation_loss=validation_loss, + learning_rate=learning_rate, + optimizer=tf.train.GradientDescentOptimizer(learning_rate), + ) + trainer.train() os.remove(tfrecords_filename) - os.remove(tfrecords_filename_val) + os.remove(tfrecords_filename_val) assert True tf.reset_default_graph() del trainer - assert len(tf.global_variables())==0 - + assert len(tf.global_variables()) == 0 + # Inference. TODO: Wrap this in a package file_name = os.path.join(directory, "model.ckp.meta") images = tf.placeholder(tf.float32, shape=(None, 28, 28, 1)) @@ -220,15 +268,16 @@ def test_cnn_tfrecord(): session = tf.Session() session.run(tf.global_variables_initializer()) saver = tf.train.import_meta_graph(file_name, clear_devices=True) - saver.restore(session, tf.train.latest_checkpoint(os.path.dirname("./temp/cnn_scratch/"))) + saver.restore(session, + tf.train.latest_checkpoint( + os.path.dirname("./temp/cnn_scratch/"))) data = numpy.random.rand(2, 28, 28, 1).astype("float32") assert session.run(graph, feed_dict={images: data}).shape == (2, 10) tf.reset_default_graph() shutil.rmtree(directory) - assert len(tf.global_variables())==0 - + assert len(tf.global_variables()) == 0 def test_cnn_tfrecord_embedding_validation(): @@ -251,67 +300,75 @@ def test_cnn_tfrecord_embedding_validation(): for i in range(6000): img = data[i] img_raw = img.tostring() - - feature = {'train/data': _bytes_feature(img_raw), - 'train/label': _int64_feature(labels[i]) - } - - example = tf.train.Example(features=tf.train.Features(feature=feature)) + + feature = { + 'train/data': _bytes_feature(img_raw), + 'train/label': _int64_feature(labels[i]) + } + + example = tf.train.Example( + features=tf.train.Features(feature=feature)) writer.write(example.SerializeToString()) writer.close() - + tf.reset_default_graph() - + # Creating the tf record - tfrecords_filename = "mnist_train.tfrecords" + tfrecords_filename = "mnist_train.tfrecords" create_tf_record(tfrecords_filename, train_data, train_labels) - filename_queue = tf.train.string_input_producer([tfrecords_filename], num_epochs=55, name="input") - + filename_queue = tf.train.string_input_producer( + [tfrecords_filename], num_epochs=55, name="input") + tfrecords_filename_val = "mnist_validation.tfrecords" - create_tf_record(tfrecords_filename_val, validation_data, validation_labels) - filename_queue_val = tf.train.string_input_producer([tfrecords_filename_val], num_epochs=55, name="input_validation") + create_tf_record(tfrecords_filename_val, validation_data, + validation_labels) + filename_queue_val = tf.train.string_input_producer( + [tfrecords_filename_val], num_epochs=55, name="input_validation") # Creating the CNN using the TFRecord as input - train_data_shuffler = TFRecord(filename_queue=filename_queue, - batch_size=batch_size) + train_data_shuffler = TFRecord( + filename_queue=filename_queue, batch_size=batch_size) + + validation_data_shuffler = TFRecord( + filename_queue=filename_queue_val, batch_size=2000) - validation_data_shuffler = TFRecord(filename_queue=filename_queue_val, - batch_size=2000) - logits = scratch_network_embeding_example(train_data_shuffler) labels = train_data_shuffler("label", from_queue=False) - validation_logits = scratch_network_embeding_example(validation_data_shuffler, reuse=True, get_embedding=True) - + validation_logits = scratch_network_embeding_example( + validation_data_shuffler, reuse=True, get_embedding=True) + # Setting the placeholders # Loss for the softmax loss = mean_cross_entropy_loss(logits, labels) # One graph trainer - - trainer = Trainer(train_data_shuffler, - validation_data_shuffler=validation_data_shuffler, - validate_with_embeddings=True, - iterations=iterations, #It is supper fast - analizer=None, - temp_dir=directory) + + trainer = Trainer( + train_data_shuffler, + validation_data_shuffler=validation_data_shuffler, + validate_with_embeddings=True, + iterations=iterations, #It is supper fast + analizer=None, + temp_dir=directory) learning_rate = constant(0.01, name="regular_lr") - trainer.create_network_from_scratch(graph=logits, - validation_graph=validation_logits, - loss=loss, - learning_rate=learning_rate, - optimizer=tf.train.GradientDescentOptimizer(learning_rate), - ) - + trainer.create_network_from_scratch( + graph=logits, + validation_graph=validation_logits, + loss=loss, + learning_rate=learning_rate, + optimizer=tf.train.GradientDescentOptimizer(learning_rate), + ) + trainer.train() os.remove(tfrecords_filename) - os.remove(tfrecords_filename_val) + os.remove(tfrecords_filename_val) assert True tf.reset_default_graph() del trainer - assert len(tf.global_variables())==0 - + assert len(tf.global_variables()) == 0 + # Inference. TODO: Wrap this in a package file_name = os.path.join(directory, "model.ckp.meta") images = tf.placeholder(tf.float32, shape=(None, 28, 28, 1)) @@ -320,12 +377,13 @@ def test_cnn_tfrecord_embedding_validation(): session = tf.Session() session.run(tf.global_variables_initializer()) saver = tf.train.import_meta_graph(file_name, clear_devices=True) - saver.restore(session, tf.train.latest_checkpoint(os.path.dirname("./temp/cnn_scratch/"))) + saver.restore(session, + tf.train.latest_checkpoint( + os.path.dirname("./temp/cnn_scratch/"))) data = numpy.random.rand(2, 28, 28, 1).astype("float32") assert session.run(graph, feed_dict={images: data}).shape == (2, 10) tf.reset_default_graph() shutil.rmtree(directory) - assert len(tf.global_variables())==0 - + assert len(tf.global_variables()) == 0 diff --git a/bob/learn/tensorflow/test/test_cnn_trainable_variables_select.py b/bob/learn/tensorflow/test/test_cnn_trainable_variables_select.py index b33623c67910636a29de83a4bf8892f2ee81ef6e..a753199f6e99a1b9c43c6919057efbd33b1c8d1f 100644 --- a/bob/learn/tensorflow/test/test_cnn_trainable_variables_select.py +++ b/bob/learn/tensorflow/test/test_cnn_trainable_variables_select.py @@ -10,7 +10,6 @@ from bob.learn.tensorflow.loss import mean_cross_entropy_loss from bob.learn.tensorflow.datashuffler import TFRecord from bob.learn.tensorflow.trainers import Trainer, constant - batch_size = 16 validation_batch_size = 400 iterations = 200 @@ -23,7 +22,10 @@ step2_path = os.path.join(directory, "step2") slim = tf.contrib.slim -def base_network(train_data_shuffler, reuse=False, get_embedding=False, trainable=True): +def base_network(train_data_shuffler, + reuse=False, + get_embedding=False, + trainable=True): if isinstance(train_data_shuffler, tf.Tensor): inputs = train_data_shuffler @@ -32,39 +34,73 @@ def base_network(train_data_shuffler, reuse=False, get_embedding=False, trainabl # Creating a random network initializer = tf.contrib.layers.xavier_initializer(seed=seed) - graph = slim.conv2d(inputs, 10, [3, 3], activation_fn=tf.nn.relu, stride=1, scope='conv1', - weights_initializer=initializer, reuse=reuse, trainable=trainable) + graph = slim.conv2d( + inputs, + 10, [3, 3], + activation_fn=tf.nn.relu, + stride=1, + scope='conv1', + weights_initializer=initializer, + reuse=reuse, + trainable=trainable) graph = slim.max_pool2d(graph, [4, 4], scope='pool1') graph = slim.flatten(graph, scope='flatten1') - graph = slim.fully_connected(graph, 30, activation_fn=None, scope='fc1', - weights_initializer=initializer, reuse=reuse, trainable=trainable) + graph = slim.fully_connected( + graph, + 30, + activation_fn=None, + scope='fc1', + weights_initializer=initializer, + reuse=reuse, + trainable=trainable) if get_embedding: graph = graph else: - graph = slim.fully_connected(graph, 10, activation_fn=None, scope='logits', - weights_initializer=initializer, reuse=reuse) - + graph = slim.fully_connected( + graph, + 10, + activation_fn=None, + scope='logits', + weights_initializer=initializer, + reuse=reuse) + return graph def amendment_network(graph, reuse=False, get_embedding=False): initializer = tf.contrib.layers.xavier_initializer(seed=seed) - graph = slim.fully_connected(graph, 30, activation_fn=None, scope='fc2', - weights_initializer=initializer, reuse=reuse) - - graph = slim.fully_connected(graph, 30, activation_fn=None, scope='fc3', - weights_initializer=initializer, reuse=reuse) + graph = slim.fully_connected( + graph, + 30, + activation_fn=None, + scope='fc2', + weights_initializer=initializer, + reuse=reuse) + + graph = slim.fully_connected( + graph, + 30, + activation_fn=None, + scope='fc3', + weights_initializer=initializer, + reuse=reuse) if get_embedding: graph = tf.nn.l2_normalize(graph, dim=1, name="embedding") else: - graph = slim.fully_connected(graph, 10, activation_fn=None, scope='logits', - weights_initializer=initializer, reuse=reuse) - + graph = slim.fully_connected( + graph, + 10, + activation_fn=None, + scope='logits', + weights_initializer=initializer, + reuse=reuse) + return graph + def test_trainable_variables(): tf.reset_default_graph() @@ -86,86 +122,100 @@ def test_trainable_variables(): for i in range(6000): img = data[i] img_raw = img.tostring() - - feature = {'train/data': _bytes_feature(img_raw), - 'train/label': _int64_feature(labels[i])} - - example = tf.train.Example(features=tf.train.Features(feature=feature)) - writer.write(example.SerializeToString()) - writer.close() + feature = { + 'train/data': _bytes_feature(img_raw), + 'train/label': _int64_feature(labels[i]) + } - ######## 1 - BASE NETWORK ######### + example = tf.train.Example( + features=tf.train.Features(feature=feature)) + writer.write(example.SerializeToString()) + writer.close() + ######## 1 - BASE NETWORK ######### - tfrecords_filename = "mnist_train.tfrecords" + tfrecords_filename = "mnist_train.tfrecords" create_tf_record(tfrecords_filename, train_data, train_labels) - filename_queue = tf.train.string_input_producer([tfrecords_filename], num_epochs=1, name="input") + filename_queue = tf.train.string_input_producer( + [tfrecords_filename], num_epochs=1, name="input") # Doing the first training - train_data_shuffler = TFRecord(filename_queue=filename_queue, - batch_size=batch_size) - + train_data_shuffler = TFRecord( + filename_queue=filename_queue, batch_size=batch_size) + logits = base_network(train_data_shuffler) labels = train_data_shuffler("label", from_queue=True) loss = mean_cross_entropy_loss(logits, labels) - trainer = Trainer(train_data_shuffler, - iterations=iterations, #It is supper fast - analizer=None, - temp_dir=step1_path) + trainer = Trainer( + train_data_shuffler, + iterations=iterations, #It is supper fast + analizer=None, + temp_dir=step1_path) learning_rate = constant(0.01, name="regular_lr") - trainer.create_network_from_scratch(graph=logits, - loss=loss, - learning_rate=learning_rate, - optimizer=tf.train.GradientDescentOptimizer(learning_rate), - ) + trainer.create_network_from_scratch( + graph=logits, + loss=loss, + learning_rate=learning_rate, + optimizer=tf.train.GradientDescentOptimizer(learning_rate), + ) trainer.train() - + # Saving the cov after first training - conv1_after_first_train = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='conv1')[0].eval(session=trainer.session)[0] + conv1_after_first_train = tf.get_collection( + tf.GraphKeys.GLOBAL_VARIABLES, + scope='conv1')[0].eval(session=trainer.session)[0] del trainer del filename_queue del train_data_shuffler tf.reset_default_graph() - - ######## 2 - AMEMDING NETWORK ######### - filename_queue = tf.train.string_input_producer([tfrecords_filename], num_epochs=1, name="input") - train_data_shuffler = TFRecord(filename_queue=filename_queue, - batch_size=batch_size) - + ######## 2 - AMEMDING NETWORK ######### + + filename_queue = tf.train.string_input_producer( + [tfrecords_filename], num_epochs=1, name="input") + train_data_shuffler = TFRecord( + filename_queue=filename_queue, batch_size=batch_size) + # Here I'm creating the base network not trainable - embedding = base_network(train_data_shuffler, get_embedding=True, trainable=False) + embedding = base_network( + train_data_shuffler, get_embedding=True, trainable=False) embedding = amendment_network(embedding) labels = train_data_shuffler("label", from_queue=True) loss = mean_cross_entropy_loss(embedding, labels) - trainer = Trainer(train_data_shuffler, - iterations=iterations, #It is supper fast - analizer=None, - temp_dir=step2_path) + trainer = Trainer( + train_data_shuffler, + iterations=iterations, #It is supper fast + analizer=None, + temp_dir=step2_path) learning_rate = constant(0.01, name="regular_lr") - trainer.create_network_from_scratch(graph=embedding, - loss=loss, - learning_rate=learning_rate, - optimizer=tf.train.GradientDescentOptimizer(learning_rate), - ) + trainer.create_network_from_scratch( + graph=embedding, + loss=loss, + learning_rate=learning_rate, + optimizer=tf.train.GradientDescentOptimizer(learning_rate), + ) # Loading two layers from the "old" model - trainer.load_variables_from_external_model(step1_path, var_list=['conv1', 'fc1']) + trainer.load_variables_from_external_model( + step1_path, var_list=['conv1', 'fc1']) - conv1_restored = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='conv1')[0].eval(session=trainer.session)[0] - - assert numpy.allclose(conv1_after_first_train, conv1_restored) + conv1_restored = tf.get_collection( + tf.GraphKeys.GLOBAL_VARIABLES, + scope='conv1')[0].eval(session=trainer.session)[0] - # Second round of training - trainer.train() - conv1_after_second_train = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='conv1')[0].eval(session=trainer.session)[0] + assert numpy.allclose(conv1_after_first_train, conv1_restored) - # Since conv1 was set as NON TRAINABLE, both have to match - assert numpy.allclose(conv1_after_first_train, conv1_after_second_train) + # Second round of training + trainer.train() + conv1_after_second_train = tf.get_collection( + tf.GraphKeys.GLOBAL_VARIABLES, + scope='conv1')[0].eval(session=trainer.session)[0] + # Since conv1 was set as NON TRAINABLE, both have to match + assert numpy.allclose(conv1_after_first_train, conv1_after_second_train) diff --git a/bob/learn/tensorflow/test/test_dataset.py b/bob/learn/tensorflow/test/test_dataset.py index 2d1b2feb1ee474b7e2f359af9e374f467e48a1d4..1c1abb7d830f827b33eb079d2a0f92b168091ce3 100644 --- a/bob/learn/tensorflow/test/test_dataset.py +++ b/bob/learn/tensorflow/test/test_dataset.py @@ -15,26 +15,44 @@ validation_batch_size = 250 epochs = 1 # Trainer logits -filenames = [pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m301_01_p01_i0_0.png'), - pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m301_01_p02_i0_0.png'), - pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m301_01_p01_i0_0.png'), - pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m301_01_p02_i0_0.png'), - pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m301_01_p01_i0_0.png'), - pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m301_01_p02_i0_0.png'), - - pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m304_01_p01_i0_0.png'), - pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m304_02_f12_i0_0.png'), - pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m304_01_p01_i0_0.png'), - pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m304_02_f12_i0_0.png'), - pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m304_01_p01_i0_0.png'), - pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m304_02_f12_i0_0.png')] -labels = [0, 0, 0, 0, 0, 0, - 1, 1, 1, 1, 1, 1] +filenames = [ + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m301_01_p01_i0_0.png'), + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m301_01_p02_i0_0.png'), + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m301_01_p01_i0_0.png'), + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m301_01_p02_i0_0.png'), + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m301_01_p01_i0_0.png'), + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m301_01_p02_i0_0.png'), + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m304_01_p01_i0_0.png'), + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m304_02_f12_i0_0.png'), + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m304_01_p01_i0_0.png'), + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m304_02_f12_i0_0.png'), + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m304_01_p01_i0_0.png'), + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m304_02_f12_i0_0.png') +] +labels = [0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1] def test_siamese_dataset(): - data, label = siamese_batch(filenames, labels, data_shape, data_type, 2, per_image_normalization=False, - output_shape=output_shape) + data, label = siamese_batch( + filenames, + labels, + data_shape, + data_type, + 2, + per_image_normalization=False, + output_shape=output_shape) with tf.Session() as session: d, l = session.run([data, label]) @@ -44,8 +62,14 @@ def test_siamese_dataset(): def test_triplet_dataset(): - data = triplet_batch(filenames, labels, data_shape, data_type, 2, per_image_normalization=False, - output_shape=output_shape) + data = triplet_batch( + filenames, + labels, + data_shape, + data_type, + 2, + per_image_normalization=False, + output_shape=output_shape) with tf.Session() as session: d = session.run([data])[0] assert len(d.keys()) == 3 diff --git a/bob/learn/tensorflow/test/test_datashuffler.py b/bob/learn/tensorflow/test/test_datashuffler.py index 74b2d169865f0a0a9ae5f80d1abe3a2b42565422..dceb0a3288481a2368b382dfc0ba52539993f8b1 100644 --- a/bob/learn/tensorflow/test/test_datashuffler.py +++ b/bob/learn/tensorflow/test/test_datashuffler.py @@ -9,14 +9,14 @@ from bob.learn.tensorflow.datashuffler import Memory, SiameseMemory, TripletMemo import pkg_resources from bob.learn.tensorflow.utils import load_mnist import os - """ Some unit tests for the datashuffler """ def get_dummy_files(): - base_path = pkg_resources.resource_filename(__name__, 'data/dummy_database') + base_path = pkg_resources.resource_filename(__name__, + 'data/dummy_database') files = [] clients = [] for f in os.listdir(base_path): @@ -46,9 +46,8 @@ def test_memory_shuffler(): shape = [None, 28, 28, 1] - data_shuffler = Memory(train_data, train_labels, - input_shape=shape, - batch_size=16) + data_shuffler = Memory( + train_data, train_labels, input_shape=shape, batch_size=16) batch = data_shuffler.get_batch() assert len(batch) == 2 @@ -61,9 +60,8 @@ def test_siamesememory_shuffler(): batch_shape = [None, 28, 28, 1] - data_shuffler = SiameseMemory(train_data, train_labels, - input_shape=batch_shape, - batch_size=16) + data_shuffler = SiameseMemory( + train_data, train_labels, input_shape=batch_shape, batch_size=16) batch = data_shuffler.get_batch() @@ -78,9 +76,8 @@ def test_tripletmemory_shuffler(): batch_shape = [None, 28, 28, 1] - data_shuffler = TripletMemory(train_data, train_labels, - input_shape=batch_shape, - batch_size=16) + data_shuffler = TripletMemory( + train_data, train_labels, input_shape=batch_shape, batch_size=16) batch = data_shuffler.get_batch() @@ -94,9 +91,8 @@ def test_disk_shuffler(): train_data, train_labels = get_dummy_files() batch_shape = [None, 250, 250, 3] - data_shuffler = Disk(train_data, train_labels, - input_shape=batch_shape, - batch_size=2) + data_shuffler = Disk( + train_data, train_labels, input_shape=batch_shape, batch_size=2) batch = data_shuffler.get_batch() @@ -109,9 +105,8 @@ def test_siamesedisk_shuffler(): batch_shape = [None, 250, 250, 3] - data_shuffler = SiameseDisk(train_data, train_labels, - input_shape=batch_shape, - batch_size=2) + data_shuffler = SiameseDisk( + train_data, train_labels, input_shape=batch_shape, batch_size=2) batch = data_shuffler.get_batch() @@ -125,9 +120,8 @@ def test_tripletdisk_shuffler(): batch_shape = [None, 250, 250, 3] - data_shuffler = TripletDisk(train_data, train_labels, - input_shape=batch_shape, - batch_size=1) + data_shuffler = TripletDisk( + train_data, train_labels, input_shape=batch_shape, batch_size=1) batch = data_shuffler.get_batch() @@ -136,6 +130,7 @@ def test_tripletdisk_shuffler(): assert batch[1].shape == (1, 250, 250, 3) assert batch[2].shape == (1, 250, 250, 3) + """ def test_triplet_fast_selection_disk_shuffler(): train_data, train_labels = get_dummy_files() @@ -153,7 +148,6 @@ def test_triplet_fast_selection_disk_shuffler(): assert len(batch[1].shape) == len(tuple(batch_shape)) assert len(batch[2].shape) == len(tuple(batch_shape)) """ - """ def test_triplet_selection_disk_shuffler(): train_data, train_labels = get_dummy_files() @@ -177,6 +171,7 @@ def test_triplet_selection_disk_shuffler(): assert placeholders['negative'].get_shape().as_list() == batch_shape """ + def test_diskaudio_shuffler(): train_data, train_labels = get_dummy_audiofiles() @@ -184,7 +179,8 @@ def test_diskaudio_shuffler(): batch_size = 582 batch_shape = [None, 6560, 1] - data_shuffler = DiskAudio(train_data, train_labels, batch_shape, batch_size=batch_size) + data_shuffler = DiskAudio( + train_data, train_labels, batch_shape, batch_size=batch_size) batch = data_shuffler.get_batch() assert len(batch) == 2 diff --git a/bob/learn/tensorflow/test/test_db_to_tfrecords.py b/bob/learn/tensorflow/test/test_db_to_tfrecords.py index 6f2fabfe17b63679d36d82667ae27cfba9117b00..8cc415a22144e41bfc2b1e8a4bcdb00023e9a926 100644 --- a/bob/learn/tensorflow/test/test_db_to_tfrecords.py +++ b/bob/learn/tensorflow/test/test_db_to_tfrecords.py @@ -12,20 +12,20 @@ dummy_config = pkg_resources.resource_filename( def test_verify_and_tfrecords(): - test_dir = tempfile.mkdtemp(prefix='bobtest_') + test_dir = tempfile.mkdtemp(prefix='bobtest_') - config_path = os.path.join(test_dir, 'config.py') - with open(dummy_config) as f, open(config_path, 'w') as f2: - f2.write(f.read().replace('TEST_DIR', test_dir)) + config_path = os.path.join(test_dir, 'config.py') + with open(dummy_config) as f, open(config_path, 'w') as f2: + f2.write(f.read().replace('TEST_DIR', test_dir)) - parameters = [config_path] - try: - tfrecords(parameters) + parameters = [config_path] + try: + tfrecords(parameters) - # TODO: test if tfrecords are equal - # tfrecords_path = os.path.join(test_dir, 'sub_directory', 'dev.tfrecords') - # if regenerate_reference: - # shutil.copy(tfrecords_path, tfrecords_reference) + # TODO: test if tfrecords are equal + # tfrecords_path = os.path.join(test_dir, 'sub_directory', 'dev.tfrecords') + # if regenerate_reference: + # shutil.copy(tfrecords_path, tfrecords_reference) - finally: - shutil.rmtree(test_dir) + finally: + shutil.rmtree(test_dir) diff --git a/bob/learn/tensorflow/test/test_dnn.py b/bob/learn/tensorflow/test/test_dnn.py index a5deff40d0d80411b9b5a4e71d9c983d5bd5760e..75b48966c775a0487f1b48ab997e6023f7350dd0 100644 --- a/bob/learn/tensorflow/test/test_dnn.py +++ b/bob/learn/tensorflow/test/test_dnn.py @@ -12,7 +12,6 @@ from bob.learn.tensorflow.utils import load_mnist from bob.learn.tensorflow.loss import mean_cross_entropy_loss import tensorflow as tf import shutil - """ Some unit tests for the datashuffler """ @@ -25,13 +24,16 @@ seed = 10 def validate_network(embedding, validation_data, validation_labels): # Testing - validation_data_shuffler = Memory(validation_data, validation_labels, - input_shape=[None, 28*28], - batch_size=validation_batch_size) + validation_data_shuffler = Memory( + validation_data, + validation_labels, + input_shape=[None, 28 * 28], + batch_size=validation_batch_size) [data, labels] = validation_data_shuffler.get_batch() predictions = embedding(data) - accuracy = 100. * numpy.sum(numpy.argmax(predictions, axis=1) == labels) / predictions.shape[0] + accuracy = 100. * numpy.sum( + numpy.argmax(predictions, axis=1) == labels) / predictions.shape[0] return accuracy @@ -42,14 +44,15 @@ def test_dnn_trainer(): train_data, train_labels, validation_data, validation_labels = load_mnist() # Creating datashufflers - train_data_shuffler = Memory(train_data, train_labels, - input_shape=[None, 784], - batch_size=batch_size) + train_data_shuffler = Memory( + train_data, + train_labels, + input_shape=[None, 784], + batch_size=batch_size) directory = "./temp/dnn" # Preparing the architecture - inputs = train_data_shuffler("data", from_queue=False) labels = train_data_shuffler("label", from_queue=False) @@ -59,20 +62,22 @@ def test_dnn_trainer(): loss = mean_cross_entropy_loss(logits, labels) # One graph trainer - trainer = Trainer(train_data_shuffler, - iterations=iterations, - analizer=None, - temp_dir=directory - ) - - trainer.create_network_from_scratch(graph=logits, - loss=loss, - learning_rate=constant(0.01, name="regular_lr"), - optimizer=tf.train.GradientDescentOptimizer(0.01), - ) + trainer = Trainer( + train_data_shuffler, + iterations=iterations, + analizer=None, + temp_dir=directory) + + trainer.create_network_from_scratch( + graph=logits, + loss=loss, + learning_rate=constant(0.01, name="regular_lr"), + optimizer=tf.train.GradientDescentOptimizer(0.01), + ) trainer.train() - embedding = Embedding(train_data_shuffler("data", from_queue=False), logits) + embedding = Embedding( + train_data_shuffler("data", from_queue=False), logits) accuracy = validate_network(embedding, validation_data, validation_labels) # At least 50% of accuracy for the DNN @@ -81,4 +86,4 @@ def test_dnn_trainer(): del trainer # Just to clean the variables tf.reset_default_graph() - assert len(tf.global_variables())==0 + assert len(tf.global_variables()) == 0 diff --git a/bob/learn/tensorflow/test/test_estimator_onegraph.py b/bob/learn/tensorflow/test/test_estimator_onegraph.py index 84f513130f569b46454f21c40a92de5eb893a53d..4dda20c9bc631e81b69194b2cbfb7bcdf5e4fcae 100644 --- a/bob/learn/tensorflow/test/test_estimator_onegraph.py +++ b/bob/learn/tensorflow/test/test_estimator_onegraph.py @@ -36,13 +36,14 @@ def test_logitstrainer(): # Trainer logits try: embedding_validation = False - trainer = Logits(model_dir=model_dir, - architecture=dummy, - optimizer=tf.train.GradientDescentOptimizer(learning_rate), - n_classes=10, - loss_op=mean_cross_entropy_loss, - embedding_validation=embedding_validation, - validation_batch_size=validation_batch_size) + trainer = Logits( + model_dir=model_dir, + architecture=dummy, + optimizer=tf.train.GradientDescentOptimizer(learning_rate), + n_classes=10, + loss_op=mean_cross_entropy_loss, + embedding_validation=embedding_validation, + validation_batch_size=validation_batch_size) run_logitstrainer_mnist(trainer, augmentation=True) finally: try: @@ -56,13 +57,14 @@ def test_logitstrainer(): def test_logitstrainer_embedding(): try: embedding_validation = True - trainer = Logits(model_dir=model_dir, - architecture=dummy, - optimizer=tf.train.GradientDescentOptimizer(learning_rate), - n_classes=10, - loss_op=mean_cross_entropy_loss, - embedding_validation=embedding_validation, - validation_batch_size=validation_batch_size) + trainer = Logits( + model_dir=model_dir, + architecture=dummy, + optimizer=tf.train.GradientDescentOptimizer(learning_rate), + n_classes=10, + loss_op=mean_cross_entropy_loss, + embedding_validation=embedding_validation, + validation_batch_size=validation_batch_size) run_logitstrainer_mnist(trainer) finally: @@ -93,13 +95,15 @@ def test_logitstrainer_centerloss(): # Checking if the centers were updated sess = tf.Session() - checkpoint_path = tf.train.get_checkpoint_state(model_dir).model_checkpoint_path - saver = tf.train.import_meta_graph(checkpoint_path + ".meta", clear_devices=True) + checkpoint_path = tf.train.get_checkpoint_state( + model_dir).model_checkpoint_path + saver = tf.train.import_meta_graph( + checkpoint_path + ".meta", clear_devices=True) saver.restore(sess, tf.train.latest_checkpoint(model_dir)) - centers = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope="center_loss/centers:0")[0] + centers = tf.get_collection( + tf.GraphKeys.GLOBAL_VARIABLES, scope="center_loss/centers:0")[0] assert numpy.sum(numpy.abs(centers.eval(sess))) > 0.0 - finally: try: os.unlink(tfrecord_train) @@ -124,10 +128,13 @@ def test_logitstrainer_centerloss_embedding(): # Checking if the centers were updated sess = tf.Session() - checkpoint_path = tf.train.get_checkpoint_state(model_dir).model_checkpoint_path - saver = tf.train.import_meta_graph(checkpoint_path + ".meta", clear_devices=True) + checkpoint_path = tf.train.get_checkpoint_state( + model_dir).model_checkpoint_path + saver = tf.train.import_meta_graph( + checkpoint_path + ".meta", clear_devices=True) saver.restore(sess, tf.train.latest_checkpoint(model_dir)) - centers = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope="center_loss/centers:0")[0] + centers = tf.get_collection( + tf.GraphKeys.GLOBAL_VARIABLES, scope="center_loss/centers:0")[0] assert numpy.sum(numpy.abs(centers.eval(sess))) > 0.0 finally: try: @@ -145,27 +152,46 @@ def run_logitstrainer_mnist(trainer, augmentation=False): # Creating tf records for mnist train_data, train_labels, validation_data, validation_labels = load_mnist() - create_mnist_tfrecord(tfrecord_train, train_data, train_labels, n_samples=6000) - create_mnist_tfrecord(tfrecord_validation, validation_data, validation_labels, n_samples=validation_batch_size) + create_mnist_tfrecord( + tfrecord_train, train_data, train_labels, n_samples=6000) + create_mnist_tfrecord( + tfrecord_validation, + validation_data, + validation_labels, + n_samples=validation_batch_size) def input_fn(): if augmentation: - return shuffle_data_and_labels_image_augmentation(tfrecord_train, data_shape, data_type, batch_size, - epochs=epochs) + return shuffle_data_and_labels_image_augmentation( + tfrecord_train, + data_shape, + data_type, + batch_size, + epochs=epochs) else: - return shuffle_data_and_labels(tfrecord_train, data_shape, data_type, - batch_size, epochs=epochs) + return shuffle_data_and_labels( + tfrecord_train, + data_shape, + data_type, + batch_size, + epochs=epochs) def input_fn_validation(): - return batch_data_and_labels(tfrecord_validation, data_shape, data_type, - validation_batch_size, epochs=1000) - - hooks = [LoggerHookEstimator(trainer, 16, 300), - - tf.train.SummarySaverHook(save_steps=1000, - output_dir=model_dir, - scaffold=tf.train.Scaffold(), - summary_writer=tf.summary.FileWriter(model_dir))] + return batch_data_and_labels( + tfrecord_validation, + data_shape, + data_type, + validation_batch_size, + epochs=1000) + + hooks = [ + LoggerHookEstimator(trainer, 16, 300), + tf.train.SummarySaverHook( + save_steps=1000, + output_dir=model_dir, + scaffold=tf.train.Scaffold(), + summary_writer=tf.summary.FileWriter(model_dir)) + ] trainer.train(input_fn, steps=steps, hooks=hooks) if not trainer.embedding_validation: diff --git a/bob/learn/tensorflow/test/test_estimator_scripts.py b/bob/learn/tensorflow/test/test_estimator_scripts.py index 73cf00adcfa9437ca06c51eadd5d8a260b2e75ed..da74d57e07d3f3d756dfd0325887f63f346e259d 100644 --- a/bob/learn/tensorflow/test/test_estimator_scripts.py +++ b/bob/learn/tensorflow/test/test_estimator_scripts.py @@ -103,8 +103,10 @@ def _create_tfrecord(test_dir): def _create_checkpoint(tmpdir, model_dir, dummy_tfrecord): - config = CONFIG % {'model_dir': model_dir, - 'tfrecord_filenames': dummy_tfrecord} + config = CONFIG % { + 'model_dir': model_dir, + 'tfrecord_filenames': dummy_tfrecord + } config_path = os.path.join(tmpdir, 'train_config.py') with open(config_path, 'w') as f: f.write(config) @@ -112,8 +114,10 @@ def _create_checkpoint(tmpdir, model_dir, dummy_tfrecord): def _eval(tmpdir, model_dir, dummy_tfrecord): - config = CONFIG % {'model_dir': model_dir, - 'tfrecord_filenames': dummy_tfrecord} + config = CONFIG % { + 'model_dir': model_dir, + 'tfrecord_filenames': dummy_tfrecord + } config_path = os.path.join(tmpdir, 'eval_config.py') with open(config_path, 'w') as f: f.write(config) @@ -121,8 +125,10 @@ def _eval(tmpdir, model_dir, dummy_tfrecord): def _train_and_evaluate(tmpdir, model_dir, dummy_tfrecord): - config = CONFIG % {'model_dir': model_dir, - 'tfrecord_filenames': dummy_tfrecord} + config = CONFIG % { + 'model_dir': model_dir, + 'tfrecord_filenames': dummy_tfrecord + } config_path = os.path.join(tmpdir, 'train_config.py') with open(config_path, 'w') as f: f.write(config) diff --git a/bob/learn/tensorflow/test/test_estimator_siamese.py b/bob/learn/tensorflow/test/test_estimator_siamese.py index ce96b3ae41c575e337066fb33f6de29ec1de93de..35cde5101777ea3f20fb9b78fbf8dc915364a2a2 100644 --- a/bob/learn/tensorflow/test/test_estimator_siamese.py +++ b/bob/learn/tensorflow/test/test_estimator_siamese.py @@ -32,38 +32,56 @@ epochs = 1 steps = 5000 # Data -filenames = [pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m301_01_p01_i0_0.png'), - pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m301_01_p02_i0_0.png'), - pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m301_01_p01_i0_0.png'), - pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m301_01_p02_i0_0.png'), - pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m301_01_p01_i0_0.png'), - pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m301_01_p02_i0_0.png'), - pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m301_01_p02_i0_0.png'), - pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m301_01_p01_i0_0.png'), - pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m301_01_p02_i0_0.png'), - - pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m304_01_p01_i0_0.png'), - pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m304_02_f12_i0_0.png'), - pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m304_01_p01_i0_0.png'), - pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m304_02_f12_i0_0.png'), - pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m304_01_p01_i0_0.png'), - pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m304_02_f12_i0_0.png'), - pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m304_01_p01_i0_0.png'), - pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m304_02_f12_i0_0.png'), - pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m304_02_f12_i0_0.png'), - ] -labels = [0, 0, 0, 0, 0, 0, 0, 0, 0, - 1, 1, 1, 1, 1, 1, 1, 1, 1] +filenames = [ + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m301_01_p01_i0_0.png'), + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m301_01_p02_i0_0.png'), + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m301_01_p01_i0_0.png'), + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m301_01_p02_i0_0.png'), + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m301_01_p01_i0_0.png'), + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m301_01_p02_i0_0.png'), + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m301_01_p02_i0_0.png'), + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m301_01_p01_i0_0.png'), + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m301_01_p02_i0_0.png'), + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m304_01_p01_i0_0.png'), + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m304_02_f12_i0_0.png'), + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m304_01_p01_i0_0.png'), + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m304_02_f12_i0_0.png'), + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m304_01_p01_i0_0.png'), + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m304_02_f12_i0_0.png'), + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m304_01_p01_i0_0.png'), + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m304_02_f12_i0_0.png'), + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m304_02_f12_i0_0.png'), +] +labels = [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1] def test_siamesetrainer(): # Trainer logits try: - trainer = Siamese(model_dir=model_dir, - architecture=dummy, - optimizer=tf.train.GradientDescentOptimizer(learning_rate), - loss_op=contrastive_loss, - validation_batch_size=validation_batch_size) + trainer = Siamese( + model_dir=model_dir, + architecture=dummy, + optimizer=tf.train.GradientDescentOptimizer(learning_rate), + loss_op=contrastive_loss, + validation_batch_size=validation_batch_size) run_siamesetrainer(trainer) finally: try: @@ -75,34 +93,45 @@ def test_siamesetrainer(): def test_siamesetrainer_transfer(): def logits_input_fn(): - return single_batch(filenames, labels, data_shape, data_type, batch_size, epochs=epochs, - output_shape=output_shape) + return single_batch( + filenames, + labels, + data_shape, + data_type, + batch_size, + epochs=epochs, + output_shape=output_shape) # Trainer logits first than siamese try: - extra_checkpoint = {"checkpoint_path": model_dir, - "scopes": dict({"Dummy/": "Dummy/"}), - "trainable_variables": [] - } + extra_checkpoint = { + "checkpoint_path": model_dir, + "scopes": dict({ + "Dummy/": "Dummy/" + }), + "trainable_variables": [] + } # LOGISTS - logits_trainer = Logits(model_dir=model_dir, - architecture=dummy, - optimizer=tf.train.GradientDescentOptimizer(learning_rate), - n_classes=2, - loss_op=mean_cross_entropy_loss, - embedding_validation=False, - validation_batch_size=validation_batch_size) + logits_trainer = Logits( + model_dir=model_dir, + architecture=dummy, + optimizer=tf.train.GradientDescentOptimizer(learning_rate), + n_classes=2, + loss_op=mean_cross_entropy_loss, + embedding_validation=False, + validation_batch_size=validation_batch_size) logits_trainer.train(logits_input_fn, steps=steps) # NOW THE FUCKING SIAMESE - trainer = Siamese(model_dir=model_dir_adapted, - architecture=dummy_adapted, - optimizer=tf.train.GradientDescentOptimizer(learning_rate), - loss_op=contrastive_loss, - validation_batch_size=validation_batch_size, - extra_checkpoint=extra_checkpoint) + trainer = Siamese( + model_dir=model_dir_adapted, + architecture=dummy_adapted, + optimizer=tf.train.GradientDescentOptimizer(learning_rate), + loss_op=contrastive_loss, + validation_batch_size=validation_batch_size, + extra_checkpoint=extra_checkpoint) run_siamesetrainer(trainer) finally: try: @@ -114,35 +143,46 @@ def test_siamesetrainer_transfer(): def test_siamesetrainer_transfer_extraparams(): def logits_input_fn(): - return single_batch(filenames, labels, data_shape, data_type, batch_size, epochs=epochs, - output_shape=output_shape) + return single_batch( + filenames, + labels, + data_shape, + data_type, + batch_size, + epochs=epochs, + output_shape=output_shape) # Trainer logits first than siamese try: - extra_checkpoint = {"checkpoint_path": model_dir, - "scopes": dict({"Dummy/": "Dummy/"}), - "trainable_variables": ["Dummy"] - } + extra_checkpoint = { + "checkpoint_path": model_dir, + "scopes": dict({ + "Dummy/": "Dummy/" + }), + "trainable_variables": ["Dummy"] + } # LOGISTS - logits_trainer = Logits(model_dir=model_dir, - architecture=dummy, - optimizer=tf.train.GradientDescentOptimizer(learning_rate), - n_classes=2, - loss_op=mean_cross_entropy_loss, - embedding_validation=False, - validation_batch_size=validation_batch_size) + logits_trainer = Logits( + model_dir=model_dir, + architecture=dummy, + optimizer=tf.train.GradientDescentOptimizer(learning_rate), + n_classes=2, + loss_op=mean_cross_entropy_loss, + embedding_validation=False, + validation_batch_size=validation_batch_size) logits_trainer.train(logits_input_fn, steps=steps) # NOW THE FUCKING SIAMESE - trainer = Siamese(model_dir=model_dir_adapted, - architecture=dummy_adapted, - optimizer=tf.train.GradientDescentOptimizer(learning_rate), - loss_op=contrastive_loss, - validation_batch_size=validation_batch_size, - extra_checkpoint=extra_checkpoint) + trainer = Siamese( + model_dir=model_dir_adapted, + architecture=dummy_adapted, + optimizer=tf.train.GradientDescentOptimizer(learning_rate), + loss_op=contrastive_loss, + validation_batch_size=validation_batch_size, + extra_checkpoint=extra_checkpoint) run_siamesetrainer(trainer) finally: try: @@ -158,20 +198,37 @@ def run_siamesetrainer(trainer): assert len(tf.global_variables()) == 0 def input_fn(): - return siamese_batch(filenames, labels, data_shape, data_type, batch_size, epochs=epochs, - output_shape=output_shape, - random_flip=True, random_brightness=True, random_contrast=True, random_saturation=True) + return siamese_batch( + filenames, + labels, + data_shape, + data_type, + batch_size, + epochs=epochs, + output_shape=output_shape, + random_flip=True, + random_brightness=True, + random_contrast=True, + random_saturation=True) def input_validation_fn(): - return single_batch(filenames, labels, data_shape, data_type, validation_batch_size, epochs=10, - output_shape=output_shape) - - hooks = [LoggerHookEstimator(trainer, batch_size, 300), - - tf.train.SummarySaverHook(save_steps=1000, - output_dir=model_dir, - scaffold=tf.train.Scaffold(), - summary_writer=tf.summary.FileWriter(model_dir))] + return single_batch( + filenames, + labels, + data_shape, + data_type, + validation_batch_size, + epochs=10, + output_shape=output_shape) + + hooks = [ + LoggerHookEstimator(trainer, batch_size, 300), + tf.train.SummarySaverHook( + save_steps=1000, + output_dir=model_dir, + scaffold=tf.train.Scaffold(), + summary_writer=tf.summary.FileWriter(model_dir)) + ] trainer.train(input_fn, steps=1, hooks=hooks) diff --git a/bob/learn/tensorflow/test/test_estimator_transfer.py b/bob/learn/tensorflow/test/test_estimator_transfer.py index d08adbcf27a53223c3d9ad6756380cf275ade794..0bf0d0355f2df2df5009561f5f18b42bd33505cb 100644 --- a/bob/learn/tensorflow/test/test_estimator_transfer.py +++ b/bob/learn/tensorflow/test/test_estimator_transfer.py @@ -27,7 +27,11 @@ epochs = 2 steps = 5000 -def dummy_adapted(inputs, reuse=False, mode=tf.estimator.ModeKeys.TRAIN, trainable_variables=None, **kwargs): +def dummy_adapted(inputs, + reuse=False, + mode=tf.estimator.ModeKeys.TRAIN, + trainable_variables=None, + **kwargs): """ Create all the necessary variables for this CNN @@ -43,24 +47,32 @@ def dummy_adapted(inputs, reuse=False, mode=tf.estimator.ModeKeys.TRAIN, trainab """ slim = tf.contrib.slim - graph, end_points = dummy(inputs, reuse=reuse, mode=mode, trainable_variables=trainable_variables) + graph, end_points = dummy( + inputs, + reuse=reuse, + mode=mode, + trainable_variables=trainable_variables) initializer = tf.contrib.layers.xavier_initializer() with tf.variable_scope('Adapted', reuse=reuse): name = 'fc2' - graph = slim.fully_connected(graph, 50, - weights_initializer=initializer, - activation_fn=tf.nn.relu, - scope=name, - trainable=True) + graph = slim.fully_connected( + graph, + 50, + weights_initializer=initializer, + activation_fn=tf.nn.relu, + scope=name, + trainable=True) end_points[name] = graph name = 'fc3' - graph = slim.fully_connected(graph, 25, - weights_initializer=initializer, - activation_fn=None, - scope=name, - trainable=True) + graph = slim.fully_connected( + graph, + 25, + weights_initializer=initializer, + activation_fn=None, + scope=name, + trainable=True) end_points[name] = graph return graph, end_points @@ -70,31 +82,35 @@ def test_logitstrainer(): # Trainer logits try: embedding_validation = False - trainer = Logits(model_dir=model_dir, - architecture=dummy, - optimizer=tf.train.GradientDescentOptimizer(learning_rate), - n_classes=10, - loss_op=mean_cross_entropy_loss, - embedding_validation=embedding_validation, - validation_batch_size=validation_batch_size) + trainer = Logits( + model_dir=model_dir, + architecture=dummy, + optimizer=tf.train.GradientDescentOptimizer(learning_rate), + n_classes=10, + loss_op=mean_cross_entropy_loss, + embedding_validation=embedding_validation, + validation_batch_size=validation_batch_size) run_logitstrainer_mnist(trainer, augmentation=True) del trainer ## Again - extra_checkpoint = {"checkpoint_path": "./temp", - "scopes": dict({"Dummy/": "Dummy/"}), - "trainable_variables": [] - } - - trainer = Logits(model_dir=model_dir_adapted, - architecture=dummy_adapted, - optimizer=tf.train.GradientDescentOptimizer(learning_rate), - n_classes=10, - loss_op=mean_cross_entropy_loss, - embedding_validation=embedding_validation, - validation_batch_size=validation_batch_size, - extra_checkpoint=extra_checkpoint - ) + extra_checkpoint = { + "checkpoint_path": "./temp", + "scopes": dict({ + "Dummy/": "Dummy/" + }), + "trainable_variables": [] + } + + trainer = Logits( + model_dir=model_dir_adapted, + architecture=dummy_adapted, + optimizer=tf.train.GradientDescentOptimizer(learning_rate), + n_classes=10, + loss_op=mean_cross_entropy_loss, + embedding_validation=embedding_validation, + validation_batch_size=validation_batch_size, + extra_checkpoint=extra_checkpoint) run_logitstrainer_mnist(trainer, augmentation=True) @@ -114,29 +130,33 @@ def test_logitstrainer_center_loss(): try: embedding_validation = False - trainer = LogitsCenterLoss(model_dir=model_dir, - architecture=dummy, - optimizer=tf.train.GradientDescentOptimizer(learning_rate), - n_classes=10, - embedding_validation=embedding_validation, - validation_batch_size=validation_batch_size) + trainer = LogitsCenterLoss( + model_dir=model_dir, + architecture=dummy, + optimizer=tf.train.GradientDescentOptimizer(learning_rate), + n_classes=10, + embedding_validation=embedding_validation, + validation_batch_size=validation_batch_size) run_logitstrainer_mnist(trainer, augmentation=True) del trainer ## Again - extra_checkpoint = {"checkpoint_path": "./temp", - "scopes": dict({"Dummy/": "Dummy/"}), - "trainable_variables": ["Dummy"] - } - - trainer = LogitsCenterLoss(model_dir=model_dir_adapted, - architecture=dummy_adapted, - optimizer=tf.train.GradientDescentOptimizer(learning_rate), - n_classes=10, - embedding_validation=embedding_validation, - validation_batch_size=validation_batch_size, - extra_checkpoint=extra_checkpoint - ) + extra_checkpoint = { + "checkpoint_path": "./temp", + "scopes": dict({ + "Dummy/": "Dummy/" + }), + "trainable_variables": ["Dummy"] + } + + trainer = LogitsCenterLoss( + model_dir=model_dir_adapted, + architecture=dummy_adapted, + optimizer=tf.train.GradientDescentOptimizer(learning_rate), + n_classes=10, + embedding_validation=embedding_validation, + validation_batch_size=validation_batch_size, + extra_checkpoint=extra_checkpoint) run_logitstrainer_mnist(trainer, augmentation=True) diff --git a/bob/learn/tensorflow/test/test_estimator_triplet.py b/bob/learn/tensorflow/test/test_estimator_triplet.py index bbca851410433cc1a95be7c001b59b952301918d..b2f1aeb0eec0433fedc36603678a36436de064c1 100644 --- a/bob/learn/tensorflow/test/test_estimator_triplet.py +++ b/bob/learn/tensorflow/test/test_estimator_triplet.py @@ -32,38 +32,56 @@ epochs = 1 steps = 5000 # Data -filenames = [pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m301_01_p01_i0_0.png'), - pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m301_01_p02_i0_0.png'), - pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m301_01_p01_i0_0.png'), - pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m301_01_p02_i0_0.png'), - pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m301_01_p01_i0_0.png'), - pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m301_01_p02_i0_0.png'), - pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m301_01_p02_i0_0.png'), - pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m301_01_p01_i0_0.png'), - pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m301_01_p02_i0_0.png'), - - pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m304_01_p01_i0_0.png'), - pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m304_02_f12_i0_0.png'), - pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m304_01_p01_i0_0.png'), - pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m304_02_f12_i0_0.png'), - pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m304_01_p01_i0_0.png'), - pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m304_02_f12_i0_0.png'), - pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m304_01_p01_i0_0.png'), - pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m304_02_f12_i0_0.png'), - pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m304_02_f12_i0_0.png'), - ] -labels = [0, 0, 0, 0, 0, 0, 0, 0, 0, - 1, 1, 1, 1, 1, 1, 1, 1, 1] +filenames = [ + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m301_01_p01_i0_0.png'), + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m301_01_p02_i0_0.png'), + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m301_01_p01_i0_0.png'), + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m301_01_p02_i0_0.png'), + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m301_01_p01_i0_0.png'), + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m301_01_p02_i0_0.png'), + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m301_01_p02_i0_0.png'), + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m301_01_p01_i0_0.png'), + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m301_01_p02_i0_0.png'), + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m304_01_p01_i0_0.png'), + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m304_02_f12_i0_0.png'), + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m304_01_p01_i0_0.png'), + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m304_02_f12_i0_0.png'), + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m304_01_p01_i0_0.png'), + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m304_02_f12_i0_0.png'), + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m304_01_p01_i0_0.png'), + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m304_02_f12_i0_0.png'), + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m304_02_f12_i0_0.png'), +] +labels = [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1] def test_triplet_estimator(): # Trainer logits try: - trainer = Triplet(model_dir=model_dir, - architecture=dummy, - optimizer=tf.train.GradientDescentOptimizer(learning_rate), - loss_op=triplet_loss, - validation_batch_size=validation_batch_size) + trainer = Triplet( + model_dir=model_dir, + architecture=dummy, + optimizer=tf.train.GradientDescentOptimizer(learning_rate), + loss_op=triplet_loss, + validation_batch_size=validation_batch_size) run_triplet_estimator(trainer) finally: try: @@ -75,34 +93,45 @@ def test_triplet_estimator(): def test_triplettrainer_transfer(): def logits_input_fn(): - return single_batch(filenames, labels, data_shape, data_type, batch_size, epochs=epochs, - output_shape=output_shape) + return single_batch( + filenames, + labels, + data_shape, + data_type, + batch_size, + epochs=epochs, + output_shape=output_shape) # Trainer logits first than siamese try: - extra_checkpoint = {"checkpoint_path": model_dir, - "scopes": dict({"Dummy/": "Dummy/"}), - "trainable_variables": [] - } + extra_checkpoint = { + "checkpoint_path": model_dir, + "scopes": dict({ + "Dummy/": "Dummy/" + }), + "trainable_variables": [] + } # LOGISTS - logits_trainer = Logits(model_dir=model_dir, - architecture=dummy, - optimizer=tf.train.GradientDescentOptimizer(learning_rate), - n_classes=2, - loss_op=mean_cross_entropy_loss, - embedding_validation=False, - validation_batch_size=validation_batch_size) + logits_trainer = Logits( + model_dir=model_dir, + architecture=dummy, + optimizer=tf.train.GradientDescentOptimizer(learning_rate), + n_classes=2, + loss_op=mean_cross_entropy_loss, + embedding_validation=False, + validation_batch_size=validation_batch_size) logits_trainer.train(logits_input_fn, steps=steps) # NOW THE FUCKING SIAMESE - trainer = Triplet(model_dir=model_dir_adapted, - architecture=dummy_adapted, - optimizer=tf.train.GradientDescentOptimizer(learning_rate), - loss_op=triplet_loss, - validation_batch_size=validation_batch_size, - extra_checkpoint=extra_checkpoint) + trainer = Triplet( + model_dir=model_dir_adapted, + architecture=dummy_adapted, + optimizer=tf.train.GradientDescentOptimizer(learning_rate), + loss_op=triplet_loss, + validation_batch_size=validation_batch_size, + extra_checkpoint=extra_checkpoint) run_triplet_estimator(trainer) finally: try: @@ -118,20 +147,37 @@ def run_triplet_estimator(trainer): assert len(tf.global_variables()) == 0 def input_fn(): - return triplet_batch(filenames, labels, data_shape, data_type, batch_size, epochs=epochs, - output_shape=output_shape, - random_flip=True, random_brightness=True, random_contrast=True, random_saturation=True) + return triplet_batch( + filenames, + labels, + data_shape, + data_type, + batch_size, + epochs=epochs, + output_shape=output_shape, + random_flip=True, + random_brightness=True, + random_contrast=True, + random_saturation=True) def input_validation_fn(): - return single_batch(filenames, labels, data_shape, data_type, validation_batch_size, epochs=10, - output_shape=output_shape) - - hooks = [LoggerHookEstimator(trainer, batch_size, 300), - - tf.train.SummarySaverHook(save_steps=1000, - output_dir=model_dir, - scaffold=tf.train.Scaffold(), - summary_writer=tf.summary.FileWriter(model_dir))] + return single_batch( + filenames, + labels, + data_shape, + data_type, + validation_batch_size, + epochs=10, + output_shape=output_shape) + + hooks = [ + LoggerHookEstimator(trainer, batch_size, 300), + tf.train.SummarySaverHook( + save_steps=1000, + output_dir=model_dir, + scaffold=tf.train.Scaffold(), + summary_writer=tf.summary.FileWriter(model_dir)) + ] trainer.train(input_fn, steps=steps, hooks=hooks) diff --git a/bob/learn/tensorflow/test/test_hooks.py b/bob/learn/tensorflow/test/test_hooks.py index 960a9aa5d506b6f2aa0d7b773ab54c555245a574..3e57117ab3fa14608faa1586c7f65428f1d830a2 100644 --- a/bob/learn/tensorflow/test/test_hooks.py +++ b/bob/learn/tensorflow/test/test_hooks.py @@ -19,8 +19,8 @@ def test_early_stopping_linear_classifier(): eval_input_fn = config.eval_input_fn hooks = [ - EarlyStopping('linear/head/metrics/accuracy/value', - min_delta=0.001, patience=1), + EarlyStopping( + 'linear/head/metrics/accuracy/value', min_delta=0.001, patience=1), ] train_spec = tf.estimator.TrainSpec(input_fn=train_input_fn) @@ -55,8 +55,8 @@ def test_early_stopping_logit_trainer(): optimizer = tf.train.GradientDescentOptimizer(learning_rate=1e-1) loss_op = mean_cross_entropy_loss - estimator = Logits(architecture, optimizer, loss_op, - n_classes=10, model_dir=None) + estimator = Logits( + architecture, optimizer, loss_op, n_classes=10, model_dir=None) try: tf.estimator.train_and_evaluate(estimator, train_spec, eval_spec) diff --git a/bob/learn/tensorflow/test/test_image_dataset.py b/bob/learn/tensorflow/test/test_image_dataset.py index d3a63c5ebfda1202134e61eb95c3e0c1a9c0abb5..43b07f94d48ad07882b71071a7a176d3ad449681 100644 --- a/bob/learn/tensorflow/test/test_image_dataset.py +++ b/bob/learn/tensorflow/test/test_image_dataset.py @@ -31,13 +31,14 @@ def test_logitstrainer_images(): # Trainer logits try: embedding_validation = False - trainer = Logits(model_dir=model_dir, - architecture=dummy, - optimizer=tf.train.GradientDescentOptimizer(learning_rate), - n_classes=10, - loss_op=mean_cross_entropy_loss, - embedding_validation=embedding_validation, - validation_batch_size=validation_batch_size) + trainer = Logits( + model_dir=model_dir, + architecture=dummy, + optimizer=tf.train.GradientDescentOptimizer(learning_rate), + n_classes=10, + loss_op=mean_cross_entropy_loss, + embedding_validation=embedding_validation, + validation_batch_size=validation_batch_size) run_logitstrainer_images(trainer) finally: try: @@ -53,27 +54,45 @@ def run_logitstrainer_images(trainer): tf.reset_default_graph() assert len(tf.global_variables()) == 0 - filenames = [pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m301_01_p01_i0_0.png'), - pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m301_01_p02_i0_0.png'), - pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m304_01_p01_i0_0.png'), - pkg_resources.resource_filename(__name__, 'data/dummy_image_database/m304_02_f12_i0_0.png')] + filenames = [ + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m301_01_p01_i0_0.png'), + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m301_01_p02_i0_0.png'), + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m304_01_p01_i0_0.png'), + pkg_resources.resource_filename( + __name__, 'data/dummy_image_database/m304_02_f12_i0_0.png') + ] labels = [0, 0, 1, 1] def input_fn(): - return shuffle_data_and_labels_image_augmentation(filenames, labels, data_shape, data_type, batch_size, - epochs=epochs) + return shuffle_data_and_labels_image_augmentation( + filenames, + labels, + data_shape, + data_type, + batch_size, + epochs=epochs) def input_fn_validation(): - return shuffle_data_and_labels_image_augmentation(filenames, labels, data_shape, data_type, - validation_batch_size, epochs=1000) - - hooks = [LoggerHookEstimator(trainer, 16, 300), - - tf.train.SummarySaverHook(save_steps=1000, - output_dir=model_dir, - scaffold=tf.train.Scaffold(), - summary_writer=tf.summary.FileWriter(model_dir))] + return shuffle_data_and_labels_image_augmentation( + filenames, + labels, + data_shape, + data_type, + validation_batch_size, + epochs=1000) + + hooks = [ + LoggerHookEstimator(trainer, 16, 300), + tf.train.SummarySaverHook( + save_steps=1000, + output_dir=model_dir, + scaffold=tf.train.Scaffold(), + summary_writer=tf.summary.FileWriter(model_dir)) + ] trainer.train(input_fn, steps=steps, hooks=hooks) diff --git a/bob/learn/tensorflow/test/test_layers.py b/bob/learn/tensorflow/test/test_layers.py index e5260b5cb5fd2c436fa11c69ea1cba623c133be8..20d6c3ee30b38b13b0eea31895d32a1d19fa9908 100644 --- a/bob/learn/tensorflow/test/test_layers.py +++ b/bob/learn/tensorflow/test/test_layers.py @@ -10,14 +10,16 @@ from nose.tools import assert_raises_regexp slim = tf.contrib.slim + def test_simple(): tf.reset_default_graph() x = np.zeros([64, 10, 36]) graph = maxout(x, num_units=3) assert graph.get_shape().as_list() == [64, 10, 3] tf.reset_default_graph() - assert len(tf.global_variables())==0 - + assert len(tf.global_variables()) == 0 + + def test_fully_connected(): tf.reset_default_graph() x = np.zeros([64, 50]) @@ -25,7 +27,7 @@ def test_fully_connected(): graph = maxout(graph, num_units=10) assert graph.get_shape().as_list() == [64, 10] tf.reset_default_graph() - assert len(tf.global_variables())==0 + assert len(tf.global_variables()) == 0 def test_nchw(): @@ -35,7 +37,8 @@ def test_nchw(): graph = maxout(graph, num_units=1) assert graph.get_shape().as_list() == [10, 100, 100, 1] tf.reset_default_graph() - assert len(tf.global_variables())==0 + assert len(tf.global_variables()) == 0 + def test_invalid_shape(): tf.reset_default_graph() @@ -44,5 +47,4 @@ def test_invalid_shape(): with assert_raises_regexp(ValueError, 'number of features'): graph = maxout(graph, num_units=2) tf.reset_default_graph() - assert len(tf.global_variables())==0 - + assert len(tf.global_variables()) == 0 diff --git a/bob/learn/tensorflow/test/test_train_script.py b/bob/learn/tensorflow/test/test_train_script.py index 6fd4a9cd4c2880f2a23a9c18ae5a5e707e10ed1b..91d56f959eaf65c66ac98cecc4591e395992325f 100644 --- a/bob/learn/tensorflow/test/test_train_script.py +++ b/bob/learn/tensorflow/test/test_train_script.py @@ -6,7 +6,6 @@ import pkg_resources import shutil import tensorflow as tf - """ def test_train_script_softmax(): tf.reset_default_graph() diff --git a/bob/learn/tensorflow/test/test_utils.py b/bob/learn/tensorflow/test/test_utils.py index 23f3ded505b260b9cf8f7cb3d3e224fb8853bb17..e4f61241acb9a34503f88f6567075c0b4e4fcdfa 100644 --- a/bob/learn/tensorflow/test/test_utils.py +++ b/bob/learn/tensorflow/test/test_utils.py @@ -7,7 +7,6 @@ from bob.learn.tensorflow.utils import compute_embedding_accuracy, cdist,\ compute_embedding_accuracy_tensors, predict_using_tensors import tensorflow as tf - """ Some unit tests for the datashuffler """ @@ -17,11 +16,13 @@ def test_embedding_accuracy(): numpy.random.seed(10) samples_per_class = 5 - - class_a = numpy.random.normal(loc=0, scale=0.1, size=(samples_per_class, 2)) + + class_a = numpy.random.normal( + loc=0, scale=0.1, size=(samples_per_class, 2)) labels_a = numpy.zeros(samples_per_class) - - class_b = numpy.random.normal(loc=10, scale=0.1, size=(samples_per_class, 2)) + + class_b = numpy.random.normal( + loc=10, scale=0.1, size=(samples_per_class, 2)) labels_b = numpy.ones(samples_per_class) data = numpy.vstack((class_a, class_b)) @@ -32,10 +33,10 @@ def test_embedding_accuracy(): # Adding noise noise = numpy.random.normal(loc=0, scale=0.1, size=(samples_per_class, 2)) noise_labels = numpy.ones(samples_per_class) - + data = numpy.vstack((data, noise)) labels = numpy.concatenate((labels, noise_labels)) - + assert compute_embedding_accuracy(data, labels) == 10 / 15. @@ -43,16 +44,18 @@ def test_embedding_accuracy_tensors(): numpy.random.seed(10) samples_per_class = 5 - - class_a = numpy.random.normal(loc=0, scale=0.1, size=(samples_per_class, 2)) + + class_a = numpy.random.normal( + loc=0, scale=0.1, size=(samples_per_class, 2)) labels_a = numpy.zeros(samples_per_class) - - class_b = numpy.random.normal(loc=10, scale=0.1, size=(samples_per_class, 2)) + + class_b = numpy.random.normal( + loc=10, scale=0.1, size=(samples_per_class, 2)) labels_b = numpy.ones(samples_per_class) data = numpy.vstack((class_a, class_b)) labels = numpy.concatenate((labels_a, labels_b)) - + data = tf.convert_to_tensor(data.astype("float32")) labels = tf.convert_to_tensor(labels.astype("int64")) diff --git a/bob/learn/tensorflow/trainers/SiameseTrainer.py b/bob/learn/tensorflow/trainers/SiameseTrainer.py index a47c5b0bdca895281bf86ba71827d9a4a8ee04ab..da7ced89432e13186a97f7e95124d788d78aab93 100644 --- a/bob/learn/tensorflow/trainers/SiameseTrainer.py +++ b/bob/learn/tensorflow/trainers/SiameseTrainer.py @@ -47,25 +47,24 @@ class SiameseTrainer(Trainer): """ - def __init__(self, - train_data_shuffler, - validation_data_shuffler=None, - validate_with_embeddings=False, + def __init__( + self, + train_data_shuffler, + validation_data_shuffler=None, + validate_with_embeddings=False, - ###### training options ########## - iterations=5000, - snapshot=500, - validation_snapshot=100, - keep_checkpoint_every_n_hours=2, + ###### training options ########## + iterations=5000, + snapshot=500, + validation_snapshot=100, + keep_checkpoint_every_n_hours=2, - ## Analizer - analizer=SoftmaxAnalizer(), + ## Analizer + analizer=SoftmaxAnalizer(), - # Temporatu dir - temp_dir="siamese_cnn", - - verbosity_level=2 - ): + # Temporatu dir + temp_dir="siamese_cnn", + verbosity_level=2): self.train_data_shuffler = train_data_shuffler @@ -119,22 +118,25 @@ class SiameseTrainer(Trainer): self.session = Session.instance(new=True).session self.from_scratch = True - def create_network_from_scratch(self, - graph, - validation_graph=None, - optimizer=tf.train.AdamOptimizer(), - loss=None, + def create_network_from_scratch( + self, + graph, + validation_graph=None, + optimizer=tf.train.AdamOptimizer(), + loss=None, - # Learning rate - learning_rate=None, - ): + # Learning rate + learning_rate=None, + ): self.data_ph = self.train_data_shuffler("data") self.label_ph = self.train_data_shuffler("label") self.graph = graph if "left" and "right" not in self.graph: - raise ValueError("`graph` should be a dictionary with two elements (`left`and `right`)") + raise ValueError( + "`graph` should be a dictionary with two elements (`left`and `right`)" + ) self.loss = loss self.optimizer_class = optimizer @@ -162,7 +164,8 @@ class SiameseTrainer(Trainer): # Preparing the optimizer self.optimizer_class._learning_rate = self.learning_rate - self.optimizer = self.optimizer_class.minimize(self.loss['loss'], global_step=self.global_step) + self.optimizer = self.optimizer_class.minimize( + self.loss['loss'], global_step=self.global_step) tf.add_to_collection("optimizer", self.optimizer) tf.add_to_collection("learning_rate", self.learning_rate) @@ -207,20 +210,24 @@ class SiameseTrainer(Trainer): [batch_left, batch_right, labels] = data_shuffler.get_batch() - feed_dict = {self.data_ph['left']: batch_left, - self.data_ph['right']: batch_right, - self.label_ph: labels} + feed_dict = { + self.data_ph['left']: batch_left, + self.data_ph['right']: batch_right, + self.label_ph: labels + } return feed_dict def fit(self, step): feed_dict = self.get_feed_dict(self.train_data_shuffler) - _, l, bt_class, wt_class, lr, summary = self.session.run([ - self.optimizer, - self.loss['loss'], self.loss['between_class'], - self.loss['within_class'], - self.learning_rate, self.summaries_train], feed_dict=feed_dict) + _, l, bt_class, wt_class, lr, summary = self.session.run( + [ + self.optimizer, self.loss['loss'], self.loss['between_class'], + self.loss['within_class'], self.learning_rate, + self.summaries_train + ], + feed_dict=feed_dict) logger.info("Loss training set step={0} = {1}".format(step, l)) self.train_summary_writter.add_summary(summary, step) @@ -252,7 +259,8 @@ class SiameseTrainer(Trainer): # Opening a new session for validation feed_dict = self.get_feed_dict(data_shuffler) - l, summary = self.session.run([self.loss, self.summaries_validation], feed_dict=feed_dict) + l, summary = self.session.run( + [self.loss, self.summaries_validation], feed_dict=feed_dict) self.validation_summary_writter.add_summary(summary, step) #summaries = [summary_pb2.Summary.Value(tag="loss", simple_value=float(l))] @@ -268,15 +276,21 @@ class SiameseTrainer(Trainer): """ while not self.thread_pool.should_stop(): - [train_data_left, train_data_right, train_labels] = self.train_data_shuffler.get_batch() + [train_data_left, train_data_right, + train_labels] = self.train_data_shuffler.get_batch() data_ph = dict() - data_ph['left'] = self.train_data_shuffler("data", from_queue=False)['left'] - data_ph['right'] = self.train_data_shuffler("data", from_queue=False)['right'] + data_ph['left'] = self.train_data_shuffler( + "data", from_queue=False)['left'] + data_ph['right'] = self.train_data_shuffler( + "data", from_queue=False)['right'] label_ph = self.train_data_shuffler("label", from_queue=False) - feed_dict = {data_ph['left']: train_data_left, - data_ph['right']: train_data_right, - label_ph: train_labels} + feed_dict = { + data_ph['left']: train_data_left, + data_ph['right']: train_data_right, + label_ph: train_labels + } - self.session.run(self.train_data_shuffler.enqueue_op, feed_dict=feed_dict) + self.session.run( + self.train_data_shuffler.enqueue_op, feed_dict=feed_dict) diff --git a/bob/learn/tensorflow/trainers/Trainer.py b/bob/learn/tensorflow/trainers/Trainer.py index 426cdf523975cb9a6edf300a6cb4f1ef542b56aa..07c69bf1857a7bbd6699e53e79d59501a6d2d400 100644 --- a/bob/learn/tensorflow/trainers/Trainer.py +++ b/bob/learn/tensorflow/trainers/Trainer.py @@ -52,24 +52,24 @@ class Trainer(object): """ - def __init__(self, - train_data_shuffler, - validation_data_shuffler=None, - validate_with_embeddings=False, + def __init__( + self, + train_data_shuffler, + validation_data_shuffler=None, + validate_with_embeddings=False, - ###### training options ########## - iterations=5000, - snapshot=1000, - validation_snapshot=2000,#2000, - keep_checkpoint_every_n_hours=2, + ###### training options ########## + iterations=5000, + snapshot=1000, + validation_snapshot=2000, #2000, + keep_checkpoint_every_n_hours=2, - ## Analizer - analizer=SoftmaxAnalizer(), + ## Analizer + analizer=SoftmaxAnalizer(), - # Temporatu dir - temp_dir="cnn", - - verbosity_level=2): + # Temporatu dir + temp_dir="cnn", + verbosity_level=2): self.train_data_shuffler = train_data_shuffler @@ -149,26 +149,30 @@ class Trainer(object): # Start a thread to enqueue data asynchronously, and hide I/O latency. if self.train_data_shuffler.prefetch: self.thread_pool = tf.train.Coordinator() - tf.train.start_queue_runners(coord=self.thread_pool, sess=self.session) + tf.train.start_queue_runners( + coord=self.thread_pool, sess=self.session) # In case you have your own queue if not isinstance(self.train_data_shuffler, TFRecord): threads = self.start_thread() # Bootstrapping the summary writters - self.train_summary_writter = tf.summary.FileWriter(os.path.join(self.temp_dir, 'train'), self.session.graph) + self.train_summary_writter = tf.summary.FileWriter( + os.path.join(self.temp_dir, 'train'), self.session.graph) if self.validation_data_shuffler is not None: - self.validation_summary_writter = tf.summary.FileWriter(os.path.join(self.temp_dir, 'validation'), - self.session.graph) + self.validation_summary_writter = tf.summary.FileWriter( + os.path.join(self.temp_dir, 'validation'), self.session.graph) ######################### Loop for ################# - for step in range(start_step, start_step+self.iterations): + for step in range(start_step, start_step + self.iterations): # Run fit in the graph start = time.time() self.fit(step) end = time.time() - summary = summary_pb2.Summary.Value(tag="elapsed_time", simple_value=float(end-start)) - self.train_summary_writter.add_summary(summary_pb2.Summary(value=[summary]), step) + summary = summary_pb2.Summary.Value( + tag="elapsed_time", simple_value=float(end - start)) + self.train_summary_writter.add_summary( + summary_pb2.Summary(value=[summary]), step) # Running validation if self.validation_data_shuffler is not None and step % self.validation_snapshot == 0: @@ -180,7 +184,8 @@ class Trainer(object): # Taking snapshot if step % self.snapshot == 0: logger.info("Taking snapshot") - path = os.path.join(self.temp_dir, 'model_snapshot{0}.ckp'.format(step)) + path = os.path.join(self.temp_dir, + 'model_snapshot{0}.ckp'.format(step)) self.saver.save(self.session, path, global_step=step) # Running validation for the last time @@ -190,7 +195,6 @@ class Trainer(object): else: self.compute_validation(step) - logger.info("Training finally finished") self.train_summary_writter.close() @@ -201,24 +205,24 @@ class Trainer(object): path = os.path.join(self.temp_dir, 'model.ckp') self.saver.save(self.session, path) - if self.train_data_shuffler.prefetch or isinstance(self.train_data_shuffler, TFRecord): + if self.train_data_shuffler.prefetch or isinstance( + self.train_data_shuffler, TFRecord): # now they should definetely stop self.thread_pool.request_stop() #if not isinstance(self.train_data_shuffler, TFRecord): # self.thread_pool.join(threads) - def create_network_from_scratch(self, - graph, - validation_graph=None, - optimizer=tf.train.AdamOptimizer(), - loss=None, - validation_loss=None, - - # Learning rate - learning_rate=None, - prelogits=None - ): - + def create_network_from_scratch( + self, + graph, + validation_graph=None, + optimizer=tf.train.AdamOptimizer(), + loss=None, + validation_loss=None, + + # Learning rate + learning_rate=None, + prelogits=None): """ Prepare all the tensorflow variables before training. @@ -255,13 +259,16 @@ class Trainer(object): # Preparing the optimizer self.optimizer_class._learning_rate = self.learning_rate - self.optimizer = self.optimizer_class.minimize(self.loss, global_step=self.global_step) + self.optimizer = self.optimizer_class.minimize( + self.loss, global_step=self.global_step) # Saving all the variables - self.saver = tf.train.Saver(var_list=tf.global_variables() + tf.local_variables(), - keep_checkpoint_every_n_hours=self.keep_checkpoint_every_n_hours) + self.saver = tf.train.Saver( + var_list=tf.global_variables() + tf.local_variables(), + keep_checkpoint_every_n_hours=self.keep_checkpoint_every_n_hours) - self.summaries_train = self.create_general_summary(self.loss, self.graph, self.label_ph) + self.summaries_train = self.create_general_summary( + self.loss, self.graph, self.label_ph) # SAving some variables tf.add_to_collection("global_step", self.global_step) @@ -278,8 +285,10 @@ class Trainer(object): # Same business with the validation if self.validation_data_shuffler is not None: - self.validation_data_ph = self.validation_data_shuffler("data", from_queue=True) - self.validation_label_ph = self.validation_data_shuffler("label", from_queue=True) + self.validation_data_ph = self.validation_data_shuffler( + "data", from_queue=True) + self.validation_label_ph = self.validation_data_shuffler( + "label", from_queue=True) self.validation_graph = validation_graph @@ -289,15 +298,20 @@ class Trainer(object): #self.validation_predictor = self.loss(self.validation_graph, self.validation_label_ph) self.validation_loss = validation_loss - self.summaries_validation = self.create_general_summary(self.validation_loss, self.validation_graph, self.validation_label_ph) - tf.add_to_collection("summaries_validation", self.summaries_validation) + self.summaries_validation = self.create_general_summary( + self.validation_loss, self.validation_graph, + self.validation_label_ph) + tf.add_to_collection("summaries_validation", + self.summaries_validation) tf.add_to_collection("validation_graph", self.validation_graph) tf.add_to_collection("validation_data_ph", self.validation_data_ph) - tf.add_to_collection("validation_label_ph", self.validation_label_ph) + tf.add_to_collection("validation_label_ph", + self.validation_label_ph) tf.add_to_collection("validation_loss", self.validation_loss) - tf.add_to_collection("summaries_validation", self.summaries_validation) + tf.add_to_collection("summaries_validation", + self.summaries_validation) # Creating the variables tf.local_variables_initializer().run(session=self.session) @@ -315,12 +329,18 @@ class Trainer(object): """ if os.path.isdir(file_name): - checkpoint_path = tf.train.get_checkpoint_state(file_name).model_checkpoint_path - self.saver = tf.train.import_meta_graph(checkpoint_path + ".meta", clear_devices=clear_devices) - self.saver.restore(self.session, tf.train.latest_checkpoint(file_name)) + checkpoint_path = tf.train.get_checkpoint_state( + file_name).model_checkpoint_path + self.saver = tf.train.import_meta_graph( + checkpoint_path + ".meta", clear_devices=clear_devices) + self.saver.restore(self.session, + tf.train.latest_checkpoint(file_name)) else: - self.saver = tf.train.import_meta_graph(file_name, clear_devices=clear_devices) - self.saver.restore(self.session, tf.train.latest_checkpoint(os.path.dirname(file_name))) + self.saver = tf.train.import_meta_graph( + file_name, clear_devices=clear_devices) + self.saver.restore(self.session, + tf.train.latest_checkpoint( + os.path.dirname(file_name))) def load_variables_from_external_model(self, checkpoint_path, var_list): """ @@ -335,14 +355,16 @@ class Trainer(object): """ - assert len(var_list)>0 + assert len(var_list) > 0 tf_varlist = [] for v in var_list: - tf_varlist += tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope=v) + tf_varlist += tf.get_collection( + tf.GraphKeys.GLOBAL_VARIABLES, scope=v) saver = tf.train.Saver(tf_varlist) - saver.restore(self.session, tf.train.latest_checkpoint(checkpoint_path)) + saver.restore(self.session, + tf.train.latest_checkpoint(checkpoint_path)) def create_network_from_file(self, file_name, clear_devices=True): """ @@ -376,14 +398,18 @@ class Trainer(object): # Loading the validation bits if self.validation_data_shuffler is not None: - self.summaries_validation = tf.get_collection("summaries_validation")[0] + self.summaries_validation = tf.get_collection( + "summaries_validation")[0] self.validation_graph = tf.get_collection("validation_graph")[0] - self.validation_data_ph = tf.get_collection("validation_data_ph")[0] - self.validation_label_ph = tf.get_collection("validation_label_ph")[0] + self.validation_data_ph = tf.get_collection("validation_data_ph")[ + 0] + self.validation_label_ph = tf.get_collection( + "validation_label_ph")[0] self.validation_loss = tf.get_collection("validation_loss")[0] - self.summaries_validation = tf.get_collection("summaries_validation")[0] + self.summaries_validation = tf.get_collection( + "summaries_validation")[0] def __del__(self): tf.reset_default_graph() @@ -399,8 +425,7 @@ class Trainer(object): """ [data, labels] = data_shuffler.get_batch() - feed_dict = {self.data_ph: data, - self.label_ph: labels} + feed_dict = {self.data_ph: data, self.label_ph: labels} return feed_dict def fit(self, step): @@ -416,16 +441,24 @@ class Trainer(object): if self.train_data_shuffler.prefetch: # TODO: SPECIFIC HACK FOR THE CENTER LOSS. I NEED TO FIND A CLEAN SOLUTION FOR THAT if self.centers is None: - _, l, lr, summary = self.session.run([self.optimizer, self.loss, - self.learning_rate, self.summaries_train]) + _, l, lr, summary = self.session.run([ + self.optimizer, self.loss, self.learning_rate, + self.summaries_train + ]) else: - _, l, lr, summary, _ = self.session.run([self.optimizer, self.loss, - self.learning_rate, self.summaries_train, self.centers]) + _, l, lr, summary, _ = self.session.run([ + self.optimizer, self.loss, self.learning_rate, + self.summaries_train, self.centers + ]) else: feed_dict = self.get_feed_dict(self.train_data_shuffler) - _, l, lr, summary = self.session.run([self.optimizer, self.loss, - self.learning_rate, self.summaries_train], feed_dict=feed_dict) + _, l, lr, summary = self.session.run( + [ + self.optimizer, self.loss, self.learning_rate, + self.summaries_train + ], + feed_dict=feed_dict) logger.info("Loss training set step={0} = {1}".format(step, l)) self.train_summary_writter.add_summary(summary, step) @@ -442,13 +475,18 @@ class Trainer(object): """ if self.validation_data_shuffler.prefetch: - l, lr, summary = self.session.run([self.validation_loss, - self.learning_rate, self.summaries_validation]) + l, lr, summary = self.session.run([ + self.validation_loss, self.learning_rate, + self.summaries_validation + ]) else: feed_dict = self.get_feed_dict(self.validation_data_shuffler) - l, lr, summary = self.session.run([self.validation_loss, - self.learning_rate, self.summaries_validation], - feed_dict=feed_dict) + l, lr, summary = self.session.run( + [ + self.validation_loss, self.learning_rate, + self.summaries_validation + ], + feed_dict=feed_dict) logger.info("Loss VALIDATION set step={0} = {1}".format(step, l)) self.validation_summary_writter.add_summary(summary, step) @@ -465,18 +503,22 @@ class Trainer(object): """ if self.validation_data_shuffler.prefetch: - embedding, labels = self.session.run([self.validation_loss, self.validation_label_ph]) + embedding, labels = self.session.run( + [self.validation_loss, self.validation_label_ph]) else: feed_dict = self.get_feed_dict(self.validation_data_shuffler) - embedding, labels = self.session.run([self.validation_loss, self.validation_label_ph], - feed_dict=feed_dict) + embedding, labels = self.session.run( + [self.validation_loss, self.validation_label_ph], + feed_dict=feed_dict) accuracy = compute_embedding_accuracy(embedding, labels) - summary = summary_pb2.Summary.Value(tag="accuracy", simple_value=accuracy) - logger.info("VALIDATION Accuracy set step={0} = {1}".format(step, accuracy)) - self.validation_summary_writter.add_summary(summary_pb2.Summary(value=[summary]), step) - + summary = summary_pb2.Summary.Value( + tag="accuracy", simple_value=accuracy) + logger.info("VALIDATION Accuracy set step={0} = {1}".format( + step, accuracy)) + self.validation_summary_writter.add_summary( + summary_pb2.Summary(value=[summary]), step) def create_general_summary(self, average_loss, output, label): """ @@ -529,9 +571,7 @@ class Trainer(object): data_ph = self.train_data_shuffler("data", from_queue=False) label_ph = self.train_data_shuffler("label", from_queue=False) - feed_dict = {data_ph: train_data, - label_ph: train_labels} - - self.session.run(self.train_data_shuffler.enqueue_op, feed_dict=feed_dict) - + feed_dict = {data_ph: train_data, label_ph: train_labels} + self.session.run( + self.train_data_shuffler.enqueue_op, feed_dict=feed_dict) diff --git a/bob/learn/tensorflow/trainers/TripletTrainer.py b/bob/learn/tensorflow/trainers/TripletTrainer.py index da02f877e714852b7df343c6f3081431d210dd04..c4120445eea774aa2df2d8f62c99f2af983e286c 100644 --- a/bob/learn/tensorflow/trainers/TripletTrainer.py +++ b/bob/learn/tensorflow/trainers/TripletTrainer.py @@ -48,25 +48,24 @@ class TripletTrainer(Trainer): """ - def __init__(self, - train_data_shuffler, - validation_data_shuffler=None, - validate_with_embeddings=False, + def __init__( + self, + train_data_shuffler, + validation_data_shuffler=None, + validate_with_embeddings=False, - ###### training options ########## - iterations=5000, - snapshot=500, - validation_snapshot=100, - keep_checkpoint_every_n_hours=2, + ###### training options ########## + iterations=5000, + snapshot=500, + validation_snapshot=100, + keep_checkpoint_every_n_hours=2, - ## Analizer - analizer=SoftmaxAnalizer(), + ## Analizer + analizer=SoftmaxAnalizer(), - # Temporatu dir - temp_dir="triplet_cnn", - - verbosity_level=2 - ): + # Temporatu dir + temp_dir="triplet_cnn", + verbosity_level=2): self.train_data_shuffler = train_data_shuffler @@ -121,21 +120,24 @@ class TripletTrainer(Trainer): self.session = Session.instance(new=True).session self.from_scratch = True - def create_network_from_scratch(self, - graph, - validation_graph=None, - optimizer=tf.train.AdamOptimizer(), - loss=None, + def create_network_from_scratch( + self, + graph, + validation_graph=None, + optimizer=tf.train.AdamOptimizer(), + loss=None, - # Learning rate - learning_rate=None, - ): + # Learning rate + learning_rate=None, + ): self.data_ph = self.train_data_shuffler("data") self.graph = graph if "anchor" and "positive" and "negative" not in self.graph: - raise ValueError("`graph` should be a dictionary with two elements (`anchor`, `positive` and `negative`)") + raise ValueError( + "`graph` should be a dictionary with two elements (`anchor`, `positive` and `negative`)" + ) self.loss = loss self.optimizer_class = optimizer @@ -165,7 +167,8 @@ class TripletTrainer(Trainer): # Preparing the optimizer self.optimizer_class._learning_rate = self.learning_rate - self.optimizer = self.optimizer_class.minimize(self.loss['loss'], global_step=self.global_step) + self.optimizer = self.optimizer_class.minimize( + self.loss['loss'], global_step=self.global_step) tf.add_to_collection("optimizer", self.optimizer) tf.add_to_collection("learning_rate", self.learning_rate) @@ -206,20 +209,25 @@ class TripletTrainer(Trainer): def get_feed_dict(self, data_shuffler): - [batch_anchor, batch_positive, batch_negative] = data_shuffler.get_batch() - feed_dict = {self.data_ph['anchor']: batch_anchor, - self.data_ph['positive']: batch_positive, - self.data_ph['negative']: batch_negative} + [batch_anchor, batch_positive, + batch_negative] = data_shuffler.get_batch() + feed_dict = { + self.data_ph['anchor']: batch_anchor, + self.data_ph['positive']: batch_positive, + self.data_ph['negative']: batch_negative + } return feed_dict def fit(self, step): feed_dict = self.get_feed_dict(self.train_data_shuffler) - _, l, bt_class, wt_class, lr, summary = self.session.run([ - self.optimizer, - self.loss['loss'], self.loss['between_class'], - self.loss['within_class'], - self.learning_rate, self.summaries_train], feed_dict=feed_dict) + _, l, bt_class, wt_class, lr, summary = self.session.run( + [ + self.optimizer, self.loss['loss'], self.loss['between_class'], + self.loss['within_class'], self.learning_rate, + self.summaries_train + ], + feed_dict=feed_dict) logger.info("Loss training set step={0} = {1}".format(step, l)) self.train_summary_writter.add_summary(summary, step) @@ -242,15 +250,22 @@ class TripletTrainer(Trainer): """ while not self.thread_pool.should_stop(): - [train_data_anchor, train_data_positive, train_data_negative] = self.train_data_shuffler.get_batch() + [train_data_anchor, train_data_positive, + train_data_negative] = self.train_data_shuffler.get_batch() data_ph = dict() - data_ph['anchor'] = self.train_data_shuffler("data", from_queue=False)['anchor'] - data_ph['positive'] = self.train_data_shuffler("data", from_queue=False)['positive'] - data_ph['negative'] = self.train_data_shuffler("data", from_queue=False)['negative'] - - feed_dict = {data_ph['anchor']: train_data_anchor, - data_ph['positive']: train_data_positive, - data_ph['negative']: train_data_negative} - - self.session.run(self.train_data_shuffler.enqueue_op, feed_dict=feed_dict) + data_ph['anchor'] = self.train_data_shuffler( + "data", from_queue=False)['anchor'] + data_ph['positive'] = self.train_data_shuffler( + "data", from_queue=False)['positive'] + data_ph['negative'] = self.train_data_shuffler( + "data", from_queue=False)['negative'] + + feed_dict = { + data_ph['anchor']: train_data_anchor, + data_ph['positive']: train_data_positive, + data_ph['negative']: train_data_negative + } + + self.session.run( + self.train_data_shuffler.enqueue_op, feed_dict=feed_dict) diff --git a/bob/learn/tensorflow/trainers/__init__.py b/bob/learn/tensorflow/trainers/__init__.py index ee0a98197281f67b7defe48a59d91ff672bae6fa..84c08dc3a056994468cb1c653d853b987fd4a609 100644 --- a/bob/learn/tensorflow/trainers/__init__.py +++ b/bob/learn/tensorflow/trainers/__init__.py @@ -1,4 +1,3 @@ - from .Trainer import Trainer from .SiameseTrainer import SiameseTrainer from .TripletTrainer import TripletTrainer @@ -11,16 +10,17 @@ def evaluate_softmax(data, labels, session, graph, data_node): Evaluate the network assuming that the output layer is a softmax """ - predictions = numpy.argmax(session.run( - graph, - feed_dict={data_node: data[:]}), 1) + predictions = numpy.argmax( + session.run(graph, feed_dict={ + data_node: data[:] + }), 1) return 100. * numpy.sum(predictions == labels) / predictions.shape[0] # gets sphinx autodoc done right - don't remove it def __appropriate__(*args): - """Says object was actually declared here, an not on the import module. + """Says object was actually declared here, an not on the import module. Parameters: @@ -30,7 +30,9 @@ def __appropriate__(*args): ` """ - for obj in args: obj.__module__ = __name__ + for obj in args: + obj.__module__ = __name__ + __appropriate__( Trainer, @@ -38,7 +40,5 @@ __appropriate__( TripletTrainer, exponential_decay, constant, - ) +) __all__ = [_ for _ in dir() if not _.startswith('_')] - - diff --git a/bob/learn/tensorflow/trainers/learning_rate.py b/bob/learn/tensorflow/trainers/learning_rate.py index 552e43dbb1c9c74257d9260080f25de347a391b2..72bc77e98623ec4899c906b162088ae968f42083 100644 --- a/bob/learn/tensorflow/trainers/learning_rate.py +++ b/bob/learn/tensorflow/trainers/learning_rate.py @@ -19,12 +19,12 @@ def exponential_decay(base_learning_rate=0.05, """ global_step = tf.train.get_or_create_global_step() - return tf.train.exponential_decay(learning_rate=base_learning_rate, - global_step=global_step, - decay_steps=decay_steps, - decay_rate=weight_decay, - staircase=staircase - ) + return tf.train.exponential_decay( + learning_rate=base_learning_rate, + global_step=global_step, + decay_steps=decay_steps, + decay_rate=weight_decay, + staircase=staircase) def constant(base_learning_rate=0.05, name="constant_learning_rate"): diff --git a/bob/learn/tensorflow/utils/commandline.py b/bob/learn/tensorflow/utils/commandline.py index 29cd5fde04de369c83af34abd80b7c31e2909f50..afed6a24538386ec718de944c242fc94680f8690 100644 --- a/bob/learn/tensorflow/utils/commandline.py +++ b/bob/learn/tensorflow/utils/commandline.py @@ -1,4 +1,7 @@ -def get_from_config_or_commandline(config, keyword, args, defaults, +def get_from_config_or_commandline(config, + keyword, + args, + defaults, default_is_valid=True): """Takes the value from command line, config file, and default value with this precedence. diff --git a/bob/learn/tensorflow/utils/reproducible.py b/bob/learn/tensorflow/utils/reproducible.py index 578ba1d5e8c4dfc6d6c6b3183bb0fcf5bc5ea32f..b18ab2ff09bf5fae42e450dc3de11635a9344670 100644 --- a/bob/learn/tensorflow/utils/reproducible.py +++ b/bob/learn/tensorflow/utils/reproducible.py @@ -53,9 +53,10 @@ def set_seed(seed=0, python_hash_seed=0, log_device_placement=False): # non-reproducible results. # For further details, see: # https://stackoverflow.com/questions/42022950/which-seeds-have-to-be-set-where-to-realize-100-reproducibility-of-training-res - session_config = tf.ConfigProto(intra_op_parallelism_threads=1, - inter_op_parallelism_threads=1, - log_device_placement=log_device_placement) + session_config = tf.ConfigProto( + intra_op_parallelism_threads=1, + inter_op_parallelism_threads=1, + log_device_placement=log_device_placement) # The below tf.set_random_seed() will make random number generation # in the TensorFlow backend have a well-defined initial state. diff --git a/bob/learn/tensorflow/utils/sequences.py b/bob/learn/tensorflow/utils/sequences.py index fa16cb82c81a515af4a70796033df749a3cb9a9b..c2de433a50c65e13d3cb7353bd1f036a8055ddc6 100644 --- a/bob/learn/tensorflow/utils/sequences.py +++ b/bob/learn/tensorflow/utils/sequences.py @@ -65,9 +65,7 @@ class PadSequence(Sequence): data, targets = [], [] for file_object, target in zip(files, labels): loaded_data = self.preprocessor.read_original_data( - file_object, - self.original_directory, - self.original_extension) + file_object, self.original_directory, self.original_extension) preprocessed_data = self.preprocessor(loaded_data) data.append(preprocessed_data) targets.append(target) @@ -100,15 +98,17 @@ def get_pad_files_labels(database, groups): tuple A tuple of (files, labels) for that particular group and protocol. """ - files = database.samples( - groups=groups, protocol=database.protocol) + files = database.samples(groups=groups, protocol=database.protocol) labels = ((f.attack_type is None) for f in files) labels = numpy.fromiter(labels, bool, len(files)) return files, labels -def get_pad_sequences(database, preprocessor, batch_size, - groups=('world', 'dev', 'eval'), shuffle=False, +def get_pad_sequences(database, + preprocessor, + batch_size, + groups=('world', 'dev', 'eval'), + shuffle=False, limit=None): """Returns a list of :any:`Sequence` objects for the database. @@ -137,7 +137,8 @@ def get_pad_sequences(database, preprocessor, batch_size, files, labels = shuffle_data(files, labels) if limit is not None: files, labels = files[:limit], labels[:limit] - seqs.append(PadSequence(files, labels, batch_size, preprocessor, - database.original_directory, - database.original_extension)) + seqs.append( + PadSequence(files, labels, batch_size, preprocessor, + database.original_directory, + database.original_extension)) return seqs diff --git a/bob/learn/tensorflow/utils/session.py b/bob/learn/tensorflow/utils/session.py index 0a68c84acc43a9f4273e449d359a9747a470cb98..3976f9f0446f14a74f0d5b1e237dd28a7937fbb9 100644 --- a/bob/learn/tensorflow/utils/session.py +++ b/bob/learn/tensorflow/utils/session.py @@ -1,12 +1,13 @@ #!/usr/bin/env python # vim: set fileencoding=utf-8 : # @author: Tiago de Freitas Pereira -# @date: Wed 11 May 2016 09:39:36 CEST +# @date: Wed 11 May 2016 09:39:36 CEST import tensorflow as tf from .singleton import Singleton from tensorflow.python import debug as tf_debug + @Singleton class Session(object): """ @@ -14,9 +15,10 @@ class Session(object): """ def __init__(self, debug=False): - config = tf.ConfigProto(log_device_placement=False, - allow_soft_placement=True, - gpu_options=tf.GPUOptions(per_process_gpu_memory_fraction=0.5)) + config = tf.ConfigProto( + log_device_placement=False, + allow_soft_placement=True, + gpu_options=tf.GPUOptions(per_process_gpu_memory_fraction=0.5)) config.gpu_options.allow_growth = True self.session = tf.Session() if debug: diff --git a/bob/learn/tensorflow/utils/singleton.py b/bob/learn/tensorflow/utils/singleton.py index 46594bd5edb7004af5957b9c8444c5500d89bea2..d91f3c3ab5cfc339936066e3642c4f728edd20da 100644 --- a/bob/learn/tensorflow/utils/singleton.py +++ b/bob/learn/tensorflow/utils/singleton.py @@ -45,7 +45,8 @@ class Singleton(object): return self._instance def __call__(self): - raise TypeError('Singletons must be accessed through the `instance()` method.') + raise TypeError( + 'Singletons must be accessed through the `instance()` method.') def __instancecheck__(self, inst): return isinstance(inst, self._decorated) diff --git a/bob/learn/tensorflow/utils/util.py b/bob/learn/tensorflow/utils/util.py index d809c2ee079599996455b405cc2143147bdbcd2e..4bde87f36ad6154d15d20e70676f356b12053c36 100644 --- a/bob/learn/tensorflow/utils/util.py +++ b/bob/learn/tensorflow/utils/util.py @@ -40,15 +40,14 @@ def load_mnist(perc_train=0.9): train_data = data[0:n_train, :].astype("float32") * 0.00390625 train_labels = labels[0:n_train] - validation_data = data[n_train:n_train + - n_validation, :].astype("float32") * 0.00390625 + validation_data = data[n_train:n_train + n_validation, :].astype( + "float32") * 0.00390625 validation_labels = labels[n_train:n_train + n_validation] return train_data, train_labels, validation_data, validation_labels def create_mnist_tfrecord(tfrecords_filename, data, labels, n_samples=6000): - def _bytes_feature(value): return tf.train.Feature(bytes_list=tf.train.BytesList(value=[value])) @@ -60,10 +59,11 @@ def create_mnist_tfrecord(tfrecords_filename, data, labels, n_samples=6000): for i in range(n_samples): img = data[i] img_raw = img.tostring() - feature = {'data': _bytes_feature(img_raw), - 'label': _int64_feature(labels[i]), - 'key': _bytes_feature(b'-') - } + feature = { + 'data': _bytes_feature(img_raw), + 'label': _int64_feature(labels[i]), + 'key': _bytes_feature(b'-') + } example = tf.train.Example(features=tf.train.Features(feature=feature)) writer.write(example.SerializeToString()) @@ -89,15 +89,19 @@ def compute_eer(data_train, labels_train, data_validation, labels_validation, # Positive scoring indexes = labels_validation == i positive_data = data_validation[indexes, :] - p = [cosine(models[i], positive_data[j]) - for j in range(positive_data.shape[0])] + p = [ + cosine(models[i], positive_data[j]) + for j in range(positive_data.shape[0]) + ] positive_scores = numpy.hstack((positive_scores, p)) # negative scoring indexes = labels_validation != i negative_data = data_validation[indexes, :] - n = [cosine(models[i], negative_data[j]) - for j in range(negative_data.shape[0])] + n = [ + cosine(models[i], negative_data[j]) + for j in range(negative_data.shape[0]) + ] negative_scores = numpy.hstack((negative_scores, n)) # Computing performance based on EER @@ -145,13 +149,15 @@ def debug_embbeding(image, architecture, embbeding_dim=2, feature_layer="fc3"): session = Session.instance(new=False).session inference_graph = architecture.compute_graph( - architecture.inference_placeholder, feature_layer=feature_layer, + architecture.inference_placeholder, + feature_layer=feature_layer, training=False) embeddings = numpy.zeros(shape=(image.shape[0], embbeding_dim)) for i in range(image.shape[0]): feed_dict = { - architecture.inference_placeholder: image[i:i + 1, :, :, :]} + architecture.inference_placeholder: image[i:i + 1, :, :, :] + } embedding = session.run( [tf.nn.l2_normalize(inference_graph, 1, 1e-10)], feed_dict=feed_dict)[0] @@ -170,17 +176,15 @@ def cdist(A): ones_1 = tf.reshape( tf.cast(tf.ones_like(A), tf.float32)[:, 0], [1, -1]) p1 = tf.matmul( - tf.expand_dims(tf.reduce_sum(tf.square(A), 1), 1), - ones_1 - ) + tf.expand_dims(tf.reduce_sum(tf.square(A), 1), 1), ones_1) ones_2 = tf.reshape( tf.cast(tf.ones_like(A), tf.float32)[:, 0], [-1, 1]) - p2 = tf.transpose(tf.matmul( - tf.reshape(tf.reduce_sum(tf.square(A), 1), shape=[-1, 1]), - ones_2, - transpose_b=True - )) + p2 = tf.transpose( + tf.matmul( + tf.reshape(tf.reduce_sum(tf.square(A), 1), shape=[-1, 1]), + ones_2, + transpose_b=True)) return tf.sqrt(tf.add(p1, p2) - 2 * tf.matmul(A, A, transpose_b=True)) @@ -210,8 +214,11 @@ def compute_embedding_accuracy_tensors(embedding, labels, num=None): # Fitting the main diagonal with infs (removing comparisons with the same # sample) predictions = predict_using_tensors(embedding, labels, num=num) - matching = [tf.equal(p, l) for p, l in zip(tf.unstack( - predictions, num=num), tf.unstack(labels, num=num))] + matching = [ + tf.equal(p, l) + for p, l in zip( + tf.unstack(predictions, num=num), tf.unstack(labels, num=num)) + ] return tf.reduce_sum(tf.cast(matching, tf.uint8)) / len(predictions) @@ -241,8 +248,9 @@ def compute_embedding_accuracy(embedding, labels): # Getting the original positions of the indexes in the 1-axis #corrected_indexes = [ i if i= "1.4.1": @@ -49,7 +41,7 @@ if os.path.exists('nitpick-exceptions.txt'): continue dtype, target = line.split(None, 1) target = target.strip() - try: # python 2.x + try: # python 2.x target = unicode(target) except NameError: pass @@ -136,7 +128,6 @@ project_variable = project.replace('.', '_') short_description = u'bob.learn.tensorflow API' owner = [u'Idiap Research Institute'] - # -- Options for HTML output --------------------------------------------------- # The theme to use for HTML and HTML Help pages. See the documentation for @@ -217,7 +208,6 @@ html_favicon = 'img/favicon.ico' # Output file base name for HTML help builder. htmlhelp_basename = project_variable + u'_doc' - # -- Post configuration -------------------------------------------------------- # Included after all input documents @@ -225,43 +215,46 @@ rst_epilog = """ .. |project| replace:: Bob .. |version| replace:: %s .. |current-year| date:: %%Y -""" % (version,) +""" % (version, ) # Default processing flags for sphinx autoclass_content = 'class' autodoc_member_order = 'bysource' autodoc_default_flags = [ - 'members', - 'undoc-members', - 'inherited-members', - 'show-inheritance', - ] + 'members', + 'undoc-members', + 'inherited-members', + 'show-inheritance', +] # For inter-documentation mapping: from bob.extension.utils import link_documentation, load_requirements sphinx_requirements = "extra-intersphinx.txt" if os.path.exists(sphinx_requirements): - intersphinx_mapping = link_documentation(additional_packages=['python', 'numpy']+load_requirements(sphinx_requirements)) + intersphinx_mapping = link_documentation( + additional_packages=['python', 'numpy'] + + load_requirements(sphinx_requirements)) else: intersphinx_mapping = link_documentation() - # We want to remove all private (i.e. _. or __.__) members # that are not in the list of accepted functions accepted_private_functions = ['__array__'] + def member_function_test(app, what, name, obj, skip, options): - # test if we have a private function - if len(name) > 1 and name[0] == '_': - # test if this private function should be allowed - if name not in accepted_private_functions: - # omit privat functions that are not in the list of accepted private functions - return skip - else: - # test if the method is documented - if not hasattr(obj, '__doc__') or not obj.__doc__: - return skip - return False + # test if we have a private function + if len(name) > 1 and name[0] == '_': + # test if this private function should be allowed + if name not in accepted_private_functions: + # omit privat functions that are not in the list of accepted private functions + return skip + else: + # test if the method is documented + if not hasattr(obj, '__doc__') or not obj.__doc__: + return skip + return False + def setup(app): - app.connect('autodoc-skip-member', member_function_test) + app.connect('autodoc-skip-member', member_function_test) diff --git a/setup.py b/setup.py index c57cacc6d5eac374f3f8ca6ae67650c351c55fb1..45bf0ac9390c71fd797398438df10e82feee9286 100644 --- a/setup.py +++ b/setup.py @@ -20,7 +20,6 @@ setup( name='bob.learn.tensorflow', version=open("version.txt").read().rstrip(), description='Bob bindings for tensorflow', - url='', license='BSD', author='Tiago de Freitas Pereira', @@ -42,7 +41,6 @@ setup( install_requires=install_requires, packages=find_packages(), zip_safe=False, - entry_points={ # scripts should be declared using this entry: @@ -56,7 +54,6 @@ setup( 'bob_tf_predict_generic = bob.learn.tensorflow.script.predict_generic:main', 'bob_tf_predict_bio = bob.learn.tensorflow.script.predict_bio:main', ], - }, # Classifiers are important if you plan to distribute this package through