Python API¶

Architectures¶

class bob.learn.pytorch.architectures.CASIANet(num_cls, drop_rate=0.5)[source]¶

Bases: torch.nn.modules.module.Module

The class defining the CASIA-Net CNN model.

This class implements the CNN described in: “Learning Face Representation From Scratch”, D. Yi, Z. Lei, S. Liao and S.z. Li, 2014

num_classes¶

The number of classes.

Type: int

drop_rate¶

The probability for dropout.

Type: float

conv¶

The output of the convolutional / maxpool layers

Type: torch.nn.Module

avgpool¶

The output of the average pooling layer (used as embedding)

Type: torch.nn.Module

classifier¶

The output of the last linear (logits)

Type: torch.nn.Module

forward(x)[source]¶

Propagate data through the network

Parameters: x (torch.Tensor) – The data to forward through the network
Returns: x – The last layer of the network
Return type: torch.Tensor

training: bool¶

class bob.learn.pytorch.architectures.CNN8(num_cls, drop_rate=0.5)[source]¶

Bases: torch.nn.modules.module.Module

The class defining the CNN8 model.

num_classes¶

The number of classes.

Type: int

drop_rate¶

The probability for dropout.

Type: float

conv¶

The output of the convolutional / maxpool layers

Type: torch.nn.Module

avgpool¶

The output of the average pooling layer (used as embedding)

Type: torch.nn.Module

classifier¶

The output of the last linear (logits)

Type: torch.nn.Module

forward(x)[source]¶

Propagate data through the network

Parameters: x (torch.Tensor) – The data to forward through the network
Returns: x – The last layer of the network
Return type: torch.Tensor

training: bool¶

class bob.learn.pytorch.architectures.ConditionalGAN_discriminator(conditional_dim, channels=3, ngpu=1)[source]¶

Bases: torch.nn.modules.module.Module

Class implementating the conditional GAN discriminator

conditional_dim¶

The dimension of the conditioning variable.

Type: int

channels¶

The number of channels in the input image (default: 3).

Type: int

ngpu¶

The number of available GPU devices

Type: int

main¶

The sequential container

Type: torch.nn.Sequential

forward(images, y)[source]¶

Forward function

Parameters

images – The minibatch of input images.
y – The corresponding conditional feature maps.

Returns

the output of the discriminator

Return type

torch.Tensor

training: bool¶

class bob.learn.pytorch.architectures.ConditionalGAN_generator(noise_dim, conditional_dim, channels=3, ngpu=1)[source]¶

Bases: torch.nn.modules.module.Module

Class implementating the conditional GAN generator

This network is introduced in the following publication: Mehdi Mirza, Simon Osindero: “Conditional Generative Adversarial Nets”

ngpu¶

The number of available GPU devices

Type: int

main¶

The sequential container

Type: torch.nn.Sequential

forward(z, y)[source]¶

Forward function

Parameters

z – The minibatch of noise.
y – The conditional one hot encoded vector for the minibatch.

Returns

the output of the generator (i.e. an image)

Return type

torch.Tensor

training: bool¶

class bob.learn.pytorch.architectures.ConvAutoencoder(return_latent_embedding=False)[source]¶

Bases: torch.nn.modules.module.Module

A class defining a simple convolutional autoencoder.

return_latent_embedding¶

returns the encoder output if true, the reconstructed image otherwise.

Type: bool

forward(x)[source]¶

Propagate data through the network

Parameters: x (torch.Tensor) – x = self.encoder(x)
Returns: either the encoder output or the reconstructed image
Return type: torch.Tensor

training: bool¶

class bob.learn.pytorch.architectures.DCGAN_discriminator(ngpu)[source]¶

Bases: torch.nn.modules.module.Module

Class implementating the discriminator part of the Deeply Convolutional GAN

This network is introduced in the following publication: Alec Radford, Luke Metz, Soumith Chintala: “Unsupervised Representation Learning with Deep Convolutional Generative Adversarial Networks”, ICLR 2016

