Ce modèle mappe ** l'image d'entrée (haute dimension) ** à ** l'espace latent (faible dimension) **, et cette fois en fonction de cette ** variable latente (faible dimension) ** ** image ( Le but est de générer de grandes dimensions) ** et de minimiser l'erreur entre celle-ci et l'image d'entrée. Après la formation, ce modèle peut générer à nouveau une image de grande dimension à partir d'une image de grande dimension à travers un espace de faible dimension, de sorte que ** un espace latent qui caractérise davantage l'image de formation ** puisse être obtenu. En d'autres termes, elle a le rôle de compression de dimension et peut être appelée analyse en composantes principales non linéaire. Ceci est très pratique car il a diverses utilisations telles que ** élimination de la malédiction dimensionnelle **, ** apprentissage par transfert ** et ** détection d'anomalie **.

Maintenant, je vais vous expliquer la structure du modèle à utiliser.

• La taille de l'image est divisée par deux avec une convolution et double avec une convolution inversée
• Stabilisation des apprentissages et accélération de la convergence
• La plage possible de variables latentes est (-∞, + ∞)
• La plage de valeurs de pixel possible est [-1, +1]

Dans l'attente de ces effets, nous avons construit le réseau suivant.

3. Ensemble de données

• Jeu de données CelebA (attributs CelebFaces à grande échelle)
  http://mmlab.ie.cuhk.edu.hk/projects/CelebA.html

Cette fois, nous utiliserons l'ensemble de données CelebA, qui est une collection de 202599 images de visages de célébrités (couleur). La taille de l'image est de 178 x 218 [pixel], ce qui cause des inconvénients lors du pliage inversé, donc cette fois je l'ai redimensionnée en ** 64 x 64 [pixel] **. Parmi ceux-ci, ** 90% (182 340) ont été utilisés pour l'apprentissage d'images **, et ** 10% (20 259) ont été utilisés pour des images de test **.

Lorsqu'il est entré dans le modèle précédent, l'espace latent devient (C, H, W) = (512,1,1). Si vous entrez une image de 128 x 128 [pixels] ou plus, la couche intermédiaire devient un espace latent spatial.

Comparaison

Cette fois, je vais principalement étudier ** "Quelle est la différence de vitesse entre C ++ et Python" **, mais j'aimerais comparer la vitesse et les performances dans les 5 types d'environnements suivants. ..

• Fonctionnement principal du processeur
  • Python
  • C++
• Fonctionnement principal du GPU
  • Python
• Non déterministe --Décisif
  • C++

1. Différence dans l'unité principale (CPU ou GPU)

• CPU
  Bonne gestion des instructions "série" et "complexes"
• GPU
  Bon pour traiter des instructions «parallèles» et «simples»

Comme le montrent les fonctionnalités ci-dessus, dans le Deep Learning qui gère les images, le GPU est extrêmement avantageux en termes de vitesse de calcul.

(1) Implémentation par Python

• Lors de l'utilisation du processeur

CPU.py

device = torch.device('cpu')  #Utiliser le processeur

model.to(device)  #Déplacer le modèle vers le processeur
image = image.to(device)  #Déplacer les données vers le processeur

• Lors de l'utilisation du GPU

GPU.py

device = torch.device('cuda')    #Utiliser le GPU par défaut
device = torch.device('cuda:0')  #Utilisez le premier GPU
device = torch.device('cuda:1')  #Utilisez le deuxième GPU

model.to(device)  #Déplacer le modèle vers le GPU
image = image.to(device)  #Déplacer les données vers le GPU

(2) Implémentation par C ++

• Lors de l'utilisation du processeur

CPU.cpp

torch::Device device(torch::kCPU);  //Utiliser le processeur

model->to(device);  //Déplacer le modèle vers le processeur
image = image.to(device);  //Déplacer les données vers le processeur

• Lors de l'utilisation du GPU

GPU.cpp

torch::Device device(torch::kCUDA);     //Utiliser le GPU par défaut
torch::Device device(torch::kCUDA, 0);  //Utilisez le premier GPU
torch::Device device(torch::kCUDA, 1);  //Utilisez le deuxième GPU

