Merge branch 'master' into packed_accessor

Author: SethHWeidman

_static/img/torchscript_to_cpp.png

@@ -1,5 +1,5 @@
-Loading a PyTorch Model in C++
-==============================
+3. Loading a TorchScript Model in C++
+=====================================
 
 **This tutorial was updated to work with PyTorch 1.2**
 
@@ -94,8 +94,8 @@ vanilla Pytorch model::
 
 Because the ``forward`` method of this module uses control flow that is
 dependent on the input, it is not suitable for tracing. Instead, we can convert
-it to a ``ScriptModule``. 
-In order to convert the module to the ``ScriptModule``, one needs to 
+it to a ``ScriptModule``.
+In order to convert the module to the ``ScriptModule``, one needs to
 compile the module with ``torch.jit.script`` as follows::
 
     class MyModule(torch.nn.Module):
@@ -133,7 +133,7 @@ on the module and pass it a filename::
 
   traced_script_module.save("traced_resnet_model.pt")
 
-This will produce a ``traced_resnet_model.pt`` file in your working directory. 
+This will produce a ``traced_resnet_model.pt`` file in your working directory.
 If you also would like to serialize ``my_module``, call ``my_module.save("my_module_model.pt")``
 We have now officially left the realm of Python and are ready to cross over to the sphere
 of C++.
@@ -168,7 +168,7 @@ do:
         return -1;
       }
 
