使用 PyTorch C++ 前端

# If you need e.g. CUDA 9.0 support, please replace "cpu" with "cu90" in the URL below.
wgethttps://download.pytorch.org/libtorch/nightly/cpu/libtorch-shared-with-deps-latest.zip
unziplibtorch-shared-with-deps-latest.zip

#include<torch/torch.h>
#include<iostream>

intmain(){
torch::Tensortensor=torch::eye(3);
std::cout<<tensor<<std::endl;
}

cmake_minimum_required(VERSION3.0FATAL_ERROR)
project(dcgan)

find_package(TorchREQUIRED)

add_executable(dcgandcgan.cpp)
target_link_libraries(dcgan"${TORCH_LIBRARIES}")
set_property(TARGETdcganPROPERTYCXX_STANDARD14)

dcgan/
CMakeLists.txt
dcgan.cpp

root@fa350df05ecf:/home#mkdirbuild
root@fa350df05ecf:/home#cdbuild
root@fa350df05ecf:/home/build#cmake-DCMAKE_PREFIX_PATH=/path/to/libtorch..
*-TheCcompileridentificationisGNU5.4.0
*-TheCXXcompileridentificationisGNU5.4.0
*-CheckforworkingCcompiler:/usr/bin/cc
*-CheckforworkingCcompiler:/usr/bin/cc--works
*-DetectingCcompilerABIinfo
*-DetectingCcompilerABIinfo-done
*-DetectingCcompilefeatures
*-DetectingCcompilefeatures-done
*-CheckforworkingCXXcompiler:/usr/bin/c++
*-CheckforworkingCXXcompiler:/usr/bin/c++--works
*-DetectingCXXcompilerABIinfo
*-DetectingCXXcompilerABIinfo-done
*-DetectingCXXcompilefeatures
*-DetectingCXXcompilefeatures-done
*-Lookingforpthread.h
*-Lookingforpthread.h-found
*-Lookingforpthread_create
*-Lookingforpthread_create-notfound
*-Lookingforpthread_createinpthreads
*-Lookingforpthread_createinpthreads-notfound
*-Lookingforpthread_createinpthread
*-Lookingforpthread_createinpthread-found
*-FoundThreads:TRUE
*-Foundtorch:/path/to/libtorch/lib/libtorch.so
*-Configuringdone
*-Generatingdone
*-Buildfileshavebeenwrittento:/home/build
root@fa350df05ecf:/home/build#cmake--build.--configRelease
Scanningdependenciesoftargetdcgan
[50%]BuildingCXXobjectCMakeFiles/dcgan.dir/dcgan.cpp.o
[100%]LinkingCXXexecutabledcgan
[100%]Builttargetdcgan

root@fa350df05ecf:/home/build#./dcgan
100
010
001
[Variable[CPUFloatType]{3,3}]

定义模块并注册参数

要将这些概念转化为代码，让我们来看一个用 Python 接口编写的简单模块：

importtorch

classNet(torch.nn.Module):
  def__init__(self, N, M):
    super(Net, self).__init__()
    self.W = torch.nn.Parameter(torch.randn(N, M))
    self.b = torch.nn.Parameter(torch.randn(M))

  defforward(self, input):
    return torch.addmm(self.b, input, self.W)

在 C++ 中，它看起来会是这样：

#include<torch/torch.h>

structNet:torch::nn::Module{
Net(int64_tN,int64_tM){
W=register_parameter("W",torch::randn({N,M}));
b=register_parameter("b",torch::randn(M));
}
torch::Tensorforward(torch::Tensorinput){
returntorch::addmm(b,input,W);
}
torch::TensorW,b;
};

