add v0.19.1 release

docs/source/tv_tensors.rst

+.. _tv_tensors:
+
+TVTensors
+==========
+
+.. currentmodule:: torchvision.tv_tensors
+
+TVTensors are :class:`torch.Tensor` subclasses which the v2 :ref:`transforms
+<transforms>` use under the hood to dispatch their inputs to the appropriate
+lower-level kernels. Most users do not need to manipulate TVTensors directly.
+
+Refer to
+:ref:`sphx_glr_auto_examples_transforms_plot_transforms_getting_started.py` for
+an introduction to TVTensors, or
+:ref:`sphx_glr_auto_examples_transforms_plot_tv_tensors.py` for more advanced
+info.
+
+.. autosummary::
+    :toctree: generated/
+    :template: class.rst
+
+    Image
+    Video
+    BoundingBoxFormat
+    BoundingBoxes
+    Mask
+    TVTensor
+    set_return_type
+    wrap

docs/source/utils.rst

-torchvision.utils
-=================
+.. _utils:
 
-.. currentmodule:: torchvision.utils
+Utils
+=====
 
-.. autofunction:: make_grid
+The ``torchvision.utils`` module contains various utilities, mostly :ref:`for
+visualization <sphx_glr_auto_examples_others_plot_visualization_utils.py>`.
 
-.. autofunction:: save_image
+.. currentmodule:: torchvision.utils
 
-.. autofunction:: draw_bounding_boxes
+.. autosummary::
+    :toctree: generated/
+    :template: function.rst
 
-.. autofunction:: draw_segmentation_masks
+    draw_bounding_boxes
+    draw_segmentation_masks
+    draw_keypoints
+    flow_to_image
+    make_grid
+    save_image

examples/cpp/CMakeLists.txt

+cmake_minimum_required(VERSION 3.10)
+project(run_model)
+
+option(USE_TORCHVISION "Whether to link to torchvision" OFF)
+
+find_package(Torch REQUIRED)
+if(USE_TORCHVISION)
+  find_package(TorchVision REQUIRED)
+endif()
+
+add_executable(run_model run_model.cpp)
+
+target_link_libraries(run_model "${TORCH_LIBRARIES}")
+if(USE_TORCHVISION)
+  target_link_libraries(run_model TorchVision::TorchVision)
+endif()
+
+set_property(TARGET run_model PROPERTY CXX_STANDARD 17)

examples/cpp/README.md