model->to(device);  //Déplacer le modèle vers le GPU
image = image.to(device);  //Déplacer les données vers le GPU

2. Différence entre déterministe et non déterministe (opération principale GPU et Python uniquement)

Dans la version Python de PyTorch, dans le cas de l'apprentissage par GPU, cuDNN est utilisé pour ** améliorer la vitesse d'apprentissage **.

Cependant, contrairement au C ++, ce n'est pas parce que la vitesse d'apprentissage est améliorée que la même situation peut être reproduite en tournant à nouveau l'apprentissage.

Par conséquent, la formule PyTorch indique que pour assurer la reproductibilité, il est nécessaire de rendre le comportement de cuDNN déterministe comme suit, et en même temps, la vitesse diminue.

https://pytorch.org/docs/stable/notes/randomness.html

Deterministic mode can have a performance impact, depending on your model. This means that due to the deterministic nature of the model, the processing speed (i.e. processed batch items per second) can be lower than when the model is non-deterministic.

Du point de vue de l'ingénieur, je l'ai inclus dans cette comparaison de vitesse parce que je peux être préoccupé par la présence ou l'absence de reproductibilité, et parce que la vitesse change en fonction de la présence ou de l'absence de reproductibilité.

Contrairement à la fonction "rand" de C ++, si vous ne définissez aucune valeur initiale du nombre aléatoire, ce sera aléatoire, donc afin d'assurer la reproductibilité en Python, ** explicitement ** la valeur initiale du nombre aléatoire Vous devez le définir. (La définition de la valeur initiale du nombre aléatoire n'affecte pas la vitesse.)

La mise en œuvre est la suivante.

• Cas définitif

deterministic.py

seed = 0
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
np.random.seed(seed)
random.seed(seed)
torch.backends.cudnn.deterministic = True  #Définitif au lieu de ralentir
torch.backends.cudnn.benchmark = False     #Définitif au lieu de ralentir

• Cas non déterministe

non_deterministic.py

torch.backends.cudnn.deterministic = False  #Plus rapide que non déterministe
torch.backends.cudnn.benchmark = True       #Accélérez lorsque la taille de l'image ne change pas

3. Différences de mise en œuvre entre les langages de programmation

Même si le contenu que vous souhaitez implémenter est le même, si le langage de programmation change, ** la notation et les règles ** peuvent changer et les ** bibliothèques requises ** peuvent changer. Comme Python et C ++ sont des langages orientés objet, les concepts eux-mêmes sont similaires, mais surtout, puisque Python est un type d'interpréteur et C ++ est un type de compilation, il doit être implémenté étant donné que le typage dynamique ne fonctionne pas pour C ++. Il faut également tenir compte du fait que certaines fonctionnalités ne sont pas disponibles car l'API C ++ de PyTorch est actuellement en cours de développement.

Sur la base de ces points, je présenterai la différence d'implémentation entre Python et C ++, et le programme que j'ai implémenté.

(1) Utilisation de la bibliothèque

En plus de l'état d'utilisation de la bibliothèque Python qui est généralement écrite à l'heure actuelle, la bibliothèque recommandée pour l'implémentation en C ++ et l'état d'utilisation de la bibliothèque du programme que j'ai réellement écrit sont également décrits.

** Pour le moment (2020/03/24) </ font> **, cela ressemble à ce qui précède.

using namespace torch;
namespace po = boost::program_options;

struct ConvolutionalAutoEncoderImpl : nn::Module{
private:
    nn::Sequential encoder, decoder;
public:
    ConvolutionalAutoEncoderImpl(po::Variables_map &vm);
    torch::Tensor forward(torch::Tensor x);
}

TORCH_MODULE(ConvolutionalAutoEncoder);

nn::Sequential sq;
sq->push_back(nn::Conv2d(nn::Conv2dOptions(3, 64, /*kernel_size=*/4).stride(2).padding(1).bias(false)));
sq->push_back(nn::BatchNorm2d(64));
sq->push_back(nn::ReLU(nn::ReLUOptions().inplace(true)));

void transforms::Normalize::forward(torch::Tensor &data_in, torch::Tensor &data_out){
    torch::Tensor data_out_src = (data_in - this->mean) / this->std;
    data_out = data_out_src.clone();
    return;
}