就像在 Python 中一样，我们定义了一个名为 Net 的类（为了简单起见，这里使用 struct 而不是 class），并从模块基类派生它。在构造函数内部，我们使用 torch::randn 创建张量，就像在 Python 中使用 torch.randn 一样。一个有趣的差异是我们如何注册参数。在 Python 中，我们用 torch.nn.Parameter 类包装张量，而在 C++ 中，我们必须通过 register_parameter 方法传递张量。这样做的原因是 Python API 可以检测到某个属性是 torch.nn.Parameter 类型，并自动注册这些张量。而在 C++ 中，反射功能非常有限，因此提供了一种更传统（且不那么神奇）的方法。

注册子模块并遍历模块层次结构

同样地，我们可以注册参数，也可以注册子模块。在 Python 中，当子模块被分配为模块的属性时，它们会被自动检测并注册：

classNet(torch.nn.Module):
  def__init__(self, N, M):
      super(Net, self).__init__()
      # Registered as a submodule behind the scenes
      self.linear = torch.nn.Linear(N, M)
      self.another_bias = torch.nn.Parameter(torch.rand(M))

  defforward(self, input):
    return self.linear(input) + self.another_bias

例如，这允许使用 parameters() 方法递归地访问我们模块层次结构中的所有参数：

>>> net = Net(4, 5)
>>> print(list(net.parameters()))
[Parameter containing:
tensor([0.0808, 0.8613, 0.2017, 0.5206, 0.5353], requires_grad=True), Parameter containing:
tensor([[-0.3740, -0.0976, -0.4786, -0.4928],
        [-0.1434,  0.4713,  0.1735, -0.3293],
        [-0.3467, -0.3858,  0.1980,  0.1986],
        [-0.1975,  0.4278, -0.1831, -0.2709],
        [ 0.3730,  0.4307,  0.3236, -0.0629]], requires_grad=True), Parameter containing:
tensor([ 0.2038,  0.4638, -0.2023,  0.1230, -0.0516], requires_grad=True)]

在 C++ 中注册子模块时，使用恰如其名的 register_module() 方法来注册像 torch::nn::Linear 这样的模块：

structNet:torch::nn::Module{
Net(int64_tN,int64_tM)
:linear(register_module("linear",torch::nn::Linear(N,M))){
another_bias=register_parameter("b",torch::randn(M));
}
torch::Tensorforward(torch::Tensorinput){
returnlinear(input)+another_bias;
}
torch::nn::Linearlinear;
torch::Tensoranother_bias;
};

您可以在 torch::nn 命名空间的文档中找到所有可用的内置模块的完整列表，例如 torch::nn::Linear、torch::nn::Dropout 或 torch::nn::Conv2d，具体请参见 这里。

上述代码的一个细微之处在于，为什么子模块是在构造函数的初始化列表中创建的，而参数则是在构造函数体内创建的。这有一个很好的理由，我们将在下面关于 C++ 前端的所有权模型部分中详细讨论。然而，最终的结果是我们可以像在 Python 中一样递归地访问模块树的参数。调用 parameters() 会返回一个 std::vector<torch::Tensor>，我们可以对其进行遍历：

intmain(){
Netnet(4,5);
for(constauto&p:net.parameters()){
std::cout<<p<<std::endl;
}
}

输出结果为：

root@fa350df05ecf:/home/build#./dcgan
0.0345
1.4456
*0.6313
*0.3585
*0.4008
[Variable[CPUFloatType]{5}]
*0.16470.28910.0527-0.0354
0.30840.20250.03430.1824
*0.4630-0.28620.2500-0.0420
0.3679-0.1482-0.04600.1967
0.2132-0.19920.42570.0739
[Variable[CPUFloatType]{5,4}]
0.01*
3.6861
*10.1166
*45.0333
7.9983
*20.0705
[Variable[CPUFloatType]{5}]

与 Python 类似，使用三个参数。为了也能查看这些参数的名称，C++ API 提供了一个 named_parameters() 方法，该方法像 Python 一样返回一个 OrderedDict：

Netnet(4,5);
for(constauto&pair:net.named_parameters()){
std::cout<<pair.key()<<": "<<pair.value()<<std::endl;
}

我们可以再次执行以查看输出：

