pytorch · wanchaol · Jul 21, 2019 · Jul 22, 2019 · Jul 22, 2019 · Jul 22, 2019
diff --git a/.jenkins/build.sh b/.jenkins/build.sh
@@ -15,30 +15,44 @@ export PATH=/opt/conda/bin:$PATH
 rm -rf src
 pip install -r $DIR/../requirements.txt
 
+# For Tensorboard. Until 1.14 moves to the release channel.
+pip install tb-nightly  
+
 export PATH=/opt/conda/bin:$PATH
-conda install -y sphinx==1.8.2 pandas
+pip install sphinx==1.8.2 pandas
+
+# install awscli
+# pip uninstall awscli
+# pip install awscli==1.16.35
+
 # PyTorch Theme
 rm -rf src
 pip install -e git+git://github.com/pytorch/pytorch_sphinx_theme.git#egg=pytorch_sphinx_theme
 # pillow >= 4.2 will throw error when trying to write mode RGBA as JPEG,
 # this is a workaround to the issue.
-pip install sphinx-gallery tqdm matplotlib ipython pillow==4.1.1
+pip install sphinx-gallery==0.3.1 tqdm matplotlib ipython pillow==4.1.1
 
 # Install torchaudio from source
 git clone https://github.com/pytorch/audio --quiet
 pushd audio
 python setup.py install
 popd
 
+# Install torchaudio from source
+git clone https://github.com/pytorch/text --quiet
+pushd text
+python setup.py install
+popd
+
 aws configure set default.s3.multipart_threshold 5120MB
 
 # Decide whether to parallelize tutorial builds, based on $JOB_BASE_NAME
 export NUM_WORKERS=20
 if [[ "${JOB_BASE_NAME}" == *worker_* ]]; then
   # Step 1: Remove runnable code from tutorials that are not supposed to be run
-  python $DIR/remove_runnable_code.py beginner_source/aws_distributed_training_tutorial.py beginner_source/aws_distributed_training_tutorial.py
+  python $DIR/remove_runnable_code.py beginner_source/aws_distributed_training_tutorial.py beginner_source/aws_distributed_training_tutorial.py || true
   # TODO: Fix bugs in these tutorials to make them runnable again
-  python $DIR/remove_runnable_code.py beginner_source/audio_classifier_tutorial.py beginner_source/audio_classifier_tutorial.py
+  python $DIR/remove_runnable_code.py beginner_source/audio_classifier_tutorial.py beginner_source/audio_classifier_tutorial.py || true
 
   # Step 2: Keep certain tutorials based on file count, and remove runnable code in all other tutorials
   # IMPORTANT NOTE: We assume that each tutorial has a UNIQUE filename.

diff --git a/_static/imagenet_class_index.json b/_static/imagenet_class_index.json
diff --git a/_static/img/cat_output1.png b/_static/img/cat_output1.png
diff --git a/_static/img/cat_superres_with_ort.jpg b/_static/img/cat_superres_with_ort.jpg
diff --git a/_static/img/chatbot/diff.png b/_static/img/chatbot/diff.png
diff --git a/_static/img/chatbot/pytorch_workflow.png b/_static/img/chatbot/pytorch_workflow.png
diff --git a/_static/img/flask.png b/_static/img/flask.png
diff --git a/_static/img/hybrid.png b/_static/img/hybrid.png
diff --git a/_static/img/sample_file.jpeg b/_static/img/sample_file.jpeg
diff --git a/_static/img/torchscript.png b/_static/img/torchscript.png
diff --git a/advanced_source/README.txt b/advanced_source/README.txt
@@ -13,6 +13,6 @@ Advanced Tutorials
 	Custom C Extensions for PyTorch
 	https://pytorch.org/tutorials/advanced/c_extension.html
 
-4. super_resolution_with_caffe2.py
-	Transfering a Model from PyTorch to Caffe2 and Mobile using ONNX
-	https://pytorch.org/tutorials/advanced/super_resolution_with_caffe2.html
+4. super_resolution_with_onnxruntime.py
+    Exporting a Model from PyTorch to ONNX and Running it using ONNXRuntime
+	https://pytorch.org/tutorials/advanced/super_resolution_with_onnxruntime.html
diff --git a/advanced_source/cpp_export.rst b/advanced_source/cpp_export.rst
@@ -92,28 +92,30 @@ 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`` by subclassing it from ``torch.jit.ScriptModule`` and
-adding a ``@torch.jit.script_method`` annotation to the model's ``forward``
-method::
-
-  import torch
-
-  class MyModule(torch.jit.ScriptModule):
-      def __init__(self, N, M):
-          super(MyModule, self).__init__()
-          self.weight = torch.nn.Parameter(torch.rand(N, M))
-
-      @torch.jit.script_method
-      def forward(self, input):
-          if bool(input.sum() > 0):
-            output = self.weight.mv(input)
-          else:
-            output = self.weight + input
-          return output
-
-  my_script_module = MyModule(2, 3)
-
-Creating a new ``MyModule`` object now directly produces an instance of
+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):
+        def __init__(self, N, M):
+            super(MyModule, self).__init__()
+            self.weight = torch.nn.Parameter(torch.rand(N, M))
+
+        def forward(self, input):
+            if input.sum() > 0:
+              output = self.weight.mv(input)
+            else:
+              output = self.weight + input
+            return output
+
+    my_module = MyModule(10,20)
+    sm = torch.jit.script(my_module)
+
+If you need to exclude some methods in your ``nn.Module``
+because they use Python features that TorchScript doesn't support yet,
+you could annotate those with ``@torch.jit.ignore``
+
+``my_module`` is an instance of
 ``ScriptModule`` that is ready for serialization.
 
 Step 2: Serializing Your Script Module to a File
