Documenting

bob/learn/tensorflow/analyzers/ExperimentAnalizer.py

@@ -31,12 +31,9 @@ class ExperimentAnalizer:
 
         ** Parameters **
 
-          data_shuffler:
-          graph:
-          session:
-          convergence_threshold:
-          convergence_reference: References to analize the convergence. Possible values are `eer`, `far10`, `far10`
+        convergence_threshold:
 
+        convergence_reference:
 
         """
 
@@ -112,8 +109,10 @@ class ExperimentAnalizer:
           - RANK 10
 
         **Parameters**
-          negative_scores:
-          positive_scores:
+
+        negative_scores:
+
+        positive_scores:
         """
 
         summaries = []

bob/learn/tensorflow/datashuffler/Base.py

@@ -15,14 +15,30 @@ class Base(object):
      The class provide base functionalities to shuffle the data to train a neural network
 
      **Parameters**
-       data: Input data to be trainer
-       labels: Labels. These labels should be set from 0..1
-       input_shape: The shape of the inputs
-       input_dtype: The type of the data,
-       batch_size: Batch size
-       seed: The seed of the random number generator
-       data_augmentation: The algorithm used for data augmentation. Look :py:class:`bob.learn.tensorflow.datashuffler.DataAugmentation`
-       normalizer: 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`
+     data:
+       Input data to be trainer
+
+     labels:
+       Labels. These labels should be set from 0..1
+
+     input_shape:
+       The shape of the inputs
+
+     input_dtype:
+       The type of the data,
+
+     batch_size:
+       Batch size
+
+     seed:
+       The seed of the random number generator
+
+     data_augmentation:
+       The algorithm used for data augmentation. Look :py:class:`bob.learn.tensorflow.datashuffler.DataAugmentation`
+
+     normalizer:
+       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,

bob/learn/tensorflow/datashuffler/Disk.py

@@ -21,14 +21,29 @@ class Disk(Base):
      The data is loaded on the fly,.
 
      **Parameters**
-       data: Input data to be trainer
-       labels: Labels. These labels should be set from 0..1
-       input_shape: The shape of the inputs
-       input_dtype: The type of the data,
-       batch_size: Batch size
-       seed: The seed of the random number generator
-       data_augmentation: The algorithm used for data augmentation. Look :py:class:`bob.learn.tensorflow.datashuffler.DataAugmentation`
-       normalizer: 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`
+     data:
+       Input data to be trainer
+
+     labels:
+       Labels. These labels should be set from 0..1
+
+     input_shape:
+       The shape of the inputs
+
+     input_dtype:
+       The type of the data,
+
+     batch_size:
+       Batch size
+
+     seed:
+       The seed of the random number generator
+
+     data_augmentation:
+       The algorithm used for data augmentation. Look :py:class:`bob.learn.tensorflow.datashuffler.DataAugmentation`
+
+     normalizer:
+       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,
@@ -88,8 +103,11 @@ class Disk(Base):
 
         ** Returns **
 
-        data: Selected samples
-        labels: Correspondent labels
+        data:
+          Selected samples
+
+        labels:
+          Correspondent labels
         """
 
         # Shuffling samples

bob/learn/tensorflow/datashuffler/Memory.py

@@ -15,14 +15,29 @@ class Memory(Base):
     This datashuffler deal with memory databases that are stored in a :py:class`numpy.array`
 
      **Parameters**
-       data: Input data to be trainer
-       labels: Labels. These labels should be set from 0..1
-       input_shape: The shape of the inputs
-       input_dtype: The type of the data,
-       batch_size: Batch size
-       seed: The seed of the random number generator
-       data_augmentation: The algorithm used for data augmentation. Look :py:class:`bob.learn.tensorflow.datashuffler.DataAugmentation`
-       normalizer: 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`
+     data:
+       Input data to be trainer
+
+     labels:
+       Labels. These labels should be set from 0..1
+
+     input_shape:
+       The shape of the inputs
+
+     input_dtype:
+       The type of the data,
+
+     batch_size:
+       Batch size
+
+     seed:
+       The seed of the random number generator
+
+     data_augmentation:
+       The algorithm used for data augmentation. Look :py:class:`bob.learn.tensorflow.datashuffler.DataAugmentation`
+
+     normalizer:
+       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,
@@ -53,8 +68,11 @@ class Memory(Base):
 
         ** Returns **
 
-        data: Selected samples
-        labels: Correspondent labels
+        data:
+          Selected samples
+
+        labels:
+          Correspondent labels
         """
         # Shuffling samples
         indexes = numpy.array(range(self.data.shape[0]))