root@fa350df05ecf:/home/build#make&&./dcgan11:13:48
Scanningdependenciesoftargetdcgan
[50%]BuildingCXXobjectCMakeFiles/dcgan.dir/dcgan.cpp.o
[100%]LinkingCXXexecutabledcgan
[100%]Builttargetdcgan
b:-0.1863
*0.8611
*0.1228
1.3269
0.9858
[Variable[CPUFloatType]{5}]
linear.weight:0.03390.24840.2035-0.2103
*0.0715-0.2975-0.4350-0.1878
*0.36160.1050-0.49820.0335
*0.16050.49630.4099-0.2883
0.1818-0.3447-0.1501-0.0215
[Variable[CPUFloatType]{5,4}]
linear.bias:-0.0250
0.0408
0.3756
*0.2149
*0.3636
[Variable[CPUFloatType]{5}]

文档 中包含了 torch::nn::Module 操作模块层次结构的完整方法列表。

在网络中运行前向模式

要在 C++ 中执行网络，我们只需调用我们自己定义的 forward() 方法：

intmain(){
Netnet(4,5);
std::cout<<net.forward(torch::ones({2,4}))<<std::endl;
}

这会打印出类似以下内容：

root@fa350df05ecf:/home/build#./dcgan
0.85591.15722.1069-0.12470.8060
0.85591.15722.1069-0.12470.8060
[Variable[CPUFloatType]{2,5}]

模块所有权

至此，我们已经了解了如何在 C++ 中定义一个模块、注册参数、注册子模块，并通过 parameters() 等方法遍历模块层次结构，最后运行模块的 forward() 方法。尽管 C++ API 中还有许多方法、类和主题需要深入研究，我将引导您参考 文档 以获取完整的菜单。在接下来的内容中，我们还将探讨一些更多的概念，特别是在实现 DCGAN 模型和端到端训练流程时。在此之前，让我简要介绍一下 C++ 前端为 torch::nn::Module 子类提供的所有权模型。

在这次讨论中，所有权模型指的是模块的存储和传递方式——这决定了谁或什么拥有特定的模块实例。在 Python 中，对象总是动态分配（在堆上）并具有引用语义。这使得使用起来非常容易且易于理解。事实上，在 Python 中，您可以很大程度上忘记对象存储在哪里以及它们如何被引用，而是专注于完成任务。

C++ 作为一种更低级别的语言，在这方面提供了更多的选择。这增加了复杂性，并极大地影响了 C++ 前端的设计和人体工程学。特别是，对于 C++ 前端中的模块，我们可以选择使用值语义或引用语义。第一种情况是最简单的，并且在前面的示例中已经展示过：模块对象在栈上分配，当传递给函数时，可以被复制、移动（使用 std::move），或者通过引用或指针传递：

structNet:torch::nn::Module{};

voida(Netnet){}
voidb(Net&net){}
voidc(Net*net){}

intmain(){
Netnet;
a(net);
a(std::move(net));
b(net);
c(&net);
}

对于第二种情况——引用语义——我们可以使用 std::shared_ptr。引用语义的优势在于，就像在 Python 中一样，它减少了思考模块如何传递给函数以及参数如何声明的认知负担（假设您在所有地方都使用 shared_ptr）。

structNet:torch::nn::Module{};

voida(std::shared_ptr<Net>net){}

intmain(){
autonet=std::make_shared<Net>();
a(net);
}

根据我们的经验，来自动态语言的研究者通常更倾向于引用语义而非值语义，尽管后者在 C++ 中更为“原生”。另外需要注意的是，torch::nn::Module 的设计为了贴近 Python API 的易用性，依赖于共享所有权。例如，我们之前（此处简化）的 Net 定义：

structNet:torch::nn::Module{
Net(int64_tN,int64_tM)
:linear(register_module("linear",torch::nn::Linear(N,M)))
{}
torch::nn::Linearlinear;
};