@@ -152,32 +154,38 @@ do:
 
 .. code-block:: cpp
 
-  #include <torch/script.h> // One-stop header.
-
-  #include <iostream>
-  #include <memory>
-
-  int main(int argc, const char* argv[]) {
-    if (argc != 2) {
-      std::cerr << "usage: example-app <path-to-exported-script-module>\n";
-      return -1;
+    #include <torch/script.h> // One-stop header.
+
+    #include <iostream>
+    #include <memory>
+
+    int main(int argc, const char* argv[]) {
+      if (argc != 2) {
+        std::cerr << "usage: example-app <path-to-exported-script-module>\n";
+        return -1;
+      }
+
+
+      torch::jit::script::Module module;
+      try {
+        // Deserialize the ScriptModule from a file using torch::jit::load().
+        module = torch::jit::load(argv[1]);
+      }
+      catch (const c10::Error& e) {
+        std::cerr << "error loading the model\n";
+        return -1;
+      }
+
+      std::cout << "ok\n";
     }
 
-    // Deserialize the ScriptModule from a file using torch::jit::load().
-    std::shared_ptr<torch::jit::script::Module> module = torch::jit::load(argv[1]);
-
-    assert(module != nullptr);
-    std::cout << "ok\n";
-  }
 
 The ``<torch/script.h>`` header encompasses all relevant includes from the
 LibTorch library necessary to run the example. Our application accepts the file
 path to a serialized PyTorch ``ScriptModule`` as its only command line argument
 and then proceeds to deserialize the module using the ``torch::jit::load()``
-function, which takes this file path as input. In return we receive a shared
-pointer to a ``torch::jit::script::Module``, the equivalent to a
-``torch.jit.ScriptModule`` in C++. For now, we only verify that this pointer is
-not null. We will examine how to execute it in a moment.
+function, which takes this file path as input. In return we receive a ``torch::jit::script::Module``
+object. We will examine how to execute it in a moment.
 
 Depending on LibTorch and Building the Application
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -300,8 +308,7 @@ application's ``main()`` function:
     inputs.push_back(torch::ones({1, 3, 224, 224}));
 
     // Execute the model and turn its output into a tensor.
-    at::Tensor output = module->forward(inputs).toTensor();
-
+    at::Tensor output = module.forward(inputs).toTensor();
     std::cout << output.slice(/*dim=*/1, /*start=*/0, /*end=*/5) << '\n';
 
 The first two lines set up the inputs to our model. We create a vector of
@@ -344,7 +351,7 @@ Looks like a good match!
 
 .. tip::
 
-  To move your model to GPU memory, you can write ``model->to(at::kCUDA);``.
+  To move your model to GPU memory, you can write ``model.to(at::kCUDA);``.
   Make sure the inputs to a model living in CUDA memory are also in CUDA memory
   by calling ``tensor.to(at::kCUDA)``, which will return a new tensor in CUDA
   memory.

diff --git a/advanced_source/cpp_extension.rst b/advanced_source/cpp_extension.rst
@@ -147,23 +147,22 @@ For the "ahead of time" flavor, we build our C++ extension by writing a
 ``setup.py`` script that uses setuptools to compile our C++ code. For the LLTM, it
 looks as simple as this::
 
-  from setuptools import setup
-  from torch.utils.cpp_extension import CppExtension, BuildExtension
+  from setuptools import setup, Extension
+  from torch.utils import cpp_extension
 
   setup(name='lltm_cpp',
-        ext_modules=[CppExtension('lltm', ['lltm.cpp'])],
-        cmdclass={'build_ext': BuildExtension})
-
+        ext_modules=[cpp_extension.CppExtension('lltm_cpp', ['lltm.cpp'])],
+        cmdclass={'build_ext': cpp_extension.BuildExtension})
 
 In this code, :class:`CppExtension` is a convenience wrapper around
 :class:`setuptools.Extension` that passes the correct include paths and sets
 the language of the extension to C++. The equivalent vanilla :mod:`setuptools`
 code would simply be::
 
-  setuptools.Extension(
+  Extension(
      name='lltm_cpp',
      sources=['lltm.cpp'],
-     include_dirs=torch.utils.cpp_extension.include_paths(),
+     include_dirs=cpp_extension.include_paths(),
      language='c++')
 
 :class:`BuildExtension` performs a number of required configuration steps and
@@ -413,7 +412,7 @@ see::
 If we call ``help()`` on the function or module, we can see that its signature
 matches our C++ code::
 
-  In[4] help(lltm.forward)
+  In[4] help(lltm_cpp.forward)
   forward(...) method of builtins.PyCapsule instance
       forward(arg0: torch::Tensor, arg1: torch::Tensor, arg2: torch::Tensor, arg3: torch::Tensor, arg4: torch::Tensor) -> List[torch::Tensor]
 
@@ -473,6 +472,8 @@ small benchmark to see how much performance we gained from rewriting our op in
 C++. We'll run the LLTM forwards and backwards a few times and measure the
 duration::
 
+  import time
+
   import torch
 
   batch_size = 16