bob/learn/tensorflow/datashuffler/SiameseDisk.py

@@ -19,14 +19,31 @@ class SiameseDisk(Siamese, Disk):
      The data is loaded on the fly,.
 
      **Parameters**
-       data: Input data to be trainer
-       labels: Labels. These labels should be set from 0..1
-       input_shape: The shape of the inputs
-       input_dtype: The type of the data,
-       batch_size: Batch size
-       seed: The seed of the random number generator
-       data_augmentation: The algorithm used for data augmentation. Look :py:class:`bob.learn.tensorflow.datashuffler.DataAugmentation`
-       normalizer: 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`
+
+     data:
+       Input data to be trainer
+
+     labels:
+       Labels. These labels should be set from 0..1
+
+     input_shape:
+       The shape of the inputs
+
+     input_dtype:
+       The type of the data,
+
+     batch_size:
+       Batch size
+
+     seed:
+       The seed of the random number generator
+
+     data_augmentation:
+       The algorithm used for data augmentation. Look :py:class:`bob.learn.tensorflow.datashuffler.DataAugmentation`
+
+     normalizer:
+       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,
                  input_shape,

bob/learn/tensorflow/datashuffler/SiameseMemory.py

@@ -17,14 +17,31 @@ class SiameseMemory(Siamese, Memory):
      The data is loaded on the fly.
 
      **Parameters**
-       data: Input data to be trainer
-       labels: Labels. These labels should be set from 0..1
-       input_shape: The shape of the inputs
-       input_dtype: The type of the data,
-       batch_size: Batch size
-       seed: The seed of the random number generator
-       data_augmentation: The algorithm used for data augmentation. Look :py:class:`bob.learn.tensorflow.datashuffler.DataAugmentation`
-       normalizer: 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`
+
+     data:
+       Input data to be trainer
+
+     labels:
+       Labels. These labels should be set from 0..1
+
+     input_shape:
+       The shape of the inputs
+
+     input_dtype:
+       The type of the data,
+
+     batch_size:
+       Batch size
+
+     seed:
+       The seed of the random number generator
+
+     data_augmentation:
+       The algorithm used for data augmentation. Look :py:class:`bob.learn.tensorflow.datashuffler.DataAugmentation`
+
+     normalizer:
+       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,

bob/learn/tensorflow/datashuffler/TripletDisk.py

@@ -23,14 +23,31 @@ class TripletDisk(Triplet, Disk):
      The data is loaded on the fly.
 
      **Parameters**
-       data: Input data to be trainer
-       labels: Labels. These labels should be set from 0..1
-       input_shape: The shape of the inputs
-       input_dtype: The type of the data,
-       batch_size: Batch size
-       seed: The seed of the random number generator
-       data_augmentation: The algorithm used for data augmentation. Look :py:class:`bob.learn.tensorflow.datashuffler.DataAugmentation`
-       normalizer: 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`
+
+     data:
+       Input data to be trainer
+
+     labels:
+       Labels. These labels should be set from 0..1
+
+     input_shape:
+       The shape of the inputs
+
+     input_dtype:
+       The type of the data,
+
+     batch_size:
+       Batch size
+
+     seed:
+       The seed of the random number generator
+
+     data_augmentation:
+       The algorithm used for data augmentation. Look :py:class:`bob.learn.tensorflow.datashuffler.DataAugmentation`
+
+     normalizer:
+       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,

bob/learn/tensorflow/datashuffler/TripletMemory.py

@@ -17,14 +17,31 @@ class TripletMemory(Triplet, Memory):
      The data is loaded on the fly.
 
      **Parameters**
-       data: Input data to be trainer
-       labels: Labels. These labels should be set from 0..1
-       input_shape: The shape of the inputs
-       input_dtype: The type of the data,
-       batch_size: Batch size
-       seed: The seed of the random number generator
-       data_augmentation: The algorithm used for data augmentation. Look :py:class:`bob.learn.tensorflow.datashuffler.DataAugmentation`
-       normalizer: 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`
+
+     data:
+       Input data to be trainer
+
+     labels:
+       Labels. These labels should be set from 0..1
+
+     input_shape:
+       The shape of the inputs
+
+     input_dtype:
+       The type of the data,
+
+     batch_size:
+       Batch size
+
+     seed:
+       The seed of the random number generator
+
+     data_augmentation:
+       The algorithm used for data augmentation. Look :py:class:`bob.learn.tensorflow.datashuffler.DataAugmentation`
+
+     normalizer:
+       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,