为了使用 linear 子模块，我们希望将其直接存储在我们的类中。然而，我们也希望模块基类能够知晓并访问这个子模块。为此，基类必须存储对该子模块的引用。此时，我们已经遇到了共享所有权的需求。torch::nn::Module 类和具体的 Net 类都需要引用这个子模块。因此，基类将模块存储为 shared_ptr，所以具体类也必须这么做。

但是等等！在上面的代码中，我并没有看到任何关于 shared_ptr 的提及！这是为什么呢？因为 std::shared_ptr<MyModule> 输入起来非常繁琐。为了让我们的研究人员保持高效，我们设计了一个复杂的方案来隐藏 shared_ptr 的提及——这种好处通常是为值语义保留的——同时保留引用语义。为了理解这是如何工作的，我们可以看一下核心库中 torch::nn::Linear 模块的简化定义（完整定义在这里）：

structLinearImpl:torch::nn::Module{
LinearImpl(int64_tin,int64_tout);

Tensorforward(constTensor&input);

Tensorweight,bias;
};

TORCH_MODULE(Linear);

简而言之：该模块不叫 Linear，而是 LinearImpl。然后，宏 TORCH_MODULE 定义了实际的 Linear 类。这个“生成”的类实际上是 std::shared_ptr<LinearImpl> 的包装器。它是一个包装器而不是简单的 typedef，原因之一是为了让构造函数仍然按预期工作，也就是说，你仍然可以写 torch::nn::Linear(3, 4)，而不是 std::make_shared<LinearImpl>(3, 4)。我们将宏创建的类称为模块 holder（持有者）。与（共享）指针类似，你可以使用箭头运算符访问底层对象（如 model->forward(...)）。最终结果是一个与 Python API 非常相似的所有权模型。引用语义成为默认行为，但无需额外的 std::shared_ptr 或 std::make_shared 类型声明。对于我们的 Net，使用模块持有者 API 的示例如下：

structNetImpl:torch::nn::Module{};
TORCH_MODULE(Net);

voida(Netnet){}

intmain(){
Netnet;
a(net);
}

这里有一个微妙的问题值得提及。默认构造的 std::shared_ptr 是“空的”，即包含一个空指针。那么默认构造的 Linear 或 Net 是什么？这是一个棘手的选择。我们可以说它应该是一个空的（空指针）std::shared_ptr<LinearImpl>。然而，回想一下 Linear(3, 4) 与 std::make_shared<LinearImpl>(3, 4) 是相同的。这意味着如果我们决定 Linear linear; 应该是一个空指针，那么就没有办法构造一个不接收任何构造函数参数或默认所有参数的模块。因此，在当前的 API 中，默认构造的模块持有者（如 Linear()）会调用底层模块的默认构造函数（LinearImpl()）。如果底层模块没有默认构造函数，你会得到一个编译错误。要改为构造空的持有者，你可以将 nullptr 传递给持有者的构造函数。

在实践中，这意味着您可以像前面展示的那样使用子模块，即在初始化列表中注册并构建模块：

structNet:torch::nn::Module{
Net(int64_tN,int64_tM)
:linear(register_module("linear",torch::nn::Linear(N,M)))
{}
torch::nn::Linearlinear;
};

或者您可以先使用空指针构造持有者，然后在构造函数中对其进行赋值（这对 Python 开发者来说更为熟悉）：

structNet:torch::nn::Module{
Net(int64_tN,int64_tM){
linear=register_module("linear",torch::nn::Linear(N,M));
}
torch::nn::Linearlinear{nullptr};// construct an empty holder
};

总结：应该使用哪种所有权模型——哪种语义？C++ 前端的 API 最好地支持了模块持有者提供的所有权模型。这种机制的唯一缺点是在模块声明下方多了一行样板代码。尽管如此，最简单的模型仍然是 C++ 模块介绍中所示的值语义模型。对于小型、简单的脚本，您可能也可以使用它。但您迟早会发现，由于技术原因，它并不总是受支持。例如，序列化 API（torch::save 和 torch::load）仅支持模块持有者（或普通的 shared_ptr）。因此，模块持有者 API 是使用 C++ 前端定义模块的推荐方式，我们将在本教程中从此使用此 API。

