Full Code of ZhouYanzhao/ORN for AI

Repository: ZhouYanzhao/ORN
Branch: master
Commit: 8c3969a71255
Files: 3
Total size: 147.3 KB

Directory structure:
gitextract_8s0okaqe/

├── LICENSE
├── README.md
└── classify.ipynb

================================================
FILE CONTENTS
================================================

================================================
FILE: LICENSE
================================================
BSD 3-Clause License

Copyright (c) 2017, Yanzhao Zhou
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

* Redistributions of source code must retain the above copyright notice, this
  list of conditions and the following disclaimer.

* Redistributions in binary form must reproduce the above copyright notice,
  this list of conditions and the following disclaimer in the documentation
  and/or other materials provided with the distribution.

* Neither the name of the copyright holder nor the names of its
  contributors may be used to endorse or promote products derived from
  this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

================================================
FILE: README.md
================================================
# Oriented Response Networks
[![](https://img.shields.io/badge/torch-V1.0-green.svg)](https://github.com/ZhouYanzhao/ORN/tree/torch) [![](https://img.shields.io/badge/pytorch-alpha-blue.svg)](https://github.com/ZhouYanzhao/ORN/tree/pytorch-v2) [![](https://img.shields.io/badge/caffe-alpha-red.svg)](https://github.com/ZhouYanzhao/ORN/tree/caffe)

[[Home]](http://yzhou.work) [[Project]](http://yzhou.work/ORN) [[Paper]](https://arxiv.org/pdf/1701.01833) [[Supp]](http://yzhou.work/ORN/Supplementary.pdf) [[Poster]](http://yzhou.work/ORN/0160_POSTER.pdf)

![illustration](illustration.png)

## 🎉Update: Reimplemented ORN that supports modern PyTorch.
* Tested with PyTorch 1.12.0 (Ubuntu / GTX 2080 Ti)
* A New helper function `upgrade_to_orn` for easy model conversion.
* Predefined ORN-upgraded models (OR-VGG, OR-ResNet, OR-Inception, OR-WRN, etc.).

Please check the [pytorch-v2 branch](https://github.com/ZhouYanzhao/ORN/tree/pytorch-v2) for more details.

## Torch Implementation
The [torch branch](https://github.com/ZhouYanzhao/ORN/tree/torch) contains:

* the official **torch** implementation of ORN.
* the **MNIST-Variants** demo.

Please follow the instruction below to install it and run the experiment demo.

### Prerequisites
* Linux (tested on ubuntu 14.04LTS)
* NVIDIA GPU + CUDA CuDNN (CPU mode and CUDA without CuDNN mode are also available but significantly slower)
* [Torch7](http://torch.ch/docs/getting-started.html)

### Getting started
You can setup everything via a single command `wget -O - https://git.io/vHCMI | bash` **or** do it manually in case something goes wrong:

1. install the dependencies (required by the demo code):
    * [torchnet](https://github.com/torchnet/torchnet): `luarocks install torchnet`
    * [optnet](https://github.com/fmassa/optimize-net): `luarocks install optnet`

2. clone the torch branch: 

    ```bash
    # git version must be greater than 1.9.10
    git clone https://github.com/ZhouYanzhao/ORN.git -b torch --single-branch ORN.torch
    cd ORN.torch
    export DIR=$(pwd)
    ```

3. install ORN: 

    ```bash
    cd $DIR/install
    # install the CPU/GPU/CuDNN version ORN.
    bash install.sh
    ```

4. unzip the MNIST dataset:

    ```bash
    cd $DIR/demo/datasets
    unzip MNIST
    ```

5. run the MNIST-Variants demo:

    ```bash
    cd $DIR/demo
    # you can modify the script to test different hyper-parameters
    bash ./scripts/Train_MNIST.sh
    ```

### Trouble shooting
If you run into `'cudnn.find' not found`, update Torch7 to the latest version via `cd <TORCH_DIR> && bash ./update.sh` then re-install everything.

### More experiments

**CIFAR 10/100**

You can train the [OR-WideResNet](https://gist.github.com/ZhouYanzhao/c7f75cd8ea3c92e2044d71ac7bc30fab/raw/or-wrn.lua) model (converted from WideResNet by simply replacing Conv layers with ORConv layers) on CIFAR dataset with [WRN](https://github.com/szagoruyko/wide-residual-networks).
```bash
dataset=cifar10_original.t7 model=or-wrn widen_factor=4 depth=40 ./scripts/train_cifar.sh
```
With exactly the same settings, ORN-augmented WideResNet achieves state-of-the-art result while using significantly fewer parameters.

![CIFAR](CIFAR.png)

Network          | Params   | CIFAR-10 (ZCA) | CIFAR-10 (mean/std) | CIFAR-100 (ZCA) | CIFAR-100 (mean/std) 
-----------------|:--------:|:--------------:|:-------------------:|:---------------:|:--------------------:
DenseNet-100-12-dropout | 7.0M     | -    | 4.10 | -  | 20.20 |
DenseNet-190-40-dropout | 25.6M    | -    | 3.46 | -  | 17.18 |
WRN-40-4         | 8.9M     | 4.97 | 4.53 | 22.89 | 21.18 |
WRN-28-10-dropout| 36.5M    | 4.17 | 3.89 | 20.50 | 18.85 |
WRN-40-10-dropout| 55.8M    | -    | 3.80 | -  | 18.3  |
ORN-40-4(1/2)    | 4.5M     | 4.13 | 3.43 | 21.24 | 18.82 |
ORN-28-10(1/2)-dropout | 18.2M | 3.52 | **2.98** | 19.22 | **16.15** |

Table.1 Test error (%) on CIFAR10/100 dataset with flip/translation augmentation) 

**ImageNet**

![ILSVRC2012](ILSVRC2012.png)

The effectiveness of ORN is further verified on large scale data. The OR-ResNet-18 model upgraded from [ResNet-18](https://github.com/facebook/fb.resnet.torch) yields significant better performance when using similar parameters.

| Network      | Params | Top1-Error | Top5-Error |
|--------------|:------:|:----------:|:----------:|
| ResNet-18    |  11.7M |   30.614   |    10.98   |
| OR-ResNet-18 |  11.4M |   **28.916**   |    **9.88**    |

Table.2 Validation error (%) on ILSVRC-2012 dataset.

You can use [facebook.resnet.torch](https://github.com/facebook/fb.resnet.torch) to train the [OR-ResNet-18](https://gist.github.com/ZhouYanzhao/c7f75cd8ea3c92e2044d71ac7bc30fab/raw/or-resnet.lua) model from scratch or finetune it on your data by using the [pre-trained weights](https://1drv.ms/u/s!Avhhrlo9ASwciWcEjJ_KWBgTWWyg).

```lua
-- To fill the model with the pre-trained weights:
model = require('or-resnet.lua')({tensorType='torch.CudaTensor', pretrained='or-resnet18_weights.t7'})
```

A more specific demo notebook of using the pre-trained OR-ResNet to classify images can be found [here](classify.ipynb).

## ~~PyTorch Implementation (Deprecated)~~
**Please check the [pytorch-v2 branch](https://github.com/ZhouYanzhao/ORN/tree/pytorch-v2) for more details.**

The [pytorch branch](https://github.com/ZhouYanzhao/ORN/tree/pytorch) contains:

* the official **pytorch** implementation of ORN *(alpha version supports 1x1/3x3 ARFs with 4/8 orientation channels only)*.
* the **MNIST-Variants** demo.

Please follow the instruction below to install it and run the experiment demo.

### Prerequisites
* Linux (tested on ubuntu 14.04LTS)
* NVIDIA GPU + CUDA CuDNN (CPU mode and CUDA without CuDNN mode are also available but significantly slower)
* [PyTorch](http://pytorch.org)

### Getting started

1. install the dependencies (required by the demo code):
    * [tqdm](https://github.com/noamraph/tqdm): `pip install tqdm`
    * [pillow](https://python-pillow.org): `pip install Pillow`

2. clone the pytorch branch: 

    ```bash
    # git version must be greater than 1.9.10
    git clone https://github.com/ZhouYanzhao/ORN.git -b pytorch --single-branch ORN.pytorch
    cd ORN.pytorch
    export DIR=$(pwd)
    ```

3. install ORN: 

    ```bash
    cd $DIR/install
    bash install.sh
    ```

4. run the MNIST-Variants demo:

    ```bash
    cd $DIR/demo
    # train ORN on MNIST-rot
    python main.py --use-arf
    # train baseline CNN
    python main.py
    ```

## Caffe Implementation 
The [caffe branch](https://github.com/ZhouYanzhao/ORN/tree/caffe) contains:

* the official **caffe** implementation of ORN *(alpha version supports 1x1/3x3 ARFs with 4/8 orientation channels only)*.
* the **MNIST-Variants** demo.

Please follow the instruction below to install it and run the experiment demo.

### Prerequisites
* Linux (tested on ubuntu 14.04LTS)
* NVIDIA GPU + CUDA CuDNN (CPU mode and CUDA without CuDNN mode are also available but significantly slower)
* [Caffe](http://caffe.berkeleyvision.org/)

### Getting started

1. install the dependency (required by the demo code):
    * [idx2numpy](https://github.com/ivanyu/idx2numpy): `pip install idx2numpy`

2. clone the caffe branch: 

    ```bash
    # git version must be greater than 1.9.10
    git clone https://github.com/ZhouYanzhao/ORN.git -b caffe --single-branch ORN.caffe
    cd ORN.caffe
    export DIR=$(pwd)
    ```

3. install ORN: 

    ```bash
    # modify Makefile.config first
    # compile ORN.caffe
    make clean && make -j"$(nproc)" all
    ```

4. run the MNIST-Variants demo:

    ```bash
    cd $DIR/examples/mnist
    bash get_mnist.sh
    # train ORN & CNN on MNIST-rot
    bash train.sh
    ```

### Note
Due to implementation differences,
* upgrading Conv layers to ORConv layers can be done by adding an `orn_param`
* num_output of ORConv layers should be multipied by nOrientation of ARFs

Example:
```YAML
layer {
  type: "Convolution"
  name: "ORConv" bottom: "Data" top: "ORConv"
  # add this line to replace regular filters with ARFs
  orn_param {orientations: 8}
  param { lr_mult: 1 decay_mult: 2}
  convolution_param {
    # this means 10 ARF feature maps
    num_output: 80
    kernel_size: 3
    stride: 1
    pad: 0
    weight_filler { type: "msra"}
    bias_filler { type: "constant" value: 0}
  }
}
```
Check the MNIST demo [prototxt](https://github.com/ZhouYanzhao/ORN/blob/caffe/examples/mnist/orn.prototxt) (and its [visualization](http://ethereon.github.io/netscope/#/gist/c7f75cd8ea3c92e2044d71ac7bc30fab)) for more details. 

## Citation 
If you use the code in your research, please cite:
```bibtex
@INPROCEEDINGS{Zhou2017ORN,
    author = {Zhou, Yanzhao and Ye, Qixiang and Qiu, Qiang and Jiao, Jianbin},
    title = {Oriented Response Networks},
    booktitle = {CVPR},
    year = {2017}
}
```


================================================
FILE: classify.ipynb
================================================
{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## OR-ResNet-18 Classification Demo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Download the [model definition](https://gist.github.com/ZhouYanzhao/c7f75cd8ea3c92e2044d71ac7bc30fab/raw/or-resnet.lua), the [pre-trained weights](https://1drv.ms/u/s!Avhhrlo9ASwciWcEjJ_KWBgTWWyg) and the [ImageNet-labels](https://gist.github.com/ZhouYanzhao/c7f75cd8ea3c92e2044d71ac7bc30fab/raw/imagenet_labels.lua)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "require 'orn'\n",
    "require 'image'\n",
    "labels = require './imagenet_labels'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       " | OR-ResNet-18 ImageNet\t\n"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "nn.Sequential {\n",
       "  [input -> (1) -> (2) -> (3) -> (4) -> (5) -> (6) -> (7) -> (8) -> (9) -> (10) -> (11) -> (12) -> (13) -> (14) -> (15) -> (16) -> output]\n",
       "  (1): cudnn.SpatialConvolution(3 -> 64, 3x3, 1,1, 1,1) without bias\n",
       "  (2): cudnn.SpatialBatchNormalization\n",
       "  (3): cudnn.ReLU\n",
       "  (4): cudnn.SpatialConvolution(64 -> 64, 3x3, 2,2, 1,1) without bias\n",
       "  (5): cudnn.SpatialBatchNormalization\n",
       "  (6): cudnn.ReLU\n",
       "  (7): nn.SpatialMaxPooling(3x3, 2,2, 1,1)\n",
       "  (8): nn.Sequential {\n",
       "    [input -> (1) -> (2) -> output]\n",
       "    (1): nn.Sequential {\n",
       "      [input -> (1) -> (2) -> (3) -> output]\n",
       "      (1): nn.ConcatTable {\n",
       "        input\n",
       "          |`-> (1): nn.Sequential {\n",
       "          |      [input -> (1) -> (2) -> (3) -> (4) -> (5) -> output]\n",
       "          |      (1): cudnn.ORConv([1-4] 64 -> 32, 3x3, 1,1, 1,1) without bias, fast mode\n",
       "          |      (2): cudnn.SpatialBatchNormalization\n",
       "          |      (3): cudnn.ReLU\n",
       "          |      (4): cudnn.ORConv([4] 32 -> 32, 3x3, 1,1, 1,1) without bias, fast mode\n",
       "          |      (5): cudnn.SpatialBatchNormalization\n",
       "          |    }\n",
       "           `-> (2): nn.Sequential {\n",
       "                 [input -> (1) -> (2) -> output]\n",
       "                 (1): cudnn.ORConv([1-4] 64 -> 32, 1x1) without bias, fast mode\n",
       "                 (2): cudnn.SpatialBatchNormalization\n",
       "               }\n",
       "           ... -> output\n",
       "      }\n",
       "      (2): nn.CAddTable\n",
       "      (3): cudnn.ReLU\n",
       "    }\n",
       "    (2): nn.Sequential {\n",
       "      [input -> (1) -> (2) -> (3) -> output]\n",
       "      (1): nn.ConcatTable {\n",
       "        input\n",
       "          |`-> (1): nn.Sequential {\n",
       "          |      [input -> (1) -> (2) -> (3) -> (4) -> (5) -> output]\n",
       "          |      (1): cudnn.ORConv([4] 32 -> 32, 3x3, 1,1, 1,1) without bias, fast mode\n",
       "          |      (2): cudnn.SpatialBatchNormalization\n",
       "          |      (3): cudnn.ReLU\n",
       "          |      (4): cudnn.ORConv([4] 32 -> 32, 3x3, 1,1, 1,1) without bias, fast mode\n",
       "          |      (5): cudnn.SpatialBatchNormalization\n",
       "          |    }\n",
       "           `-> (2): nn.Identity\n",
       "           ... -> output\n",
       "      }\n",
       "      (2): nn.CAddTable\n",
       "      (3): cudnn.ReLU\n",
       "    }\n",
       "  }\n",
       "  (9): nn.Sequential {\n",
       "    [input -> (1) -> (2) -> output]\n",
       "    (1): nn.Sequential {\n",
       "      [input -> (1) -> (2) -> (3) -> output]\n",
       "      (1): nn.ConcatTable {\n",
       "        input\n",
       "          |`-> (1): nn.Sequential {\n",
       "          |      [input -> (1) -> (2) -> (3) -> (4) -> (5) -> output]\n",
       "          |      (1): cudnn.ORConv([4] 32 -> 64, 3x3, 2,2, 1,1) without bias, fast mode\n",
       "          |      (2): cudnn.SpatialBatchNormalization\n",
       "          |      (3): cudnn.ReLU\n",
       "          |      (4): cudnn.ORConv([4] 64 -> 64, 3x3, 1,1, 1,1) without bias, fast mode\n",
       "          |      (5): cudnn.SpatialBatchNormalization\n",
       "          |    }\n",
       "           `-> (2): nn.Sequential {\n",
       "                 [input -> (1) -> (2) -> output]\n",
       "                 (1): cudnn.ORConv([4] 32 -> 64, 1x1, 2,2) without bias, fast mode\n",
       "                 (2): cudnn.SpatialBatchNormalization\n",
       "               }\n",
       "           ... -> output\n",
       "      }\n",
       "      (2): nn.CAddTable\n",
       "      (3): cudnn.ReLU\n",
       "    }\n",
       "    (2): nn.Sequential {\n",
       "      [input -> (1) -> (2) -> (3) -> output]\n",
       "      (1): nn.ConcatTable {\n",
       "        input\n",
       "          |`-> (1): nn.Sequential {\n",
       "          |      [input -> (1) -> (2) -> (3) -> (4) -> (5) -> output]\n",
       "          |      (1): cudnn.ORConv([4] 64 -> 64, 3x3, 1,1, 1,1) without bias, fast mode\n",
       "          |      (2): cudnn.SpatialBatchNormalization\n",
       "          |      (3): cudnn.ReLU\n",
       "          |      (4): cudnn.ORConv([4] 64 -> 64, 3x3, 1,1, 1,1) without bias, fast mode\n",
       "          |      (5): cudnn.SpatialBatchNormalization\n",
       "          |    }\n",
       "           `-> (2): nn.Identity\n",
       "           ... -> output\n",
       "      }\n",
       "      (2): nn.CAddTable\n",
       "      (3): cudnn.ReLU\n",
       "    }\n",
       "  }\n",
       "  (10): nn.Sequential {\n",
       "    [input -> (1) -> (2) -> output]\n",
       "    (1): nn.Sequential {\n",
       "      [input -> (1) -> (2) -> (3) -> output]\n",
       "      (1): nn.ConcatTable {\n",
       "        input\n",
       "          |`-> (1): nn.Sequential {\n",
       "          |      [input -> (1) -> (2) -> (3) -> (4) -> (5) -> output]\n",
       "          |      (1): cudnn.ORConv([4] 64 -> 128, 3x3, 2,2, 1,1) without bias, fast mode\n",
       "          |      (2): cudnn.SpatialBatchNormalization\n",
       "         "
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       " |      (3): cudnn.ReLU\n",
       "          |      (4): cudnn.ORConv([4] 128 -> 128, 3x3, 1,1, 1,1) without bias, fast mode\n",
       "          |      (5): cudnn.SpatialBatchNormalization\n",
       "          |    }\n",
       "           `-> (2): nn.Sequential {\n",
       "                 [input -> (1) -> (2) -> output]\n",
       "                 (1): cudnn.ORConv([4] 64 -> 128, 1x1, 2,2) without bias, fast mode\n",
       "                 (2): cudnn.SpatialBatchNormalization\n",
       "               }\n",
       "           ... -> output\n",
       "      }\n",
       "      (2): nn.CAddTable\n",
       "      (3): cudnn.ReLU\n",
       "    }\n",
       "    (2): nn.Sequential {\n",
       "      [input -> (1) -> (2) -> (3) -> output]\n",
       "      (1): nn.ConcatTable {\n",
       "        input\n",
       "          |`-> (1): nn.Sequential {\n",
       "          |      [input -> (1) -> (2) -> (3) -> (4) -> (5) -> output]\n",
       "          |      (1): cudnn.ORConv([4] 128 -> 128, 3x3, 1,1, 1,1) without bias, fast mode\n",
       "          |      (2): cudnn.SpatialBatchNormalization\n",
       "          |      (3): cudnn.ReLU\n",
       "          |      (4): cudnn.ORConv([4] 128 -> 128, 3x3, 1,1, 1,1) without bias, fast mode\n",
       "          |      (5): cudnn.SpatialBatchNormalization\n",
       "          |    }\n",
       "           `-> (2): nn.Identity\n",
       "           ... -> output\n",
       "      }\n",
       "      (2): nn.CAddTable\n",
       "      (3): cudnn.ReLU\n",
       "    }\n",
       "  }\n",
       "  (11): nn.Sequential {\n",
       "    [input -> (1) -> (2) -> output]\n",
       "    (1): nn.Sequential {\n",
       "      [input -> (1) -> (2) -> (3) -> output]\n",
       "      (1): nn.ConcatTable {\n",
       "        input\n",
       "          |`-> (1): nn.Sequential {\n",
       "          |      [input -> (1) -> (2) -> (3) -> (4) -> (5) -> output]\n",
       "          |      (1): cudnn.ORConv([4] 128 -> 256, 3x3, 2,2, 1,1) without bias, fast mode\n",
       "          |      (2): cudnn.SpatialBatchNormalization\n",
       "          |      (3): cudnn.ReLU\n",
       "          |      (4): cudnn.ORConv([4] 256 -> 256, 3x3, 1,1, 1,1) without bias, fast mode\n",
       "          |      (5): cudnn.SpatialBatchNormalization\n",
       "          |    }\n",
       "           `-> (2): nn.Sequential {\n",
       "                 [input -> (1) -> (2) -> output]\n",
       "                 (1): cudnn.ORConv([4] 128 -> 256, 1x1, 2,2) without bias, fast mode\n",
       "                 (2): cudnn.SpatialBatchNormalization\n",
       "               }\n",
       "           ... -> output\n",
       "      }\n",
       "      (2): nn.CAddTable\n",
       "      (3): cudnn.ReLU\n",
       "    }\n",
       "    (2): nn.Sequential {\n",
       "      [input -> (1) -> (2) -> (3) -> output]\n",
       "      (1): nn.ConcatTable {\n",
       "        input\n",
       "          |`-> (1): nn.Sequential {\n",
       "          |      [input -> (1) -> (2) -> (3) -> (4) -> (5) -> output]\n",
       "          |      (1): cudnn.ORConv([4] 256 -> 256, 3x3, 1,1, 1,1) without bias, fast mode\n",
       "          |      (2): cudnn.SpatialBatchNormalization\n",
       "          |      (3): cudnn.ReLU\n",
       "          |      (4): cudnn.ORConv([4] 256 -> 256, 3x3, 1,1, 1,1) without bias, fast mode\n",
       "          |      (5): cudnn.SpatialBatchNormalization\n",
       "          |    }\n",
       "           `-> (2): nn.Identity\n",
       "           ... -> output\n",
       "      }\n",
       "      (2): nn.CAddTable\n",
       "      (3): cudnn.ReLU\n",
       "    }\n",
       "  }\n",
       "  (12): cudnn.SpatialAveragePooling(7x7, 1,1)\n",
       "  (13): nn.View(256, 4)\n",
       "  (14): nn.Max\n",
       "  (15): nn.Linear(256 -> 1000)\n",
       "  (16): cudnn.SoftMax\n",
       "}\t\n"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "-- Init pre-trained OR-ResNet-18 model\n",
    "model = require('or-resnet')({tensorType='torch.CudaTensor', pretrained='or-resnet18_weights.t7'})\n",
    "model:add(cudnn.SoftMax():cuda())\n",
    "model:evaluate()\n",
    "print(model:__tostring())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "-- Image transforms\n",
    "M = {}\n",
    "\n",
    "function M.Compose(transforms)\n",
    "   return function(input)\n",
    "      for _, transform in ipairs(transforms) do\n",
    "         input = transform(input)\n",
    "      end\n",
    "      return input\n",
    "   end\n",
    "end\n",
    "\n",
    "function M.ColorNormalize(meanstd)\n",
    "   return function(img)\n",
    "      img = img:clone()\n",
    "      for i=1,3 do\n",
    "         img[i]:add(-meanstd.mean[i])\n",
    "         img[i]:div(meanstd.std[i])\n",
    "      end\n",
    "      return img\n",
    "   end\n",
    "end\n",
    "\n",
    "-- Scales the smaller edge to size\n",
    "function M.Scale(size, interpolation)\n",
    "   interpolation = interpolation or 'bicubic'\n",
    "   return function(input)\n",
    "      local w, h = input:size(3), input:size(2)\n",
    "      if (w <= h and w == size) or (h <= w and h == size) then\n",
    "         return input\n",
    "      end\n",
    "      if w < h then\n",
    "         return image.scale(input, size, h/w * size, interpolation)\n",
    "      else\n",
    "         return image.scale(input, w/h * size, size, interpolation)\n",
    "      end\n",
    "   end\n",
    "end\n",
    "\n",
    "-- Crop to centered rectangle\n",
    "function M.CenterCrop(size)\n",
    "   return function(input)\n",
    "      local w1 = math.ceil((input:size(3) - size)/2)\n",
    "      local h1 = math.ceil((input:size(2) - size)/2)\n",
    "      return image.crop(input, w1, h1, w1 + size, h1 + size) -- center patch\n",
    "   end\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "-- Image pre-processing\n",
    "meanstd = {\n",
    "   mean = { 0.485, 0.456, 0.406 },\n",
    "   std = { 0.229, 0.224, 0.225 },\n",
    "}\n",
    "preprocess = M.Compose{\n",
    "     M.Scale(256),\n",
    "     M.ColorNormalize(meanstd),\n",
    "     M.CenterCrop(224),\n",
    "  }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "Console does not support images"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 224,
       "width": 224
      }
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "-- Load an image\n",
    "img = preprocess(image.load('Cat.jpg', 3, 'float'))\n",
    "itorch.image(img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "-- Forwarding\n",
    "batch = img:view(1, table.unpack(img:size():totable()))\n",
    "output = model:forward(batch:cuda()):squeeze()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.62781953811646\ttabby, tabby cat\t\n",
       "0.18881273269653\tEgyptian cat\t\n"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "0.16771727800369\ttiger cat\t\n",
       "0.0011343017686158\ttiger, Panthera tigris\t\n",
       "0.0010373247787356\tcarton\t\n"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "-- Top5 predictions\n",
    "N = 5\n",
    "probs, indexes = output:topk(N, true, true)\n",
    "for n=1, N do\n",
    "     print(probs[n], labels[indexes[n]])\n",
    "end"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "iTorch",
   "language": "lua",
   "name": "itorch"
  },
  "language_info": {
   "name": "lua",
   "version": "5.1"
  },
  "ssap_exp_config": {
   "error_alert": "Error Occurs!",
   "initial": [],
   "max_iteration": 1000,
   "recv_id": "",
   "running": [],
   "summary": [],
   "version": "1.1.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}