+Using torchvision models in C++
+===============================
+
+This is a minimal example of getting TorchVision models to work in C++ with
+Torchscript. The model is first scripted in Python and exported to a file, and
+then loaded in C++. For a similar tutorial, see [this
+tutorial](https://pytorch.org/tutorials/advanced/cpp_export.html).
+
+In order to successfully compile this example, make sure you have ``LibTorch``
+installed. You can either:
+
+- Install PyTorch normally
+- Or download the LibTorch C++ distribution.
+
+In both cases refer [here](https://pytorch.org/get-started/locally/) the
+corresponding install or download instructions.
+
+Some torchvision models only depend on PyTorch operators, and can be used in C++
+without depending on the torchvision lib. Other models rely on torchvision's C++
+operators like NMS, RoiAlign (typically the detection models) and those need to
+be linked against the torchvision lib.
+
+We'll first see the simpler case of running a model without the torchvision lib
+dependency.
+
+Running a model that doesn't need torchvision lib
+-------------------------------------------------
+
+Create a ``build`` directory inside the current one.
+
+```bash
+mkdir build
+cd build
+```
+
+Then run `python ../trace_model.py` which should create a `resnet18.pt` file in
+the build directory. This is the scripted model that will be used in the C++
+code.
+
+We can now start building with CMake. We have to tell CMake where it can find
+the necessary PyTorch resources. If you installed PyTorch normally, you can do:
+
+```bash
+TORCH_PATH=$(python -c "import pathlib, torch; print(pathlib.Path(torch.__path__[0]))")
+Torch_DIR="${TORCH_PATH}/share/cmake/Torch"   # there should be .cmake files in there
+
+cmake .. -DTorch_DIR=$Torch_DIR
+```
+
+If instead you downloaded the LibTorch somewhere, you can do:
+
+```bash
+cmake .. -DCMAKE_PREFIX_PATH=/path/to/libtorch
+```
+
+Then `cmake --build .` and you should now be able to run
+
+```bash
+./run_model resnet18.pt
+```
+
+If you try to run the model with a model that depends on the torchvision lib, like
+`./run_model fasterrcnn_resnet50_fpn.pt`, you should get a runtime error. This is
+because the executable wasn't linked against the torchvision lib.
+
+
+Running a model that needs torchvision lib
+------------------------------------------
+
+First, we need to build the torchvision lib. To build the torchvision lib go to
+the root of the torchvision project and run:
+
+```bash
+mkdir build
+cd build
+cmake .. -DCMAKE_PREFIX_PATH=/path/to/libtorch  # or -DTorch_DIR= if you installed PyTorch normally, see above
+cmake --build .
+cmake --install .
+```
+
+You may want to pass `-DCMAKE_INSTALL_PREFIX=/path/to/libtorchvision` for
+cmake to copy/install the files to a specific location (e.g. `$CONDA_PREFIX`).
+
+**DISCLAIMER**: the `libtorchvision` library includes the torchvision
+custom ops as well as most of the C++ torchvision APIs. Those APIs do not come
+with any backward-compatibility guarantees and may change from one version to
+the next. Only the Python APIs are stable and with backward-compatibility
+guarantees. So, if you need stability within a C++ environment, your best bet is
+to export the Python APIs via torchscript.
+
+Now that libtorchvision is built and installed we can tell our project to use
+and link to it via the `-DUSE_TORCHVISION` flag. We also need to tell CMake
+where to find it, just like we did with LibTorch, e.g.:
+
+```bash
+cmake .. -DTorch_DIR=$Torch_DIR -DTorchVision_DIR=path/to/libtorchvision -DUSE_TORCHVISION=ON
+cmake --build .
+```
+
+Now the `run_model` executable should be able to run the
+`fasterrcnn_resnet50_fpn.pt` file.

examples/cpp/hello_world/CMakeLists.txt

-cmake_minimum_required(VERSION 3.10)
-project(hello-world)
-
-# The first thing do is to tell cmake to find the TorchVision library.
-# The package pulls in all the necessary torch libraries,
-# so there is no need to also add `find_package(Torch)` here.
-find_package(TorchVision REQUIRED)
-
-add_executable(hello-world main.cpp)
-
-# We now need to link the TorchVision library to our executable.
-# We can do that by using the TorchVision::TorchVision target,
-# which also adds all the necessary torch dependencies.
-target_compile_features(hello-world PUBLIC cxx_range_for)
-target_link_libraries(hello-world TorchVision::TorchVision)
-set_property(TARGET hello-world PROPERTY CXX_STANDARD 14)

examples/cpp/hello_world/README.rst

-Hello World!
-============
-
-This is a minimal example of getting TorchVision to work in C++ with CMake.
-
-
-In order to successfully compile this example, make sure you have both ``LibTorch`` and
-``TorchVision`` installed.
-Once both dependencies are sorted, we can start the CMake fun:
-
-1) Create a ``build`` directory inside the current one.
-2) from within the ``build`` directory, run the following commands:
-    - | ``cmake -DCMAKE_PREFIX_PATH="<PATH_TO_LIBTORCH>;<PATH_TO_TORCHVISION>" ..``
-      | where ``<PATH_TO_LIBTORCH>`` and ``<PATH_TO_TORCHVISION>`` are the paths to the libtorch and torchvision installations.
-    - ``cmake --build .``
-
-| That's it!
-| You should now have a ``hello-world`` executable in your ``build`` folder.
- Running it will output a (fairly long) tensor of random values to your terminal.
\ No newline at end of file

examples/cpp/hello_world/main.cpp

