tutorials/PytorchCaffe2SuperResolution.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Transfering a model from PyTorch to Caffe2 and Mobile using ONNX"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this tutorial, we describe how to use ONNX to convert a model defined\n",
    "in PyTorch into the ONNX format and then load it into Caffe2. Once in\n",
    "Caffe2, we can run the model to double-check it was exported correctly,\n",
    "and we then show how to use Caffe2 features such as mobile exporter for\n",
    "executing the model on mobile devices.\n",
    "\n",
    "For this tutorial, you will need to install [onnx](https://github.com/onnx/onnx),\n",
    "and [Caffe2](https://caffe2.ai/).\n",
    "You can get binary builds of onnx with\n",
    "``conda install -c conda-forge onnx``.\n",
    "\n",
    "``NOTE``: This tutorial needs PyTorch master branch which can be installed by following\n",
    "[the instructions here](https://github.com/pytorch/pytorch#from-source)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Some standard imports\n",
    "import io\n",
    "import numpy as np\n",
    "\n",
    "from torch import nn\n",
    "from torch.autograd import Variable\n",
    "import torch.utils.model_zoo as model_zoo\n",
    "import torch.onnx\n",
    "\n",
    "import onnx\n",
    "import caffe2.python.onnx.backend"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Super-resolution is a way of increasing the resolution of images, videos and is widely used in image processing or video editing. For this tutorial, we will first use a small super-resolution model with a dummy input.  \n",
    "\n",
    "\n",
    "First, let's create a SuperResolution model in PyTorch. [This model](https://github.com/pytorch/examples/blob/master/super_resolution/model.py) comes directly from PyTorch's examples without modification:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Super Resolution model definition in PyTorch\n",
    "import torch.nn as nn\n",
    "import torch.nn.init as init\n",
    "\n",
    "\n",
    "class SuperResolutionNet(nn.Module):\n",
    "    def __init__(self, upscale_factor, inplace=False):\n",
    "        super(SuperResolutionNet, self).__init__()\n",
    "\n",
    "        self.relu = nn.ReLU(inplace=inplace)\n",
    "        self.conv1 = nn.Conv2d(1, 64, (5, 5), (1, 1), (2, 2))\n",
    "        self.conv2 = nn.Conv2d(64, 64, (3, 3), (1, 1), (1, 1))\n",
    "        self.conv3 = nn.Conv2d(64, 32, (3, 3), (1, 1), (1, 1))\n",
    "        self.conv4 = nn.Conv2d(32, upscale_factor ** 2, (3, 3), (1, 1), (1, 1))\n",
    "        self.pixel_shuffle = nn.PixelShuffle(upscale_factor)\n",
    "\n",
    "        self._initialize_weights()\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.relu(self.conv1(x))\n",
    "        x = self.relu(self.conv2(x))\n",
    "        x = self.relu(self.conv3(x))\n",
    "        x = self.pixel_shuffle(self.conv4(x))\n",
    "        return x\n",
    "\n",
    "    def _initialize_weights(self):\n",
    "        init.orthogonal(self.conv1.weight, init.calculate_gain('relu'))\n",
    "        init.orthogonal(self.conv2.weight, init.calculate_gain('relu'))\n",
    "        init.orthogonal(self.conv3.weight, init.calculate_gain('relu'))\n",
    "        init.orthogonal(self.conv4.weight)\n",
    "\n",
    "# Create the super-resolution model by using the above model definition.\n",
    "torch_model = SuperResolutionNet(upscale_factor=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ordinarily, you would now train this model; however, for this tutorial, we will instead download some pre-trained weights. Note that this model was not trained fully for good accuracy and is used here for demonstration purposes only."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SuperResolutionNet(\n",
       "  (relu): ReLU()\n",
       "  (conv1): Conv2d (1, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "  (conv2): Conv2d (64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (conv3): Conv2d (64, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (conv4): Conv2d (32, 9, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (pixel_shuffle): PixelShuffle(upscale_factor=3)\n",
       ")"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Load pretrained model weights\n",
    "model_url = 'https://s3.amazonaws.com/pytorch/test_data/export/superres_epoch100-44c6958e.pth'\n",
    "batch_size = 1    # just a random number\n",
    "\n",
    "# Initialize model with the pretrained weights\n",
    "torch_model.load_state_dict(model_zoo.load_url(model_url))\n",
    "\n",
    "# set the train mode to false since we will only run the forward pass.\n",
    "torch_model.train(False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Exporting a model in PyTorch works via tracing. To export a model, you call the `torch.onnx._export()` function. This will execute the model, recording a trace of what operators are used to compute the outputs. Because `_export` runs the model, we need provide an input tensor `x`. The values in this tensor are not important; it can be an image or a random tensor as long as it is the right size.\n",
    "\n",
    "To learn more details about PyTorch's export interface, check out the\n",
    "[torch.onnx documentation](http://pytorch.org/docs/master/onnx.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Input to the model\n",
    "x = Variable(torch.randn(batch_size, 1, 224, 224), requires_grad=True)\n",
    "\n",
    "# Export the model\n",
    "torch_out = torch.onnx._export(torch_model,             # model being run \n",
    "                               x,                       # model input (or a tuple for multiple inputs) \n",
    "                               \"super_resolution.onnx\", # where to save the model (can be a file or file-like object)\n",
    "                               export_params=True)      # store the trained parameter weights inside the model file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`torch_out` is the output after executing the model. Normally you can ignore this output, but here we will use it to verify that the model we exported computes the same values when run in Caffe2.\n",
    "\n",
    "\n",
    "Now let's take the ONNX representation and use it in Caffe2. This part can normally be done in a separate process or on another machine, but we will continue in the same process so that we can verify that Caffe2 and PyTorch are computing the same value for the network:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exported model has been executed on Caffe2 backend, and the result looks good!\n"
     ]
    }
   ],
   "source": [
    "# Load the ONNX GraphProto object. Graph is a standard Python protobuf object\n",
    "model = onnx.load(\"super_resolution.onnx\")\n",
    "\n",
    "# prepare the caffe2 backend for executing the model this converts the ONNX model into a \n",
    "# Caffe2 NetDef that can execute it. Other ONNX backends, like one for CNTK will be \n",
    "# availiable soon.\n",
    "prepared_backend = caffe2.python.onnx.backend.prepare(model)\n",
    "\n",
    "# run the model in Caffe2\n",
    "\n",
    "# Construct a map from input names to Tensor data.\n",
    "# The graph of the model itself contains inputs for all weight parameters, after the input image.\n",
    "# Since the weights are already embedded, we just need to pass the input image.\n",
    "# Set the first input\n",
    "W = {model.graph.input[0].name: x.data.numpy()}\n",
    "\n",
    "# Run the Caffe2 net:\n",
    "c2_out = prepared_backend.run(W)[0]\n",
    "\n",
    "# Verify the numerical correctness upto 3 decimal places\n",
    "np.testing.assert_almost_equal(torch_out.data.cpu().numpy(), c2_out, decimal=3)\n",
    "\n",
    "print(\"Exported model has been executed on Caffe2 backend, and the result looks good!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We should see that the output of PyTorch and Caffe2 runs match numerically up to 3 decimal places. As a side-note, if they do not match then there is an issue that the operators in Caffe2 and PyTorch are implemented differently and please contact us in that case."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Transfering SRResNet using ONNX"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the same process as above, we also transferred an interesting new model \"SRResNet\" for super-resolution presented in [this paper](https://arxiv.org/pdf/1609.04802.pdf) (thanks to the authors at Twitter for providing us code and pretrained parameters for the purpose of this tutorial). The model definition and a pre-trained model can be found [here](https://gist.github.com/prigoyal/b245776903efbac00ee89699e001c9bd). Below is what SRResNet model input, output looks like.\n",
    "![SRResNet](SRResNet.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Running the model on mobile devices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So far we have exported a model from PyTorch and shown how to load it and run it in Caffe2. Now that the model is loaded in Caffe2, we can convert it into a format suitable for [running on mobile devices](https://caffe2.ai/docs/mobile-integration.html).\n",
    "\n",
    "We will use Caffe2's [mobile_exporter](https://github.com/caffe2/caffe2/blob/master/caffe2/python/predictor/mobile_exporter.py) to generate the two model protobufs that can run on mobile. The first is used to initialize the network with the correct weights, and the second actual runs executes the model. We will continue to use the small super-resolution model for the rest of this tutorial."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# extract the workspace and the graph proto from the internal representation\n",
    "c2_workspace = prepared_backend.workspace\n",
    "c2_net_def = prepared_backend.predict_net\n",
    "\n",
    "# Now import the caffe2 mobile exporter\n",
    "from caffe2.python.predictor import mobile_exporter\n",
    "\n",
    "# TODO: remove two lines below - my caffe2 is not up-to-date and there was fix pushed for exporter\n",
    "from caffe2.python import core\n",
    "cnet = core.Net(c2_net_def)\n",
    "\n",
    "# call the Export to get the predict_net, init_net. These nets are needed for running things on mobile\n",
    "init_net, predict_net = mobile_exporter.Export(c2_workspace, cnet, c2_net_def.external_input)\n",
    "\n",
    "# Let's also save the init_net and predict_net to a file that we will later use for running them on mobile\n",
    "with open('init_net.pb', \"wb\") as fopen:\n",
    "    fopen.write(init_net.SerializeToString())\n",
    "with open('predict_net.pb', \"wb\") as fopen:\n",
    "    fopen.write(predict_net.SerializeToString())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`init_net` has the model parameters and the model input embedded in it and `predict_net` will be used to guide the `init_net` execution at run-time. In this tutorial, we will use the `init_net` and `predict_net` generated above and run them in both normal Caffe2 backend and mobile and verify that the output high-resolution cat image produced in both runs is the same.\n",
    "\n",
    "For this tutorial, we will use a famous cat image used widely which looks like below\n",
    "\n",
    "![cat](cat_224x224.jpg)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "net_drawer will not run correctly. Please install the correct dependencies.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "No handlers could be found for logger \"caffe2.python.net_drawer\"\n"
     ]
    }
   ],
   "source": [
    "# Some standard imports\n",
    "from caffe2.proto import caffe2_pb2\n",
    "from caffe2.python import core, net_drawer, net_printer, visualize, workspace, utils\n",
    "\n",
    "import numpy as np\n",
    "import os\n",
    "import subprocess\n",
    "from PIL import Image\n",
    "from matplotlib import pyplot\n",
    "from skimage import io, transform"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, let's load the image, pre-process it using standard skimage python library. Note that this preprocessing is the standard practice of processing data for training/testing neural networks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load the image\n",
    "img_in = io.imread(\"cat.jpg\")\n",
    "\n",
    "# resize the image to dimensions 224x224 \n",
    "img = transform.resize(img_in, [224, 224])\n",
    "\n",
    "# save this resized image to be used as input to the model\n",
    "io.imsave(\"cat_224x224.jpg\", img)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, as a next step, let's take the resized cat image and run the super-resolution model in Caffe2 backend and save the output image. The image processing steps below have been adopted from PyTorch implementation of super-resolution model [here](https://github.com/pytorch/examples/blob/master/super_resolution/super_resolve.py)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch-jit-export = core.Net('torch-jit-export')\n",
      "torch-jit-export.Conv(['0', '1'], ['9'], dilations=[1L, 1L], strides=[1L, 1L], pads=[2L, 2L, 2L, 2L], group=1, kernels=[5L, 5L])\n",
      "torch-jit-export.Add(['9', '2'], ['10'], broadcast=1, axis=1)\n",
      "torch-jit-export.Relu(['10'], ['11'])\n",
      "torch-jit-export.Conv(['11', '3'], ['12'], dilations=[1L, 1L], strides=[1L, 1L], pads=[1L, 1L, 1L, 1L], group=1, kernels=[3L, 3L])\n",
      "torch-jit-export.Add(['12', '4'], ['13'], broadcast=1, axis=1)\n",
      "torch-jit-export.Relu(['13'], ['14'])\n",
      "torch-jit-export.Conv(['14', '5'], ['15'], dilations=[1L, 1L], strides=[1L, 1L], pads=[1L, 1L, 1L, 1L], group=1, kernels=[3L, 3L])\n",
      "torch-jit-export.Add(['15', '6'], ['16'], broadcast=1, axis=1)\n",
      "torch-jit-export.Relu(['16'], ['17'])\n",
      "torch-jit-export.Conv(['17', '7'], ['18'], dilations=[1L, 1L], strides=[1L, 1L], pads=[1L, 1L, 1L, 1L], group=1, kernels=[3L, 3L])\n",
      "torch-jit-export.Add(['18', '8'], ['19'], broadcast=1, axis=1)\n",
      "torch-jit-export.Reshape(['19'], ['20', 'OC2_DUMMY_0'], shape=[1L, 1L, 3L, 3L, 224L, 224L])\n",
      "torch-jit-export.Transpose(['20'], ['21'], axes=[0L, 1L, 4L, 2L, 5L, 3L])\n",
      "torch-jit-export.Reshape(['21'], ['22', 'OC2_DUMMY_1'], shape=[1L, 1L, 672L, 672L])\n",
      "Input blob:  0\n",
      "Output blob:  22\n"
     ]
    }
   ],
   "source": [
    "# load the resized image and convert it to Ybr format\n",
    "img = Image.open(\"cat_224x224.jpg\")\n",
    "img_ycbcr = img.convert('YCbCr')\n",
    "img_y, img_cb, img_cr = img_ycbcr.split()\n",
    "\n",
    "# Let's run the mobile nets that we generated above so that caffe2 workspace is properly initialized\n",
    "workspace.RunNetOnce(init_net)\n",
    "workspace.RunNetOnce(predict_net)\n",
    "\n",
    "# Caffe2 has a nice net_printer to be able to inspect what the net looks like and identify\n",
    "# what our input and output blob names are.\n",
    "print(net_printer.to_string(predict_net))\n",
    "\n",
    "model_input_blob = predict_net.external_input[0]\n",
    "model_output_blob = predict_net.external_output[-1]\n",
    "print 'Input blob: ', model_input_blob\n",
    "print 'Output blob: ', model_output_blob"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From the above output, we can see that input and outputs are named with numbers (it is a little bit weird that we will have numbers as blob names but this is because the tracing JIT produces numbered entries for the models)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Now, let's also pass in the resized cat image for processing by the model.\n",
    "workspace.FeedBlob(model_input_blob, np.array(img_y)[np.newaxis, np.newaxis, :, :].astype(np.float32))\n",
    "\n",
    "# run the predict_net to get the model output\n",
    "workspace.RunNetOnce(predict_net)\n",
    "\n",
    "# Now let's get the model output blob\n",
    "img_out = workspace.FetchBlob(model_output_blob)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we'll refer back to the post-processing steps in PyTorch implementation of super-resolution model [here](https://github.com/pytorch/examples/blob/master/super_resolution/super_resolve.py) to construct back the final output image and save the image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "img_out_y = Image.fromarray(np.uint8((img_out[0,0]).clip(0, 255)), mode='L')\n",
    "\n",
    "# get the output image follow post-processing step from PyTorch implementation\n",
    "final_img = Image.merge(\n",
    "    \"YCbCr\", [\n",
    "        img_out_y,\n",
    "        img_cb.resize(img_out_y.size, Image.BICUBIC),\n",
    "        img_cr.resize(img_out_y.size, Image.BICUBIC),\n",
    "    ]).convert(\"RGB\")\n",
    "\n",
    "# Save the image, we will compare this with the output image from mobile device\n",
    "final_img.save(\"cat_superres.jpg\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's see how the image looks like:\n",
    "\n",
    "![cat_superres](cat_superres.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have finished running our mobile nets in pure Caffe2 backend and now, let's execute the model on an Android device and get the model output.\n",
    "\n",
    "`NOTE`: for Android development, `adb` shell is needed otherwise the following section of tutorial will not run.\n",
    "\n",
    "\n",
    "In our first step of runnig model on mobile, we will push a native speed benchmark binary for mobile device to adb. This binary can execute the model on mobile and also export the model output that we can retrieve later. The binary is available [here](https://github.com/caffe2/caffe2/blob/master/caffe2/binaries/speed_benchmark.cc). In order to build the binary, execute the `build_android.sh` script following the instructions [here](https://github.com/caffe2/caffe2/blob/master/scripts/build_android.sh). \n",
    "\n",
    "`NOTE`: You need to have `ANDROID_NDK` installed and set your env variable `ANDROID_NDK=path to ndk root`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# let's first push a bunch of stuff to adb, specify the path for the binary\n",
    "CAFFE2_MOBILE_BINARY = ('caffe2/binaries/speed_benchmark')\n",
    "\n",
    "# we had saved our init_net and proto_net in steps above, we use them now. \n",
    "# Push the binary and the model protos\n",
    "os.system('adb push ' + CAFFE2_MOBILE_BINARY + ' /data/local/tmp/')\n",
    "os.system('adb push init_net.pb /data/local/tmp')\n",
    "os.system('adb push predict_net.pb /data/local/tmp')\n",
    "\n",
    "# Let's serialize the input image blob to a blob proto and then send it to mobile for execution.\n",
    "with open(\"input.blobproto\", \"wb\") as fid:\n",
    "    fid.write(workspace.SerializeBlob(\"9\"))\n",
    "\n",
    "# push the input image blob to adb \n",
    "os.system('adb push input.blobproto /data/local/tmp/')\n",
    "\n",
    "# Now we run the net on mobile, look at the speed_benchmark --help for what various options mean\n",
    "os.system(\n",
    "    'adb shell /data/local/tmp/speed_benchmark '                     # binary to execute\n",
    "    '--init_net=/data/local/tmp/super_resolution_mobile_init.pb '    # mobile init_net\n",
    "    '--net=/data/local/tmp/super_resolution_mobile_predict.pb '      # mobile predict_net\n",
    "    '--input=9 '                                                     # name of our input image blob\n",
    "    '--input_file=/data/local/tmp/input.blobproto '                  # serialized input image \n",
    "    '--output_folder=/data/local/tmp '                               # destination folder for saving mobile output\n",
    "    '--output=27,9 '                                                 # output blobs we are interested in\n",
    "    '--iter=1 '                                                      # number of net iterations to execute\n",
    "    '--caffe2_log_level=0 '\n",
    ")\n",
    "\n",
    "# get the model output from adb and save to a file\n",
    "os.system('adb pull /data/local/tmp/27 ./output.blobproto')\n",
    "\n",
    "\n",
    "# We can recover the output content and post-process the model using same steps as we followed earlier\n",
    "blob_proto = caffe2_pb2.BlobProto()\n",
    "blob_proto.ParseFromString(open('./output.blobproto').read())\n",
    "img_out = utils.Caffe2TensorToNumpyArray(blob_proto.tensor)\n",
    "img_out_y = Image.fromarray(np.uint8((img_out[0,0]).clip(0, 255)), mode='L')\n",
    "final_img = Image.merge(\n",
    "    \"YCbCr\", [\n",
    "        img_out_y,\n",
    "        img_cb.resize(img_out_y.size, Image.BICUBIC),\n",
    "        img_cr.resize(img_out_y.size, Image.BICUBIC),\n",
    "    ]).convert(\"RGB\")\n",
    "final_img.save(\"cat_superres_mobile.jpg\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, you can compare the image `cat_superres.jpg` (model output from pure caffe2 backend execution) and `cat_superres_mobile.jpg` (model output from mobile execution) and see that both the images look same. If they don't look same, something went wrong with execution on mobile and in that case, please contact Caffe2 community. You should expect to see the output image to look like following:\n",
    "\n",
    "![output_cat](cat_output1.png)\n",
    "\n",
    "\n",
    "Using the above steps, you can deploy your models on mobile easily. Also, for more information on caffe2 mobile backend, checkout [caffe2-android-demo](https://caffe2.ai/docs/AI-Camera-demo-android.html)."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}