Several minor content changes:

- Modified getting started on landing page to address changes from delta PR
- Added torchvision dependency text to tutorials (instructions on how to install via conda or pip)
- Added getting started with captum insights content to site.

Author: Carlos Araya

docs/captum_insights.md

@@ -7,7 +7,7 @@ Interpreting model output in complex models can be difficult. Even with interpre
 
 Captum Insights is an interpretability visualization widget built on top of Captum to facilitate model understanding. Captum Insights works across images, text, and other features to help users understand feature attribution. Some examples of the widget are below.
 
-Getting started with Captum Insights is easy. To analyze a sample model on CIFAR10 via Captum Insights execute the line below and navigate to the URL specified in the output.
+Getting started with Captum Insights is easy. You can learn how to use Captum Insights with the [Getting started with Captum Sights](/tutorials/CIFAR_TorchVision_Captum_Insights) tutorial.  Alternatively, to analyze a sample model on CIFAR10 via Captum Insights execute the line below and navigate to the URL specified in the output.
 
 ```
 python -m captum.insights.example

tutorials/CIFAR_TorchVision_Captum_Insights.ipynb

@@ -4,7 +4,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# Showcases Captum Insights with a simple model on CIFAR10 dataset"
+    "# Getting started with Captum Insights: a simple model on CIFAR10 dataset"
    ]
   },
   {
@@ -13,7 +13,11 @@
    "source": [
     "Demonstrates how to use Captum Insights embedded in a notebook to debug a CIFAR model and test samples. This is a slight modification of the CIFAR_TorchVision_Interpret notebook.\n",
     "\n",
-    "More details about the model can be found here: https://pytorch.org/tutorials/beginner/blitz/cifar10_tutorial.html#sphx-glr-beginner-blitz-cifar10-tutorial-py"
+    "More details about the model can be found here: https://pytorch.org/tutorials/beginner/blitz/cifar10_tutorial.html#sphx-glr-beginner-blitz-cifar10-tutorial-py\n  ",
+    "\n  ",
+    "**Note:**  This tutorial uses torchvision.  To download torchvision you can do one of the following:\n  ",
+    "- **Conda:** conda install torchvision -c pytorch\n  ",
+    "- **Pip:** pip3 install torchvision"
    ]
   },
   {
@@ -161,15 +165,6 @@
     {
      "data": {
       "text/html": [
-       "\n",
-       "        <iframe\n",
-       "            width=\"100%\"\n",
-       "            height=\"500px\"\n",
-       "            src=\"http://127.0.0.1:53361\"\n",
-       "            frameborder=\"0\"\n",
-       "            allowfullscreen\n",
-       "        ></iframe>\n",
-       "        "
       ],
       "text/plain": [
        "<IPython.lib.display.IFrame at 0x127aeb150>"

tutorials/CIFAR_TorchVision_Interpret.ipynb

@@ -13,7 +13,11 @@
    "source": [
     "Demonstrates how to apply model interpretability algorithms from Captum library on CIFAR model and test samples.\n",
     "\n",
-    "More details about the model can be found here: https://pytorch.org/tutorials/beginner/blitz/cifar10_tutorial.html#sphx-glr-beginner-blitz-cifar10-tutorial-py"
+    "More details about the model can be found here: https://pytorch.org/tutorials/beginner/blitz/cifar10_tutorial.html#sphx-glr-beginner-blitz-cifar10-tutorial-py\n  ",
+    "\n  ",
+    "**Note:**  This tutorial uses torchvision.  To download torchvision you can do one of the following:\n  ",
+    "- **Conda:** conda install torchvision -c pytorch\n  ",
+    "- **Pip:** pip3 install torchvision"
    ]
   },
   {

tutorials/Multimodal_VQA_Interpret.ipynb

@@ -14,7 +14,11 @@
     "In this notebook we demonstrate how to apply model interpretability algorithms from captum library on VQA models. More specifically we explain model predictions by applying integrated gradients on a small sample of image-question pairs. More details about Integrated gradients can be found in the original paper: https://arxiv.org/pdf/1703.01365.pdf\n",
     "\n",
     "As a reference VQA model we use the following open source implementation:\n",
-    "https://github.com/Cyanogenoid/pytorch-vqa"
+    "https://github.com/Cyanogenoid/pytorch-vqa\n  ",
+    "\n  ",
+    "**Note:**  This tutorial uses torchvision.  To download torchvision you can do one of the following:\n  ",
+    "- **Conda:** conda install torchvision -c pytorch\n  ",
+    "- **Pip:** pip3 install torchvision"
    ]
   },
   {

tutorials/Resnet_TorchVision_Interpret.ipynb

@@ -13,7 +13,11 @@
    "source": [
     "This notebook demonstrates how to apply model interpretability algorithms on pretrained ResNet model using a handpicked images and visualizes the attributions for each pixel by overlaying them on the image.\n",
     "\n",
-    "The interpretation algorithms that we use in this notebook are Integrated Gradients (w/o noise tunnel) and GradientShap. Noise tunnel allows to smoothen the attributions after adding gaussian noise to each input sample."
+    "The interpretation algorithms that we use in this notebook are Integrated Gradients (w/o noise tunnel) and GradientShap. Noise tunnel allows to smoothen the attributions after adding gaussian noise to each input sample.\n  ",
+    "\n  ",
+    "**Note:**  This tutorial uses torchvision.  To download torchvision you can do one of the following:\n  ",
+    "- **Conda:** conda install torchvision -c pytorch\n  ",
+    "- **Pip:** pip3 install torchvision"
    ]
   },
   {

website/pages/en/index.js

@@ -118,53 +118,51 @@ import torch
 import torch.nn as nn
 
 from captum.attr import (
-    GradientShap,
-    IntegratedGradients,
-    LayerConductance,
-    NeuronConductance,
-    NoiseTunnel,
+    IntegratedGradients
 )
 
 class ToyModel(nn.Module):
     def __init__(self):
         super().__init__()
-
-        self.lin1 = nn.Linear(3, 4)
-        self.lin1.weight = nn.Parameter(torch.ones(4, 3))
-        self.lin1.bias = nn.Parameter(torch.tensor([-10.0, 1.0, 1.0, 1.0]))
+        self.lin1 = nn.Linear(3, 3)
         self.relu = nn.ReLU()
-        self.lin2 = nn.Linear(4, 1)
-        self.lin2.weight = nn.Parameter(torch.ones(1, 4))
-        self.lin2.bias = nn.Parameter(torch.tensor([-3.0]))
+        self.lin2 = nn.Linear(3, 2)
+        self.sigmoid = nn.Sigmoid()
+
+        # initialize weights and biases
+        self.lin1.weight = nn.Parameter(torch.arange(0.0, 9.0).view(3, 3))
+        self.lin1.bias = nn.Parameter(torch.zeros(1,3))
+        self.lin2.weight = nn.Parameter(torch.arange(0.0, 6.0).view(2, 3))
+        self.lin2.bias = nn.Parameter(torch.ones(1,2))
 
     def forward(self, input):
-        lin1 = self.lin1(input)
-        relu = self.relu(lin1)
-        lin2 = self.lin2(relu)
-        return lin2
+        return self.sigmoid(self.lin2(self.relu(self.lin1(input))))
 
 
 model = ToyModel()
 model.eval()
-torch.manual_seed(123)
-np.random.seed(124)
     `;
     // Example for defining an acquisition function
     const defineInputBaseline = `${pre}python
 input = torch.rand(2, 3)
 baseline = torch.zeros(2, 3)
     `;
