Dieses Modell ordnet ** Eingabebild (hohe Dimension) ** dem ** latenten Raum (niedrige Dimension) ** zu und diesmal basierend auf dieser ** latenten Variablen (niedrige Dimension) ** ** Bild ( Der Zweck besteht darin, hochdimensional zu erzeugen ** und den Fehler zwischen diesem und dem Eingabebild zu minimieren. Nach dem Training kann dieses Modell wieder ein hochdimensionales Bild aus einem hochdimensionalen Bild durch einen niedrigdimensionalen Raum erzeugen, so dass ** ein latenter Raum erhalten werden kann, der das Trainingsbild ** charakterisiert **. Mit anderen Worten, es hat die Rolle der Dimensionskomprimierung und kann als sogenannte nichtlineare Hauptkomponentenanalyse bezeichnet werden. Dies ist sehr praktisch, da es verschiedene Verwendungszwecke hat, wie z. B. ** Beseitigung des Dimensionsfluchs **, ** Transferlernen ** und ** Erkennung von Anomalien **.

Jetzt werde ich die Struktur des zu verwendenden Modells erläutern.

• Die Bildgröße wird mit einer Faltung halbiert und mit umgekehrter Faltung verdoppelt
• Stabilisierung des Lernens und Beschleunigung der Konvergenz
• Der mögliche Bereich latenter Variablen ist (-∞, + ∞)
• Der mögliche Bereich von Pixelwerten ist [-1, +1]

In Erwartung dieser Effekte haben wir das folgende Netzwerk aufgebaut.

3. Datensatz

• CelebA-Datensatz (Large-Scale CelebFaces Attributes)
  http://mmlab.ie.cuhk.edu.hk/projects/CelebA.html

Dieses Mal verwenden wir den CelebA-Datensatz, eine Sammlung von 202.599 Promi-Gesichtsbildern (Farbe). Die Bildgröße beträgt 178 x 218 [Pixel], was beim umgekehrten Falten einige Unannehmlichkeiten verursacht. Deshalb habe ich diesmal die Größe auf ** 64 x 64 [Pixel] ** geändert. Von diesen wurden ** 90% (182.340) zum Lernen von Bildern ** und ** 10% (20.259) für Testbilder ** verwendet.

Wenn dies in das vorherige Modell eingegeben wird, wird der latente Raum (C, H, W) = (512,1,1). Wenn Sie ein Bild mit 128 x 128 [Pixel] oder mehr eingeben, wird die Zwischenebene zu einem räumlichen latenten Raum.

Vergleich

Dieses Mal werde ich hauptsächlich untersuchen, ** "wie unterschiedlich die Geschwindigkeit zwischen C ++ und Python ist" **, aber ich möchte die Geschwindigkeit und Leistung unter den folgenden 5 Arten von Umgebungen vergleichen. ..

• CPU-Hauptbetrieb
  • Python
  • C++
• GPU Hauptbetrieb
  • Python
• Nicht deterministisch --Entscheidend
  • C++

1. Unterschied in der Haupteinheit (CPU oder GPU)

• CPU
  Gut im Umgang mit "seriellen" und "komplexen" Anweisungen
• GPU
  Gut in der Verarbeitung von "parallelen" und "einfachen" Anweisungen

Wie aus den obigen Funktionen hervorgeht, ist die GPU in Deep Learning, das Bilder verarbeitet, hinsichtlich der Berechnungsgeschwindigkeit überwältigend vorteilhaft.

(1) Implementierung durch Python

• Bei Verwendung der CPU

CPU.py

device = torch.device('cpu')  #CPU verwenden

model.to(device)  #Modell in CPU verschieben
image = image.to(device)  #Daten in die CPU verschieben

• Bei Verwendung der GPU

GPU.py

device = torch.device('cuda')    #Verwenden Sie die Standard-GPU
device = torch.device('cuda:0')  #Verwenden Sie die erste GPU
device = torch.device('cuda:1')  #Verwenden Sie die zweite GPU

model.to(device)  #Modell auf GPU verschieben
image = image.to(device)  #Verschieben Sie Daten auf die GPU

(2) Implementierung durch C ++

• Bei Verwendung der CPU

CPU.cpp

torch::Device device(torch::kCPU);  //CPU verwenden

model->to(device);  //Modell in CPU verschieben
image = image.to(device);  //Daten in die CPU verschieben

• Bei Verwendung der GPU

GPU.cpp

torch::Device device(torch::kCUDA);     //Verwenden Sie die Standard-GPU
torch::Device device(torch::kCUDA, 0);  //Verwenden Sie die erste GPU
torch::Device device(torch::kCUDA, 1);  //Verwenden Sie die zweite GPU

model->to(device);  //Modell auf GPU verschieben
image = image.to(device);  //Verschieben Sie Daten auf die GPU

2. Unterschied zwischen deterministisch und nicht deterministisch (GPU-Hauptoperation & nur Python)

In der Python-Version von PyTorch wird beim Lernen mit GPU cuDNN verwendet, um die Lerngeschwindigkeit zu verbessern.

Im Gegensatz zu C ++ bedeutet die Verbesserung der Lerngeschwindigkeit jedoch nicht, dass genau dieselbe Situation reproduziert werden kann, indem das Lernen erneut gedreht wird.

Daher besagt die PyTorch-Formel, dass zur Gewährleistung der Reproduzierbarkeit das Verhalten von cuDNN wie folgt deterministisch gemacht werden muss und gleichzeitig die Geschwindigkeit abnimmt.

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.

Aus Sicht des Ingenieurs habe ich es in diesen Geschwindigkeitsvergleich aufgenommen, da ich möglicherweise besorgt bin über das Vorhandensein oder Nichtvorhandensein von Reproduzierbarkeit und die Geschwindigkeitsänderungen in Abhängigkeit vom Vorhandensein oder Fehlen von Reproduzierbarkeit.

Wenn Sie im Gegensatz zur "Rand" -Funktion von C ++ keinen Anfangswert der Zufallszahl festlegen, ist diese zufällig. Um die Reproduzierbarkeit in Python sicherzustellen, ** explizit ** den Anfangswert der Zufallszahl Sie müssen es einstellen. (Das Einstellen des Anfangswertes der Zufallszahl hat keinen Einfluss auf die Geschwindigkeit.)

Die Implementierung ist wie folgt.

• Definitiver Fall

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  #Definitiv statt langsamer zu werden
torch.backends.cudnn.benchmark = False     #Definitiv statt langsamer zu werden

• Nicht deterministischer Fall

non_deterministic.py

torch.backends.cudnn.deterministic = False  #Schneller statt nicht deterministisch
torch.backends.cudnn.benchmark = True       #Beschleunigen Sie, wenn sich die Bildgröße nicht ändert

3. Unterschiede in der Implementierung zwischen den Programmiersprachen

Selbst wenn der Inhalt, den Sie implementieren möchten, derselbe ist, können sich bei Änderung der Programmiersprache ** Notation und Regeln ** und ** erforderliche Bibliotheken ** ändern. Da sowohl Python als auch C ++ objektorientierte Sprachen sind, sind die Konzepte selbst ähnlich. Vor allem aber, da Python ein Interpretertyp und C ++ ein Kompilierungstyp ist, muss es implementiert werden, da die dynamische Typisierung für C ++ nicht funktioniert. Es sollte auch berücksichtigt werden, dass einige Funktionen nicht verfügbar sind, da die C ++ - API von PyTorch derzeit entwickelt wird.

Basierend auf diesen Punkten werde ich den Unterschied in der Implementierung zwischen Python und C ++ und dem von mir implementierten Programm vorstellen.

(1) Bibliotheksnutzung

Neben dem derzeit allgemein geschriebenen Nutzungsstatus der Python-Bibliothek werden auch die für die Implementierung in C ++ empfohlene Bibliothek und der Nutzungsstatus der Bibliothek des Programms beschrieben, das ich tatsächlich geschrieben habe.

** Im Moment (24.03.2020) </ font> ** sieht es wie oben aus.

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;
}