and most of the code is based on: https://github.com/pytorch/examples/tree/master/dcgan

ngpu¶

The number of available GPU devices

Type: int

forward(input)[source]¶

Forward function

Parameters: input (torch.Tensor) –
Returns: the output of the generator (i.e. an image)
Return type: torch.Tensor

training: bool¶

class bob.learn.pytorch.architectures.DCGAN_generator(ngpu)[source]¶

Bases: torch.nn.modules.module.Module

Class implementating the generator part of the Deeply Convolutional GAN

This network is introduced in the following publication: Alec Radford, Luke Metz, Soumith Chintala: “Unsupervised Representation Learning with Deep Convolutional Generative Adversarial Networks”, ICLR 2016

and most of the code is based on: https://github.com/pytorch/examples/tree/master/dcgan

ngpu¶

The number of available GPU devices

Type: int

forward(input)[source]¶

Forward function

Parameters: input (torch.Tensor) –
Returns: the output of the generator (i.e. an image)
Return type: torch.Tensor

training: bool¶

class bob.learn.pytorch.architectures.DeepMSPAD(pretrained=True, num_channels=4)[source]¶

Bases: torch.nn.modules.module.Module

Deep multispectral PAD algorithm

The initialization uses Cross modality pre-training idea from the following paper:

Wang L, Xiong Y, Wang Z, Qiao Y, Lin D, Tang X, Van Gool L. Temporal segment networks: Towards good practices for deep action recognition. InEuropean conference on computer vision 2016 Oct 8 (pp. 20-36). Springer, Cham.

pretrained¶: bool if set True loads the pretrained vgg16 model.

vgg¶: torch.nn.Module The VGG16 model

relu¶: torch.nn.Module ReLU activation

enc¶: torch.nn.Module Uses the layers for feature extraction

linear1¶: torch.nn.Module Fully connected layer

linear2¶: torch.nn.Module Fully connected layer

dropout¶: torch.nn.Module Dropout layer

sigmoid¶: torch.nn.Module Sigmoid activation

forward(x)[source]¶

Propagate data through the network

Parameters: x (torch.Tensor) – The data to forward through the network
Returns: x – The last layer of the network
Return type: torch.Tensor

training: bool¶

class bob.learn.pytorch.architectures.DeepPixBiS(pretrained=True)[source]¶

Bases: torch.nn.modules.module.Module

The class defining Deep Pixelwise Binary Supervision for Face Presentation Attack Detection:

Reference: Anjith George and Sébastien Marcel. “Deep Pixel-wise Binary Supervision for Face Presentation Attack Detection.” In 2019 International Conference on Biometrics (ICB).IEEE, 2019.

pretrained¶

If set to True uses the pretrained DenseNet model as the base. If set to False, the network will be trained from scratch. default: True

Type: bool

forward(x)[source]¶

Propagate data through the network

Parameters

img (torch.Tensor) – The data to forward through the network. Expects RGB image of size 3x224x224

Returns

dec (torch.Tensor) – Binary map of size 1x14x14
op (torch.Tensor) – Final binary score.

training: bool¶

class bob.learn.pytorch.architectures.FASNet(pretrained=True)[source]¶

Bases: torch.nn.modules.module.Module

PyTorch Reimplementation of Lucena, Oeslle, et al. “Transfer learning using convolutional neural networks for face anti-spoofing.” International Conference Image Analysis and Recognition. Springer, Cham, 2017. Referenced from keras implementation: https://github.com/OeslleLucena/FASNet

pretrained¶: bool if set True loads the pretrained vgg16 model.

vgg¶: torch.nn.Module The VGG16 model

relu¶: torch.nn.Module ReLU activation

enc¶: torch.nn.Module Uses the layers for feature extraction

linear1¶: torch.nn.Module Fully connected layer

linear2¶: torch.nn.Module Fully connected layer

dropout¶: torch.nn.Module Dropout layer

sigmoid¶: torch.nn.Module Sigmoid activation

