Skip to content
Snippets Groups Projects
Commit 64efc538 authored by Amir MOHAMMADI's avatar Amir MOHAMMADI
Browse files

add more functionality. Change default feature

parent e3da96e9
No related branches found
No related tags found
1 merge request!23Change default feature
Hide whitespace changes
Inline Side-by-side
bob/learn/tensorflow/dataset/__init__.py
+ 79
− 18
View file @ 64efc538
import tensorflow as tf
import numpy
DEFAULT_FEATURE = {'train/data': tf.FixedLenFeature([], tf.string),
'train/label': tf.FixedLenFeature([], tf.int64)}
DEFAULT_FEATURE = {'data': tf.FixedLenFeature([], tf.string),
'label': tf.FixedLenFeature([], tf.int64),
'key': tf.FixedLenFeature([], tf.string)}
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,
......@@ -15,11 +15,11 @@ def append_image_augmentation(image, gray_scale=False,
per_image_normalization=True):
"""
Append to the current tensor some random image augmentation operation
**Parameters**
gray_scale:
Convert to gray scale?
output_shape:
If set, will randomly crop the image given the output shape
......@@ -37,16 +37,16 @@ def append_image_augmentation(image, gray_scale=False,
per_image_normalization:
Linearly scales image to have zero mean and unit norm.
"""
# Casting to float32
image = tf.cast(image, tf.float32)
if output_shape is not None:
assert len(output_shape) == 2
assert len(output_shape) == 2
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)
......@@ -68,17 +68,17 @@ def append_image_augmentation(image, gray_scale=False,
image = tf.image.per_image_standardization(image)
return image
def siamease_pairs_generator(input_data, input_labels):
"""
Giving a list of samples and a list of labels, it dumps a series of
pairs for siamese nets.
**Parameters**
input_data: List of whatever representing the data samples
input_labels: List of the labels (needs to be in EXACT same order as input_data)
"""
......@@ -86,7 +86,7 @@ def siamease_pairs_generator(input_data, input_labels):
left_data = []
right_data = []
labels = []
def append(left, right, label):
"""
Just appending one element in each list
......@@ -97,8 +97,8 @@ def siamease_pairs_generator(input_data, input_labels):
possible_labels = list(set(input_labels))
input_data = numpy.array(input_data)
input_labels = numpy.array(input_labels)
total_samples = input_data.shape[0]
input_labels = numpy.array(input_labels)
total_samples = input_data.shape[0]
# Filtering the samples by label and shuffling all the indexes
indexes_per_labels = dict()
......@@ -107,7 +107,7 @@ def siamease_pairs_generator(input_data, input_labels):
numpy.random.shuffle(indexes_per_labels[l])
left_possible_indexes = numpy.random.choice(possible_labels, total_samples, replace=True)
right_possible_indexes = numpy.random.choice(possible_labels, total_samples, replace=True)
right_possible_indexes = numpy.random.choice(possible_labels, total_samples, replace=True)
genuine = True
for i in range(total_samples):
......@@ -142,6 +142,67 @@ def siamease_pairs_generator(input_data, input_labels):
append(left, right, 1)
genuine = not genuine
genuine = not genuine
return left_data, right_data, labels
def blocks_tensorflow(images, block_size):
"""Return all non-overlapping blocks of an image using tensorflow
operations.
Parameters
----------
images : :any:`tf.Tensor`
The input color images. It is assumed that the image has a shape of
[?, H, W, C].
block_size : (int, int)
A tuple of two integers indicating the block size.
Returns
-------
blocks : :any:`tf.Tensor`
All the blocks in the batch dimension. The output will be of
size [?, block_size[0], block_size[1], C].
n_blocks : int
The number of blocks that was obtained per image.
"""
# normalize block_size
block_size = [1] + list(block_size) + [1]
output_size = list(block_size)
output_size[0] = -1
# 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")
if i == 0:
n_blocks = int(numpy.prod(blocks.shape[1:3]))
blocks = tf.reshape(blocks, output_size)
output.append(blocks)
# concatenate the colors back
output = tf.concat(output, axis=3)
return output, n_blocks
def tf_repeat(tensor, repeats):
"""
Parameters
----------
tensor
A Tensor. 1-D or higher.
repeats
A list. Number of repeat for each dimension, length must be the same as
the number of dimensions in input
Returns
-------
A Tensor. Has the same type as input. Has the shape of tensor.shape *
repeats
"""
with tf.variable_scope("repeat"):
expanded_tensor = tf.expand_dims(tensor, -1)
multiples = [1] + repeats
tiled_tensor = tf.tile(expanded_tensor, multiples=multiples)
repeated_tesnor = tf.reshape(tiled_tensor, tf.shape(tensor) * repeats)
return repeated_tesnor
bob/learn/tensorflow/dataset/tfrecords.py
+ 73
− 76
View file @ 64efc538
......@@ -6,31 +6,31 @@ from . import append_image_augmentation, DEFAULT_FEATURE
def example_parser(serialized_example, feature, data_shape, data_type):
"""
Parses a single tf.Example into image and label tensors.
"""
# Decode the record read by the reader
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'], data_type)
image = tf.decode_raw(features['data'], data_type)
# Cast label data into int64
label = tf.cast(features['train/label'], tf.int64)
label = tf.cast(features['label'], tf.int64)
# Reshape image data into the original shape
image = tf.reshape(image, data_shape)
return image, label
key = tf.cast(features['key'], tf.string)
return image, label, key
def image_augmentation_parser(serialized_example, feature, data_shape, data_type,
gray_scale=False,
gray_scale=False,
output_shape=None,
random_flip=False,
random_brightness=False,
random_contrast=False,
random_saturation=False,
per_image_normalization=True):
"""
Parses a single tf.Example into image and label tensors.
"""
# Decode the record read by the reader
features = tf.parse_single_example(serialized_example, features=feature)
......@@ -39,8 +39,8 @@ def image_augmentation_parser(serialized_example, feature, data_shape, data_type
# Reshape image data into the original shape
image = tf.reshape(image, data_shape)
#Applying image augmentation
# Applying image augmentation
image = append_image_augmentation(image, gray_scale=gray_scale,
output_shape=output_shape,
random_flip=random_flip,
......@@ -48,7 +48,7 @@ def image_augmentation_parser(serialized_example, feature, data_shape, data_type
random_contrast=random_contrast,
random_saturation=random_saturation,
per_image_normalization=per_image_normalization)
# Cast label data into int64
label = tf.cast(features['train/label'], tf.int64)
return image, label
......@@ -56,12 +56,11 @@ def image_augmentation_parser(serialized_example, feature, data_shape, data_type
def read_and_decode(filename_queue, data_shape, data_type=tf.float32,
feature=None):
"""
Simples parse possible for a tfrecord.
It assumes that you have the pair **train/data** and **train/label**
"""
if feature is None:
feature = DEFAULT_FEATURE
# Define a reader and read the next record
......@@ -74,22 +73,22 @@ def create_dataset_from_records(tfrecord_filenames, data_shape, data_type,
feature=None):
"""
Create dataset from a list of tf-record files
**Parameters**
tfrecord_filenames:
tfrecord_filenames:
List containing the tf-record paths
data_shape:
Samples shape saved in the tf-record
data_type:
tf data type(https://www.tensorflow.org/versions/r0.12/resources/dims_types#data_types)
feature:
"""
if feature is None:
feature = DEFAULT_FEATURE
dataset = tf.contrib.data.TFRecordDataset(tfrecord_filenames)
......@@ -100,39 +99,38 @@ def create_dataset_from_records(tfrecord_filenames, data_shape, data_type,
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):
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
**Parameters**
tfrecord_filenames:
tfrecord_filenames:
List containing the tf-record paths
data_shape:
Samples shape saved in the tf-record
data_type:
tf data type(https://www.tensorflow.org/versions/r0.12/resources/dims_types#data_types)
feature:
"""
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,
gray_scale=gray_scale,
output_shape=output_shape,
random_flip=random_flip,
random_brightness=random_brightness,
......@@ -144,40 +142,40 @@ def create_dataset_from_records_with_augmentation(tfrecord_filenames, data_shape
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,
random_brightness=False,
random_contrast=False,
random_saturation=False,
per_image_normalization=True):
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):
"""
Dump random batches from a list of tf-record files and applies some image augmentation
**Parameters**
tfrecord_filenames:
tfrecord_filenames:
List containing the tf-record paths
data_shape:
Samples shape saved in the tf-record
data_type:
tf data type(https://www.tensorflow.org/versions/r0.12/resources/dims_types#data_types)
batch_size:
Size of the batch
epochs:
Number of epochs to be batched
buffer_size:
Size of the shuffle bucket
gray_scale:
Convert to gray scale?
output_shape:
If set, will randomly crop the image given the output shape
......@@ -194,20 +192,20 @@ def shuffle_data_and_labels_image_augmentation(tfrecord_filenames, data_shape, d
Adjust the saturation of an RGB image by a random factor (https://www.tensorflow.org/api_docs/python/tf/image/random_saturation)
per_image_normalization:
Linearly scales image to have zero mean and unit norm.
"""
Linearly scales image to have zero mean and unit norm.
"""
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)
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 = dataset.make_one_shot_iterator().get_next()
......@@ -221,25 +219,25 @@ def shuffle_data_and_labels(tfrecord_filenames, data_shape, data_type,
**Parameters**
tfrecord_filenames:
tfrecord_filenames:
List containing the tf-record paths
data_shape:
Samples shape saved in the tf-record
data_type:
tf data type(https://www.tensorflow.org/versions/r0.12/resources/dims_types#data_types)
batch_size:
Size of the batch
epochs:
Number of epochs to be batched
buffer_size:
Size of the shuffle bucket
"""
"""
dataset = create_dataset_from_records(tfrecord_filenames, data_shape,
data_type)
......@@ -256,26 +254,25 @@ def batch_data_and_labels(tfrecord_filenames, data_shape, data_type,
**Parameters**
tfrecord_filenames:
tfrecord_filenames:
List containing the tf-record paths
data_shape:
Samples shape saved in the tf-record
data_type:
tf data type(https://www.tensorflow.org/versions/r0.12/resources/dims_types#data_types)
batch_size:
Size of the batch
epochs:
Number of epochs to be batched
"""
"""
dataset = create_dataset_from_records(tfrecord_filenames, data_shape,
data_type)
dataset = dataset.batch(batch_size).repeat(epochs)
data, labels = dataset.make_one_shot_iterator().get_next()
return data, labels
bob/learn/tensorflow/network/SimpleCNN.py
+ 35
− 26
View file @ 64efc538
import tensorflow as tf
from ..utils import get_available_gpus, to_channels_first
def architecture(input_layer, mode=tf.estimator.ModeKeys.TRAIN):
# TODO: figure out a way to accept different input sizes
def architecture(input_layer, mode=tf.estimator.ModeKeys.TRAIN,
kernerl_size=(3, 3), n_classes=2):
data_format = 'channels_last'
if len(get_available_gpus()) != 0:
# When running on GPU, transpose the data from channels_last (NHWC) to
# channels_first (NCHW) to improve performance. See
# https://www.tensorflow.org/performance/performance_guide#data_formats
input_layer = to_channels_first('input_layer')
data_format = 'channels_first'
# Convolutional Layer #1
# Computes 32 features using a 5x5 filter with ReLU activation.
# Computes 32 features using a kernerl_size filter with ReLU activation.
# Padding is added to preserve width and height.
# Input Tensor Shape: [batch_size, 50, 1024, 1]
# Output Tensor Shape: [batch_size, 50, 1024, 32]
conv1 = tf.layers.conv2d(
inputs=input_layer,
filters=32,
kernel_size=[5, 5],
kernel_size=kernerl_size,
padding="same",
activation=tf.nn.relu)
activation=tf.nn.relu,
data_format=data_format)
# Pooling Layer #1
# First max pooling layer with a 2x2 filter and stride of 2
# Input Tensor Shape: [batch_size, 50, 1024, 32]
# Output Tensor Shape: [batch_size, 25, 512, 32]
pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)
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.
# Computes 64 features using a kernerl_size filter.
# Padding is added to preserve width and height.
# Input Tensor Shape: [batch_size, 25, 512, 32]
# Output Tensor Shape: [batch_size, 25, 512, 64]
conv2 = tf.layers.conv2d(
inputs=pool1,
filters=64,
kernel_size=[5, 5],
kernel_size=kernerl_size,
padding="same",
activation=tf.nn.relu)
activation=tf.nn.relu,
data_format=data_format)
# Pooling Layer #2
# Second max pooling layer with a 2x2 filter and stride of 2
# Input Tensor Shape: [batch_size, 25, 512, 64]
# Output Tensor Shape: [batch_size, 12, 256, 64]
pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2)
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, 12, 256, 64]
# Output Tensor Shape: [batch_size, 12 * 256 * 64]
pool2_flat = tf.reshape(pool2, [-1, 12 * 256 * 64])
dim = tf.reduce_prod(tf.shape(pool2)[1:])
pool2_flat = tf.reshape(pool2, [-1, dim])
# Dense Layer
# Densely connected layer with 1024 neurons
# Input Tensor Shape: [batch_size, 12 * 256 * 64]
# Output Tensor Shape: [batch_size, 1024]
dense = tf.layers.dense(
inputs=pool2_flat, units=1024, activation=tf.nn.relu)
......@@ -59,24 +62,30 @@ def architecture(input_layer, mode=tf.estimator.ModeKeys.TRAIN):
# Logits layer
# Input Tensor Shape: [batch_size, 1024]
# Output Tensor Shape: [batch_size, 2]
logits = tf.layers.dense(inputs=dropout, units=2)
logits = tf.layers.dense(inputs=dropout, units=n_classes)
return logits
def model_fn(features, labels, mode, params, config):
def model_fn(features, labels, mode, params=None, config=None):
"""Model function for CNN."""
params = params or {}
learning_rate = params.get('learning_rate', 0.00001)
learning_rate = params.get('learning_rate', 1e-5)
kernerl_size = params.get('kernerl_size', (3, 3))
n_classes = params.get('n_classes', 2)
logits = architecture(features, mode)
data = features['data']
keys = features['keys']
logits = architecture(
data, mode, kernerl_size=kernerl_size, n_classes=n_classes)
predictions = {
# Generate predictions (for PREDICT and EVAL mode)
"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"),
'keys': keys,
}
if mode == tf.estimator.ModeKeys.PREDICT:
return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)
......
bob/learn/tensorflow/utils/util.py
+ 129
− 38
View file @ 64efc538
#!/usr/bin/env python
# vim: set fileencoding=utf-8 :
# @author: Tiago de Freitas Pereira <tiago.pereira@idiap.ch>
# @date: Wed 11 May 2016 09:39:36 CEST
# @date: Wed 11 May 2016 09:39:36 CEST
import numpy
import tensorflow as tf
numpy.random.seed(10)
from tensorflow.python.client import device_lib
def compute_euclidean_distance(x, y):
......@@ -13,7 +13,7 @@ def compute_euclidean_distance(x, y):
Computes the euclidean distance between two tensorflow variables
"""
with tf.name_scope('euclidean_distance') as scope:
with tf.name_scope('euclidean_distance'):
d = tf.sqrt(tf.reduce_sum(tf.square(tf.subtract(x, y)), 1))
return d
......@@ -34,14 +34,15 @@ def load_mnist(perc_train=0.9):
numpy.random.shuffle(indexes)
# Spliting train and validation
n_train = int(perc_train*indexes.shape[0])
n_train = int(perc_train * indexes.shape[0])
n_validation = total_samples - n_train
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_labels = labels[n_train:n_train+n_validation]
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
......@@ -59,17 +60,18 @@ 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 = {'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()
def compute_eer(data_train, labels_train, data_validation, labels_validation, n_classes):
def compute_eer(data_train, labels_train, data_validation, labels_validation,
n_classes):
import bob.measure
from scipy.spatial.distance import cosine
......@@ -87,13 +89,15 @@ def compute_eer(data_train, labels_train, data_validation, labels_validation, n_
# 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
......@@ -107,7 +111,8 @@ def compute_eer(data_train, labels_train, data_validation, labels_validation, n_
return eer
def compute_accuracy(data_train, labels_train, data_validation, labels_validation, n_classes):
def compute_accuracy(data_train, labels_train, data_validation,
labels_validation, n_classes):
from scipy.spatial.distance import cosine
# Creating client models
......@@ -120,7 +125,7 @@ def compute_accuracy(data_train, labels_train, data_validation, labels_validatio
tp = 0
for i in range(data_validation.shape[0]):
d = data_validation[i,:]
d = data_validation[i, :]
l = labels_validation[i]
scores = [cosine(m, d) for m in models]
......@@ -130,21 +135,26 @@ def compute_accuracy(data_train, labels_train, data_validation, labels_validatio
tp += 1
return (float(tp) / data_validation.shape[0]) * 100
def debug_embbeding(image, architecture, embbeding_dim=2, feature_layer="fc3"):
"""
"""
import tensorflow as tf
from bob.learn.tensorflow.utils.session import Session
session = Session.instance(new=False).session
inference_graph = architecture.compute_graph(architecture.inference_placeholder, feature_layer=feature_layer, training=False)
session = Session.instance(new=False).session
inference_graph = architecture.compute_graph(
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, :,:,:]}
embedding = session.run([tf.nn.l2_normalize(inference_graph, 1, 1e-10)], feed_dict=feed_dict)[0]
feed_dict = {
architecture.inference_placeholder: image[i:i + 1, :, :, :]}
embedding = session.run(
[tf.nn.l2_normalize(inference_graph, 1, 1e-10)],
feed_dict=feed_dict)[0]
embedding = numpy.reshape(embedding, numpy.prod(embedding.shape[1:]))
embeddings[i] = embedding
......@@ -157,15 +167,15 @@ def cdist(A):
as in scipy.spation.distance.cdist
"""
with tf.variable_scope('Pairwisedistance'):
#ones_1 = tf.ones(shape=(1, A.shape.as_list()[0]))
ones_1 = tf.reshape(tf.cast(tf.ones_like(A), tf.float32)[:, 0], [1, -1])
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
)
#ones_2 = tf.ones(shape=(A.shape.as_list()[0], 1))
ones_2 = tf.reshape(tf.cast(tf.ones_like(A), tf.float32)[:, 0], [-1, 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,
......@@ -181,7 +191,8 @@ def predict_using_tensors(embedding, labels, num=None):
embeddings using tensors
"""
# Fitting the main diagonal with infs (removing comparisons with the same sample)
# Fitting the main diagonal with infs (removing comparisons with the same
# sample)
inf = tf.cast(tf.ones_like(labels), tf.float32) * numpy.inf
distances = cdist(embedding)
......@@ -192,30 +203,34 @@ def predict_using_tensors(embedding, labels, num=None):
def compute_embedding_accuracy_tensors(embedding, labels, num=None):
"""
Compute the accuracy through exhaustive comparisons between the embeddings using tensors
Compute the accuracy through exhaustive comparisons between the embeddings
using tensors
"""
# Fitting the main diagonal with infs (removing comparisons with the same sample)
# 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)
return tf.reduce_sum(tf.cast(matching, tf.uint8)) / len(predictions)
def compute_embedding_accuracy(embedding, labels):
"""
Compute the accuracy through exhaustive comparisons between the embeddings
Compute the accuracy through exhaustive comparisons between the embeddings
"""
from scipy.spatial.distance import cdist
distances = cdist(embedding, embedding)
n_samples = embedding.shape[0]
# Fitting the main diagonal with infs (removing comparisons with the same sample)
# Fitting the main diagonal with infs (removing comparisons with the same
# sample)
numpy.fill_diagonal(distances, numpy.inf)
indexes = distances.argmin(axis=1)
# Computing the argmin excluding comparisons with the same samples
......@@ -226,8 +241,84 @@ def compute_embedding_accuracy(embedding, labels):
# Getting the original positions of the indexes in the 1-axis
#corrected_indexes = [ i if i<j else i+1 for i, j in zip(valid_indexes, range(n_samples))]
matching = [ labels[i]==labels[j] for i,j in zip(range(n_samples), indexes)]
accuracy = sum(matching)/float(n_samples)
matching = [labels[i] == labels[j]
for i, j in zip(range(n_samples), indexes)]
accuracy = sum(matching) / float(n_samples)
return accuracy
def get_available_gpus():
"""Returns the number of GPU devices that are available.
Returns
-------
[str]
The names of available GPU devices.
"""
local_device_protos = device_lib.list_local_devices()
return [x.name for x in local_device_protos if x.device_type == 'GPU']
def to_channels_last(image):
"""Converts the image to channel_last format. This is the same format as in
matplotlib, skimage, and etc.
Parameters
----------
image : :any:`tf.Tensor`
At least a 3 dimensional image. If the dimension is more than 3, the
last 3 dimensions are assumed to be [C, H, W].
Returns
-------
image : :any:`tf.Tensor`
The image in [..., H, W, C] format.
Raises
------
ValueError
If dim of image is less than 3.
"""
ndim = len(image.shape)
if ndim < 3:
raise ValueError("The image needs to be at least 3 dimensional but it "
"was {}".format(ndim))
axis_order = [1, 2, 0]
shift = ndim - 3
axis_order = list(range(ndim - 3)) + [n + shift for n in axis_order]
return tf.transpose(image, axis_order)
def to_channels_first(image):
"""Converts the image to channel_first format. This is the same format as
in bob.io.image and bob.io.video.
Parameters
----------
image : :any:`tf.Tensor`
At least a 3 dimensional image. If the dimension is more than 3, the
last 3 dimensions are assumed to be [H, W, C].
Returns
-------
image : :any:`tf.Tensor`
The image in [..., C, H, W] format.
Raises
------
ValueError
If dim of image is less than 3.
"""
ndim = len(image.shape)
if ndim < 3:
raise ValueError("The image needs to be at least 3 dimensional but it "
"was {}".format(ndim))
axis_order = [2, 0, 1]
shift = ndim - 3
axis_order = list(range(ndim - 3)) + [n + shift for n in axis_order]
return tf.transpose(image, axis_order)
to_skimage = to_matplotlib = to_channels_last
to_bob = to_channels_first
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment