CNN-Survival_Prediction-Multichannel ResNet.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "321b3eec",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-05-19 14:39:33.004862: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
      "To enable the following instructions: AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: torchinfo in /Users/ilaydailerten/opt/anaconda3/lib/python3.8/site-packages (1.8.0)\n",
      "\u001b[33mWARNING: You are using pip version 21.3.1; however, version 23.1.2 is available.\n",
      "You should consider upgrading via the '/Users/ilaydailerten/opt/anaconda3/bin/python -m pip install --upgrade pip' command.\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "import scipy.misc\n",
    "\n",
    "\n",
    "#from PIL import Image\n",
    "import PIL.Image as Image\n",
    "import torchvision.transforms as transforms\n",
    "to_tensor = transforms.ToTensor()\n",
    "import torchvision\n",
    "import torch.nn as nn\n",
    "from functools import partial\n",
    "import torch\n",
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "!pip install torchinfo\n",
    "from torchinfo import summary\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "f57f5d66",
   "metadata": {},
   "outputs": [],
   "source": [
    "current_dir = 'TONIC_TMA4_R1C2/'\n",
    "#os.mkdir(new_dir)\n",
    "\n",
    "cdir = !ls $current_dir\n",
    "\n",
    "for n in cdir:\n",
    "    if n[-5:] == '.tiff':\n",
    "        newn = n.replace(\".tiff\", \".tif\" )\n",
    "        os.rename(current_dir+n, current_dir+newn)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "57c4c639",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([38, 2048, 2048])\n"
     ]
    }
   ],
   "source": [
    "\n",
    "cdir = !ls $current_dir\n",
    "\n",
    "\n",
    "i=0\n",
    "for n in cdir:\n",
    "    image_dir = current_dir+n\n",
    "    if i==0:\n",
    "        im = Image.open(image_dir)\n",
    "        #im = im.resize([2024,2024])\n",
    "        image = to_tensor(im)\n",
    "    else:\n",
    "        im = Image.open(image_dir) \n",
    "        #im = im.resize([224,224])\n",
    "        next_channel = to_tensor(im)\n",
    "        image = torch.cat((image,next_channel),0)\n",
    "    i += 1\n",
    "print(image.shape)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "e72bbba4",
   "metadata": {},
   "outputs": [],
   "source": [
    "resnet_models = {18: torchvision.models.resnet18,\n",
    "                 34: torchvision.models.resnet34,\n",
    "                 50: torchvision.models.resnet50,\n",
    "                 101: torchvision.models.resnet101,\n",
    "                 152: torchvision.models.resnet152}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "726fe941",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Resnet_multichannel(nn.Module):\n",
    "    def __init__(self, pretrained=True, encoder_depth=34, num_in_channels=4):\n",
    "        super().__init__()\n",
    "        \n",
    "        if encoder_depth not in [18, 34, 50, 101, 152]:\n",
    "            raise ValueError(f\"Encoder depth {encoder_depth} specified does not match any existing Resnet models\")\n",
    "            \n",
    "        model = resnet_models[encoder_depth](pretrained)\n",
    "        \n",
    "        print(model.conv1)\n",
    "        \n",
    "        ##For reference: layers to use (in order):\n",
    "        # conv1, bn1, relu, maxpool, layer1, layer2, layer3, layer4, avgpool, fc\n",
    "        \n",
    "        # This increases the number of in channels for our network\n",
    "        self.conv1 = self.increase_channels(model.conv1, num_in_channels)\n",
    "        \n",
    "        self.bn1 = model.bn1\n",
    "        self.relu = model.relu\n",
    "        self.maxpool = model.maxpool\n",
    "        self.layer1 = model.layer1\n",
    "        self.layer2 = model.layer2\n",
    "        self.layer3 = model.layer3\n",
    "        self.layer4 = model.layer4\n",
    "        self.avgpool = model.avgpool\n",
    "        self.fc = model.fc\n",
    "        \n",
    "    def forward(self, x):\n",
    "        x = self.conv1(x)\n",
    "        x = self.bn1(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.maxpool(x)\n",
    "        x = self.layer1(x)\n",
    "        x = self.layer2(x)\n",
    "        x = self.layer3(x)\n",
    "        x = self.layer4(x)\n",
    "        x = self.avgpool(x)\n",
    "        x = x.view(x.size(0), -1)\n",
    "        x = self.fc(x)\n",
    "        return x\n",
    "        \n",
    "    def increase_channels(self, m, num_channels=None, copy_weights=0):\n",
    "        \"\"\"\n",
    "        takes as input a Conv2d layer and returns the a Conv2d layer with `num_channels` input channels\n",
    "        and all the previous weights copied into the new layer.\n",
    "        \"\"\"\n",
    "        # number of input channels the new module should have\n",
    "        new_in_channels = num_channels if num_channels is not None else m.in_channels + 1\n",
    "        \n",
    "        print(m.in_channels)\n",
    "        print(new_in_channels)\n",
    "       \n",
    "        \n",
    "        bias = False if m.bias is None else True\n",
    "        \n",
    "        # Creating new Conv2d layer\n",
    "        new_m = nn.Conv2d(in_channels=new_in_channels, \n",
    "                          out_channels=m.out_channels, \n",
    "                          kernel_size=m.kernel_size, \n",
    "                          stride=m.stride, \n",
    "                          padding=m.padding,\n",
    "                          bias=bias)\n",
    "        \n",
    "        # Copying the weights from the old to the new layer\n",
    "        new_m.weight.data[:, :m.in_channels, :, :] = m.weight.clone()\n",
    "        \n",
    "        #Copying the weights of the `copy_weights` channel of the old layer to the extra channels of the new layer\n",
    "        print(new_in_channels - m.in_channels)\n",
    "        for i in range(new_in_channels - m.in_channels):\n",
    "            channel = m.in_channels + i\n",
    "            new_m.weight.data[:, channel:channel+1, :, :] = m.weight[:, copy_weights:copy_weights+1, : :].clone()\n",
    "        new_m.weight = nn.Parameter(new_m.weight)\n",
    "\n",
    "        return new_m\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "530aa484",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_arch(encoder_depth, num_in_channels):\n",
    "    \"\"\"\n",
    "    Returns just an architecture which can then be called in the usual way.\n",
    "    For example:\n",
    "    resnet34_4_channel = get_arch(34, 4)\n",
    "    model = resnet34_4_channel(True)\n",
    "    \"\"\"\n",
    "    return partial(Resnet_multichannel, encoder_depth=encoder_depth, num_in_channels=num_in_channels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "03dc410e",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/ilaydailerten/opt/anaconda3/lib/python3.8/site-packages/torchvision/models/_utils.py:135: UserWarning: Using 'weights' as positional parameter(s) is deprecated since 0.13 and may be removed in the future. Please use keyword parameter(s) instead.\n",
      "  warnings.warn(\n",
      "/Users/ilaydailerten/opt/anaconda3/lib/python3.8/site-packages/torchvision/models/_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=ResNet50_Weights.IMAGENET1K_V1`. You can also use `weights=ResNet50_Weights.DEFAULT` to get the most up-to-date weights.\n",
      "  warnings.warn(msg)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n",
      "3\n",
      "38\n",
      "35\n",
      "New input channels :  38\n"
     ]
    }
   ],
   "source": [
    "resnet50_mchannel = get_arch(50, 38)\n",
    "model = resnet50_mchannel(True) \n",
    "print(\"New input channels : \", model.conv1.in_channels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "144af5fe",
   "metadata": {},
   "outputs": [],
   "source": [
    "def set_parameter_requires_grad(model, feature_extracting):\n",
    "    if feature_extracting:\n",
    "        for param in model.parameters():\n",
    "            param.requires_grad = False\n",
    "            \n",
    "feature_extract = True\n",
    "set_parameter_requires_grad(model, feature_extract)\n",
    "num_ftrs = model.fc.in_features\n",
    "model.fc = nn.Linear(num_ftrs, 2)\n",
    "input_size = 2024 #224"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "47ba8964",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=================================================================\n",
      "Layer (type:depth-idx)                   Param #\n",
      "=================================================================\n",
      "Resnet_multichannel                      --\n",
      "├─Conv2d: 1-1                            (119,168)\n",
      "├─BatchNorm2d: 1-2                       (128)\n",
      "├─ReLU: 1-3                              --\n",
      "├─MaxPool2d: 1-4                         --\n",
      "├─Sequential: 1-5                        --\n",
      "│    └─Bottleneck: 2-1                   --\n",
      "│    │    └─Conv2d: 3-1                  (4,096)\n",
      "│    │    └─BatchNorm2d: 3-2             (128)\n",
      "│    │    └─Conv2d: 3-3                  (36,864)\n",
      "│    │    └─BatchNorm2d: 3-4             (128)\n",
      "│    │    └─Conv2d: 3-5                  (16,384)\n",
      "│    │    └─BatchNorm2d: 3-6             (512)\n",
      "│    │    └─ReLU: 3-7                    --\n",
      "│    │    └─Sequential: 3-8              (16,896)\n",
      "│    └─Bottleneck: 2-2                   --\n",
      "│    │    └─Conv2d: 3-9                  (16,384)\n",
      "│    │    └─BatchNorm2d: 3-10            (128)\n",
      "│    │    └─Conv2d: 3-11                 (36,864)\n",
      "│    │    └─BatchNorm2d: 3-12            (128)\n",
      "│    │    └─Conv2d: 3-13                 (16,384)\n",
      "│    │    └─BatchNorm2d: 3-14            (512)\n",
      "│    │    └─ReLU: 3-15                   --\n",
      "│    └─Bottleneck: 2-3                   --\n",
      "│    │    └─Conv2d: 3-16                 (16,384)\n",
      "│    │    └─BatchNorm2d: 3-17            (128)\n",
      "│    │    └─Conv2d: 3-18                 (36,864)\n",
      "│    │    └─BatchNorm2d: 3-19            (128)\n",
      "│    │    └─Conv2d: 3-20                 (16,384)\n",
      "│    │    └─BatchNorm2d: 3-21            (512)\n",
      "│    │    └─ReLU: 3-22                   --\n",
      "├─Sequential: 1-6                        --\n",
      "│    └─Bottleneck: 2-4                   --\n",
      "│    │    └─Conv2d: 3-23                 (32,768)\n",
      "│    │    └─BatchNorm2d: 3-24            (256)\n",
      "│    │    └─Conv2d: 3-25                 (147,456)\n",
      "│    │    └─BatchNorm2d: 3-26            (256)\n",
      "│    │    └─Conv2d: 3-27                 (65,536)\n",
      "│    │    └─BatchNorm2d: 3-28            (1,024)\n",
      "│    │    └─ReLU: 3-29                   --\n",
      "│    │    └─Sequential: 3-30             (132,096)\n",
      "│    └─Bottleneck: 2-5                   --\n",
      "│    │    └─Conv2d: 3-31                 (65,536)\n",
      "│    │    └─BatchNorm2d: 3-32            (256)\n",
      "│    │    └─Conv2d: 3-33                 (147,456)\n",
      "│    │    └─BatchNorm2d: 3-34            (256)\n",
      "│    │    └─Conv2d: 3-35                 (65,536)\n",
      "│    │    └─BatchNorm2d: 3-36            (1,024)\n",
      "│    │    └─ReLU: 3-37                   --\n",
      "│    └─Bottleneck: 2-6                   --\n",
      "│    │    └─Conv2d: 3-38                 (65,536)\n",
      "│    │    └─BatchNorm2d: 3-39            (256)\n",
      "│    │    └─Conv2d: 3-40                 (147,456)\n",
      "│    │    └─BatchNorm2d: 3-41            (256)\n",
      "│    │    └─Conv2d: 3-42                 (65,536)\n",
      "│    │    └─BatchNorm2d: 3-43            (1,024)\n",
      "│    │    └─ReLU: 3-44                   --\n",
      "│    └─Bottleneck: 2-7                   --\n",
      "│    │    └─Conv2d: 3-45                 (65,536)\n",
      "│    │    └─BatchNorm2d: 3-46            (256)\n",
      "│    │    └─Conv2d: 3-47                 (147,456)\n",
      "│    │    └─BatchNorm2d: 3-48            (256)\n",
      "│    │    └─Conv2d: 3-49                 (65,536)\n",
      "│    │    └─BatchNorm2d: 3-50            (1,024)\n",
      "│    │    └─ReLU: 3-51                   --\n",
      "├─Sequential: 1-7                        --\n",
      "│    └─Bottleneck: 2-8                   --\n",
      "│    │    └─Conv2d: 3-52                 (131,072)\n",
      "│    │    └─BatchNorm2d: 3-53            (512)\n",
      "│    │    └─Conv2d: 3-54                 (589,824)\n",
      "│    │    └─BatchNorm2d: 3-55            (512)\n",
      "│    │    └─Conv2d: 3-56                 (262,144)\n",
      "│    │    └─BatchNorm2d: 3-57            (2,048)\n",
      "│    │    └─ReLU: 3-58                   --\n",
      "│    │    └─Sequential: 3-59             (526,336)\n",
      "│    └─Bottleneck: 2-9                   --\n",
      "│    │    └─Conv2d: 3-60                 (262,144)\n",
      "│    │    └─BatchNorm2d: 3-61            (512)\n",
      "│    │    └─Conv2d: 3-62                 (589,824)\n",
      "│    │    └─BatchNorm2d: 3-63            (512)\n",
      "│    │    └─Conv2d: 3-64                 (262,144)\n",
      "│    │    └─BatchNorm2d: 3-65            (2,048)\n",
      "│    │    └─ReLU: 3-66                   --\n",
      "│    └─Bottleneck: 2-10                  --\n",
      "│    │    └─Conv2d: 3-67                 (262,144)\n",
      "│    │    └─BatchNorm2d: 3-68            (512)\n",
      "│    │    └─Conv2d: 3-69                 (589,824)\n",
      "│    │    └─BatchNorm2d: 3-70            (512)\n",
      "│    │    └─Conv2d: 3-71                 (262,144)\n",
      "│    │    └─BatchNorm2d: 3-72            (2,048)\n",
      "│    │    └─ReLU: 3-73                   --\n",
      "│    └─Bottleneck: 2-11                  --\n",
      "│    │    └─Conv2d: 3-74                 (262,144)\n",
      "│    │    └─BatchNorm2d: 3-75            (512)\n",
      "│    │    └─Conv2d: 3-76                 (589,824)\n",
      "│    │    └─BatchNorm2d: 3-77            (512)\n",
      "│    │    └─Conv2d: 3-78                 (262,144)\n",
      "│    │    └─BatchNorm2d: 3-79            (2,048)\n",
      "│    │    └─ReLU: 3-80                   --\n",
      "│    └─Bottleneck: 2-12                  --\n",
      "│    │    └─Conv2d: 3-81                 (262,144)\n",
      "│    │    └─BatchNorm2d: 3-82            (512)\n",
      "│    │    └─Conv2d: 3-83                 (589,824)\n",
      "│    │    └─BatchNorm2d: 3-84            (512)\n",
      "│    │    └─Conv2d: 3-85                 (262,144)\n",
      "│    │    └─BatchNorm2d: 3-86            (2,048)\n",
      "│    │    └─ReLU: 3-87                   --\n",
      "│    └─Bottleneck: 2-13                  --\n",
      "│    │    └─Conv2d: 3-88                 (262,144)\n",
      "│    │    └─BatchNorm2d: 3-89            (512)\n",
      "│    │    └─Conv2d: 3-90                 (589,824)\n",
      "│    │    └─BatchNorm2d: 3-91            (512)\n",
      "│    │    └─Conv2d: 3-92                 (262,144)\n",
      "│    │    └─BatchNorm2d: 3-93            (2,048)\n",
      "│    │    └─ReLU: 3-94                   --\n",
      "├─Sequential: 1-8                        --\n",
      "│    └─Bottleneck: 2-14                  --\n",
      "│    │    └─Conv2d: 3-95                 (524,288)\n",
      "│    │    └─BatchNorm2d: 3-96            (1,024)\n",
      "│    │    └─Conv2d: 3-97                 (2,359,296)\n",
      "│    │    └─BatchNorm2d: 3-98            (1,024)\n",
      "│    │    └─Conv2d: 3-99                 (1,048,576)\n",
      "│    │    └─BatchNorm2d: 3-100           (4,096)\n",
      "│    │    └─ReLU: 3-101                  --\n",
      "│    │    └─Sequential: 3-102            (2,101,248)\n",
      "│    └─Bottleneck: 2-15                  --\n",
      "│    │    └─Conv2d: 3-103                (1,048,576)\n",
      "│    │    └─BatchNorm2d: 3-104           (1,024)\n",
      "│    │    └─Conv2d: 3-105                (2,359,296)\n",
      "│    │    └─BatchNorm2d: 3-106           (1,024)\n",
      "│    │    └─Conv2d: 3-107                (1,048,576)\n",
      "│    │    └─BatchNorm2d: 3-108           (4,096)\n",
      "│    │    └─ReLU: 3-109                  --\n",
      "│    └─Bottleneck: 2-16                  --\n",
      "│    │    └─Conv2d: 3-110                (1,048,576)\n",
      "│    │    └─BatchNorm2d: 3-111           (1,024)\n",
      "│    │    └─Conv2d: 3-112                (2,359,296)\n",
      "│    │    └─BatchNorm2d: 3-113           (1,024)\n",
      "│    │    └─Conv2d: 3-114                (1,048,576)\n",
      "│    │    └─BatchNorm2d: 3-115           (4,096)\n",
      "│    │    └─ReLU: 3-116                  --\n",
      "├─AdaptiveAvgPool2d: 1-9                 --\n",
      "├─Linear: 1-10                           4,098\n",
      "=================================================================\n",
      "Total params: 23,621,890\n",
      "Trainable params: 4,098\n",
      "Non-trainable params: 23,617,792\n",
      "=================================================================\n"
     ]
    }
   ],
   "source": [
    "print(summary(model))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "21bbd379",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Resnet_multichannel(\n",
       "  (conv1): Conv2d(38, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n",
       "  (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (relu): ReLU(inplace=True)\n",
       "  (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
       "  (layer1): Sequential(\n",
       "    (0): Bottleneck(\n",
       "      (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU(inplace=True)\n",
       "      (downsample): Sequential(\n",
       "        (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      )\n",
       "    )\n",
       "    (1): Bottleneck(\n",
       "      (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU(inplace=True)\n",
       "    )\n",
       "    (2): Bottleneck(\n",
       "      (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU(inplace=True)\n",
       "    )\n",
       "  )\n",
       "  (layer2): Sequential(\n",
       "    (0): Bottleneck(\n",
       "      (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU(inplace=True)\n",
       "      (downsample): Sequential(\n",
       "        (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
       "        (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      )\n",
       "    )\n",
       "    (1): Bottleneck(\n",
       "      (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU(inplace=True)\n",
       "    )\n",
       "    (2): Bottleneck(\n",
       "      (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU(inplace=True)\n",
       "    )\n",
       "    (3): Bottleneck(\n",
       "      (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU(inplace=True)\n",
       "    )\n",
       "  )\n",
       "  (layer3): Sequential(\n",
       "    (0): Bottleneck(\n",
       "      (conv1): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU(inplace=True)\n",
       "      (downsample): Sequential(\n",
       "        (0): Conv2d(512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
       "        (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      )\n",
       "    )\n",
       "    (1): Bottleneck(\n",
       "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU(inplace=True)\n",
       "    )\n",
       "    (2): Bottleneck(\n",
       "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU(inplace=True)\n",
       "    )\n",
       "    (3): Bottleneck(\n",
       "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU(inplace=True)\n",
       "    )\n",
       "    (4): Bottleneck(\n",
       "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU(inplace=True)\n",
       "    )\n",
       "    (5): Bottleneck(\n",
       "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU(inplace=True)\n",
       "    )\n",
       "  )\n",
       "  (layer4): Sequential(\n",
       "    (0): Bottleneck(\n",
       "      (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU(inplace=True)\n",
       "      (downsample): Sequential(\n",
       "        (0): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
       "        (1): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      )\n",
       "    )\n",
       "    (1): Bottleneck(\n",
       "      (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU(inplace=True)\n",
       "    )\n",
       "    (2): Bottleneck(\n",
       "      (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU(inplace=True)\n",
       "    )\n",
       "  )\n",
       "  (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))\n",
       "  (fc): Linear(in_features=2048, out_features=2, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# image = torch.unsqueeze(image, 1)\n",
    "uimage = torch.unsqueeze(image, 0)\n",
    "model.eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "e77be0a7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[-0.1966,  0.2150]], grad_fn=<AddmmBackward0>)\n"
     ]
    }
   ],
   "source": [
    "out = model(uimage)\n",
    "print(out)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}