forward(x)[source]¶

Propagate data through the network

Parameters: x (torch.Tensor) – The data to forward through the network
Returns: x – The last layer of the network
Return type: torch.Tensor

training: bool¶

class bob.learn.pytorch.architectures.LightCNN29(block=<class 'bob.learn.pytorch.architectures.utils.resblock'>, layers=[1, 2, 3, 4], num_classes=79077)[source]¶

Bases: torch.nn.modules.module.Module

The class defining the light CNN with 29 layers

This class implements the CNN described in: “A light CNN for deep face representation with noisy labels”, Wu, Xiang and He, Ran and Sun, Zhenan and Tan, Tieniu, IEEE Transactions on Information Forensics and Security, vol 13, issue 11, 2018

forward(x)[source]¶

Propagate data through the network

Parameters

x (torch.Tensor) – The data to forward through the network. Image of size 1x128x128

Returns

out (torch.Tensor) – class probabilities
x (torch.Tensor) – Output of the penultimate layer (i.e. embedding)

training: bool¶

class bob.learn.pytorch.architectures.LightCNN29v2(block=<class 'bob.learn.pytorch.architectures.utils.resblock'>, layers=[1, 2, 3, 4], num_classes=79077)[source]¶

Bases: torch.nn.modules.module.Module

The class defining the light CNN with 29 layers (version 2)

This class implements the CNN described in: “A light CNN for deep face representation with noisy labels”, Wu, Xiang and He, Ran and Sun, Zhenan and Tan, Tieniu, IEEE Transactions on Information Forensics and Security, vol 13, issue 11, 2018

forward(x)[source]¶

Propagate data through the network

Parameters

x (torch.Tensor) – The data to forward through the network. Image of size 1x128x128

Returns

out (torch.Tensor) – class probabilities
x (torch.Tensor) – Output of the penultimate layer (i.e. embedding)

training: bool¶

class bob.learn.pytorch.architectures.LightCNN9(num_classes=79077)[source]¶

Bases: torch.nn.modules.module.Module

The class defining the light CNN with 9 layers

This class implements the CNN described in: “A light CNN for deep face representation with noisy labels”, Wu, Xiang and He, Ran and Sun, Zhenan and Tan, Tieniu, IEEE Transactions on Information Forensics and Security, vol 13, issue 11, 2018

features¶

The output of the convolutional / max layers

Type: torch.nn.Module

avgpool¶

The output of the average pooling layer (used as embedding)

Type: torch.nn.Module

classifier¶

The output of the last linear (logits)

Type: torch.nn.Module

forward(x)[source]¶

Propagate data through the network

Parameters

x (torch.Tensor) – The data to forward through the network. Image of size 1x128x128

Returns

out (torch.Tensor) – class probabilities
x (torch.Tensor) – Output of the penultimate layer (i.e. embedding)

training: bool¶

class bob.learn.pytorch.architectures.MCCNN(block=<class 'bob.learn.pytorch.architectures.utils.resblock'>, layers=[1, 2, 3, 4], num_channels=4, verbosity_level=2, use_sigmoid=True)[source]¶

Bases: torch.nn.modules.module.Module

The class defining the MCCNN

This class implements the MCCNN for multi-channel PAD

num_channels¶

The number of channels present in the input

Type: int

lcnn_layers¶

The adaptable layers present in the base LightCNN model

Type: list

module_dict¶

A dictionary containing module names and torch.nn.Module elements as key, value pairs.

Type: dict

layer_dict¶

Pytorch class containing the modules as a dictionary.

Type: torch.nn.ModuleDict

light_cnn_model_file¶

Absolute path to the pretrained LightCNN model file.

Type: str

url¶

The path to download the pretrained LightCNN model from.

Type: str

forward(img)[source]¶

Propagate data through the network

Parameters: img (torch.Tensor) – The data to forward through the network. Image of size num_channelsx128x128
Returns: output – score
Return type: torch.Tensor