什么是 GAN？

GAN 由两个独立的神经网络模型组成：一个生成器和一个判别器。生成器接收来自噪声分布的样本，其目标是将每个噪声样本转换为类似于目标分布中的图像——在我们的案例中是 MNIST 数据集。判别器则接收来自 MNIST 数据集的真实图像或来自生成器的伪造图像。它需要输出一个概率值，判断特定图像的真实性（越接近 1 表示越真实，越接近 0 表示越伪造）。生成器根据判别器对其生成图像真实性的反馈进行训练，而判别器则根据其判断真实性的能力进行优化。理论上，生成器和判别器之间的微妙平衡使它们能够协同改进，最终生成器生成的图像与目标分布无法区分，从而让判别器（此时）出色的判断力对真实和伪造图像都输出 0.5 的概率。对我们来说，最终的结果是一台机器，它接收噪声作为输入，并生成逼真的数字图像作为输出。

生成器模块

我们首先定义生成器模块，该模块由一系列转置的二维卷积、批量归一化和ReLU激活单元组成。在我们自己定义的模块的forward()方法中，我们会显式地（以函数式的方式）在模块之间传递输入：

structDCGANGeneratorImpl:nn::Module{
DCGANGeneratorImpl(intkNoiseSize)
:conv1(nn::ConvTranspose2dOptions(kNoiseSize,256,4)
.bias(false)),
batch_norm1(256),
conv2(nn::ConvTranspose2dOptions(256,128,3)
.stride(2)
.padding(1)
.bias(false)),
batch_norm2(128),
conv3(nn::ConvTranspose2dOptions(128,64,4)
.stride(2)
.padding(1)
.bias(false)),
batch_norm3(64),
conv4(nn::ConvTranspose2dOptions(64,1,4)
.stride(2)
.padding(1)
.bias(false))
{
// register_module() is needed if we want to use the parameters() method later on
register_module("conv1",conv1);
register_module("conv2",conv2);
register_module("conv3",conv3);
register_module("conv4",conv4);
register_module("batch_norm1",batch_norm1);
register_module("batch_norm2",batch_norm2);
register_module("batch_norm3",batch_norm3);
}

torch::Tensorforward(torch::Tensorx){
x=torch::relu(batch_norm1(conv1(x)));
x=torch::relu(batch_norm2(conv2(x)));
x=torch::relu(batch_norm3(conv3(x)));
x=torch::tanh(conv4(x));
returnx;
}

nn::ConvTranspose2dconv1,conv2,conv3,conv4;
nn::BatchNorm2dbatch_norm1,batch_norm2,batch_norm3;
};
TORCH_MODULE(DCGANGenerator);

DCGANGeneratorgenerator(kNoiseSize);

我们现在可以在 DCGANGenerator 上调用 forward() 方法，将噪声样本映射为图像。

所选择的特定模块，如 nn::ConvTranspose2d 和 nn::BatchNorm2d，遵循了之前概述的结构。kNoiseSize 常量决定了输入噪声向量的大小，并设置为 100。当然，超参数是通过“研究生下降法”找到的。

在超参数的发现过程中，没有研究生受到伤害。他们定期被喂食 Soylent。

关于如何将选项传递给 C++ 前端中内置模块（如 Conv2d）的简要说明：每个模块都有一些必需的选项，比如 BatchNorm2d 的特征数量。如果只需要配置这些必需的选项，可以直接将它们传递给模块的构造函数，例如 BatchNorm2d(128)、Dropout(0.5) 或 Conv2d(8, 4, 2)（分别表示输入通道数、输出通道数和卷积核大小）。然而，如果需要修改其他通常使用默认值的选项，比如 Conv2d 的 bias，则需要构造并传递一个 options 对象。C++ 前端中的每个模块都有一个相关的选项结构体，称为 ModuleOptions，其中 Module 是模块的名称，例如 Linear 模块的 LinearOptions。这就是我们在上面的 Conv2d 模块中所做的操作。