-      
+
       torch::jit::script::Module module;
       try {
         // Deserialize the ScriptModule from a file using torch::jit::load().

_static/img/transformer_architecture.jpg

@@ -769,24 +769,24 @@ modules in the ``forward()`` method of a module we define ourselves:
 .. code-block:: cpp
 
   struct GeneratorImpl : nn::Module {
-    GeneratorImpl()
-        : conv1(nn::Conv2dOptions(kNoiseSize, 512, 4)
+    GeneratorImpl(int kNoiseSize)
+        : conv1(nn::Conv2dOptions(kNoiseSize, 256, 4)
                     .with_bias(false)
                     .transposed(true)),
-          batch_norm1(512),
-          conv2(nn::Conv2dOptions(512, 256, 4)
+          batch_norm1(256),
+          conv2(nn::Conv2dOptions(256, 128, 3)
                     .stride(2)
                     .padding(1)
                     .with_bias(false)
                     .transposed(true)),
-          batch_norm2(256),
-          conv3(nn::Conv2dOptions(256, 128, 4)
+          batch_norm2(128),
+          conv3(nn::Conv2dOptions(128, 64, 4)
                     .stride(2)
                     .padding(1)
                     .with_bias(false)
                     .transposed(true)),
-          batch_norm3(128),
-          conv4(nn::Conv2dOptions(128, 64, 4)
+          batch_norm3(64),
+          conv4(nn::Conv2dOptions(64, 1, 4)
                     .stride(2)
                     .padding(1)
                     .with_bias(false)
@@ -796,19 +796,28 @@ modules in the ``forward()`` method of a module we define ourselves:
                     .stride(2)
                     .padding(1)
                     .with_bias(false)
-                    .transposed(true)) {}
-
-    torch::Tensor forward(torch::Tensor x) {
-      x = torch::relu(batch_norm1(conv1(x)));
-      x = torch::relu(batch_norm2(conv2(x)));
-      x = torch::relu(batch_norm3(conv3(x)));
-      x = torch::relu(batch_norm4(conv4(x)));
-      x = torch::tanh(conv5(x));
-      return x;
-    }
-
-    nn::Conv2d conv1, conv2, conv3, conv4, conv5;
-    nn::BatchNorm batch_norm1, batch_norm2, batch_norm3, batch_norm4;
+                    .transposed(true))
+   {
+     // 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_norm1);
+     register_module("batch_norm3", batch_norm1);
+   }
+
+   torch::Tensor forward(torch::Tensor x) {
+     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));
+     return x;
+   }
+
+   nn::Conv2d conv1, conv2, conv3, conv4;
+   nn::BatchNorm batch_norm1, batch_norm2, batch_norm3;
   };
   TORCH_MODULE(Generator);
 

advanced_source/cpp_export.rst

@@ -1,5 +1,5 @@
 """
-Exporting a Model from PyTorch to ONNX and Running it using ONNX Runtime
+4. (optional) Exporting a Model from PyTorch to ONNX and Running it using ONNX Runtime
 ========================================================================
 
 In this tutorial, we describe how to convert a model defined
@@ -37,14 +37,14 @@
 # and is widely used in image processing or video editing. For this
 # tutorial, we will use a small super-resolution model.
 #
-# First, let's create a SuperResolution model in PyTorch. 
+# First, let's create a SuperResolution model in PyTorch.
 # This model uses the efficient sub-pixel convolution layer described in
 # `"Real-Time Single Image and Video Super-Resolution Using an Efficient
 # Sub-Pixel Convolutional Neural Network" - Shi et al <https://arxiv.org/abs/1609.05158>`__
 # for increasing the resolution of an image by an upscale factor.
 # The model expects the Y component of the YCbCr of an image as an input, and
-# outputs the upscaled Y component in super resolution. 
-# 
+# outputs the upscaled Y component in super resolution.
+#
 # `The
 # model <https://github.com/pytorch/examples/blob/master/super_resolution/model.py>`__
 # comes directly from PyTorch's examples without modification:
@@ -94,7 +94,7 @@ def _initialize_weights(self):
 # It is important to call ``torch_model.eval()`` or ``torch_model.train(False)``
 # before exporting the model, to turn the model to inference mode.
 # This is required since operators like dropout or batchnorm behave
-# differently in inference and training mode. 
+# differently in inference and training mode.
 #
 
 # Load pretrained model weights
@@ -113,7 +113,7 @@ def _initialize_weights(self):
 
 ######################################################################
 # Exporting a model in PyTorch works via tracing or scripting. This
-# tutorial will use as an example a model exported by tracing. 
+# tutorial will use as an example a model exported by tracing.
 # To export a model, we call the ``torch.onnx.export()`` function.
 # This will execute the model, recording a trace of what operators
 # are used to compute the outputs.
@@ -124,10 +124,10 @@ def _initialize_weights(self):
 # all the input's dimensions, unless specified as a dynamic axes.
 # In this example we export the model with an input of batch_size 1,
 # but then specify the first dimension as dynamic in the ``dynamic_axes``
-# parameter in ``torch.onnx.export()``. 
+# parameter in ``torch.onnx.export()``.
 # The exported model will thus accept inputs of size [batch_size, 1, 224, 224]
-# where batch_size can be variable. 
-# 
+# where batch_size can be variable.
+#
 # To learn more details about PyTorch's export interface, check out the
 # `torch.onnx documentation <https://pytorch.org/docs/master/onnx.html>`__.
 #
@@ -238,7 +238,7 @@ def to_numpy(tensor):
 # Then we split the image into its Y, Cb, and Cr components.
 # These components represent a greyscale image (Y), and
 # the blue-difference (Cb) and red-difference (Cr) chroma components.
-# The Y component being more sensitive to the human eye, we are 
+# The Y component being more sensitive to the human eye, we are
 # interested in this component which we will be transforming.
 # After extracting the Y component, we convert it to a tensor which
 # will be the input of our model.
@@ -278,7 +278,7 @@ def to_numpy(tensor):
 # The post-processing steps have been adopted from PyTorch
 # implementation of super-resolution model
 # `here <https://github.com/pytorch/examples/blob/master/super_resolution/super_resolve.py>`__.
-# 
+#
 
 img_out_y = Image.fromarray(np.uint8((img_out_y[0] * 255.0).clip(0, 255)[0]), mode='L')
 
@@ -301,12 +301,12 @@ def to_numpy(tensor):
 #
 # ONNX Runtime being a cross platform engine, you can run it across
 # multiple platforms and on both CPUs and GPUs.
-# 
+#
 # ONNX Runtime can also be deployed to the cloud for model inferencing
 # using Azure Machine Learning Services. More information `here <https://docs.microsoft.com/en-us/azure/machine-learning/service/concept-onnx>`__.
 #
 # More information about ONNX Runtime's performance `here <https://github.com/microsoft/onnxruntime#high-performance>`__.
 #
-# 
+#
 # For more information about ONNX Runtime `here <https://github.com/microsoft/onnxruntime>`__.
 #