static get_mccnnpath()[source]¶

get_model_state_dict(pretrained_model_path)[source]¶

The class to load pretrained LightCNN model

pretrained_model_path¶

Absolute path to the LightCNN model file

Type: str

new_state_dict¶

Dictionary with LightCNN weights

Type: dict

training: bool¶

class bob.learn.pytorch.architectures.MCCNNv2(block=<class 'bob.learn.pytorch.architectures.utils.resblock'>, layers=[1, 2, 3, 4], num_channels=4, adapted_layers='conv1-block1-group1-ffc', verbosity_level=2)[source]¶

Bases: torch.nn.modules.module.Module

The class defining the MCCNNv2 the difference from MCCNN is that it uses shared layers for layers which are not adapted. This avoids replicating shared layers.

num_channels¶

The number of channels present in the input

Type: int

lcnn_layers¶

The adaptable layers present in the base LightCNN model

Type: list

module_dict¶

A dictionary containing module names and torch.nn.Module elements as key, value pairs.

Type: dict

layer_dict¶

Pytorch class containing the modules as a dictionary.

Type: torch.nn.ModuleDict

light_cnn_model_file¶

Absolute path to the pretrained LightCNN model file.

Type: str

adapted_layers¶

The layers to be adapted in training, they are to be separated by ‘-‘. Example: ‘conv1-block1-group1-ffc’; ‘ffc’ denotes final fully connected layers which are adapted in all the cases.

Type: str

url¶

The path to download the pretrained LightCNN model from.

Type: str

forward(img)[source]¶

Propagate data through the network

Parameters: img (torch.Tensor) – The data to forward through the network. Image of size num_channelsx128x128
Returns: output – score
Return type: torch.Tensor

static get_mccnnv2path()[source]¶

get_model_state_dict(pretrained_model_path)[source]¶

The class to load pretrained LightCNN model

pretrained_model_path¶

Absolute path to the LightCNN model file

Type: str

new_state_dict¶

Dictionary with LightCNN weights

Type: dict

training: bool¶

class bob.learn.pytorch.architectures.MCDeepPixBiS(pretrained=True, num_channels=4)[source]¶

Bases: torch.nn.modules.module.Module

The class defining Multi-Channel Deep Pixelwise Binary Supervision for Face Presentation Attack Detection:

This extends the following paper to multi-channel/ multi-spectral images with cross modal pretraining.

Reference: Anjith George and Sébastien Marcel. “Deep Pixel-wise Binary Supervision for Face Presentation Attack Detection.” In 2019 International Conference on Biometrics (ICB).IEEE, 2019.

The initialization uses Cross modality pre-training idea from the following paper:

Wang L, Xiong Y, Wang Z, Qiao Y, Lin D, Tang X, Van Gool L. Temporal segment networks: Towards good practices for deep action recognition. InEuropean conference on computer vision 2016 Oct 8 (pp. 20-36). Springer, Cham.

pretrained¶

If set to True uses the pretrained DenseNet model as the base. If set to False, the network will be trained from scratch. default: True

Type: bool

num_channels¶

Number of channels in the input.

Type: int

forward(x)[source]¶

Propagate data through the network

Parameters

img (torch.Tensor) – The data to forward through the network. Expects Multi-channel images of size num_channelsx224x224

Returns

dec (torch.Tensor) – Binary map of size 1x14x14
op (torch.Tensor) – Final binary score.

training: bool¶

bob.learn.pytorch.architectures.weights_init(m)[source]¶

Initialize the weights

Initialize the weights in the different layers of the network.

Parameters: m (torch.nn.Conv2d) – The layer to initialize

Datasets¶

class bob.learn.pytorch.datasets.CasiaDataset(*args, **kwds)[source]¶

Bases: torch.utils.data.dataset.Dataset

Class representing the CASIA WebFace dataset

Note that in this class, two labels are provided with each image: identity and pose.

Pose labels have been automatically inferred using the ROC face recognirion SDK from RankOne.