-#include <iostream>
-#include <torch/torch.h>
-#include <torchvision/vision.h>
-#include <torchvision/models/resnet.h>
-
-int main()
-{
-  auto model = vision::models::ResNet18();
-  model->eval();
-
-  // Create a random input tensor and run it through the model.
-  auto in = torch::rand({1, 3, 10, 10});
-  auto out = model->forward(in);
-
-  std::cout << out.sizes();
-
-  if (torch::cuda::is_available()) {
-    // Move model and inputs to GPU
-    model->to(torch::kCUDA);
-    auto gpu_in = in.to(torch::kCUDA);
-    auto gpu_out = model->forward(gpu_in);
-
-    std::cout << gpu_out.sizes();
-  }
-}

test/tracing/frcnn/test_frcnn_tracing.cpp → examples/cpp/run_model.cpp

 #include <torch/script.h>
 #include <torch/torch.h>
-#include <torchvision/vision.h>
-#include <torchvision/ops/nms.h>
+#include <cstring>
+#include <iostream>
 
+#ifdef _WIN32
+#include <torchvision/vision.h>
+#endif // _WIN32
 
-int main() {
+int main(int argc, const char* argv[]) {
+  if (argc != 2) {
+    std::cout << "Usage: run_model <path_to_scripted_model>\n";
+    return -1;
+  }
   torch::DeviceType device_type;
   device_type = torch::kCPU;
 
-  torch::jit::script::Module module;
+  torch::jit::script::Module model;
   try {
     std::cout << "Loading model\n";
     // Deserialize the ScriptModule from a file using torch::jit::load().
-    module = torch::jit::load("fasterrcnn_resnet50_fpn.pt");
+    model = torch::jit::load(argv[1]);
     std::cout << "Model loaded\n";
   } catch (const torch::Error& e) {
-    std::cout << "error loading the model\n";
+    std::cout << "error loading the model.\n";
     return -1;
   } catch (const std::exception& e) {
     std::cout << "Other error: " << e.what() << "\n";
@@ -25,34 +32,36 @@ int main() {
   // TorchScript models require a List[IValue] as input
   std::vector<torch::jit::IValue> inputs;
 
-  // Faster RCNN accepts a List[Tensor] as main input
-  std::vector<torch::Tensor> images;
-  images.push_back(torch::rand({3, 256, 275}));
-  images.push_back(torch::rand({3, 256, 275}));
-
-  inputs.push_back(images);
-  auto output = module.forward(inputs);
-
-  std::cout << "ok\n";
-  std::cout << "output" << output << "\n";
+  if (std::strstr(argv[1], "fasterrcnn") != NULL) {
+    // Faster RCNN accepts a List[Tensor] as main input
+    std::vector<torch::Tensor> images;
+    images.push_back(torch::rand({3, 256, 275}));
+    images.push_back(torch::rand({3, 256, 275}));
+    inputs.push_back(images);
+  } else {
+    inputs.push_back(torch::rand({1, 3, 10, 10}));
+  }
+  auto out = model.forward(inputs);
+  std::cout << out << "\n";
 
   if (torch::cuda::is_available()) {
-    // Move traced model to GPU
-    module.to(torch::kCUDA);
+    // Move model and inputs to GPU
+    model.to(torch::kCUDA);
 
     // Add GPU inputs
-    images.clear();
     inputs.clear();
-
     torch::TensorOptions options = torch::TensorOptions{torch::kCUDA};
-    images.push_back(torch::rand({3, 256, 275}, options));
-    images.push_back(torch::rand({3, 256, 275}, options));
-
-    inputs.push_back(images);
-    auto output = module.forward(inputs);
+    if (std::strstr(argv[1], "fasterrcnn") != NULL) {
+      // Faster RCNN accepts a List[Tensor] as main input
+      std::vector<torch::Tensor> images;
+      images.push_back(torch::rand({3, 256, 275}, options));
+      images.push_back(torch::rand({3, 256, 275}, options));
+      inputs.push_back(images);
+    } else {
+      inputs.push_back(torch::rand({1, 3, 10, 10}, options));
+    }
 
-    std::cout << "ok\n";
-    std::cout << "output" << output << "\n";
+    auto gpu_out = model.forward(inputs);
+    std::cout << gpu_out << "\n";
   }
-  return 0;
 }

examples/cpp/script_model.py

+import torch
+from torchvision import models
+
+for model, name in (
+    (models.resnet18(weights=None), "resnet18"),
+    (models.detection.fasterrcnn_resnet50_fpn(weights=None, weights_backbone=None), "fasterrcnn_resnet50_fpn"),
+):
+    model.eval()
+    traced_model = torch.jit.script(model)
+    traced_model.save(f"{name}.pt")

examples/python/README.md

 # Python examples
 
-- [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/pytorch/vision/blob/master/examples/python/tensor_transforms.ipynb)
-[Examples of Tensor Images transformations](https://github.com/pytorch/vision/blob/master/examples/python/tensor_transforms.ipynb)
-- [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/pytorch/vision/blob/master/examples/python/video_api.ipynb)
-[Example of VideoAPI](https://github.com/pytorch/vision/blob/master/examples/python/video_api.ipynb)
-- [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/pytorch/vision/blob/master/examples/python/visualization_utils.ipynb)
-[Example of Visualization Utils](https://github.com/pytorch/vision/blob/master/examples/python/visualization_utils.ipynb)
-
-
-Prior to v0.8.0, transforms in torchvision have traditionally been PIL-centric and presented multiple limitations due to 
-that. Now, since v0.8.0, transforms implementations are Tensor and PIL compatible and we can achieve the following new 
-features:
-- transform multi-band torch tensor images (with more than 3-4 channels) 
-- torchscript transforms together with your model for deployment
-- support for GPU acceleration
-- batched transformation such as for videos
-- read and decode data directly as torch tensor with torchscript support (for PNG and JPEG image formats)
-
-Furthermore, previously we used to provide a very high-level API for video decoding which left little control to the user. We're now expanding that API (and replacing it in the future) with a lower-level API that allows the user a frame-based access to a video.
-
-Torchvision also provides utilities to visualize results. You can make grid of images, plot bounding boxes as well as segmentation masks. Thse utilities work standalone as well as with torchvision models for detection and segmentation.
+The examples in this directory have been moved online in our [gallery
+page](https://pytorch.org/vision/stable/auto_examples/index.html).

examples/python/tensor_transforms.ipynb

-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "vjAC2mZnb4nz"
-   },
-   "source": [
-    "# Image transformations\n",
-    "\n",
-    "This notebook shows new features of torchvision image transformations. \n",
-    "\n",
-    "Prior to v0.8.0, transforms in torchvision have traditionally been PIL-centric and presented multiple limitations due to that. Now, since v0.8.0, transforms implementations are Tensor and PIL compatible and we can achieve the following new \n",
-    "features:\n",
-    "- transform multi-band torch tensor images (with more than 3-4 channels) \n",
-    "- torchscript transforms together with your model for deployment\n",
-    "- support for GPU acceleration\n",
-    "- batched transformation such as for videos\n",
-    "- read and decode data directly as torch tensor with torchscript support (for PNG and JPEG image formats)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "colab": {
-     "base_uri": "https://localhost:8080/",
-     "height": 35
-    },
-    "id": "btaDWPDbgIyW",
-    "outputId": "8a83d408-f643-42da-d247-faf3a1bd3ae0"
-   },
-   "outputs": [],
-   "source": [
-    "import torch, torchvision\n",
-    "torch.__version__, torchvision.__version__"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "9Vj9draNb4oA"
-   },
-   "source": [
-    "## Transforms on CPU/CUDA tensor images\n",
-    "\n",
-    "Let's show how to apply transformations on images opened directly as a torch tensors.\n",
-    "Now, torchvision provides image reading functions for PNG and JPG images with torchscript support. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "id": "Epp3hCy0b4oD"
-   },
-   "outputs": [],
-   "source": [
-    "from torchvision.datasets.utils import download_url\n",
-    "\n",
-    "download_url(\"https://farm1.static.flickr.com/152/434505223_8d1890e1e2.jpg\", \".\", \"test-image.jpg\")\n",
-    "download_url(\"https://farm3.static.flickr.com/2142/1896267403_24939864ba.jpg\", \".\", \"test-image2.jpg\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "id": "Y-m7lYDPb4oK"
-   },
-   "outputs": [],
-   "source": [
-    "import matplotlib.pylab as plt\n",
-    "%matplotlib inline"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "colab": {
-     "base_uri": "https://localhost:8080/",
-     "height": 303
-    },
-    "id": "5bi8Q7L3b4oc",
-    "outputId": "e5de5c73-e16d-4992-ebee-94c7ddf0bf54"
-   },
-   "outputs": [],
-   "source": [
-    "from torchvision.io.image import read_image\n",
-    "\n",
-    "tensor_image = read_image(\"test-image.jpg\")\n",
-    "\n",
-    "print(\"tensor image info: \", tensor_image.shape, tensor_image.dtype)\n",
-    "\n",
-    "plt.imshow(tensor_image.numpy().transpose((1, 2, 0)))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def to_rgb_image(tensor):\n",
-    "    \"\"\"Helper method to get RGB numpy array for plotting\"\"\"\n",
-    "    np_img = tensor.cpu().numpy().transpose((1, 2, 0))\n",
-    "    m1, m2 = np_img.min(axis=(0, 1)), np_img.max(axis=(0, 1))\n",
-    "    return (255.0 * (np_img - m1) / (m2 - m1)).astype(\"uint8\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "colab": {
-     "base_uri": "https://localhost:8080/",
-     "height": 322
-    },
-    "id": "PgWpjxQ3b4pF",
-    "outputId": "e9a138e8-b45c-4f75-d849-3b41de0e5472"
-   },
-   "outputs": [],
-   "source": [
-    "import torchvision.transforms as T\n",
-    "\n",
-    "# to fix random seed is now:\n",
-    "torch.manual_seed(12)\n",
-    "\n",
-    "transforms = T.Compose([\n",
-    "    T.RandomCrop(224),\n",
-    "    T.RandomHorizontalFlip(p=0.3),\n",
-    "    T.ConvertImageDtype(torch.float),\n",
-    "    T.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n",
-    "])\n",
-    "\n",
-    "out_image = transforms(tensor_image)\n",
-    "print(\"output tensor image info: \", out_image.shape, out_image.dtype)\n",
-    "\n",
-    "plt.imshow(to_rgb_image(out_image))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "LmYQB4cxb4pI"
-   },
-   "source": [
-    "Tensor images can be on GPU"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "colab": {
-     "base_uri": "https://localhost:8080/",
-     "height": 322
-    },
-    "id": "S6syYJGEb4pN",
-    "outputId": "86bddb64-e648-45f2-c216-790d43cfc26d"
-   },
-   "outputs": [],
-   "source": [
-    "out_image = transforms(tensor_image.to(\"cuda\"))\n",
-    "print(\"output tensor image info: \", out_image.shape, out_image.dtype, out_image.device)\n",
-    "\n",
-    "plt.imshow(to_rgb_image(out_image))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "jg9TQd7ajfyn"
-   },
-   "source": [
-    "## Scriptable transforms for easier deployment via torchscript\n",
-    "\n",
-    "Next, we show how to combine input transformations and model's forward pass and use `torch.jit.script` to obtain a single scripted module.\n",
-    "\n",
-    "**Note:** we have to use only scriptable transformations that should be derived from `torch.nn.Module`. \n",
-    "Since v0.8.0, all transformations are scriptable except `Compose`, `RandomChoice`, `RandomOrder`, `Lambda` and those applied on PIL images.\n",
-    "The transformations like `Compose` are kept for backward compatibility and can be easily replaced by existing torch modules, like `nn.Sequential`.\n",
-    "\n",
-    "Let's define a module `Predictor` that transforms input tensor and applies ImageNet pretrained resnet18 model on it."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "id": "NSDOJ3RajfvO"
-   },
-   "outputs": [],
-   "source": [
-    "import torch\n",
-    "import torch.nn as nn\n",
-    "import torchvision.transforms as T\n",
-    "from torchvision.io.image import read_image\n",
-    "from torchvision.models import resnet18\n",
-    "\n",
-    "\n",
-    "class Predictor(nn.Module):\n",
-    "\n",
-    "    def __init__(self):\n",
-    "        super().__init__()\n",
-    "        self.resnet18 = resnet18(pretrained=True).eval()\n",
-    "        self.transforms = nn.Sequential(\n",
-    "            T.Resize([256, ]), # We use single int value inside a list due to torchscript type restrictions\n",
-    "            T.CenterCrop(224),\n",
-    "            T.ConvertImageDtype(torch.float),\n",
-    "            T.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n",
-    "        )\n",
-    "\n",
-    "    def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
-    "        with torch.no_grad():\n",
-    "            x = self.transforms(x)\n",
-    "            y_pred = self.resnet18(x)\n",
-    "            return y_pred.argmax(dim=1)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "ZZKDovqej5vA"
-   },
-   "source": [
-    "Now, let's define scripted and non-scripted instances of `Predictor` and apply on multiple tensor images of the same size"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "id": "GBBMSo7vjfr0"
-   },
-   "outputs": [],
-   "source": [
-    "from torchvision.io.image import read_image\n",
-    "\n",
-    "predictor = Predictor().to(\"cuda\")\n",
-    "scripted_predictor = torch.jit.script(predictor).to(\"cuda\")\n",
-    "\n",
-    "\n",
-    "tensor_image1 = read_image(\"test-image.jpg\")\n",
-    "tensor_image2 = read_image(\"test-image2.jpg\")\n",
-    "batch = torch.stack([tensor_image1[:, -320:, :], tensor_image2[:, -320:, :]]).to(\"cuda\")\n",
-    "\n",
-    "res1 = scripted_predictor(batch)\n",
-    "res2 = predictor(batch)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "colab": {
-     "base_uri": "https://localhost:8080/",
-     "height": 501
-    },
-    "id": "Dmi9r_p-oKsk",
-    "outputId": "b9c55e7d-5db1-4975-c485-fecc4075bf47"
-   },
-   "outputs": [],
-   "source": [
-    "import json\n",
-    "from torchvision.datasets.utils import download_url\n",
-    "\n",
-    "\n",
-    "download_url(\"https://s3.amazonaws.com/deep-learning-models/image-models/imagenet_class_index.json\", \".\", \"imagenet_class_index.json\")\n",
-    "\n",
-    "\n",
-    "with open(\"imagenet_class_index.json\", \"r\") as h:\n",
-    "    labels = json.load(h)\n",
-    "\n",
-    "\n",
-    "plt.figure(figsize=(12, 7))\n",
-    "for i, p in enumerate(res1):\n",
-    "    plt.subplot(1, 2, i + 1)\n",
-    "    plt.title(\"Scripted predictor:\\n{label})\".format(label=labels[str(p.item())]))\n",
-    "    plt.imshow(batch[i, ...].cpu().numpy().transpose((1, 2, 0)))\n",
-    "\n",
-    "\n",
-    "plt.figure(figsize=(12, 7))\n",
-    "for i, p in enumerate(res2):\n",
-    "    plt.subplot(1, 2, i + 1)\n",
-    "    plt.title(\"Original predictor:\\n{label})\".format(label=labels[str(p.item())]))\n",
-    "    plt.imshow(batch[i, ...].cpu().numpy().transpose((1, 2, 0)))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "7IYsjzpFqcK8"
-   },
-   "source": [
-    "We save and reload scripted predictor in Python or C++ and use it for inference:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "colab": {
-     "base_uri": "https://localhost:8080/",
-     "height": 52
-    },
-    "id": "0kk9LLw5jfol",
-    "outputId": "05ea6db7-7fcf-4b74-a763-5f117c14cc00"
-   },
-   "outputs": [],
-   "source": [
-    "scripted_predictor.save(\"scripted_predictor.pt\")\n",
-    "\n",
-    "scripted_predictor = torch.jit.load(\"scripted_predictor.pt\")\n",
-    "res1 = scripted_predictor(batch)\n",
-    "\n",
-    "for i, p in enumerate(res1):\n",
-    "    print(\"Scripted predictor: {label})\".format(label=labels[str(p.item())]))\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Data reading and decoding functions also support torch script and therefore can be part of the model as well:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class AnotherPredictor(Predictor):\n",
-    "\n",
-    "    def forward(self, path: str) -> int:\n",
-    "        with torch.no_grad():\n",
-    "            x = read_image(path).unsqueeze(0)\n",
-    "            x = self.transforms(x)\n",
-    "            y_pred = self.resnet18(x)\n",
-    "            return int(y_pred.argmax(dim=1).item())"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "id": "-cMwTs3Yjffy"
-   },
-   "outputs": [],
-   "source": [
-    "scripted_predictor2 = torch.jit.script(AnotherPredictor())\n",
-    "\n",
-    "res = scripted_predictor2(\"test-image.jpg\")\n",
-    "\n",
-    "print(\"Scripted another predictor: {label})\".format(label=labels[str(res)]))"
-   ]
-  }
- ],
- "metadata": {
-  "accelerator": "GPU",
-  "colab": {
-   "collapsed_sections": [],
-   "name": "torchvision_scriptable_transforms.ipynb",
-   "provenance": []
-  },
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.7.4"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}

gallery/README.rst

-Example gallery
-===============
+.. _gallery:
 
-Below is a gallery of examples
\ No newline at end of file
+Examples and tutorials
+======================

gallery/assets/coco/images/000000000001.jpg

+../../astronaut.jpg
\ No newline at end of file

gallery/assets/coco/images/000000000002.jpg

+../../dog2.jpg
\ No newline at end of file

gallery/assets/coco/instances.json

+{"images": [{"file_name": "000000000001.jpg", "height": 512, "width": 512, "id": 1}, {"file_name": "000000000002.jpg", "height": 500, "width": 500, "id": 2}], "annotations": [{"segmentation": [[40.0, 511.0, 26.0, 487.0, 28.0, 438.0, 17.0, 397.0, 24.0, 346.0, 38.0, 306.0, 61.0, 250.0, 111.0, 206.0, 111.0, 187.0, 120.0, 183.0, 136.0, 159.0, 159.0, 150.0, 181.0, 148.0, 182.0, 132.0, 175.0, 132.0, 168.0, 120.0, 154.0, 102.0, 153.0, 62.0, 188.0, 35.0, 191.0, 29.0, 208.0, 20.0, 210.0, 22.0, 227.0, 16.0, 240.0, 16.0, 276.0, 31.0, 285.0, 39.0, 301.0, 88.0, 297.0, 108.0, 281.0, 128.0, 273.0, 138.0, 266.0, 138.0, 264.0, 153.0, 257.0, 162.0, 256.0, 174.0, 284.0, 197.0, 300.0, 221.0, 303.0, 236.0, 337.0, 258.0, 357.0, 306.0, 361.0, 351.0, 358.0, 511.0]], "iscrowd": 0, "image_id": 1, "bbox": [17.0, 16.0, 344.0, 495.0], "category_id": 1, "id": 1}, {"segmentation": [[0.0, 411.0, 43.0, 401.0, 99.0, 395.0, 105.0, 351.0, 124.0, 326.0, 181.0, 294.0, 227.0, 280.0, 245.0, 262.0, 259.0, 234.0, 262.0, 207.0, 271.0, 140.0, 283.0, 139.0, 301.0, 162.0, 309.0, 181.0, 341.0, 175.0, 362.0, 139.0, 369.0, 139.0, 377.0, 163.0, 378.0, 203.0, 381.0, 212.0, 380.0, 220.0, 382.0, 242.0, 404.0, 264.0, 392.0, 293.0, 384.0, 295.0, 385.0, 316.0, 399.0, 343.0, 391.0, 448.0, 452.0, 475.0, 457.0, 494.0, 436.0, 498.0, 402.0, 491.0, 369.0, 488.0, 366.0, 496.0, 319.0, 496.0, 302.0, 485.0, 226.0, 469.0, 128.0, 456.0, 74.0, 458.0, 29.0, 439.0, 0.0, 445.0]], "iscrowd": 0, "image_id": 2, "bbox": [0.0, 139.0, 457.0, 359.0], "category_id": 18, "id": 2}]}