MobileCount.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 100450,
     "status": "ok",
     "timestamp": 1610708848049,
     "user": {
      "displayName": "omar elharrouss",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GjeGC_l4X-u1jl7ka6nlFmF9bP8pq1h8yOVXg_Wvg=s64",
      "userId": "07323381654864768298"
     },
     "user_tz": -180
    },
    "id": "FSUbmrwYUJTM",
    "outputId": "817d81ea-435b-4b77-d449-f96ba7139408"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from google.colab import drive\n",
    "drive.mount('/content/drive')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!unzip \"/content/drive/My Drive/Data.zip\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np # linear algebra\n",
    "import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n",
    "\n",
    "# Input data files are available in the \"../input/\" directory.\n",
    "# For example, running this (by clicking run lllor pressing Shift+Enter) will list the files in the input directory\n",
    "\n",
    "import os\n",
    "\n",
    "\n",
    "# Any results you write to the current directory are saved as output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 100444,
     "status": "ok",
     "timestamp": 1610708848050,
     "user": {
      "displayName": "omar elharrouss",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GjeGC_l4X-u1jl7ka6nlFmF9bP8pq1h8yOVXg_Wvg=s64",
      "userId": "07323381654864768298"
     },
     "user_tz": -180
    },
    "id": "iMiEEegeUNeR",
    "outputId": "81114495-54ca-4dbb-9837-2d216d7da53f"
   },
   "outputs": [],
   "source": [
    "print(os.listdir(\"Data\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "executionInfo": {
     "elapsed": 103071,
     "status": "ok",
     "timestamp": 1610708850683,
     "user": {
      "displayName": "omar elharrouss",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GjeGC_l4X-u1jl7ka6nlFmF9bP8pq1h8yOVXg_Wvg=s64",
      "userId": "07323381654864768298"
     },
     "user_tz": -180
    },
    "id": "Duw_HqqUUOMU"
   },
   "outputs": [],
   "source": [
    "DATA_PATH = \"Data/train_data/\"\n",
    "TEST_DATA_PATH =\"Data/test_data/\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "executionInfo": {
     "elapsed": 103067,
     "status": "ok",
     "timestamp": 1610708850683,
     "user": {
      "displayName": "omar elharrouss",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GjeGC_l4X-u1jl7ka6nlFmF9bP8pq1h8yOVXg_Wvg=s64",
      "userId": "07323381654864768298"
     },
     "user_tz": -180
    },
    "id": "G8geK_7vUP6e"
   },
   "outputs": [],
   "source": [
    "PRETRAINED_MODEL = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "executionInfo": {
     "elapsed": 105648,
     "status": "ok",
     "timestamp": 1610708853268,
     "user": {
      "displayName": "omar elharrouss",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GjeGC_l4X-u1jl7ka6nlFmF9bP8pq1h8yOVXg_Wvg=s64",
      "userId": "07323381654864768298"
     },
     "user_tz": -180
    },
    "id": "Fu7ORXSlUSBE"
   },
   "outputs": [],
   "source": [
    "import h5py\n",
    "import torch\n",
    "import shutil\n",
    "\n",
    "def save_net(fname, net):\n",
    "    with h5py.File(fname, 'w') as h5f:\n",
    "        for k, v in net.state_dict().items():\n",
    "            h5f.create_dataset(k, data=v.cpu().numpy())\n",
    "def load_net(fname, net):\n",
    "    with h5py.File(fname, 'r') as h5f:\n",
    "        for k, v in net.state_dict().items():        \n",
    "            param = torch.from_numpy(np.asarray(h5f[k]))         \n",
    "            v.copy_(param)\n",
    "            \n",
    "def save_checkpoint(state, is_best,task_id, filename='checkpoint.pth.tar'):\n",
    "    torch.save(state, task_id+filename)\n",
    "    if is_best:\n",
    "        shutil.copyfile(task_id+filename, task_id+'model_best.pth.tar')   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "executionInfo": {
     "elapsed": 105645,
     "status": "ok",
     "timestamp": 1610708853269,
     "user": {
      "displayName": "omar elharrouss",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GjeGC_l4X-u1jl7ka6nlFmF9bP8pq1h8yOVXg_Wvg=s64",
      "userId": "07323381654864768298"
     },
     "user_tz": -180
    },
    "id": "zkBe7RmXUUTy"
   },
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "contain dummy args with config\n",
    "helpfull for copy paste Kaggle\n",
    "\"\"\"\n",
    "import argparse\n",
    "\n",
    "\n",
    "def make_args(train_json= \"\", test_json=\"\", pre=\"\", gpu=\"0\", task=\"task_one_\"):\n",
    "    \"\"\"\n",
    "    these arg does not have any required commandline arg (all with default value)\n",
    "    :param train_json:\n",
    "    :param test_json:\n",
    "    :param pre:\n",
    "    :param gpu:\n",
    "    :param task:\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    parser = argparse.ArgumentParser(description='PyTorch CSRNet')\n",
    "\n",
    "    args = parser.parse_args()\n",
    "    args.gpu = gpu\n",
    "    args.task = task\n",
    "    args.pre = None\n",
    "    return args\n",
    "\n",
    "\n",
    "class Meow():\n",
    "    def __init__(self):\n",
    "        pass\n",
    "\n",
    "\n",
    "def make_meow_args(gpu=\"0\", task=\"task_one_\"):\n",
    "    args = Meow()\n",
    "    args.gpu = gpu\n",
    "    args.task = task\n",
    "    args.pre = None\n",
    "    return args"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "executionInfo": {
     "elapsed": 106428,
     "status": "ok",
     "timestamp": 1610708854056,
     "user": {
      "displayName": "omar elharrouss",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GjeGC_l4X-u1jl7ka6nlFmF9bP8pq1h8yOVXg_Wvg=s64",
      "userId": "07323381654864768298"
     },
     "user_tz": -180
    },
    "id": "DFAMlVrUUW_P"
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import glob\n",
    "from sklearn.model_selection import train_test_split\n",
    "import json\n",
    "\"\"\"\n",
    "create a list of file (full directory)\n",
    "\"\"\"\n",
    "\n",
    "def create_training_image_list(data_path):\n",
    "    \"\"\"\n",
    "    create a list of absolutely path of jpg file\n",
    "    :param data_path: must contain subfolder \"images\" with *.jpg  (example ShanghaiTech/part_A/train_data/)\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    DATA_PATH = data_path\n",
    "    image_path_list = glob.glob(os.path.join(DATA_PATH, \"images\", \"*.jpg\"))\n",
    "    return image_path_list\n",
    "\n",
    "def get_train_val_list(data_path):\n",
    "    DATA_PATH = data_path\n",
    "    image_path_list = glob.glob(os.path.join(DATA_PATH, \"images\", \"*.jpg\"))\n",
    "    train, val = train_test_split(image_path_list, test_size=0.3, random_state=113)\n",
    "\n",
    "    print(\"train size \", len(train))\n",
    "    print(\"val size \", len(val))\n",
    "    return train, val"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "executionInfo": {
     "elapsed": 106879,
     "status": "ok",
     "timestamp": 1610708854511,
     "user": {
      "displayName": "omar elharrouss",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GjeGC_l4X-u1jl7ka6nlFmF9bP8pq1h8yOVXg_Wvg=s64",
      "userId": "07323381654864768298"
     },
     "user_tz": -180
    },
    "id": "Op2Q6phZUY-s"
   },
   "outputs": [],
   "source": [
    "import random\n",
    "import os\n",
    "from PIL import Image,ImageFilter,ImageDraw\n",
    "import numpy as np\n",
    "import h5py\n",
    "from PIL import ImageStat\n",
    "import cv2\n",
    "\n",
    "def load_data(img_path,train = True):\n",
    "    gt_path = img_path.replace('.jpg','.h5').replace('images','ground-truth')\n",
    "    img = Image.open(img_path).convert('RGB')\n",
    "    gt_file = h5py.File(gt_path, 'r')\n",
    "    target = np.asarray(gt_file['density'])\n",
    "\n",
    "    target = cv2.resize(target,(int(target.shape[1]/8), int(target.shape[0]/8)),interpolation = cv2.INTER_CUBIC)*64\n",
    "    \n",
    "    return img,target"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "executionInfo": {
     "elapsed": 106876,
     "status": "ok",
     "timestamp": 1610708854511,
     "user": {
      "displayName": "omar elharrouss",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GjeGC_l4X-u1jl7ka6nlFmF9bP8pq1h8yOVXg_Wvg=s64",
      "userId": "07323381654864768298"
     },
     "user_tz": -180
    },
    "id": "B1cTobUyUa12"
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import random\n",
    "import torch\n",
    "import numpy as np\n",
    "from torch.utils.data import Dataset\n",
    "from PIL import Image\n",
    "import torchvision.transforms.functional as F\n",
    "class ListDataset(Dataset):\n",
    "    def __init__(self, root, shape=None, shuffle=True, transform=None,  train=False, seen=0, batch_size=1, num_workers=4):\n",
    "        \"\"\"\n",
    "        if you have different image size, then batch_size must be 1\n",
    "        :param root:\n",
    "        :param shape:\n",
    "        :param shuffle:\n",
    "        :param transform:\n",
    "        :param train:\n",
    "        :param seen:\n",
    "        :param batch_size:\n",
    "        :param num_workers:\n",
    "        \"\"\"\n",
    "        if train:\n",
    "            root = root *2\n",
    "        if shuffle:\n",
    "            random.shuffle(root)\n",
    "        \n",
    "        self.nSamples = len(root)\n",
    "        self.lines = root\n",
    "        self.transform = transform\n",
    "        self.train = train\n",
    "        self.shape = shape\n",
    "        self.seen = seen\n",
    "        self.batch_size = batch_size\n",
    "        self.num_workers = num_workers\n",
    "        \n",
    "    def __len__(self):\n",
    "        return self.nSamples\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        assert index <= len(self), 'index range error' \n",
    "        \n",
    "        img_path = self.lines[index]\n",
    "        \n",
    "        img,target = load_data(img_path,self.train)\n",
    "        \n",
    "        #img = 255.0 * F.to_tensor(img)\n",
    "        \n",
    "        #img[0,:,:]=img[0,:,:]-92.8207477031\n",
    "        #img[1,:,:]=img[1,:,:]-95.2757037428\n",
    "        #img[2,:,:]=img[2,:,:]-104.877445883\n",
    "\n",
    "\n",
    "        \n",
    "        \n",
    "        if self.transform is not None:\n",
    "            img = self.transform(img)\n",
    "        return img,target"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "executionInfo": {
     "elapsed": 106872,
     "status": "ok",
     "timestamp": 1610708854512,
     "user": {
      "displayName": "omar elharrouss",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GjeGC_l4X-u1jl7ka6nlFmF9bP8pq1h8yOVXg_Wvg=s64",
      "userId": "07323381654864768298"
     },
     "user_tz": -180
    },
    "id": "fVK7n8IJPINm"
   },
   "outputs": [],
   "source": [
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "executionInfo": {
     "elapsed": 107214,
     "status": "ok",
     "timestamp": 1610708854858,
     "user": {
      "displayName": "omar elharrouss",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GjeGC_l4X-u1jl7ka6nlFmF9bP8pq1h8yOVXg_Wvg=s64",
      "userId": "07323381654864768298"
     },
     "user_tz": -180
    },
    "id": "efoXAZ6Fj4fw"
   },
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "import math\n",
    "\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.utils.model_zoo as model_zoo\n",
    "import torch\n",
    "from torch.autograd import Variable\n",
    "import torchvision.models as models\n",
    "\n",
    "\n",
    "model_urls = {\n",
    "    'resnet101': 'https://download.pytorch.org/models/resnet101-5d3b4d8f.pth',\n",
    "    'resnet50': 'https://download.pytorch.org/models/resnet50-19c8e357.pth',\n",
    "}\n",
    "\n",
    "\n",
    "# Helpers / wrappers\n",
    "def conv3x3(in_planes, out_planes, stride=1, bias=False):\n",
    "    \"3x3 convolution with padding\"\n",
    "    return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,\n",
    "                     padding=1, bias=bias)\n",
    "\n",
    "\n",
    "def conv1x1(in_planes, out_planes, stride=1, bias=False):\n",
    "    \"1x1 convolution\"\n",
    "    return nn.Conv2d(in_planes, out_planes, kernel_size=1, stride=stride,\n",
    "                     padding=0, bias=bias)\n",
    "\n",
    "\n",
    "class CRPBlock(nn.Module):\n",
    "\n",
    "    def __init__(self, in_planes, out_planes, n_stages):\n",
    "        super(CRPBlock, self).__init__()\n",
    "        for i in range(n_stages):\n",
    "            setattr(self, '{}_{}'.format(i + 1, 'outvar_dimred'),\n",
    "                    conv1x1(in_planes if (i == 0) else out_planes,\n",
    "                            out_planes, stride=1,\n",
    "                            bias=False))\n",
    "        self.stride = 1\n",
    "        self.n_stages = n_stages\n",
    "        self.maxpool = nn.MaxPool2d(kernel_size=5, stride=1, padding=2)\n",
    "\n",
    "    def forward(self, x):\n",
    "        top = x\n",
    "        for i in range(self.n_stages):\n",
    "            top = self.maxpool(top)\n",
    "            top = getattr(self, '{}_{}'.format(i + 1, 'outvar_dimred'))(top)\n",
    "            x = top + x\n",
    "        return x\n",
    "\n",
    "\n",
    "class BasicBlock(nn.Module):\n",
    "    expansion = 1\n",
    "\n",
    "    def __init__(self, inplanes, planes, stride=1, downsample=None):\n",
    "        super(BasicBlock, self).__init__()\n",
    "        self.conv1 = conv3x3(inplanes, planes, stride)\n",
    "        self.bn1 = nn.BatchNorm2d(planes, momentum=0.05)\n",
    "        self.relu = nn.ReLU(inplace=True)\n",
    "        self.conv2 = conv3x3(planes, planes)\n",
    "        self.bn2 = nn.BatchNorm2d(planes, momentum=0.05)\n",
    "        self.downsample = downsample\n",
    "        self.stride = stride\n",
    "\n",
    "    def forward(self, x):\n",
    "        residual = x\n",
    "\n",
    "        out = self.conv1(x)\n",
    "        out = self.bn1(out)\n",
    "        out = self.relu(out)\n",
    "\n",
    "        out = self.conv2(out)\n",
    "        out = self.bn2(out)\n",
    "\n",
    "        if self.downsample is not None:\n",
    "            residual = self.downsample(x)\n",
    "\n",
    "        out += residual\n",
    "        out = self.relu(out)\n",
    "\n",
    "        return out\n",
    "\n",
    "\n",
    "class Bottleneck(nn.Module):\n",
    "    expansion = 4\n",
    "\n",
    "    def __init__(self, inplanes, planes, stride=1, downsample=None, expansion=1):\n",
    "        super(Bottleneck, self).__init__()\n",
    "        self.conv1 = nn.Conv2d(inplanes, inplanes*expansion, kernel_size=1, bias=False)\n",
    "        self.bn1 = nn.BatchNorm2d(inplanes*expansion)\n",
    "        self.conv2 = nn.Conv2d(inplanes*expansion, inplanes*expansion, kernel_size=3, stride=stride,\n",
    "                               padding=1, bias=False, groups=inplanes*expansion)\n",
    "        self.bn2 = nn.BatchNorm2d(inplanes*expansion)\n",
    "        self.conv3 = nn.Conv2d(inplanes*expansion, planes, kernel_size=1, bias=False)\n",
    "        self.bn3 = nn.BatchNorm2d(planes)\n",
    "        self.relu = nn.ReLU(inplace=True)\n",
    "        self.downsample = downsample\n",
    "        self.stride = stride\n",
    "\n",
    "    def forward(self, x):\n",
    "        residual = x\n",
    "\n",
    "        out = self.conv1(x)\n",
    "        out = self.bn1(out)\n",
    "        out = self.relu(out)\n",
    "\n",
    "        out = self.conv2(out)\n",
    "        out = self.bn2(out)\n",
    "        out = self.relu(out)\n",
    "\n",
    "        out = self.conv3(out)\n",
    "        out = self.bn3(out)\n",
    "\n",
    "        if self.downsample is not None:\n",
    "            residual = self.downsample(x)\n",
    "\n",
    "        out += residual\n",
    "        out = self.relu(out)\n",
    "\n",
    "        return out\n",
    "\n",
    "\n",
    "class MobileCount(nn.Module):\n",
    "\n",
    "    def __init__(self, num_classes=1, pretrained=False):\n",
    "        self.inplanes = 64\n",
    "        block = Bottleneck\n",
    "        self.seen = 0\n",
    "        layers = [1, 2, 3, 4]\n",
    "        super(MobileCount, self).__init__()\n",
    "\n",
    "        # implement of mobileNetv2\n",
    "        # self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3,\n",
    "        #                        bias=False)\n",
    "\n",
    "        self.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=2, padding=1, bias=False)\n",
    "        self.bn1 = nn.BatchNorm2d(64)\n",
    "        self.relu = nn.ReLU(inplace=True)\n",
    "\n",
    "        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)\n",
    "        self.layer1 = self._make_layer(block, 64, layers[0], stride=1, expansion=1)\n",
    "        self.layer2 = self._make_layer(block, 128, layers[1], stride=2, expansion=6)\n",
    "        self.layer3 = self._make_layer(block, 256, layers[2], stride=2, expansion=6)\n",
    "        self.layer4 = self._make_layer(block, 512, layers[3], stride=2, expansion=6)\n",
    "\n",
    "        self.dropout4 = nn.Dropout(p=0.5)\n",
    "        self.p_ims1d2_outl1_dimred = conv1x1(512, 128, bias=False)\n",
    "        self.mflow_conv_g1_pool = self._make_crp(128, 128, 4)\n",
    "        self.mflow_conv_g1_b3_joint_varout_dimred = conv1x1(128, 64, bias=False)\n",
    "\n",
    "        self.dropout3 = nn.Dropout(p=0.5)\n",
    "        self.p_ims1d2_outl2_dimred = conv1x1(256, 64, bias=False)\n",
    "        self.adapt_stage2_b2_joint_varout_dimred = conv1x1(64, 64, bias=False)\n",
    "        self.mflow_conv_g2_pool = self._make_crp(64, 64, 4)\n",
    "        self.mflow_conv_g2_b3_joint_varout_dimred = conv1x1(64, 64, bias=False)\n",
    "\n",
    "        self.p_ims1d2_outl3_dimred = conv1x1(128, 64, bias=False)\n",
    "        self.adapt_stage3_b2_joint_varout_dimred = conv1x1(64, 64, bias=False)\n",
    "        self.mflow_conv_g3_pool = self._make_crp(64, 64, 4)\n",
    "        self.mflow_conv_g3_b3_joint_varout_dimred = conv1x1(64, 64, bias=False)\n",
    "\n",
    "        self.p_ims1d2_outl4_dimred = conv1x1(64, 64, bias=False)\n",
    "        self.adapt_stage4_b2_joint_varout_dimred = conv1x1(64, 64, bias=False)\n",
    "        self.mflow_conv_g4_pool = self._make_crp(64, 64, 4)\n",
    "\n",
    "        self.dropout_clf = nn.Dropout(p=0.5)\n",
    "        # self.clf_conv = nn.Conv2d(256, num_classes, kernel_size=3, stride=1,\n",
    "        #                           padding=1, bias=True)\n",
    "        self.clf_conv = nn.Conv2d(64, 1, kernel_size=3, stride=1,\n",
    "                                  padding=1, bias=True)\n",
    "\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, nn.Conv2d):\n",
    "                n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels\n",
    "                m.weight.data.normal_(0, 0.01)\n",
    "            elif isinstance(m, nn.BatchNorm2d):\n",
    "                m.weight.data.fill_(1)\n",
    "                m.bias.data.zero_()\n",
    "\n",
    "        if pretrained:\n",
    "            print('load the pre-trained model.')\n",
    "            resnet = models.resnet101(pretrained)\n",
    "            self.conv1 = resnet.conv1\n",
    "            self.bn1 = resnet.bn1\n",
    "            self.layer1 = resnet.layer1\n",
    "            self.layer2 = resnet.layer2\n",
    "            self.layer3 = resnet.layer3\n",
    "            self.layer4 = resnet.layer4\n",
    "\n",
    "    def _make_crp(self, in_planes, out_planes, stages):\n",
    "        layers = [CRPBlock(in_planes, out_planes, stages)]\n",
    "        return nn.Sequential(*layers)\n",
    "\n",
    "    def _make_layer(self, block, planes, blocks, stride, expansion):\n",
    "\n",
    "        downsample = None\n",
    "\n",
    "        if stride != 1 or self.inplanes != planes * block.expansion:\n",
    "            downsample = nn.Sequential(\n",
    "                nn.Conv2d(self.inplanes, planes,\n",
    "                          kernel_size=1, stride=stride, bias=False),\n",
    "                nn.BatchNorm2d(planes),\n",
    "            )\n",
    "\n",
    "        layers = []\n",
    "        layers.append(block(self.inplanes, planes, stride=stride, downsample=downsample, expansion=expansion))\n",
    "        self.inplanes = planes\n",
    "        for i in range(1, blocks):\n",
    "            layers.append(block(self.inplanes, planes, expansion=expansion))\n",
    "\n",
    "        return nn.Sequential(*layers)\n",
    "\n",
    "    def forward(self, x):\n",
    "        size1 = x.shape[2:]\n",
    "        x = self.conv1(x)\n",
    "        x = self.bn1(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.maxpool(x)\n",
    "\n",
    "        l1 = self.layer1(x)\n",
    "        l2 = self.layer2(l1)\n",
    "        l3 = self.layer3(l2)\n",
    "        l4 = self.layer4(l3)\n",
    "\n",
    "        l4 = self.dropout4(l4)\n",
    "        x4 = self.p_ims1d2_outl1_dimred(l4)\n",
    "        x4 = self.relu(x4)\n",
    "        x4 = self.mflow_conv_g1_pool(x4)\n",
    "        x4 = self.mflow_conv_g1_b3_joint_varout_dimred(x4)\n",
    "        x4 = nn.Upsample(size=l3.size()[2:], mode='bilinear')(x4)\n",
    "\n",
    "        l3 = self.dropout3(l3)\n",
    "        x3 = self.p_ims1d2_outl2_dimred(l3)\n",
    "        x3 = self.adapt_stage2_b2_joint_varout_dimred(x3)\n",
    "        x3 = x3 + x4\n",
    "        x3 = F.relu(x3)\n",
    "        x3 = self.mflow_conv_g2_pool(x3)\n",
    "        x3 = self.mflow_conv_g2_b3_joint_varout_dimred(x3)\n",
    "        x3 = nn.Upsample(size=l2.size()[2:], mode='bilinear')(x3)\n",
    "\n",
    "        x2 = self.p_ims1d2_outl3_dimred(l2)\n",
    "        x2 = self.adapt_stage3_b2_joint_varout_dimred(x2)\n",
    "        x2 = x2 + x3\n",
    "        x2 = F.relu(x2)\n",
    "        x2 = self.mflow_conv_g3_pool(x2)\n",
    "        x2 = self.mflow_conv_g3_b3_joint_varout_dimred(x2)\n",
    "        x2 = nn.Upsample(size=l1.size()[2:], mode='bilinear')(x2)\n",
    "\n",
    "        x1 = self.p_ims1d2_outl4_dimred(l1)\n",
    "        x1 = self.adapt_stage4_b2_joint_varout_dimred(x1)\n",
    "        x1 = x1 + x2\n",
    "        x1 = F.relu(x1)\n",
    "        x1 = self.mflow_conv_g4_pool(x1)\n",
    "\n",
    "        x1 = self.dropout_clf(x1)\n",
    "        out = self.clf_conv(x1)\n",
    "\n",
    "        #out = F.upsample(out, size=(85, 128), mode='bilinear')\n",
    "        #print(\"c\", out.size())\n",
    "\n",
    "        return out\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 53
    },
    "executionInfo": {
     "elapsed": 107569,
     "status": "ok",
     "timestamp": 1610708855219,
     "user": {
      "displayName": "omar elharrouss",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GjeGC_l4X-u1jl7ka6nlFmF9bP8pq1h8yOVXg_Wvg=s64",
      "userId": "07323381654864768298"
     },
     "user_tz": -180
    },
    "id": "wFalquZDh5Be",
    "outputId": "3e78c0c5-4a9a-4705-e250-4d3e229b421f"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "executionInfo": {
     "elapsed": 107564,
     "status": "ok",
     "timestamp": 1610708855219,
     "user": {
      "displayName": "omar elharrouss",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GjeGC_l4X-u1jl7ka6nlFmF9bP8pq1h8yOVXg_Wvg=s64",
      "userId": "07323381654864768298"
     },
     "user_tz": -180
    },
    "id": "hJKelhbJoaZw"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 53
    },
    "executionInfo": {
     "elapsed": 107558,
     "status": "ok",
     "timestamp": 1610708855220,
     "user": {
      "displayName": "omar elharrouss",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GjeGC_l4X-u1jl7ka6nlFmF9bP8pq1h8yOVXg_Wvg=s64",
      "userId": "07323381654864768298"
     },
     "user_tz": -180
    },
    "id": "SnL-wOkio8Ew",
    "outputId": "aa717a8a-b2e3-4da1-d15c-9824d842059c"
   },
   "outputs": [],
   "source": [
    "'''\n",
    "spn = MobileCount()\n",
    "print(spn)\n",
    "\n",
    "model = MobileCount()\n",
    "x = torch.randn(1, 3, 768, 1024)\n",
    "\n",
    "# Let's print it\n",
    "model(x)\n",
    "pytorch_total_params = sum(p.numel() for p in model.parameters())\n",
    "print(pytorch_total_params )\n",
    "pytorch_total_params = sum(p.numel() for p in model.parameters() if p.requires_grad)\n",
    "print(pytorch_total_params )\n",
    "'''\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "cqxtOhfcUqco",
    "outputId": "cc97e778-a04e-47f5-ef80-37e67894fedf"
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "import os\n",
    "\n",
    "import warnings\n",
    "\n",
    "# import from library\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.autograd import Variable\n",
    "from torchvision import datasets, transforms\n",
    "import numpy as np\n",
    "import argparse\n",
    "import json\n",
    "import cv2\n",
    "import time\n",
    "\n",
    "\"\"\"\n",
    "A dublicate of train.py \n",
    "However it does not need commandline arg\n",
    "\"\"\"\n",
    "def main():\n",
    "    global args, best_prec1\n",
    "    args = make_meow_args()\n",
    "\n",
    "\n",
    "    best_prec1 = 1e6\n",
    "\n",
    "    args.original_lr = 1e-7\n",
    "    args.lr = 1e-7\n",
    "    args.batch_size = 1\n",
    "    args.momentum = 0.95\n",
    "    args.decay = 5 * 1e-4\n",
    "    args.start_epoch = 0\n",
    "    args.epochs = 100\n",
    "    args.steps = [-1, 1, 100, 150]\n",
    "    args.scales = [1, 1, 1, 1]\n",
    "    args.workers = 4\n",
    "    args.seed = time.time()\n",
    "    args.print_freq = 30\n",
    "    args.pre = PRETRAINED_MODEL\n",
    "\n",
    "    os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu\n",
    "    torch.cuda.manual_seed(args.seed)\n",
    "\n",
    "    train_list, val_list = get_train_val_list(DATA_PATH)\n",
    "\n",
    "    model = MobileCount()\n",
    "\n",
    "    model = model.cuda()\n",
    "\n",
    "    criterion = nn.MSELoss(size_average=False).cuda()\n",
    "\n",
    "    optimizer = torch.optim.SGD(model.parameters(), args.lr,\n",
    "                                momentum=args.momentum,\n",
    "                                weight_decay=args.decay)\n",
    "\n",
    "    if args.pre:\n",
    "        if os.path.isfile(args.pre):\n",
    "            print(\"=> loading checkpoint '{}'\".format(args.pre))\n",
    "            checkpoint = torch.load(args.pre)\n",
    "            args.start_epoch = checkpoint['epoch']\n",
    "            best_prec1 = checkpoint['best_prec1']\n",
    "            model.load_state_dict(checkpoint['state_dict'])\n",
    "            optimizer.load_state_dict(checkpoint['optimizer'])\n",
    "            print(\"=> loaded checkpoint '{}' (epoch {})\"\n",
    "                  .format(args.pre, checkpoint['epoch']))\n",
    "        else:\n",
    "            print(\"=> no checkpoint found at '{}'\".format(args.pre))\n",
    "\n",
    "    for epoch in range(args.start_epoch, args.epochs):\n",
    "        adjust_learning_rate(optimizer, epoch)\n",
    "\n",
    "        train(train_list, model, criterion, optimizer, epoch)\n",
    "        prec1 = validate(val_list, model, criterion)\n",
    "        is_best = prec1 < best_prec1\n",
    "        best_prec1 = min(prec1, best_prec1)\n",
    "        print(' * best MAE {mae:.3f} '\n",
    "              .format(mae=best_prec1))\n",
    "        save_checkpoint({\n",
    "            'epoch': epoch + 1,\n",
    "            'arch': args.pre,\n",
    "            'state_dict': model.state_dict(),\n",
    "            'best_prec1': best_prec1,\n",
    "            'optimizer': optimizer.state_dict(),\n",
    "        }, is_best, args.task)\n",
    "\n",
    "\n",
    "def train(train_list, model, criterion, optimizer, epoch):\n",
    "    losses = AverageMeter()\n",
    "    batch_time = AverageMeter()\n",
    "    data_time = AverageMeter()\n",
    "    train_loader = torch.utils.data.DataLoader(\n",
    "        ListDataset(train_list,\n",
    "                            shuffle=True,\n",
    "                            transform=transforms.Compose([\n",
    "                                transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406],\n",
    "                                                                            std=[0.229, 0.224, 0.225]),\n",
    "                            ]),\n",
    "                            train=True,\n",
    "                            seen=model.seen,\n",
    "                            batch_size=args.batch_size,\n",
    "                            num_workers=args.workers),\n",
    "        batch_size=args.batch_size)\n",
    "    print('epoch %d, processed %d samples, lr %.10f' % (epoch, epoch * len(train_loader.dataset), args.lr))\n",
    "\n",
    "    model.train()\n",
    "    end = time.time()\n",
    "\n",
    "    for i, (img, target) in enumerate(train_loader):\n",
    "        data_time.update(time.time() - end)\n",
    "\n",
    "        img = img.cuda()\n",
    "        img = Variable(img)\n",
    "        output = model(img)\n",
    "\n",
    "        target = target.type(torch.FloatTensor).unsqueeze(0).cuda()\n",
    "        target = Variable(target)\n",
    "        \n",
    "        #print('out ', output.size(),' tar ',target.size())\n",
    "        #target.reshape([1, 1, 34, 120]) #out[1, 1, 34, 120])#tar[1, 1, 67, 120]\n",
    "        loss = criterion(output, target)\n",
    "\n",
    "        losses.update(loss.item(), img.size(0))\n",
    "        optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        batch_time.update(time.time() - end)\n",
    "        end = time.time()\n",
    "\n",
    "        if i % args.print_freq == 0:\n",
    "            print('Epoch: [{0}][{1}/{2}]\\t'\n",
    "                  'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\\t'\n",
    "                  'Data {data_time.val:.3f} ({data_time.avg:.3f})\\t'\n",
    "                  'Loss {loss.val:.4f} ({loss.avg:.4f})\\t'\n",
    "                .format(\n",
    "                epoch, i, len(train_loader), batch_time=batch_time,\n",
    "                data_time=data_time, loss=losses))\n",
    "\n",
    "\n",
    "def validate(val_list, model, criterion):\n",
    "    print('begin test')\n",
    "    test_loader = torch.utils.data.DataLoader(\n",
    "        ListDataset(val_list,\n",
    "                            shuffle=False,\n",
    "                            transform=transforms.Compose([\n",
    "                                transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406],\n",
    "                                                                            std=[0.229, 0.224, 0.225]),\n",
    "                            ]), train=False),\n",
    "        batch_size=args.batch_size)\n",
    "\n",
    "    model.eval()\n",
    "\n",
    "    mae = 0\n",
    "\n",
    "    for i, (img, target) in enumerate(test_loader):\n",
    "        img = img.cuda()\n",
    "        img = Variable(img)\n",
    "        output = model(img)\n",
    "\n",
    "        mae += abs(output.data.sum() - target.sum().type(torch.FloatTensor).cuda())\n",
    "        #print('kkkk',format(mae))\n",
    "\n",
    "    mae = mae / len(test_loader)\n",
    "    print(' * MAE {mae:.3f} '\n",
    "          .format(mae=mae))\n",
    "\n",
    "    return mae\n",
    "\n",
    "def adjust_learning_rate(optimizer, epoch):\n",
    "    \"\"\"Sets the learning rate to the initial LR decayed by 10 every 30 epochs\"\"\"\n",
    "\n",
    "    args.lr = args.original_lr\n",
    "\n",
    "    for i in range(len(args.steps)):\n",
    "\n",
    "        scale = args.scales[i] if i < len(args.scales) else 1\n",
    "\n",
    "        if epoch >= args.steps[i]:\n",
    "            args.lr = args.lr * scale\n",
    "            if epoch == args.steps[i]:\n",
    "                break\n",
    "        else:\n",
    "            break\n",
    "    for param_group in optimizer.param_groups:\n",
    "        param_group['lr'] = args.lr\n",
    "\n",
    "class AverageMeter(object):\n",
    "    \"\"\"Computes and stores the average and current value\"\"\"\n",
    "\n",
    "    def __init__(self):\n",
    "        self.reset()\n",
    "\n",
    "    def reset(self):\n",
    "        self.val = 0\n",
    "        self.avg = 0\n",
    "        self.sum = 0\n",
    "        self.count = 0\n",
    "\n",
    "    def update(self, val, n=1):\n",
    "        self.val = val\n",
    "        self.sum += val * n\n",
    "        self.count += n\n",
    "        self.avg = self.sum / self.count\n",
    "        \n",
    "if __name__ == '__main__':\n",
    "\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "kLAzw3sKkVq_"
   },
   "outputs": [],
   "source": [
    "test_image_list = create_training_image_list(TEST_DATA_PATH)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "LT1ygH9xkXqj"
   },
   "outputs": [],
   "source": [
    "best_checkpoint = torch.load(\"task_one_checkpoint.pth.tar\")\n",
    "model = MobileCount()\n",
    "optimizer = torch.optim.SGD(model.parameters(), args.lr,\n",
    "                            momentum=args.momentum,\n",
    "                            weight_decay=args.decay)\n",
    "criterion = nn.MSELoss(size_average=False).cuda()\n",
    "model.load_state_dict(best_checkpoint['state_dict'])\n",
    "optimizer.load_state_dict(best_checkpoint['optimizer'])\n",
    "model = model.cuda()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "jhBKNXiNkYQw"
   },
   "outputs": [],
   "source": [
    "test_result = validate(test_image_list, model, criterion)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "aWQuhpPWkaUw"
   },
   "outputs": [],
   "source": [
    "best_checkpoint = torch.load(\"task_one_model_best.pth.tar\")\n",
    "model = MobileCount()\n",
    "optimizer = torch.optim.SGD(model.parameters(), args.lr,\n",
    "                            momentum=args.momentum,\n",
    "                            weight_decay=args.decay)\n",
    "criterion = nn.MSELoss(size_average=False).cuda()\n",
    "model.load_state_dict(best_checkpoint['state_dict'])\n",
    "optimizer.load_state_dict(best_checkpoint['optimizer'])\n",
    "model = model.cuda()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "yp2G4LjZkeBN"
   },
   "outputs": [],
   "source": [
    "test_result = validate(test_image_list, model, criterion)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "tKVJ3Z1gbmXL"
   },
   "outputs": [],
   "source": [
    "val_list=create_training_image_list(TEST_DATA_PATH)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "HFAKDwOZbZ4A"
   },
   "outputs": [],
   "source": [
    "import glob\n",
    "# importing libraries\n",
    "import h5py\n",
    "import scipy.io as io\n",
    "import PIL.Image as Image\n",
    "import numpy as np\n",
    "import os\n",
    "import glob\n",
    "from matplotlib import pyplot as plt\n",
    "from scipy.ndimage.filters import gaussian_filter\n",
    "import scipy\n",
    "import json\n",
    "from matplotlib import cm as CM\n",
    "import torch\n",
    "from tqdm import tqdm\n",
    "%matplotlib inline\n",
    "\n",
    "from torchvision import datasets, transforms\n",
    "transform=transforms.Compose([\n",
    "                       transforms.ToTensor(),transforms.Normalize(mean=[0.485, 0.456, 0.406],\n",
    "                                     std=[0.229, 0.224, 0.225]),\n",
    "                   ])\n",
    "model = MobileCount()\n",
    "model = model.cuda()\n",
    "checkpoint = torch.load('./task_one_model_best.pth.tar')\n",
    "model.load_state_dict(checkpoint['state_dict'])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "OBOFQTwqbZ7_"
   },
   "outputs": [],
   "source": [
    "from matplotlib import cm as c\n",
    "for i in range(len(val_list)):\n",
    "    print('frame:',i)\n",
    "    #print('kkkk',os.path.splitext(os.path.basename(val_list[i]))[0])\n",
    "    ll=os.path.splitext(os.path.basename(val_list[i]))[0]\n",
    "    img = transform(Image.open(val_list[i]).convert('RGB')).cuda()\n",
    "    output = model(img.unsqueeze(0))\n",
    "    #print(\"Predicted Count : \",int(output.detach().cpu().sum().numpy()))\n",
    "    temp = np.asarray(output.detach().cpu().reshape(output.detach().cpu().shape[2],output.detach().cpu().shape[3]))\n",
    "    fig = plt.figure()\n",
    "    ax = fig.add_subplot(111)\n",
    "    ax.set_title(int(output.detach().cpu().sum().numpy()))\n",
    "    plt.imshow(temp,cmap = c.jet)\n",
    "    plt.savefig('./data_results/SCNet_'+ ll + '.png')\n",
    "    plt.show()\n",
    "    \n",
    "    temp = h5py.File('./Data/test_data/ground-truth/' + ll + '.h5', 'r')\n",
    "    temp_1 = np.asarray(temp['density'])\n",
    "    fig = plt.figure()\n",
    "    ax = fig.add_subplot(111)\n",
    "    ax.set_title(int(np.sum(temp_1)) + 1)\n",
    "    plt.imshow(temp_1,cmap = c.jet)\n",
    "    plt.savefig('./data_results/'+ ll + '_GT.png')\n",
    "    print(\"Original Count : \",int(np.sum(temp_1)) + 1)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "machine_shape": "hm",
   "name": "SCNet_Noise.ipynb",
   "provenance": [
    {
     "file_id": "1lwhIWmPtuRTVxjbFNTvJ6eCxwiA31bap",
     "timestamp": 1610365456444
    },
    {
     "file_id": "12vU-c_ylj7TGKPcKLvGfvzXvumJsFbE1",
     "timestamp": 1593574342224
    },
    {
     "file_id": "1RML6_NrScU6kToBp0PXBxnq0VVQM6EZk",
     "timestamp": 1593037402983
    },
    {
     "file_id": "1DBHeyiUkLWx7Z3v0IqUm66OYI1-5scpC",
     "timestamp": 1592901670352
    },
    {
     "file_id": "1Apn_K4xy2GD1dhj-dXZXvi2JyIP3wZs5",
     "timestamp": 1592883244181
    },
    {
     "file_id": "11J0BP6gh3z0Tm8goj-nqO_kpwS6vDJxy",
     "timestamp": 1592871323270
    },
    {
     "file_id": "1YkjWuzbj9f_Fib8QxAQ13VPaERIqZTR0",
     "timestamp": 1592728935157
    },
    {
     "file_id": "1fC6sSVameLJqz30S2pks_565pdGXjurs",
     "timestamp": 1592627209425
    },
    {
     "file_id": "1Su3hgh6k005ooGJFGZlVkXib8Hwsvgc2",
     "timestamp": 1592507243771
    }
   ]
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}