There are 13 pose labels, corresponding to cluster of 15 degrees, ranging from -90 degress (left profile) to 90 degrees (right profile)

root_dir¶

The path to the data

Type: str

transform¶

The transform(s) to apply to the face images

Type: torchvision.transforms

data_files¶

The list of data files

Type: list of str

id_labels¶

The list of identities, for each data file

Type: list of int

pose_labels¶

The list containing the pose labels

Type: list of int

class bob.learn.pytorch.datasets.CasiaWebFaceDataset(*args, **kwds)[source]¶

Bases: torch.utils.data.dataset.Dataset

Class representing the CASIA WebFace dataset

Note that here the only label is identity

root_dir¶

The path to the data

Type: str

transform¶

The transform(s) to apply to the face images

Type: torchvision.transforms

data_files¶

The list of data files

Type: list of str

id_labels¶

The list of identities, for each data file

Type: list of int

class bob.learn.pytorch.datasets.ChannelSelect(selected_channels=[0, 1, 2, 3])[source]¶

Bases: object

Subselects or re-orders channels in a multi-channel image. Expects a numpy.ndarray as input with size HxWxnum_channels and returns an image with size HxWxlen(selected_channels), where the last dimension is subselected using the indexes in the list selected_channels.

selected_channels¶

The indexes of the channels to be selected.

Type: list

img¶

A multi channel image, HxWxnum_channels

Type: numpy.ndarray

class bob.learn.pytorch.datasets.ConcatDataset(*args, **kwds)[source]¶

Bases: torch.utils.data.dataset.Dataset

Class to concatenate two or more datasets for DR-GAN training

Parameters

datasets: list: The list of datasets (as torch.utils.data.Dataset)

class bob.learn.pytorch.datasets.DataFolder(*args, **kwds)[source]¶

Bases: torch.utils.data.dataset.Dataset

A generic data loader compatible with Bob High Level Database Interfaces (HLDI). Only HLDI’s of bob.pad.face are currently supported.

The basic functionality is composed of two steps: load the data from hdf5 file, and transform it using user defined transformation function.

Two types of user defined transformations are supported:

1. An instance of Compose transformation class from torchvision package.

2. A custom transformation function, which takes numpy.ndarray as input, and returns a transformed Tensor. The dimensionality of the output tensor must match the format expected by the network to be trained.

Note: if no special transformation is needed, the transform must at least convert an input numpy array to Tensor.

data_folder¶

A directory containing the training data. Note, that the training data must be stored as a FrameContainers written to the hdf5 files. Other formats are currently not supported.

Type: str

transform¶

A function transform takes an input numpy.ndarray sample/image, and returns a transformed version as a Tensor. Default: None.

Type: object

extension¶

Extension of the data files. Default: “.hdf5”. Note: this is the only extension supported at the moment.

Type: str

bob_hldi_instance¶

An instance of the HLDI interface. Only HLDI’s of bob.pad.face are currently supported.

Type: object

hldi_type¶

String defining the type of the HLDI. Default: “pad”. Note: this is the only option currently supported.

Type: str

groups¶

The groups for which the clients should be returned. Usually, groups are one or more elements of [‘train’, ‘dev’, ‘eval’]. Default: [‘train’, ‘dev’, ‘eval’].

Type: str or [str]

protocol¶

The protocol for which the clients should be retrieved. Default: ‘grandtest’.

Type: str

purposes¶

The purposes for which File objects should be retrieved. Usually it is either ‘real’ or ‘attack’. Default: [‘real’, ‘attack’].

Type: str or [str]

allow_missing_files¶

The missing files in the data_folder will not break the execution if set to True. Default: True.

Type: bool

class bob.learn.pytorch.datasets.DataFolderGeneric(*args, **kwds)[source]¶

Bases: torch.utils.data.dataset.Dataset

A generic data loader compatible with Bob High Level Database Interfaces (HLDI). Only HLDI’s of bob.pad.face are currently supported.

