Test_pytorch.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "@common.py:  \n",
      "\tset random seed\n",
      "\t\tSEED=1513097643\n",
      "\tset cuda environment\n",
      "\t\ttorch.cuda.device_count()   = 2\n",
      "\t\ttorch.cuda.current_device() = 0\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "import cv2\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import os\n",
    "from common import *\n",
    "from torch.autograd import Variable\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "#from excited_inception_v3 import SEInception3\n",
    "#from inception_v3 import Inception3\n",
    "#from xception import Xception\n",
    "from resnet101 import ResNet101\n",
    "from tqdm import tqdm_notebook\n",
    "from pytorch_img_functions import ten_crop, resize\n",
    "from PIL import Image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "FILELIST_CSV =\"/media/cvpr/SSD/Cdiscount/pytorch_models/release/demo_code/FileList.csv\"\n",
    "\n",
    "\n",
    "CATEGORIES_CSV=\"/media/cvpr/SSD/Cdiscount/pytorch_models/release/demo_code/categories.csv\" \n",
    "category_ids = np.array(pd.read_csv(CATEGORIES_CSV, header=None).values).flatten()\n",
    "\n",
    "#CATEGORIES_PKL='/media/cvpr/SSD/Cdiscount/downloaded/class_order.pkl'\n",
    "#category_ids = pickle.load(open(CATEGORIES_PKL, \"rb\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "result_ids=np.array([], dtype=int)\n",
    "result_classes=np.array([], dtype=int)\n",
    "\n",
    "buffer_pred=np.array([], dtype=np.float32) #buffer to keep temporary predictios\n",
    "buffer_id=np.array([], dtype=np.float32) # buffers to keep temporary ids\n",
    "\n",
    "INCLUDE_FLIPPED_IMAGES=True\n",
    "\n",
    "#result_csv=\"Inceptionv3pytorch_result.csv\"\n",
    "result_predictions=\"ensemble.h5\"\n",
    "\n",
    "#result_csv = os.path.join(\"/home/cvpr/Desktop/Nabin/cdiscount/\", result_csv)\n",
    "result_predictions=os.path.join(\"/home/cvpr/Desktop/Nabin/cdiscount/ensemble\", result_predictions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import tables\n",
    "hdf5_file = tables.open_file(result_predictions, mode='a')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#hdf5_ids = hdf5_file.create_earray(hdf5_file.root, 'product_id', tables.Int32Atom(), shape=(0, 1))\n",
    "#hdf5_categories = hdf5_file.create_earray(hdf5_file.root, 'category_id', tables.Int32Atom(), shape=(0, 1))\n",
    "#hdf5_categories.append(category_ids.reshape(5270, 1))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#hdf5_predictions = hdf5_file.create_earray(hdf5_file.root, 'inecptionV3', tables.Float32Atom(), shape=(0, 5270))\n",
    "#hdf5_predictions = hdf5_file.create_earray(hdf5_file.root, 'xception', tables.Float32Atom(), shape=(0, 5270))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "predictions_mean = hdf5_file.create_earray(hdf5_file.root, 'pytorch_resnet101_mean', \n",
    "                                           tables.Float32Atom(), shape=(0, 5270),\n",
    "                                          expectedrows=1768182)\n",
    "predictions_median = hdf5_file.create_earray(hdf5_file.root, 'pytorch_resnet101_median', \n",
    "                                           tables.Float32Atom(), shape=(0, 5270),\n",
    "                                          expectedrows=1768182)\n",
    "predictions_max = hdf5_file.create_earray(hdf5_file.root, 'pytorch_resnet101_max', \n",
    "                                           tables.Float32Atom(), shape=(0, 5270),\n",
    "                                          expectedrows=1768182)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class CDiscountPytorch(Dataset):\n",
    "    \n",
    "    def __init__(self, csv_file, img_size=(180, 180)):\n",
    "        '''\n",
    "        Parameters:\n",
    "            csv_file: a csv file with all details about images\n",
    "            img_size: a tuple (image rows, image columns)\n",
    "        '''\n",
    "        super(CDiscountPytorch, self).__init__()\n",
    "        self.csv_file  = pd.read_csv(csv_file)\n",
    "        self.img_files = self.csv_file[\"file_name\"].values\n",
    "        self.ids = self.csv_file[\"id\"].values\n",
    "        self.img_nums=self.csv_file[\"img_num\"].values\n",
    "        self.img_size=img_size\n",
    "        \n",
    "        \n",
    "    def __getitem__(self, index):\n",
    "        filename = self.img_files[index]\n",
    "        img_id = self.ids[index]\n",
    "        img_num = self.img_nums[index]\n",
    "        \n",
    "        image = cv2.imread(filename, 1)\n",
    "        image = self.transform(image)  \n",
    "        return image, img_id, img_num\n",
    "    \n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.img_files)\n",
    "    \n",
    "    \n",
    "    def transform1(self,x, reverse_mode=False):\n",
    "        '''\n",
    "        converts RGB values from [0,255] \n",
    "        to [0, 1] and vice versa\n",
    "                Parameter:\n",
    "            reverse_mode: boolean, default is False\n",
    "                          False:[0, 255]-->[0, 1] \n",
    "                          True: [0, 1]-->[0, 255]\n",
    "        '''\n",
    "        if reverse_mode:\n",
    "            return x * 255.\n",
    "        else:\n",
    "            return x/255.\n",
    "    \n",
    "    def transform2(self,x, reverse_mode=False):\n",
    "        '''\n",
    "        converts RGB values from [0,255] \n",
    "        to [-1, 1] and vice versa\n",
    "        \n",
    "        Parameter:\n",
    "            reverse_mode: boolean, default is False\n",
    "                          False:[0, 255]-->[-1, 1] \n",
    "                          True: [-1, 1]-->[0, 255]\n",
    "        '''\n",
    "        if reverse_mode:\n",
    "            return ((x / 2.0)+0.5)*255.0\n",
    "        else:\n",
    "            return ((x / 255.0)-0.5)*2.0\n",
    "\n",
    "        \n",
    "    \n",
    "    def transform(self,image):\n",
    "        mean = [0.485, 0.456, 0.406 ]\n",
    "        std  = [0.229, 0.224, 0.225 ]\n",
    "        image = cv2.cvtColor(image,cv2.COLOR_BGR2RGB)\n",
    "        image = image.transpose((2,0,1))\n",
    "        tensor = torch.from_numpy(image).float().div(255.0)\n",
    "        tensor[0] = (tensor[0] - mean[0]) / std[0]\n",
    "        tensor[1] = (tensor[1] - mean[1]) / std[1]\n",
    "        tensor[2] = (tensor[2] - mean[2]) / std[2]\n",
    "        return tensor "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "cdiscount_test_data=CDiscountPytorch(csv_file=FILELIST_CSV)\n",
    "dataloader = DataLoader(cdiscount_test_data, batch_size=256, num_workers=16)\n",
    "data=iter(dataloader)\n",
    "total_batches = len(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ResNet101 (\n",
       "  (layer0): Sequential (\n",
       "    (0): ConvBn2d (\n",
       "      (conv): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n",
       "      (bn): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True)\n",
       "    )\n",
       "    (1): ReLU (inplace)\n",
       "    (2): MaxPool2d (size=(3, 3), stride=(2, 2), padding=(1, 1), dilation=(1, 1))\n",
       "  )\n",
       "  (layer1): Sequential (\n",
       "    (0): Bottleneck (\n",
       "      (conv_bn1): ConvBn2d (\n",
       "        (conv): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn2): ConvBn2d (\n",
       "        (conv): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn3): ConvBn2d (\n",
       "        (conv): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (downsample): ConvBn2d (\n",
       "        (conv): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "    )\n",
       "    (1): Bottleneck (\n",
       "      (conv_bn1): ConvBn2d (\n",
       "        (conv): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn2): ConvBn2d (\n",
       "        (conv): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn3): ConvBn2d (\n",
       "        (conv): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "    )\n",
       "    (2): Bottleneck (\n",
       "      (conv_bn1): ConvBn2d (\n",
       "        (conv): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn2): ConvBn2d (\n",
       "        (conv): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn3): ConvBn2d (\n",
       "        (conv): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (layer2): Sequential (\n",
       "    (0): Bottleneck (\n",
       "      (conv_bn1): ConvBn2d (\n",
       "        (conv): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn2): ConvBn2d (\n",
       "        (conv): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn3): ConvBn2d (\n",
       "        (conv): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (downsample): ConvBn2d (\n",
       "        (conv): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
       "        (bn): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "    )\n",
       "    (1): Bottleneck (\n",
       "      (conv_bn1): ConvBn2d (\n",
       "        (conv): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn2): ConvBn2d (\n",
       "        (conv): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn3): ConvBn2d (\n",
       "        (conv): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "    )\n",
       "    (2): Bottleneck (\n",
       "      (conv_bn1): ConvBn2d (\n",
       "        (conv): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn2): ConvBn2d (\n",
       "        (conv): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn3): ConvBn2d (\n",
       "        (conv): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "    )\n",
       "    (3): Bottleneck (\n",
       "      (conv_bn1): ConvBn2d (\n",
       "        (conv): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn2): ConvBn2d (\n",
       "        (conv): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn3): ConvBn2d (\n",
       "        (conv): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (layer3): Sequential (\n",
       "    (0): Bottleneck (\n",
       "      (conv_bn1): ConvBn2d (\n",
       "        (conv): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn2): ConvBn2d (\n",
       "        (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn3): ConvBn2d (\n",
       "        (conv): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (downsample): ConvBn2d (\n",
       "        (conv): Conv2d(512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
       "        (bn): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "    )\n",
       "    (1): Bottleneck (\n",
       "      (conv_bn1): ConvBn2d (\n",
       "        (conv): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn2): ConvBn2d (\n",
       "        (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn3): ConvBn2d (\n",
       "        (conv): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "    )\n",
       "    (2): Bottleneck (\n",
       "      (conv_bn1): ConvBn2d (\n",
       "        (conv): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn2): ConvBn2d (\n",
       "        (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn3): ConvBn2d (\n",
       "        (conv): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "    )\n",
       "    (3): Bottleneck (\n",
       "      (conv_bn1): ConvBn2d (\n",
       "        (conv): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn2): ConvBn2d (\n",
       "        (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn3): ConvBn2d (\n",
       "        (conv): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "    )\n",
       "    (4): Bottleneck (\n",
       "      (conv_bn1): ConvBn2d (\n",
       "        (conv): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn2): ConvBn2d (\n",
       "        (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn3): ConvBn2d (\n",
       "        (conv): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "    )\n",
       "    (5): Bottleneck (\n",
       "      (conv_bn1): ConvBn2d (\n",
       "        (conv): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn2): ConvBn2d (\n",
       "        (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn3): ConvBn2d (\n",
       "        (conv): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "    )\n",
       "    (6): Bottleneck (\n",
       "      (conv_bn1): ConvBn2d (\n",
       "        (conv): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn2): ConvBn2d (\n",
       "        (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn3): ConvBn2d (\n",
       "        (conv): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "    )\n",
       "    (7): Bottleneck (\n",
       "      (conv_bn1): ConvBn2d (\n",
       "        (conv): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn2): ConvBn2d (\n",
       "        (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn3): ConvBn2d (\n",
       "        (conv): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "    )\n",
       "    (8): Bottleneck (\n",
       "      (conv_bn1): ConvBn2d (\n",
       "        (conv): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn2): ConvBn2d (\n",
       "        (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn3): ConvBn2d (\n",
       "        (conv): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "    )\n",
       "    (9): Bottleneck (\n",
       "      (conv_bn1): ConvBn2d (\n",
       "        (conv): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn2): ConvBn2d (\n",
       "        (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn3): ConvBn2d (\n",
       "        (conv): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "    )\n",
       "    (10): Bottleneck (\n",
       "      (conv_bn1): ConvBn2d (\n",
       "        (conv): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn2): ConvBn2d (\n",
       "        (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn3): ConvBn2d (\n",
       "        (conv): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "    )\n",
       "    (11): Bottleneck (\n",
       "      (conv_bn1): ConvBn2d (\n",
       "        (conv): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn2): ConvBn2d (\n",
       "        (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn3): ConvBn2d (\n",
       "        (conv): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "    )\n",
       "    (12): Bottleneck (\n",
       "      (conv_bn1): ConvBn2d (\n",
       "        (conv): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn2): ConvBn2d (\n",
       "        (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn3): ConvBn2d (\n",
       "        (conv): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "    )\n",
       "    (13): Bottleneck (\n",
       "      (conv_bn1): ConvBn2d (\n",
       "        (conv): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn2): ConvBn2d (\n",
       "        (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn3): ConvBn2d (\n",
       "        (conv): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "    )\n",
       "    (14): Bottleneck (\n",
       "      (conv_bn1): ConvBn2d (\n",
       "        (conv): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn2): ConvBn2d (\n",
       "        (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn3): ConvBn2d (\n",
       "        (conv): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "    )\n",
       "    (15): Bottleneck (\n",
       "      (conv_bn1): ConvBn2d (\n",
       "        (conv): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn2): ConvBn2d (\n",
       "        (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn3): ConvBn2d (\n",
       "        (conv): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "    )\n",
       "    (16): Bottleneck (\n",
       "      (conv_bn1): ConvBn2d (\n",
       "        (conv): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn2): ConvBn2d (\n",
       "        (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn3): ConvBn2d (\n",
       "        (conv): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "    )\n",
       "    (17): Bottleneck (\n",
       "      (conv_bn1): ConvBn2d (\n",
       "        (conv): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn2): ConvBn2d (\n",
       "        (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn3): ConvBn2d (\n",
       "        (conv): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "    )\n",
       "    (18): Bottleneck (\n",
       "      (conv_bn1): ConvBn2d (\n",
       "        (conv): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn2): ConvBn2d (\n",
       "        (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn3): ConvBn2d (\n",
       "        (conv): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "    )\n",
       "    (19): Bottleneck (\n",
       "      (conv_bn1): ConvBn2d (\n",
       "        (conv): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn2): ConvBn2d (\n",
       "        (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn3): ConvBn2d (\n",
       "        (conv): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "    )\n",
       "    (20): Bottleneck (\n",
       "      (conv_bn1): ConvBn2d (\n",
       "        (conv): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn2): ConvBn2d (\n",
       "        (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn3): ConvBn2d (\n",
       "        (conv): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "    )\n",
       "    (21): Bottleneck (\n",
       "      (conv_bn1): ConvBn2d (\n",
       "        (conv): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn2): ConvBn2d (\n",
       "        (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn3): ConvBn2d (\n",
       "        (conv): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "    )\n",
       "    (22): Bottleneck (\n",
       "      (conv_bn1): ConvBn2d (\n",
       "        (conv): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn2): ConvBn2d (\n",
       "        (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn3): ConvBn2d (\n",
       "        (conv): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (layer4): Sequential (\n",
       "    (0): Bottleneck (\n",
       "      (conv_bn1): ConvBn2d (\n",
       "        (conv): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn2): ConvBn2d (\n",
       "        (conv): Conv2d(512, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn3): ConvBn2d (\n",
       "        (conv): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (downsample): ConvBn2d (\n",
       "        (conv): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
       "        (bn): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "    )\n",
       "    (1): Bottleneck (\n",
       "      (conv_bn1): ConvBn2d (\n",
       "        (conv): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn2): ConvBn2d (\n",
       "        (conv): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn3): ConvBn2d (\n",
       "        (conv): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "    )\n",
       "    (2): Bottleneck (\n",
       "      (conv_bn1): ConvBn2d (\n",
       "        (conv): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn2): ConvBn2d (\n",
       "        (conv): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "      (conv_bn3): ConvBn2d (\n",
       "        (conv): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (bn): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True)\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (fc): Linear (2048 -> 5270)\n",
       ")"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# cdiscount data set ----\n",
    "CDISCOUNT_NUM_CLASSES = 5270\n",
    "CDISCOUNT_HEIGHT=180\n",
    "CDISCOUNT_WIDTH =180\n",
    "\n",
    "#load the newtork\n",
    "\n",
    "#model_file ='LB=0.69673_se-inc3_00026000_model.pth' #does not give this result\n",
    "#net = SEInception3(in_shape=(3,CDISCOUNT_HEIGHT,CDISCOUNT_WIDTH),num_classes=CDISCOUNT_NUM_CLASSES)\n",
    "\n",
    "#model_file ='LB=0.69565_inc3_00075000_model.pth'\n",
    "#net = Inception3(in_shape=(3,CDISCOUNT_HEIGHT,CDISCOUNT_WIDTH),num_classes=CDISCOUNT_NUM_CLASSES)\n",
    "\n",
    "#model_file='LB=0.69422_xception_00158000_model.pth'\n",
    "#net = Xception(in_shape=(3,CDISCOUNT_HEIGHT,CDISCOUNT_WIDTH),num_classes=CDISCOUNT_NUM_CLASSES)\n",
    "\n",
    "model_file='Resnet_101_00243000_model.pth'\n",
    "net = ResNet101(in_shape=(3,CDISCOUNT_HEIGHT,CDISCOUNT_WIDTH),num_classes=CDISCOUNT_NUM_CLASSES)\n",
    "\n",
    "\n",
    "net.load_state_dict(torch.load(model_file))\n",
    "#net.cuda().eval()\n",
    "net.cuda()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def process_buffer(data=None, index=None):\n",
    "    pred_df = pd.DataFrame(data=data,  index=index, columns= category_ids, dtype=np.float32)\n",
    "    #merge rows with same index (product id)\n",
    "    pred_df_mean = pred_df.groupby(pred_df.index).mean()\n",
    "    pred_df_median = pred_df.groupby(pred_df.index).median()\n",
    "    pred_df_max = pred_df.groupby(pred_df.index).max()\n",
    "    \n",
    "    predictions_mean.append(pred_df_mean.values)\n",
    "    predictions_median.append(pred_df_median.values)\n",
    "    predictions_max.append(pred_df_max.values)\n",
    "    #hdf5_ids.append(pred_df.index.values.reshape(-1, 1))\n",
    "    \n",
    "    #find the column with maximum predicted value\n",
    "    #pred_df[\"category_id\"] = pred_df.idxmax(axis=1)\n",
    "\n",
    "    #result_ids = pred_df.index.tolist()\n",
    "    #result_classes = pred_df[\"category_id\"].values\n",
    "    #return result_ids, result_classes\n",
    "    return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d74f43e38e3b4c94a8cfcd6616300d50",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "A Jupyter Widget"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#total_batches=200\n",
    "bar = tqdm_notebook(total=total_batches)\n",
    "for batch_number in range(total_batches):\n",
    "    \n",
    "    current_batch=data.next()\n",
    "    \n",
    "    first_image_number=current_batch[2][0]\n",
    "    \n",
    "    ids=np.array(current_batch[1].numpy())\n",
    "    if INCLUDE_FLIPPED_IMAGES:\n",
    "        ids=np.concatenate((ids,ids), axis=0)\n",
    "    \n",
    "    X_data=current_batch[0]\n",
    "    if INCLUDE_FLIPPED_IMAGES:\n",
    "        flipped_images=torch.from_numpy(X_data.numpy()[:,:,:,::-1].copy())\n",
    "        X_data=torch.cat((X_data, flipped_images), 0)\n",
    "    \n",
    "    X_data = Variable(X_data,volatile=True).cuda()\n",
    "    \n",
    "\n",
    "    ## Predictions of model\n",
    "    logits = net(X_data)\n",
    "    probs  = F.softmax(logits)\n",
    "    predictions  = probs.cpu().data.numpy()\n",
    "    del logits, probs\n",
    "    \n",
    "    #predictions=F.softmax(net(X_data)).cpu().data.numpy()\n",
    "\n",
    "\n",
    "    # if it is a first batch, simply put predictions in buffer\n",
    "    if batch_number==0:\n",
    "        buffer_pred=predictions\n",
    "        buffer_id=ids\n",
    "\n",
    "    else:\n",
    "        #if first image number is zero\n",
    "        # 1. first process the items of buffer\n",
    "        if first_image_number == 0:\n",
    "            process_buffer(data=buffer_pred,  index=buffer_id)\n",
    "            #res_ids, res_classes=process_buffer(data=buffer_pred,  index=buffer_id)\n",
    "            #result_ids = np.concatenate((result_ids, res_ids), axis=0)\n",
    "            #result_classes = np.concatenate((result_classes, res_classes), axis=0)\n",
    "            \n",
    "            # 2. Then put only current predictions and ids in the buffers\n",
    "            buffer_pred=predictions\n",
    "            buffer_id=ids\n",
    "        else:\n",
    "            # if first image number is not zero simply append predictins and ids to buffer\n",
    "            buffer_pred = np.concatenate((buffer_pred, predictions), axis=0)\n",
    "            buffer_id = np.concatenate((buffer_id, ids), axis=0)\n",
    "    \n",
    "    if batch_number == total_batches-1:\n",
    "        process_buffer(data=buffer_pred,  index=buffer_id)\n",
    "        #res_ids, res_classes=process_buffer(data=buffer_pred,  index=buffer_id)\n",
    "        #result_ids = np.concatenate((result_ids, res_ids), axis=0)\n",
    "        #result_classes = np.concatenate((result_classes, res_classes), axis=0)\n",
    "    \n",
    "    del ids, predictions, X_data, current_batch\n",
    "    bar.update()\n",
    "    \n",
    "hdf5_file.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.6.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}