判别器模块

判别器同样由一系列卷积、批量归一化和激活函数组成。然而，这里的卷积是常规卷积而非转置卷积，并且我们使用 alpha 值为 0.2 的 Leaky ReLU 而不是普通的 ReLU。此外，最终的激活函数变为 Sigmoid，它将值压缩到 0 到 1 之间。我们可以将这些压缩后的值解释为判别器认为图像是真实的概率。

为了构建判别器，我们将尝试一种不同的方法：使用 Sequential 模块。与 Python 类似，PyTorch 在这里提供了两种定义模型的 API：一种是函数式 API，其中输入通过一系列函数传递（例如生成器模块示例）；另一种是更面向对象的 API，我们构建一个包含整个模型作为子模块的 Sequential 模块。使用 Sequential，判别器将如下所示：

nn::Sequentialdiscriminator(
// Layer 1
nn::Conv2d(
nn::Conv2dOptions(1,64,4).stride(2).padding(1).bias(false)),
nn::LeakyReLU(nn::LeakyReLUOptions().negative_slope(0.2)),
// Layer 2
nn::Conv2d(
nn::Conv2dOptions(64,128,4).stride(2).padding(1).bias(false)),
nn::BatchNorm2d(128),
nn::LeakyReLU(nn::LeakyReLUOptions().negative_slope(0.2)),
// Layer 3
nn::Conv2d(
nn::Conv2dOptions(128,256,4).stride(2).padding(1).bias(false)),
nn::BatchNorm2d(256),
nn::LeakyReLU(nn::LeakyReLUOptions().negative_slope(0.2)),
// Layer 4
nn::Conv2d(
nn::Conv2dOptions(256,1,3).stride(1).padding(0).bias(false)),
nn::Sigmoid());

Sequential 模块只是简单地执行函数组合。第一个子模块的输出成为第二个子模块的输入，第三个子模块的输出成为第四个子模块的输入，依此类推。

autodataset=torch::data::datasets::MNIST("./mnist")
.map(torch::data::transforms::Normalize<>(0.5,0.5))
.map(torch::data::transforms::Stack<>());

autodata_loader=torch::data::make_data_loader(std::move(dataset));

autodata_loader=torch::data::make_data_loader(
std::move(dataset),
torch::data::DataLoaderOptions().batch_size(kBatchSize).workers(2));

for(torch::data::Example<>&batch:*data_loader){
std::cout<<"Batch size: "<<batch.data.size(0)<<" | Labels: ";
for(int64_ti=0;i<batch.data.size(0);++i){
std::cout<<batch.target[i].item<int64_t>()<<" ";
}
std::cout<<std::endl;
}

root@fa350df05ecf:/home/build#make
Scanningdependenciesoftargetdcgan
[50%]BuildingCXXobjectCMakeFiles/dcgan.dir/dcgan.cpp.o
[100%]LinkingCXXexecutabledcgan
[100%]Builttargetdcgan
root@fa350df05ecf:/home/build#make
[100%]Builttargetdcgan
root@fa350df05ecf:/home/build#./dcgan
Batchsize:64|Labels:5267216701623691840653304666408606924028633292014234829935800799
Batchsize:64|Labels:2247128869022936138044888926471509754354128071961653441232350162
Batchsize:64|Labels:4542148383615436225131508215324459728920674383588305808785561780
Batchsize:64|Labels:3371416103640254042819651632892387459608300648254183780089672147
Batchsize:64|Labels:3055983989595041277200548776107930632627633405889192194492462940
Batchsize:64|Labels:9675359086678219881182071416751774032906634481286920312856485862
Batchsize:64|Labels:9303651860199161774447886782604682539840993705824562825371918227
Batchsize:64|Labels:9192726086877486116857913205173161086081054938584801262427737453
Batchsize:64|Labels:8831864295802866709838716627745521795491031939885375368942012547
Batchsize:64|Labels:9270844275006205959889357547305765716287632656127700590091783294
Batchsize:64|Labels:7657752249948748945712698512367811398795085187265120974090460086
...