+
+    const randomSeedsDefinition = `${pre}python
+torch.manual_seed(123)
+np.random.seed(123)
+    `;
     // Example for optimizing candidates
     const instantiateApply = `${pre}python
 ig = IntegratedGradients(model)
-attributions, delta = ig.attribute(input, baseline)
-print('IG Attributions: ', attributions, ' Approximation error: ', delta)
+attributions, delta = ig.attribute(input, baseline, target=0, return_convergence_delta=True)
+print('IG Attributions: ', attributions, ' Convergence Delta: ', delta)
     `;
 
     const igOutput = `${pre}python
-IG Attributions:  tensor([[0.8883, 1.5497, 0.7550],
-                          [2.0657, 0.2219, 2.5996]])
-Approximation Error:  9.5367431640625e-07
+IG Attributions:  tensor([[0.0628, 0.1314, 0.0747],
+                          [0.0930, 0.0120, 0.1639]])
+Convergence Delta: tensor([0., 0.])
     `;
     //
     const QuickStart = () => (
@@ -186,6 +184,10 @@ Approximation Error:  9.5367431640625e-07
               <h4>Create and prepare model:</h4>
               <MarkdownBlock>{createModelExample}</MarkdownBlock>
             </li>
+            <li>
+              <h4>To make computations deterministic, let's fix random seeds:</h4>
+              <MarkdownBlock>{randomSeedsDefinition}</MarkdownBlock>
+            </li>
             <li>
               <h4>Define input and baseline tensors:</h4>
               <MarkdownBlock>{defineInputBaseline}</MarkdownBlock>

website/pages/tutorials/index.js

@@ -77,6 +77,10 @@ class TutorialHome extends React.Component {
                 Using Captum and Integrated Gradients we interpret the output of several test questions and analyze the attribution scores
                 of the text and visual parts of the model. Find the tutorial <a href="Multimodal_VQA_Interpret">here</a>.
 
+                <h4>Getting Started with Captum Insights:</h4>
+                This tutorial demonstrates how to use Captum Insights for a vision model in a notebook setting.  A simple pretrained torchvision
+                CNN model is loaded and then used on the CIFAR dataset.  Captum Insights is then loaded to visualize the interpretation of specific examples.
+                Find the tutorial <a href="CIFAR_TorchVision_Captum_Insights">here</a>.
               </p>
             </body>
           </div>

website/tutorials.json

@@ -18,6 +18,10 @@
     {
       "id": "Multimodal_VQA_Interpret",
       "title": "Intepreting multimodal models"
+    },
+    {
+      "id": "CIFAR_TorchVision_Captum_Insights",
+      "title": "Getting started with Captum Insights"
     }
   ]
 }