The basic functionality is composed of two steps: load the data from hdf5 file, and transform it using user defined transformation function.

Two types of user defined transformations are supported:

1. An instance of Compose transformation class from torchvision package.

2. A custom transformation function, which takes numpy.ndarray as input, and returns a transformed Tensor. The dimensionality of the output tensor must match the format expected by the network to be trained.

Note: if no special transformation is needed, the transform must at least convert an input numpy array to Tensor.

data_folder¶

A directory containing the training data. Note, that the training data must be stored as a FrameContainers written to the hdf5 files. Other formats are currently not supported.

Type: str

transform¶

A function transform takes an input numpy.ndarray sample/image, and returns a transformed version as a Tensor. Default: None.

Type: object

extension¶

Extension of the data files. Default: “.hdf5”. Note: this is the only extension supported at the moment.

Type: str

bob_hldi_instance¶

An instance of the HLDI interface. Only HLDI’s of bob.pad.face are currently supported.

Type: object

hldi_type¶

String defining the type of the HLDI. Default: “pad”. Note: this is the only option currently supported.

Type: str

groups¶

The groups for which the clients should be returned. Usually, groups are one or more elements of [‘train’, ‘dev’, ‘eval’]. Default: [‘train’, ‘dev’, ‘eval’].

Type: str or [str]

protocol¶

The protocol for which the clients should be retrieved. Default: ‘grandtest’.

Type: str

purposes¶

The purposes for which File objects should be retrieved. Usually it is either ‘real’ or ‘attack’. Default: [‘real’, ‘attack’].

Type: str or [str]

allow_missing_files¶

The missing files in the data_folder will not break the execution if set to True. Default: True.

Type: bool

class bob.learn.pytorch.datasets.FaceCropAlign(face_size, rgb_output_flag=False, use_face_alignment=True, alignment_type='lightcnn', face_detection_method='mtcnn')[source]¶

Bases: object

Wrapper to the FaceCropAlign of bob.pad.face preprocessor

class bob.learn.pytorch.datasets.FaceCropper(cropped_height, cropped_width, color_channel='rgb')[source]¶

Bases: object

Class to crop a face, based on eyes position

class bob.learn.pytorch.datasets.Normalize(mean, std)[source]¶: Bases: object

class bob.learn.pytorch.datasets.RandomHorizontalFlipImage(p=0.5)[source]¶

Bases: object

Flips the image horizontally, works on numpy arrays.

p¶

Probability of image returned being flipped .

Type: float

class bob.learn.pytorch.datasets.Resize(size)[source]¶: Bases: object

class bob.learn.pytorch.datasets.RollChannels[source]¶

Bases: object

Class to transform a bob image into skimage. i.e. CxHxW to HxWxC

class bob.learn.pytorch.datasets.ToGray[source]¶: Bases: object

class bob.learn.pytorch.datasets.ToTensor[source]¶: Bases: object

bob.learn.pytorch.datasets.map_labels(raw_labels, start_index=0)[source]¶