torch::optim::Adamgenerator_optimizer(
generator->parameters(),torch::optim::AdamOptions(2e-4).betas(std::make_tuple(0.5,0.5)));
torch::optim::Adamdiscriminator_optimizer(
discriminator->parameters(),torch::optim::AdamOptions(5e-4).betas(std::make_tuple(0.5,0.5)));

for(int64_tepoch=1;epoch<=kNumberOfEpochs;++epoch){
int64_tbatch_index=0;
for(torch::data::Example<>&batch:*data_loader){
// Train discriminator with real images.
discriminator->zero_grad();
torch::Tensorreal_images=batch.data;
torch::Tensorreal_labels=torch::empty(batch.data.size(0)).uniform_(0.8,1.0);
torch::Tensorreal_output=discriminator->forward(real_images).reshape(real_labels.sizes());
torch::Tensord_loss_real=torch::binary_cross_entropy(real_output,real_labels);
d_loss_real.backward();

// Train discriminator with fake images.
torch::Tensornoise=torch::randn({batch.data.size(0),kNoiseSize,1,1});
torch::Tensorfake_images=generator->forward(noise);
torch::Tensorfake_labels=torch::zeros(batch.data.size(0));
torch::Tensorfake_output=discriminator->forward(fake_images.detach()).reshape(fake_labels.sizes());
torch::Tensord_loss_fake=torch::binary_cross_entropy(fake_output,fake_labels);
d_loss_fake.backward();

torch::Tensord_loss=d_loss_real+d_loss_fake;
discriminator_optimizer.step();

// Train generator.
generator->zero_grad();
fake_labels.fill_(1);
fake_output=discriminator->forward(fake_images).reshape(fake_labels.sizes());
torch::Tensorg_loss=torch::binary_cross_entropy(fake_output,fake_labels);
g_loss.backward();
generator_optimizer.step();

std::printf(
"\r[%2ld/%2ld][%3ld/%3ld] D_loss: %.4f | G_loss: %.4f",
epoch,
kNumberOfEpochs,
++batch_index,
batches_per_epoch,
d_loss.item<float>(),
g_loss.item<float>());
}
}

root@3c0711f20896:/home/build#make&&./dcgan
Scanningdependenciesoftargetdcgan
[50%]BuildingCXXobjectCMakeFiles/dcgan.dir/dcgan.cpp.o
[100%]LinkingCXXexecutabledcgan
[100%]Builttargetdcga
[1/10][100/938]D_loss:0.6876|G_loss:4.1304
[1/10][200/938]D_loss:0.3776|G_loss:4.3101
[1/10][300/938]D_loss:0.3652|G_loss:4.6626
[1/10][400/938]D_loss:0.8057|G_loss:2.2795
[1/10][500/938]D_loss:0.3531|G_loss:4.4452
[1/10][600/938]D_loss:0.3501|G_loss:5.0811
[1/10][700/938]D_loss:0.3581|G_loss:4.5623
[1/10][800/938]D_loss:0.6423|G_loss:1.7385
[1/10][900/938]D_loss:0.3592|G_loss:4.7333
[2/10][100/938]D_loss:0.4660|G_loss:2.5242
[2/10][200/938]D_loss:0.6364|G_loss:2.0886
[2/10][300/938]D_loss:0.3717|G_loss:3.8103
[2/10][400/938]D_loss:1.0201|G_loss:1.3544
[2/10][500/938]D_loss:0.4522|G_loss:2.6545
...

// Place this somewhere at the top of your training script.
torch::Devicedevice(torch::kCPU);

torch::Tensorfake_labels=torch::zeros(batch.data.size(0));

torch::Tensorfake_labels=torch::zeros(batch.data.size(0),device);

torch::Tensorreal_images=batch.data;