bob/learn/tensorflow/datashuffler/TripletWithFastSelectionDisk.py

@@ -35,14 +35,30 @@ class TripletWithFastSelectionDisk(Triplet, Disk, OnLineSampling):
       argmin(||f(x_a) - f(x_p)||^2 < ||f(x_a) - f(x_n)||^2
 
      **Parameters**
-      data: Input data to be trainer
-      labels: Labels. These labels should be set from 0..1
-      input_shape: The shape of the inputs
-      input_dtype: The type of the data,
-      batch_size: Batch size
-      seed: The seed of the random number generator
-      data_augmentation: The algorithm used for data augmentation. Look :py:class:`bob.learn.tensorflow.datashuffler.DataAugmentation`
-      normalizer: 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`
+
+     data:
+       Input data to be trainer
+
+     labels:
+       Labels. These labels should be set from 0..1
+
+     input_shape:
+       The shape of the inputs
+
+     input_dtype:
+       The type of the data,
+
+     batch_size:
+       Batch size
+
+     seed:
+       The seed of the random number generator
+
+     data_augmentation:
+       The algorithm used for data augmentation. Look :py:class:`bob.learn.tensorflow.datashuffler.DataAugmentation`
+
+     normalizer:
+       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,

bob/learn/tensorflow/datashuffler/TripletWithSelectionDisk.py

@@ -23,14 +23,30 @@ class TripletWithSelectionDisk(Triplet, Disk, OnLineSampling):
     The selection of the triplets are random.
 
      **Parameters**
-       data: Input data to be trainer
-       labels: Labels. These labels should be set from 0..1
-       input_shape: The shape of the inputs
-       input_dtype: The type of the data,
-       batch_size: Batch size
-       seed: The seed of the random number generator
-       data_augmentation: The algorithm used for data augmentation. Look :py:class:`bob.learn.tensorflow.datashuffler.DataAugmentation`
-       normalizer: 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`
+     data:
+       Input data to be trainer
+
+     labels:
+       Labels. These labels should be set from 0..1
+
+     input_shape:
+       The shape of the inputs
+
+     input_dtype:
+       The type of the data,
+
+     batch_size:
+       Batch size
+
+     seed:
+       The seed of the random number generator
+
+     data_augmentation:
+       The algorithm used for data augmentation. Look :py:class:`bob.learn.tensorflow.datashuffler.DataAugmentation`
+
+     normalizer:
+       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,

bob/learn/tensorflow/datashuffler/TripletWithSelectionMemory.py

@@ -32,14 +32,31 @@ class TripletWithSelectionMemory(Triplet, Memory, OnLineSampling):
       argmin(||f(x_a) - f(x_p)||^2 < ||f(x_a) - f(x_n)||^2
 
      **Parameters**
-      data: Input data to be trainer
-      labels: Labels. These labels should be set from 0..1
-      input_shape: The shape of the inputs
-      input_dtype: The type of the data,
-      batch_size: Batch size
-      seed: The seed of the random number generator
-      data_augmentation: The algorithm used for data augmentation. Look :py:class:`bob.learn.tensorflow.datashuffler.DataAugmentation`
-      normalizer: 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`
+
+     data:
+       Input data to be trainer
+
+     labels:
+       Labels. These labels should be set from 0..1
+
+     input_shape:
+       The shape of the inputs
+
+     input_dtype:
+       The type of the data,
+
+     batch_size:
+       Batch size
+
+     seed:
+       The seed of the random number generator
+
+     data_augmentation:
+       The algorithm used for data augmentation. Look :py:class:`bob.learn.tensorflow.datashuffler.DataAugmentation`
+
+     normalizer:
+       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,

bob/learn/tensorflow/layers/AveragePooling.py

@@ -13,11 +13,22 @@ class AveragePooling(MaxPooling):
     Wraps the tensorflow average pooling
 
     **Parameters**
-     name: The name of the layer
-     shape: Shape of the pooling kernel
-     stride: Shape of the stride
-     batch_norm: Do batch norm?
-     activation: Tensor Flow activation
+
+    name: str
+      The name of the layer
+
+    shape:
+      Shape of the pooling kernel
+
+    stride:
+      Shape of the stride
+
+    batch_norm: bool
+      Do batch norm?
+
+    activation: bool
+      Tensor Flow activation
+
     """
 
     def __init__(self, name, shape=[1, 2, 2, 1],

bob/learn/tensorflow/layers/Conv2D.py

@@ -15,15 +15,34 @@ class Conv2D(Layer):
     2D Convolution
 
     **Parameters**
-     name: The name of the layer
-     activation: Tensor Flow activation
-     kernel_size: Size of the convolutional kernel
-     filters: Number of filters
-     stride: Shape of the stride
-     weights_initialization: Initialization type for the weights
-     bias_initialization: Initialization type for the weights
-     batch_norm: Do batch norm?
-     use_gpu: Store data in the GPU
+
+    name: str
+      The name of the layer
+
+    activation:
+     Tensor Flow activation
+
+    kernel_size: int
+      Size of the convolutional kernel
+
+    filters: int
+      Number of filters
+
+    stride:
+      Shape of the stride
+
+    weights_initialization: py:class:`bob.learn.tensorflow.initialization.Initialization`
+      Initialization type for the weights
+
+    bias_initialization: py:class:`bob.learn.tensorflow.initialization.Initialization`
+      Initialization type for the weights
+
+    batch_norm: bool
+      Do batch norm?
+
+    use_gpu: bool
+      Store data in the GPU
+
     """
 
     def __init__(self, name, activation=None,

bob/learn/tensorflow/layers/Dropout.py

@@ -14,8 +14,12 @@ class Dropout(Layer):
     Dropout
 
     **Parameters**
-     name: The name of the layer
-     keep_prob: With probability keep_prob, outputs the input element scaled up by 1 / keep_prob, otherwise outputs 0.
+     name: str
+       The name of the layer
+
+     keep_prob: float
+       With probability keep_prob, outputs the input element scaled up by 1 / keep_prob, otherwise outputs 0.
+
     """
 
     def __init__(self, name,

bob/learn/tensorflow/layers/FullyConnected.py

@@ -16,14 +16,29 @@ class FullyConnected(Layer):
     Fully Connected layer
 
     **Parameters**
-     name: The name of the layer
-     output_dim: Size of the output
-     activation: Tensor Flow activation
-     weights_initialization: Initialization type for the weights
-     bias_initialization: Initialization type for the weights
-     batch_norm: Do batch norm?
-     use_gpu: Store data in the GPU
-     """
+
+    name: str
+      The name of the layer
+
+    output_dim: int
+      Size of the output
+
+    activation:
+      Tensor Flow activation
+
+    weights_initialization:  py:class:`bob.learn.tensorflow.initialization.Initialization`
+      Initialization type for the weights
+
+    bias_initialization:  py:class:`bob.learn.tensorflow.initialization.Initialization`
+      Initialization type for the weights
+
+    batch_norm: bool
+      Do batch norm?
+
+    use_gpu: bool
+      Store data in the GPU
+
+    """
 
     def __init__(self, name,
                  output_dim,

bob/learn/tensorflow/layers/Layer.py

@@ -14,12 +14,23 @@ class Layer(object):
     Layer base class
 
     **Parameters**
-     name: The name of the layer
-     activation: Tensor Flow activation
-     weights_initialization: Initialization type for the weights
-     bias_initialization: Initialization type for the weights
-     batch_norm: Do batch norm?
-     use_gpu: Store data in the GPU
+    name: str
+      The name of the layer
+
+    activation:
+      Tensor Flow activation
+
+    weights_initialization: py:class:`bob.learn.tensorflow.initialization.Initialization`
+      Initialization type for the weights
+
+    bias_initialization: py:class:`bob.learn.tensorflow.initialization.Initialization`
+      Initialization type for the biases
+
+    batch_norm: bool
+      Do batch norm?
+
+    use_gpu: bool
+      Store data in the GPU
 
     """
 

bob/learn/tensorflow/layers/MaxPooling.py

@@ -12,11 +12,22 @@ class MaxPooling(Layer):
     Wraps the tensorflow max pooling
 
     **Parameters**
-     name: The name of the layer