Map the ID label to [0 - # of IDs]

Parameters: raw_labels (list of int) – The labels of the samples

Scripts¶

Trainers¶

class bob.learn.pytorch.trainers.CNNTrainer(network, batch_size=64, use_gpu=False, verbosity_level=2, num_classes=2)[source]¶

Bases: object

Class to train a CNN

network¶

The network to train

Type: torch.nn.Module

batch_size¶

The size of your minibatch

Type: int

use_gpu¶

If you would like to use the gpu

Type: bool

verbosity_level¶

The level of verbosity output to stdout

Type: int

load_and_initialize_model(model_filename)[source]¶

Loads and initialize a model

Parameters: model_filename (str) –

save_model(output_dir, epoch=0, iteration=0, losses=None)[source]¶

Save the trained network

Parameters

output_dir (str) – The directory to write the models to
epoch (int) – the current epoch
iteration (int) – the current (last) iteration
losses (list(float)) – The list of losses since the beginning of training

train(dataloader, n_epochs=20, learning_rate=0.01, output_dir='out', model=None)[source]¶

Performs the training.

Parameters

dataloader (torch.utils.data.DataLoader) – The dataloader for your data
n_epochs (int) – The number of epochs you would like to train for
learning_rate (float) – The learning rate for SGD optimizer.
output_dir (str) – The directory where you would like to save models

class bob.learn.pytorch.trainers.ConditionalGANTrainer(netG, netD, image_size, batch_size=64, noise_dim=100, conditional_dim=13, use_gpu=False, verbosity_level=2)[source]¶

Bases: object

Class to train a Conditional GAN

generator¶

The generator network

Type: torch.nn.Module

discriminator¶

The discriminator network

Type: torch.nn.Module

image_size¶

The size of the images in this format: [channels,height, width]

Type: list of int

batch_size¶

The size of your minibatch

Type: int

noise_dim¶

The dimension of the noise (input to the generator)

Type: int

conditional_dim¶

The dimension of the conditioning variable

Type: int

use_gpu¶

If you would like to use the gpu

Type: bool

fixed_noise¶

The fixed input noise to the generator.

Type: torch.Tensor

fixed_one_hot¶

The set of fixed one-hot encoded conditioning variable

Type: torch.Tensor

criterion¶

The binary cross-entropy loss

Type: torch.nn.BCELoss

train(dataloader, n_epochs=10, learning_rate=0.0002, beta1=0.5, output_dir='out')[source]¶

trains the Conditional GAN.

Parameters

dataloader (torch.utils.data.DataLoader) – The dataloader for your data
n_epochs (int) – The number of epochs you would like to train for
learning_rate (float) – The learning rate for Adam optimizer
beta1 (float) – The beta1 for Adam optimizer
output_dir (str) – The directory where you would like to output images and models

class bob.learn.pytorch.trainers.DCGANTrainer(netG, netD, batch_size=64, noise_dim=100, use_gpu=False, verbosity_level=2)[source]¶

Bases: object

Class to train a DCGAN

netG¶

The generator network

Type: torch.nn.Module

netD¶

The discriminator network

Type: torch.nn.Module

batch_size¶

The size of your minibatch

Type: int

noise_dim¶

The dimension of the noise (input to the generator)

Type: int

use_gpu¶

If you would like to use the gpu

Type: bool

input¶

The input image

Type: torch.Tensor

noise¶

The input noise to the generator

Type: torch.Tensor

fixed_noise¶

The fixed input noise to the generator. Used for generating images to save.

Type: torch.Tensor

label¶

label for real/fake images.

Type: torch.Tensor

criterion¶

The binary cross-entropy loss

Type: torch.nn.BCELoss

train(dataloader, n_epochs=10, learning_rate=0.0002, beta1=0.5, output_dir='out')[source]¶

trains the DCGAN.

Parameters

dataloader (torch.utils.data.DataLoader) – The dataloader for your data
n_epochs (int) – The number of epochs you would like to train for
learning_rate (float) – The learning rate for Adam optimizer
beta1 (float) – The beta1 for Adam optimizer
output_dir (str) – The directory where you would like to output images and models

class bob.learn.pytorch.trainers.FASNetTrainer(network, batch_size=64, use_gpu=False, verbosity_level=2, tf_logdir='tf_logs', do_crossvalidation=False)[source]¶

Bases: object

Class to train the MCCNN

network¶

The network to train

Type: torch.nn.Module

batch_size¶

The size of your minibatch

Type: int

use_gpu¶

If you would like to use the gpu

Type: bool

verbosity_level¶

The level of verbosity output to stdout

Type: int

load_model(model_filename)[source]¶

Loads an existing model

Parameters

model_file (str) – The filename of the model to load

Returns

start_epoch (int) – The epoch to start with
start_iteration (int) – The iteration to start with
losses (list(float)) – The list of losses from previous training

save_model(output_dir, epoch=0, iteration=0, losses=None)[source]¶

Save the trained network

Parameters

output_dir (str) – The directory to write the models to
epoch (int) – the current epoch
iteration (int) – the current (last) iteration
losses (list(float)) – The list of losses since the beginning of training

train(dataloader, n_epochs=25, learning_rate=0.0001, output_dir='out', model=None)[source]¶

Performs the training.

Parameters

dataloader (torch.utils.data.DataLoader) – The dataloader for your data
n_epochs (int) – The number of epochs you would like to train for
learning_rate (float) – The learning rate for Adam optimizer.
output_dir (str) – The directory where you would like to save models
model (str) – The path to a pretrained model file to start training from; this is the PAD model; not the LightCNN model

class bob.learn.pytorch.trainers.GenericTrainer(network, optimizer, compute_loss, learning_rate=0.0001, device='cpu', verbosity_level=2, tf_logdir='tf_logs', do_crossvalidation=False, save_interval=5)[source]¶

Bases: object

Class to train a generic NN; all the parameters are provided in configs

network¶

The network to train

Type: torch.nn.Module

optimizer¶

Optimizer object to be used. Initialized in the config file.

Type: torch.optim.Optimizer

device¶

Device which will be used for training the model

Type: str

verbosity_level¶

The level of verbosity output to stdout

Type: int

load_model(model_filename)[source]¶

Loads an existing model

Parameters

model_file (str) – The filename of the model to load

Returns

start_epoch (int) – The epoch to start with
start_iteration (int) – The iteration to start with
losses (list(float)) – The list of losses from previous training

save_model(output_dir, epoch=0, iteration=0, losses=None)[source]¶

Save the trained network

Parameters

output_dir (str) – The directory to write the models to
epoch (int) – the current epoch
iteration (int) – the current (last) iteration
losses (list(float)) – The list of losses since the beginning of training

train(dataloader, n_epochs=25, output_dir='out', model=None)[source]¶

Performs the training.

Parameters

dataloader (torch.utils.data.DataLoader) – The dataloader for your data
n_epochs (int) – The number of epochs you would like to train for
learning_rate (float) – The learning rate for Adam optimizer.
output_dir (str) – The directory where you would like to save models
model (str) – The path to a pretrained model file to start training from; this is the PAD model; not the LightCNN model

class bob.learn.pytorch.trainers.MCCNNTrainer(network, batch_size=64, use_gpu=False, adapted_layers='conv1-block1-group1-ffc', adapt_reference_channel=False, verbosity_level=2, tf_logdir='tf_logs', do_crossvalidation=False)[source]¶

Bases: object

Class to train the MCCNN

network¶

The network to train

Type: torch.nn.Module

batch_size¶

The size of your minibatch

Type: int

use_gpu¶

If you would like to use the gpu

Type: bool

verbosity_level¶

The level of verbosity output to stdout

Type: int

load_model(model_filename)[source]¶

Loads an existing model

Parameters

model_file (str) – The filename of the model to load

Returns

start_epoch (int) – The epoch to start with
start_iteration (int) – The iteration to start with
losses (list(float)) – The list of losses from previous training

save_model(output_dir, epoch=0, iteration=0, losses=None)[source]¶

Save the trained network

Parameters

output_dir (str) – The directory to write the models to
epoch (int) – the current epoch
iteration (int) – the current (last) iteration
losses (list(float)) – The list of losses since the beginning of training

train(dataloader, n_epochs=25, learning_rate=0.0001, output_dir='out', model=None)[source]¶

Performs the training.

Parameters

dataloader (torch.utils.data.DataLoader) – The dataloader for your data
n_epochs (int) – The number of epochs you would like to train for
learning_rate (float) – The learning rate for Adam optimizer.
output_dir (str) – The directory where you would like to save models
model (str) – The path to a pretrained model file to start training from; this is the PAD model; not the LightCNN model

Python API¶

Architectures¶

Datasets¶

Scripts¶

Trainers¶

Preprocessors¶

Extractors¶