torch::Tensorreal_images=batch.data.to(device);

generator->to(device);
discriminator->to(device);

torch::Devicedevice(torch::kCUDA)

torch::Devicedevice=torch::kCPU;
if(torch::cuda::is_available()){
std::cout<<"CUDA is available! Training on GPU."<<std::endl;
device=torch::kCUDA;
}

torch::Devicedevice(torch::cuda::is_available()?torch::kCUDA:torch::kCPU);

if(batch_index%kCheckpointEvery==0){
// Checkpoint the model and optimizer state.
torch::save(generator,"generator-checkpoint.pt");
torch::save(generator_optimizer,"generator-optimizer-checkpoint.pt");
torch::save(discriminator,"discriminator-checkpoint.pt");
torch::save(discriminator_optimizer,"discriminator-optimizer-checkpoint.pt");
// Sample the generator and save the images.
torch::Tensorsamples=generator->forward(torch::randn({8,kNoiseSize,1,1},device));
torch::save((samples+1.0)/2.0,torch::str("dcgan-sample-",checkpoint_counter,".pt"));
std::cout<<"\n-> checkpoint "<<++checkpoint_counter<<'\n';
}

torch::optim::Adamgenerator_optimizer(
generator->parameters(),torch::optim::AdamOptions(2e-4).beta1(0.5));
torch::optim::Adamdiscriminator_optimizer(
discriminator->parameters(),torch::optim::AdamOptions(2e-4).beta1(0.5));

if(kRestoreFromCheckpoint){
torch::load(generator,"generator-checkpoint.pt");
torch::load(generator_optimizer,"generator-optimizer-checkpoint.pt");
torch::load(discriminator,"discriminator-checkpoint.pt");
torch::load(
discriminator_optimizer,"discriminator-optimizer-checkpoint.pt");
}

int64_tcheckpoint_counter=0;
for(int64_tepoch=1;epoch<=kNumberOfEpochs;++epoch){
int64_tbatch_index=0;
for(torch::data::Example<>&batch:*data_loader){

importargparse

importmatplotlib.pyplotasplt
importtorch


parser = argparse.ArgumentParser()
parser.add_argument("-i", "--sample-file", required=True)
parser.add_argument("-o", "--out-file", default="out.png")
parser.add_argument("-d", "--dimension", type=int, default=3)
options = parser.parse_args()

module = torch.jit.load(options.sample_file)
images = list(module.parameters())[0]

for index in range(options.dimension * options.dimension):
  image = images[index].detach().cpu().reshape(28, 28).mul(255).to(torch.uint8)
  array = image.numpy()
  axis = plt.subplot(options.dimension, options.dimension, 1 + index)
  plt.imshow(array, cmap="gray")
  axis.get_xaxis().set_visible(False)
  axis.get_yaxis().set_visible(False)

plt.savefig(options.out_file)
print("Saved ", options.out_file)

root@3c0711f20896:/home/build#make&&./dcgan10:17:57
Scanningdependenciesoftargetdcgan
[50%]BuildingCXXobjectCMakeFiles/dcgan.dir/dcgan.cpp.o
[100%]LinkingCXXexecutabledcgan
[100%]Builttargetdcgan
CUDAisavailable!TrainingonGPU.
[1/30][200/938]D_loss:0.4953|G_loss:4.0195
*>checkpoint1
[1/30][400/938]D_loss:0.3610|G_loss:4.8148
*>checkpoint2
[1/30][600/938]D_loss:0.4072|G_loss:4.36760
*>checkpoint3
[1/30][800/938]D_loss:0.4444|G_loss:4.0250
*>checkpoint4
[2/30][200/938]D_loss:0.3761|G_loss:3.8790
*>checkpoint5
[2/30][400/938]D_loss:0.3977|G_loss:3.3315
...
*>checkpoint120
[30/30][938/938]D_loss:0.3610|G_loss:3.8084

root@3c0711f20896:/home/build#pythondisplay.py-idcgan-sample-100.pt
Savedout.png