diff --git a/Error_analysis.ipynb b/Error_analysis.ipynb
index adcc3fe..e0663d0 100644
--- a/Error_analysis.ipynb
+++ b/Error_analysis.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 2,
    "metadata": {
     "scrolled": true
    },
@@ -10,7 +10,7 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "9d15e09286194fd1a2cd73a89fbb81d5",
+       "model_id": "09731d05652c476dbf4581de5acb2730",
        "version_major": 2,
        "version_minor": 0
       },
@@ -37,7 +37,7 @@
     "CLASSES = ('tennis-court', 'container-crane', 'storage-tank', 'baseball-diamond', 'plane','ground-track-field',\n",
     "               'helicopter', 'airport','harbor', 'ship', 'large-vehicle', 'swimming-pool', 'soccer-ball-field',\n",
     "               'roundabout', 'basketball-court', 'bridge', 'small-vehicle', 'helipad')\n",
-    "ann = mmcv.load(\"./result/eval_postnms.pkl\")\n",
+    "ann = mmcv.load(\"./result/post_nms.pkl\")\n",
     "ret = {}\n",
     "names = ann.keys()\n",
     "for name in tqdm(names):\n",
@@ -67,7 +67,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [
     {
@@ -75,7 +75,7 @@
      "output_type": "stream",
      "text": [
       "loading annotations into memory...\n",
-      "Done (t=0.59s)\n",
+      "Done (t=0.81s)\n",
       "creating index...\n",
       "index created!\n"
      ]
@@ -83,7 +83,7 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "c14b060169f54e71a774b2d79c999e13",
+       "model_id": "d083f9c5f226426c9b291719d34315ff",
        "version_major": 2,
        "version_minor": 0
       },
@@ -154,7 +154,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 4,
    "metadata": {
     "collapsed": true
    },
@@ -356,13 +356,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "bfe29a831f264524a84ed7abd3949bd9",
+       "model_id": "ec48c113525746da95659e534e31254c",
        "version_major": 2,
        "version_minor": 0
       },
@@ -378,8 +378,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "81048 46969\n",
-      "90237 46969\n"
+      "81048 52725\n",
+      "148945 52725\n"
      ]
     }
    ],
diff --git a/PrepareData.ipynb b/PrepareData.ipynb
index ad3921f..76637ee 100644
--- a/PrepareData.ipynb
+++ b/PrepareData.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 54,
+   "execution_count": 119,
    "metadata": {},
    "outputs": [
     {
@@ -48,8 +48,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 89,
-   "metadata": {},
+   "execution_count": 150,
+   "metadata": {
+    "collapsed": true
+   },
    "outputs": [],
    "source": [
     "def bbox_overlaps_py(boxes, query_boxes):\n",
@@ -197,7 +199,6 @@
     "def scale_genrate_warpper(label_path, img_name, img_path, outdir, phase, SCALE):\n",
     "    annotation = []\n",
     "    original_img = cv2.imread(img_path)\n",
-    "    h, w, _ = original_img.shape\n",
     "    scales = copy.deepcopy(SCALE)\n",
     "    fp = open(label_path).readlines()[2:]\n",
     "    for scale in scales:\n",
@@ -276,6 +277,8 @@
     "def increment_warpper_train(img_path, img_name, label_path, outdir, phase):\n",
     "    original_img = cv2.imread(img_path)\n",
     "    h, w, _ = original_img.shape\n",
+    "    if(max(h,w)/min(h,w)>5):\n",
+    "        return None\n",
     "    scale = 512 /  max(h, w)\n",
     "    fp = open(label_path).readlines()[2:]\n",
     "    img, scale_factor = mmcv.imrescale(original_img, scale, return_scale=True)\n",
@@ -306,6 +309,8 @@
     "        rets.append(p.apply_async(increment_warpper_train, args=(img_path, imgs[img_id], label_path, outdir, phase), callback=update))\n",
     "    for ret in rets:\n",
     "        info = ret.get()\n",
+    "        if info is None:\n",
+    "            continue\n",
     "        filename, h, w = info[\"image\"]\n",
     "        image =  construct_imginfo(filename, h, w, ID)\n",
     "        annotations[\"images\"].append(image)\n",
@@ -365,7 +370,6 @@
     "def test_generater(imgname, img_path, outdir, phase, SCALE):\n",
     "    annotation = []\n",
     "    original_img = cv2.imread(img_path)\n",
-    "    h, w, _ = original_img.shape\n",
     "    scales = copy.deepcopy(SCALE)\n",
     "    for scale in scales:\n",
     "        img, scale_factor = mmcv.imrescale(original_img, scale, return_scale=True)\n",
@@ -377,7 +381,7 @@
     "                count+=1\n",
     "                xmin, ymin, xmax, ymax = chip\n",
     "                img2 = copy.deepcopy(img[int(ymin):int(ymax), int(xmin):int(xmax),:])\n",
-    "                hh, ww, _ = img2.shape\n",
+    "                h, w, _ = img2.shape\n",
     "                filename = imgname.split(\".\")[0] + \"_{}_{}_{}_{}\".format(str(scale), str(xmin), str(ymin), str(0))+\"part\" +str(count) + \".jpg\"\n",
     "                cv2.imwrite(\"{}/{}/\".format(outdir, phase)+filename, img2)\n",
     "                image = [filename, h ,w]\n",
@@ -434,6 +438,8 @@
     "def increment_warpper(img_path, img_name, outdir, phase):\n",
     "    original_img = cv2.imread(img_path)\n",
     "    h, w, _ = original_img.shape\n",
+    "    if(max(h, w)/min(h,w) > 5):\n",
+    "        return None\n",
     "    scale_factor = 512 /  max(h, w)\n",
     "    img, scale_factor = mmcv.imrescale(original_img, scale_factor, return_scale=True)\n",
     "    H,W,_ = img.shape\n",
@@ -457,6 +463,8 @@
     "        rets.append(p.apply_async(increment_warpper, args=(img_path, imgs[img_id], outdir, phase), callback=update))\n",
     "    for ret in rets:\n",
     "        info = ret.get()\n",
+    "        if(info is None):\n",
+    "            continue\n",
     "        filename, h, w = info \n",
     "        image = construct_imginfo(filename, h, w, ID)\n",
     "        annotations[\"images\"].append(image)\n",
@@ -565,7 +573,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 66,
+   "execution_count": 151,
    "metadata": {},
    "outputs": [
     {
@@ -578,7 +586,7 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "aa66e321a3ac434aae78837f2f8b1037",
+       "model_id": "e963afb13bab4fa78113de06d69dbab6",
        "version_major": 2,
        "version_minor": 0
       },
@@ -593,14 +601,39 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "totol number 63607\n"
+      "totol number 63607\n",
+      "loading annotations into memory...\n",
+      "Done (t=0.16s)\n",
+      "creating index...\n",
+      "index created!\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "823f28ff6a6d4ba1a3d072e53b6f67c7",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "HBox(children=(IntProgress(value=0, max=780), HTML(value='')))"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "totol number 64387\n"
      ]
     }
    ],
    "source": [
     "datadir = \"/home/xfr/rssid/data/test/images\"\n",
-    "scale_generate_test(datadir, \"./data/trash\", \"test\", [0.5, 1])\n",
-    "increment_generate(datadir, \"./data/trash/annotation/annos_rscup_test.json\", \"./data/trash\", \"test\")"
+    "scale_generate_test(datadir, \"./data/rscup\", \"test\", [0.5, 1])\n",
+    "increment_generate(datadir, \"./data/rscup/annotation/annos_rscup_test.json\", \"./data/rscup\", \"test\")"
    ]
   },
   {
@@ -612,7 +645,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 70,
+   "execution_count": 148,
    "metadata": {},
    "outputs": [
     {
@@ -625,7 +658,7 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "6779a371c7704cdabbaaf37c96626eb6",
+       "model_id": "46121ac81072426ba5c3cf9a4b4b2419",
        "version_major": 2,
        "version_minor": 0
       },
@@ -642,7 +675,7 @@
      "text": [
       "totol number 36909\n",
       "loading annotations into memory...\n",
-      "Done (t=0.13s)\n",
+      "Done (t=0.11s)\n",
       "creating index...\n",
       "index created!\n"
      ]
@@ -650,21 +683,7 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "224495db72ab441ca2af8c31e759b381",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "HBox(children=(IntProgress(value=0, max=593), HTML(value='')))"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "f64b9e7be96545f18baa8f17474909e6",
+       "model_id": "223ce2286ea14cc689ecfcc19cb53db4",
        "version_major": 2,
        "version_minor": 0
       },
@@ -679,19 +698,19 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "totol number 37502\n"
+      "totol number 37499\n"
      ]
     }
    ],
    "source": [
     "datadir = \"/home/xfr/rssid/data/val/images\"\n",
-    "scale_generate_test(datadir, \"./data/trash\", \"val\", [0.5, 1])\n",
-    "increment_generate(datadir, \"./data/trash/annotation/annos_rscup_val.json\", \"./data/trash\", \"val\")"
+    "scale_generate_test(datadir, \"./data/rscup\", \"val\", [0.5, 1])\n",
+    "increment_generate(datadir, \"./data/rscup/annotation/annos_rscup_val.json\", \"./data/rscup\", \"val\")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 112,
+   "execution_count": 129,
    "metadata": {},
    "outputs": [
     {
@@ -699,7 +718,75 @@
      "output_type": "stream",
      "text": [
       "loading annotations into memory...\n",
-      "Done (t=10.84s)\n",
+      "Done (t=0.15s)\n",
+      "creating index...\n",
+      "index created!\n"
+     ]
+    }
+   ],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Debug"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 157,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[{'id': 0, 'name': 'tennis-court', 'supercategory': 'object'}, {'id': 1, 'name': 'container-crane', 'supercategory': 'object'}, {'id': 2, 'name': 'storage-tank', 'supercategory': 'object'}, {'id': 3, 'name': 'baseball-diamond', 'supercategory': 'object'}, {'id': 4, 'name': 'plane', 'supercategory': 'object'}, {'id': 5, 'name': 'ground-track-field', 'supercategory': 'object'}, {'id': 6, 'name': 'helicopter', 'supercategory': 'object'}, {'id': 7, 'name': 'airport', 'supercategory': 'object'}, {'id': 8, 'name': 'harbor', 'supercategory': 'object'}, {'id': 9, 'name': 'ship', 'supercategory': 'object'}, {'id': 10, 'name': 'large-vehicle', 'supercategory': 'object'}, {'id': 11, 'name': 'swimming-pool', 'supercategory': 'object'}, {'id': 12, 'name': 'soccer-ball-field', 'supercategory': 'object'}, {'id': 13, 'name': 'roundabout', 'supercategory': 'object'}, {'id': 14, 'name': 'basketball-court', 'supercategory': 'object'}, {'id': 15, 'name': 'bridge', 'supercategory': 'object'}, {'id': 16, 'name': 'small-vehicle', 'supercategory': 'object'}, {'id': 17, 'name': 'helipad', 'supercategory': 'object'}]\n"
+     ]
+    }
+   ],
+   "source": [
+    "info = {\n",
+    "        \"description\": \"rscup\",\n",
+    "        \"url\": \"http://cocodataset.org\",\n",
+    "        \"version\": \"1.0\",\n",
+    "        \"year\": 2014,\n",
+    "        \"contributor\": \"COCO Consortium\",\n",
+    "        \"date_created\": \"2017/09/01\"\n",
+    "      }\n",
+    "license = [{ \"url\": \"http://creativecommons.org/licenses/by-nc-sa/2.0/\", \"id\": 1, \"name\": \"Attribution-NonCommercial-ShareAlike License\"}]\n",
+    "categories = []\n",
+    "for cls in CLASS:\n",
+    "    category = { \"id\" : class_to_ind[cls], \"name\" : cls, \"supercategory\" : \"object\",}\n",
+    "    categories.append(category)\n",
+    "print(categories)\n",
+    "annotations = {\"info\": info, \"images\": [], \"annotations\": [], \"categories\":categories, \"license\":license}\n",
+    "img1 = cv2.imread(\"./data/rscup/debug/1.jpg\")\n",
+    "filename = \"1.jpg\"\n",
+    "h,w,_ = img1.shape\n",
+    "image =  construct_imginfo(filename, h, w, 0)\n",
+    "annotations[\"images\"].append(image)\n",
+    "img2 = cv2.imread(\"./data/rscup/debug/2.jpg\")\n",
+    "filename = \"2.jpg\"\n",
+    "h,w,_ = img2.shape\n",
+    "image =  construct_imginfo(filename, h, w, 1)\n",
+    "annotations[\"images\"].append(image)\n",
+    "with open(\"./data/rscup/debug.json\", 'w') as json_file:\n",
+    "        json.dump(annotations, json_file, cls=MyEncoder)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 160,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "loading annotations into memory...\n",
+      "Done (t=0.00s)\n",
       "creating index...\n",
       "index created!\n"
      ]
@@ -711,8 +798,68 @@
     "import skimage.io as io\n",
     "from pycocotools.coco import COCO   # 载入 cocoz\n",
     "%matplotlib inline\n",
-    "phase = \"train\"\n",
-    "coco=COCO(\"./data/trash/annotation/annos_rscup_{}.json\".format(phase))"
+    "phase = \"debug\"\n",
+    "coco=COCO(\"./data/rscup/debug.json\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 165,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2\n",
+      "0\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\n",
+    "imgIds = coco.getImgIds()\n",
+    "print(len(imgIds))\n",
+    "width = []\n",
+    "height = []\n",
+    "for i in range(len(imgIds)):\n",
+    "    print(i)\n",
+    "    img = coco.loadImgs(imgIds[i])[0]\n",
+    "    I = io.imread('./data/rscup/{}/'.format(phase)+img['file_name'])\n",
+    "    plt.imshow(I)\n",
+    "    plt.show()\n",
+    "\n"
    ]
   },
   {
diff --git a/configs/rscup/htc_deform_cas.py b/configs/rscup/htc_deform_cas.py
index e4d8c35..5e835fe 100644
--- a/configs/rscup/htc_deform_cas.py
+++ b/configs/rscup/htc_deform_cas.py
@@ -193,7 +193,7 @@
         nms_thr=0.7,
         min_bbox_size=0),
     rcnn=dict(
-        score_thr=0.001,
+        score_thr=0.05,
         nms=dict(type='nms', iou_thr=0.5),
         max_per_img=1000,
         mask_thr_binary=0.5),
@@ -251,8 +251,8 @@
         with_label=True),
     test=dict(
         type=dataset_type,
-        ann_file=data_root + 'annotation/annos_rscup_test.json',
-        img_prefix=data_root + 'test',
+        ann_file='./data/rscup/debug.json',
+        img_prefix='./data/rscup/debug/',
         img_scale=(512, 512),
         img_norm_cfg=img_norm_cfg,
         size_divisor=32,
diff --git a/configs/rscup/htc_deform_focal.py b/configs/rscup/htc_deform_focal.py
new file mode 100644
index 0000000..3f7db35
--- /dev/null
+++ b/configs/rscup/htc_deform_focal.py
@@ -0,0 +1,296 @@
+# model settings
+fp16 = dict(loss_scale=512.)
+model = dict(
+    type='HybridTaskCascade',
+    num_stages=3,
+    pretrained='modelzoo://resnet50',
+    interleaved=True,
+    mask_info_flow=True,
+    backbone=dict(
+        type='ResNet',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        frozen_stages=1,
+        style='pytorch',
+        dcn=dict(
+            modulated=False, deformable_groups=1, fallback_on_stride=False),
+        stage_with_dcn=(False, True, True, True),
+        ),
+    neck=dict(
+        type='FPN',
+        in_channels=[256, 512, 1024, 2048],
+        out_channels=256,
+        num_outs=5),
+    rpn_head=dict(
+        type='RPNHead',
+        in_channels=256,
+        feat_channels=256,
+        anchor_scales=[8],
+        anchor_ratios=[0.5, 1.0, 1.5, 2.5, 5.0, 7.0],
+        anchor_strides=[4, 8, 16, 32, 64],
+        target_means=[.0, .0, .0, .0],
+        target_stds=[1.0, 1.0, 1.0, 1.0],
+        loss_cls=dict(
+            type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0),
+        loss_bbox=dict(type='SmoothL1Loss', beta=1.0 / 9.0, loss_weight=1.0)),
+    bbox_roi_extractor=dict(
+        type='SingleRoIExtractor',
+        roi_layer=dict(type='RoIAlign', out_size=7, sample_num=2),
+        out_channels=256,
+        featmap_strides=[4, 8, 16, 32]),
+    bbox_head=[
+        dict(
+            type='SharedFCBBoxHead',
+            num_fcs=2,
+            in_channels=256,
+            fc_out_channels=1024,
+            roi_feat_size=7,
+            num_classes=19,
+            target_means=[0., 0., 0., 0.],
+            target_stds=[0.1, 0.1, 0.2, 0.2],
+            reg_class_agnostic=True,
+            loss_cls=dict(
+                type='FocalLoss',
+                use_sigmoid=False,
+                gamma=2.0,
+                alpha=0.25,
+                loss_weight=1.0),
+            loss_bbox=dict(
+                type='SmoothL1Loss',
+                beta=1.0,
+                loss_weight=1.0)),
+
+        dict(
+            type='SharedFCBBoxHead',
+            num_fcs=2,
+            in_channels=256,
+            fc_out_channels=1024,
+            roi_feat_size=7,
+            num_classes=19,
+            target_means=[0., 0., 0., 0.],
+            target_stds=[0.05, 0.05, 0.1, 0.1],
+            reg_class_agnostic=True,
+            loss_cls=dict(
+                type='FocalLoss',
+                use_sigmoid=False,
+                gamma=2.0,
+                alpha=0.25,
+                loss_weight=1.0),
+            loss_bbox=dict(
+                type='SmoothL1Loss',
+                beta=1.0,
+                loss_weight=1.0)),
+        dict(
+            type='SharedFCBBoxHead',
+            num_fcs=2,
+            in_channels=256,
+            fc_out_channels=1024,
+            roi_feat_size=7,
+            num_classes=19,
+            target_means=[0., 0., 0., 0.],
+            target_stds=[0.033, 0.033, 0.067, 0.067],
+            reg_class_agnostic=True,
+            loss_cls=dict(
+                type='FocalLoss',
+                use_sigmoid=False,
+                gamma=2.0,
+                alpha=0.25,
+                loss_weight=1.0),
+            loss_bbox=dict(
+                type='SmoothL1Loss',
+                beta=1.0,
+                loss_weight=1.0))
+    ],
+    mask_roi_extractor=dict(
+        type='SingleRoIExtractor',
+        roi_layer=dict(type='RoIAlign', out_size=14, sample_num=2),
+        out_channels=256,
+        featmap_strides=[4, 8, 16, 32]),
+    mask_head=dict(
+        type='HTCMaskHead',
+        num_convs=4,
+        in_channels=256,
+        conv_out_channels=256,
+        num_classes=19,
+        loss_mask=dict(
+            type='CrossEntropyLoss', use_mask=True, loss_weight=1.0)))
+# model training and testing settings
+train_cfg = dict(
+    rpn=dict(
+        assigner=dict(
+            type='MaxIoUAssigner',
+            pos_iou_thr=0.7,
+            neg_iou_thr=0.3,
+            min_pos_iou=0.3,
+            ignore_iof_thr=-1),
+        sampler=dict(
+            type='RandomSampler',
+            num=256,
+            pos_fraction=0.5,
+            neg_pos_ub=-1,
+            add_gt_as_proposals=False),
+        allowed_border=0,
+        pos_weight=-1,
+        debug=False),
+    rpn_proposal=dict(
+        nms_across_levels=False,
+        nms_pre=2000,
+        nms_post=2000,
+        max_num=2000,
+        nms_thr=0.7,
+        min_bbox_size=0),
+    rcnn=[
+        dict(
+            assigner=dict(
+                type='MaxIoUAssigner',
+                pos_iou_thr=0.4,
+                neg_iou_thr=0.4,
+                min_pos_iou=0.4,
+                ignore_iof_thr=-1),
+            sampler=dict(
+                type='RandomSampler',
+                num=512,
+                pos_fraction=0.25,
+                neg_pos_ub=-1,
+                add_gt_as_proposals=True),
+            mask_size=28,
+            pos_weight=-1,
+            debug=False),
+        dict(
+            assigner=dict(
+                type='MaxIoUAssigner',
+                pos_iou_thr=0.5,
+                neg_iou_thr=0.5,
+                min_pos_iou=0.5,
+                ignore_iof_thr=-1),
+            sampler=dict(
+                type='RandomSampler',
+                num=512,
+                pos_fraction=0.25,
+                neg_pos_ub=-1,
+                add_gt_as_proposals=True),
+            mask_size=28,
+            pos_weight=-1,
+            debug=False),
+        dict(
+            assigner=dict(
+                type='MaxIoUAssigner',
+                pos_iou_thr=0.6,
+                neg_iou_thr=0.6,
+                min_pos_iou=0.6,
+                ignore_iof_thr=-1),
+            sampler=dict(
+                type='RandomSampler',
+                num=512,
+                pos_fraction=0.25,
+                neg_pos_ub=-1,
+                add_gt_as_proposals=True),
+            mask_size=28,
+            pos_weight=-1,
+            debug=False)
+    ],
+    stage_loss_weights=[0.5, 1, 0.25])
+test_cfg = dict(
+    rpn=dict(
+        nms_across_levels=False,
+        nms_pre=1000,
+        nms_post=1000,
+        max_num=1000,
+        nms_thr=0.7,
+        min_bbox_size=0),
+    rcnn=dict(
+        score_thr=0.05,
+        nms=dict(type='nms', iou_thr=0.5),
+        max_per_img=1000,
+        mask_thr_binary=0.5),
+    keep_all_stages=False)
+# dataset settings
+dataset_type = 'CocoDataset'
+data_root = './data/rscup/'
+aug_root = "./data/rscup/aug/"
+other_aug_root = "./data/rscup/otheraug/"
+img_norm_cfg = dict(
+    mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
+data = dict(
+    imgs_per_gpu=6,
+    workers_per_gpu=4,
+    train=dict(
+        type=dataset_type,
+        ann_file=(data_root + 'annotation/annos_rscup_train.json',
+                  aug_root + 'annos_rscup_airport.json',
+                  other_aug_root + "annos_rscup_baseball-diamond.json",
+                  other_aug_root + "annos_rscup_basketball-court.json",
+                  other_aug_root + "annos_rscup_container-crane.json",
+                  other_aug_root + "annos_rscup_helicopter.json",
+                  other_aug_root + "annos_rscup_helipad.json",
+                  other_aug_root + "annos_rscup_helipad_ship.json",
+                  other_aug_root + "annos_rscup_roundabout.json",
+                  other_aug_root + "annos_rscup_soccer-ball-field_ground-track-field.json",
+        ),
+        img_prefix=(data_root + 'train/',
+                    aug_root + "airport/",
+                    other_aug_root + "baseball-diamond",
+                    other_aug_root + "basketball-court",
+                    other_aug_root + "container-crane",
+                    other_aug_root + "helicopter",
+                    other_aug_root + "helipad",
+                    other_aug_root + "helipad_ship",
+                    other_aug_root + "roundabout",
+                    other_aug_root + "soccer-ball-field_ground-track-field"),
+        img_scale=(512, 512),
+        img_norm_cfg=img_norm_cfg,
+        size_divisor=32,
+        flip_ratio=0.5,
+        with_mask=True,
+        with_crowd=True,
+        with_label=True),
+    val=dict(
+        type=dataset_type,
+        ann_file=data_root + 'annotation/annos_rscup_val.json',
+        img_prefix=data_root + 'val/',
+        img_scale=(512, 512),
+        img_norm_cfg=img_norm_cfg,
+        size_divisor=32,
+        flip_ratio=0,
+        with_mask=True,
+        with_crowd=True,
+        with_label=True),
+    test=dict(
+        type=dataset_type,
+        ann_file='./data/rscup/annotation/annos_rscup_test.json',
+        img_prefix='./data/rscup/test',
+        img_scale=(512, 512),
+        img_norm_cfg=img_norm_cfg,
+        size_divisor=32,
+        flip_ratio=0,
+        with_mask=True,
+        with_label=False,
+        test_mode=True))
+# optimizer
+optimizer = dict(type='SGD', lr=9e-3, momentum=0.9, weight_decay=0.0001)
+optimizer_config = dict(grad_clip=dict(max_norm=35, norm_type=2))
+# learning policy
+lr_config = dict(
+    policy='step',
+    warmup='linear',
+    warmup_iters=500,
+    warmup_ratio=1.0 / 3,
+    step=[8, 11])
+checkpoint_config = dict(interval=1)
+# yapf:disable
+log_config = dict(
+    interval=50,
+    hooks=[
+        dict(type='TextLoggerHook'),
+        dict(type='TensorboardLoggerHook')
+    ])
+# yapf:enable
+# runtime settings
+total_epochs = 12
+dist_params = dict(backend='nccl')
+log_level = 'INFO'
+work_dir = './work_dirs/htc_deform_focal'
+load_from = None
+resume_from = None
+workflow = [('train', 1)]
diff --git a/configs/rscup/htc_deform_weighted.py b/configs/rscup/htc_deform_weighted.py
index 356ee87..3085e15 100644
--- a/configs/rscup/htc_deform_weighted.py
+++ b/configs/rscup/htc_deform_weighted.py
@@ -57,7 +57,9 @@
                 alpha=0.25,
                 loss_weight=1.0),
             loss_bbox=dict(
-                type='SmoothL1Loss',
+                type='BalancedL1Loss',
+                alpha=0.5,
+                gamma=1.5,
                 beta=1.0,
                 loss_weight=1.0)),
         dict(
@@ -77,7 +79,9 @@
                 alpha=0.25,
                 loss_weight=1.0),
             loss_bbox=dict(
-                type='SmoothL1Loss',
+                type='BalancedL1Loss',
+                alpha=0.5,
+                gamma=1.5,
                 beta=1.0,
                 loss_weight=1.0)),
         dict(
@@ -97,7 +101,9 @@
                 alpha=0.25,
                 loss_weight=1.0),
             loss_bbox=dict(
-                type='SmoothL1Loss',
+                type='BalancedL1Loss',
+                alpha=0.5,
+                gamma=1.5,
                 beta=1.0,
                 loss_weight=1.0))
     ],
@@ -148,11 +154,16 @@
                 min_pos_iou=0.5,
                 ignore_iof_thr=-1),
             sampler=dict(
-                type='RandomSampler',
+                type='CombinedSampler',
                 num=512,
                 pos_fraction=0.25,
-                neg_pos_ub=-1,
-                add_gt_as_proposals=True),
+                add_gt_as_proposals=True,
+                pos_sampler=dict(type='InstanceBalancedPosSampler'),
+                neg_sampler=dict(
+                    type='IoUBalancedNegSampler',
+                    floor_thr=-1,
+                    floor_fraction=0,
+                    num_bins=3)),
             mask_size=28,
             pos_weight=-1,
             debug=False),
@@ -164,11 +175,16 @@
                 min_pos_iou=0.6,
                 ignore_iof_thr=-1),
             sampler=dict(
-                type='RandomSampler',
+                type='CombinedSampler',
                 num=512,
                 pos_fraction=0.25,
-                neg_pos_ub=-1,
-                add_gt_as_proposals=True),
+                add_gt_as_proposals=True,
+                pos_sampler=dict(type='InstanceBalancedPosSampler'),
+                neg_sampler=dict(
+                    type='IoUBalancedNegSampler',
+                    floor_thr=-1,
+                    floor_fraction=0,
+                    num_bins=3)),
             mask_size=28,
             pos_weight=-1,
             debug=False),
@@ -180,11 +196,16 @@
                 min_pos_iou=0.7,
                 ignore_iof_thr=-1),
             sampler=dict(
-                type='RandomSampler',
+                type='CombinedSampler',
                 num=512,
                 pos_fraction=0.25,
-                neg_pos_ub=-1,
-                add_gt_as_proposals=True),
+                add_gt_as_proposals=True,
+                pos_sampler=dict(type='InstanceBalancedPosSampler'),
+                neg_sampler=dict(
+                    type='IoUBalancedNegSampler',
+                    floor_thr=-1,
+                    floor_fraction=0,
+                    num_bins=3)),
             mask_size=28,
             pos_weight=-1,
             debug=False)
diff --git a/mmdet/apis/inference.py b/mmdet/apis/inference.py
index c8c37ed..cbbd127 100644
--- a/mmdet/apis/inference.py
+++ b/mmdet/apis/inference.py
@@ -10,7 +10,7 @@
 from mmdet.datasets import to_tensor
 from mmdet.datasets.transforms import ImageTransform
 from mmdet.models import build_detector
-
+from icecream import ic
 
 def init_detector(config, checkpoint=None, device='cuda:0'):
     """Initialize a detector from config file.
@@ -70,6 +70,8 @@ def inference_detector(model, imgs):
 
 def _prepare_data(img, img_transform, cfg, device):
     ori_shape = img.shape
+    ic(ori_shape)
+    ic(cfg.data.test.img_scale)
     img, img_shape, pad_shape, scale_factor = img_transform(
         img,
         scale=cfg.data.test.img_scale,
diff --git a/mmdet/models/detectors/base.py b/mmdet/models/detectors/base.py
index 96fb48e..1685f66 100644
--- a/mmdet/models/detectors/base.py
+++ b/mmdet/models/detectors/base.py
@@ -73,7 +73,7 @@ def forward_test(self, imgs, img_metas, **kwargs):
                     len(imgs), len(img_metas)))
         # TODO: remove the restriction of imgs_per_gpu == 1 when prepared
         imgs_per_gpu = imgs[0].size(0)
-        assert imgs_per_gpu == 1
+        #assert imgs_per_gpu == 1
 
         if num_augs == 1:
             return self.simple_test(imgs[0], img_metas[0], **kwargs)
diff --git a/mmdet/models/detectors/htc.py b/mmdet/models/detectors/htc.py
index 0384aa9..2b3e82b 100644
--- a/mmdet/models/detectors/htc.py
+++ b/mmdet/models/detectors/htc.py
@@ -6,8 +6,8 @@
 from ..registry import DETECTORS
 from mmdet.core import (bbox2roi, bbox2result, build_assigner, build_sampler,
                         merge_aug_masks)
-
-
+from icecream import ic
+import time
 @DETECTORS.register_module
 class HybridTaskCascade(CascadeRCNN):
 
@@ -262,19 +262,21 @@ def forward_train(self,
                 with torch.no_grad():
                     proposal_list = self.bbox_head[i].refine_bboxes(
                         rois, roi_labels, bbox_pred, pos_is_gts, img_meta)
-
         return losses
 
     def simple_test(self, img, img_meta, proposals=None, rescale=False):
+        ic(len(img))
         x = self.extract_feat(img)
+        ic(len(x))
+        ic(x[0].shape)
         proposal_list = self.simple_test_rpn(
             x, img_meta, self.test_cfg.rpn) if proposals is None else proposals
-
+        ic(len(proposal_list))
         if self.with_semantic:
             _, semantic_feat = self.semantic_head(x)
         else:
             semantic_feat = None
-
+        ic(proposal_list.shape)
         img_shape = img_meta[0]['img_shape']
         ori_shape = img_meta[0]['ori_shape']
         scale_factor = img_meta[0]['scale_factor']
@@ -286,6 +288,7 @@ def simple_test(self, img, img_meta, proposals=None, rescale=False):
         rcnn_test_cfg = self.test_cfg.rcnn
 
         rois = bbox2roi(proposal_list)
+        ic(rois.shape)
         for i in range(self.num_stages):
             bbox_head = self.bbox_head[i]
             cls_score, bbox_pred = self._bbox_forward_test(
@@ -336,10 +339,11 @@ def simple_test(self, img, img_meta, proposals=None, rescale=False):
             scale_factor,
             rescale=rescale,
             cfg=rcnn_test_cfg)
+        ic(det_bboxes.shape)
         bbox_result = bbox2result(det_bboxes, det_labels,
                                   self.bbox_head[-1].num_classes)
         ms_bbox_result['ensemble'] = bbox_result
-
+        ic(bbox_result.shape)
         if self.with_mask:
             if det_bboxes.shape[0] == 0:
                 segm_result = [
@@ -389,7 +393,7 @@ def simple_test(self, img, img_meta, proposals=None, rescale=False):
                 }
             else:
                 results = ms_bbox_result
-
+        ic(len(results[0][0].shape))
         return results
 
     def aug_test(self, img, img_meta, proposals=None, rescale=False):
diff --git a/mmdet/models/losses/cross_entropy_loss.py b/mmdet/models/losses/cross_entropy_loss.py
index fe10b86..77cfaa7 100644
--- a/mmdet/models/losses/cross_entropy_loss.py
+++ b/mmdet/models/losses/cross_entropy_loss.py
@@ -9,7 +9,7 @@
 def cross_entropy(pred, label, weight=None, reduction='mean', avg_factor=None):
     # element-wise losses
     loss = F.cross_entropy(pred, label, reduction='none')
-
+    
     # apply weights and do the reduction
     if weight is not None:
         weight = weight.float()
diff --git a/mmdet/models/losses/focal_loss.py b/mmdet/models/losses/focal_loss.py
index 4cbc994..7369521 100644
--- a/mmdet/models/losses/focal_loss.py
+++ b/mmdet/models/losses/focal_loss.py
@@ -53,15 +53,13 @@ def weighted_focal_loss(pred,
     # "weighted_loss" is not applicable
     loss = _sigmoid_focal_loss(pred, target, gamma, alpha)
     # TODO: find a proper way to handle the shape of weight
-    weight = loss.new(target.shape).fill_(1)
+    weight = loss.new(19).fill_(1)
+    weight[11] = 0.5
+    weight[17] = 0.1
+    weight[10] = 0.25
     # large-vehicle
-    weight[target == 11] = 0.5
     # small-vehicle
-    weight[target == 17] = 0.1
     # ship
-    weight[target == 10] = 0.25
-    if weight is not None:
-        weight = weight.view(-1, 1)
     loss = weight_reduce_loss(loss, weight, reduction, avg_factor)
     return loss
 
diff --git a/pipeline.ipynb b/pipeline.ipynb
index 2466d62..0a26dfc 100644
--- a/pipeline.ipynb
+++ b/pipeline.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 97,
+   "execution_count": 1,
    "metadata": {
     "collapsed": true
    },
@@ -30,7 +30,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 110,
+   "execution_count": 2,
    "metadata": {
     "collapsed": true
    },
@@ -133,7 +133,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 111,
+   "execution_count": 3,
    "metadata": {
     "collapsed": true
    },
@@ -461,7 +461,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 112,
+   "execution_count": 4,
    "metadata": {
     "collapsed": true
    },
@@ -479,7 +479,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 101,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [
     {
@@ -487,11 +487,11 @@
      "output_type": "stream",
      "text": [
       "loading annotations into memory...\n",
-      "Done (t=0.16s)\n",
+      "Done (t=0.18s)\n",
       "creating index...\n",
       "index created!\n",
       "loading annotations into memory...\n",
-      "Done (t=0.11s)\n",
+      "Done (t=0.14s)\n",
       "creating index...\n",
       "index created!\n"
      ]
@@ -499,12 +499,12 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "9d1d07c9cde84769a896b56dd959d5cc",
+       "model_id": "ae9d1233f0d04647bd520eb498f4ccde",
        "version_major": 2,
        "version_minor": 0
       },
       "text/plain": [
-       "HBox(children=(IntProgress(value=0, max=36909), HTML(value='')))"
+       "HBox(children=(IntProgress(value=0, max=37499), HTML(value='')))"
       ]
      },
      "metadata": {},
@@ -513,7 +513,7 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "1b93e29113c44873a107c8e1203402b5",
+       "model_id": "01ec2f08a25f41bea0f8663c23258c72",
        "version_major": 2,
        "version_minor": 0
       },
@@ -527,7 +527,7 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "f15976d2753647378ec894cae6bfd612",
+       "model_id": "6ae2e66c079d4c5a968a15316f3071a0",
        "version_major": 2,
        "version_minor": 0
       },
@@ -543,43 +543,43 @@
      "output_type": "stream",
      "text": [
       "tennis-court\n",
-      "1231\n",
+      "1715\n",
       "container-crane\n",
-      "97\n",
+      "230\n",
       "storage-tank\n",
-      "4713\n",
+      "5307\n",
       "baseball-diamond\n",
-      "574\n",
+      "1138\n",
       "plane\n",
-      "4286\n",
+      "5145\n",
       "ground-track-field\n",
-      "597\n",
+      "1300\n",
       "helicopter\n",
-      "333\n",
+      "368\n",
       "airport\n",
-      "200\n",
+      "172\n",
       "harbor\n",
-      "5639\n",
+      "6907\n",
       "ship\n",
-      "21046\n",
+      "24129\n",
       "large-vehicle\n",
-      "18987\n",
+      "20872\n",
       "swimming-pool\n",
-      "2176\n",
+      "2435\n",
       "soccer-ball-field\n",
-      "412\n",
+      "585\n",
       "roundabout\n",
-      "898\n",
+      "2005\n",
       "basketball-court\n",
-      "610\n",
+      "810\n",
       "bridge\n",
-      "2472\n",
+      "4994\n",
       "small-vehicle\n",
-      "68459\n",
+      "70740\n",
       "helipad\n",
-      "3\n",
+      "93\n",
       "loading annotations into memory...\n",
-      "Done (t=0.94s)\n",
+      "Done (t=0.72s)\n",
       "creating index...\n",
       "index created!\n"
      ]
@@ -587,7 +587,7 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "2cd2b34351f045f7be1caae65f9f8246",
+       "model_id": "1e2127b68fcd4ec4ba6915e268b1e779",
        "version_major": 2,
        "version_minor": 0
       },
@@ -603,24 +603,24 @@
      "output_type": "stream",
      "text": [
       "ap of container-crane is 0.0\n",
-      "ap of tennis-court is 0.947635992872383\n",
-      "ap of baseball-diamond is 0.7475720400148251\n",
-      "ap of storage-tank is 0.6481483320956984\n",
-      "ap of ground-track-field is 0.7322359095126263\n",
-      "ap of helicopter is 0.517045192059318\n",
-      "ap of airport is 0.8573812261846522\n",
-      "ap of plane is 0.8960666451223294\n",
-      "ap of harbor is 0.738795218322645\n",
-      "ap of swimming-pool is 0.5710704035349637\n",
-      "ap of soccer-ball-field is 0.5413147023961622\n",
-      "ap of roundabout is 0.6161605413378348\n",
-      "ap of basketball-court is 0.6711710223953747\n",
-      "ap of bridge is 0.46531824272750344\n",
-      "ap of helipad is 0.0\n",
-      "ap of large-vehicle is 0.7650800959661235\n",
-      "ap of ship is 0.8562518667655296\n",
-      "ap of small-vehicle is 0.4790875397667991\n",
-      "map is 0.6139074983930427\n"
+      "ap of tennis-court is 0.9420828609083332\n",
+      "ap of baseball-diamond is 0.7161250016956516\n",
+      "ap of ground-track-field is 0.7828051817618804\n",
+      "ap of helicopter is 0.5710499008658795\n",
+      "ap of storage-tank is 0.6475583369114917\n",
+      "ap of airport is 0.7868113379082367\n",
+      "ap of plane is 0.9034451254980395\n",
+      "ap of soccer-ball-field is 0.6352499794081782\n",
+      "ap of swimming-pool is 0.5690378712223216\n",
+      "ap of harbor is 0.7411073993923495\n",
+      "ap of roundabout is 0.6445210985182199\n",
+      "ap of basketball-court is 0.6713363698409788\n",
+      "ap of helipad is 0.16666666666666666\n",
+      "ap of bridge is 0.45025108136865716\n",
+      "ap of large-vehicle is 0.758869159487075\n",
+      "ap of ship is 0.8557910086229983\n",
+      "ap of small-vehicle is 0.4752361156613877\n",
+      "map is 0.6287746942076857\n"
      ]
     }
    ],
@@ -632,6 +632,7 @@
     "img_prefix = \"./data/rscup/val/\"\n",
     "ann = merge_result(config_file, result_file, anno_file, img_prefix,out_file)\n",
     "ann = nms(ann, \"poly\", 0.5)\n",
+    "mmcv.dump(ann, \"./result/post_nms.pkl\")\n",
     "generate_submit(ann, \"val_temp\", CLASSES)\n",
     "evaluate(0.5)"
    ]
@@ -758,6 +759,7 @@
    "source": [
     "ann = mmcv.load(out_file)\n",
     "ann = nms(ann, \"rec\", 0.5)\n",
+    "mmcv.dump()\n",
     "generate_submit(ann, \"val_temp\", CLASSES)\n",
     "evaluate(0.5)"
    ]
@@ -771,7 +773,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 113,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
@@ -779,11 +781,11 @@
      "output_type": "stream",
      "text": [
       "loading annotations into memory...\n",
-      "Done (t=0.29s)\n",
+      "Done (t=0.13s)\n",
       "creating index...\n",
       "index created!\n",
       "loading annotations into memory...\n",
-      "Done (t=0.14s)\n",
+      "Done (t=0.13s)\n",
       "creating index...\n",
       "index created!\n"
      ]
@@ -791,7 +793,7 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "e1d17b0d4b2e43668a71917d77bc9133",
+       "model_id": "e8f16d96833f4c888081ca2ec2de8df5",
        "version_major": 2,
        "version_minor": 0
       },
@@ -814,13 +816,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 114,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "a189dce2bc1948b6adddf7188492e620",
+       "model_id": "b461ef2a166847fa87f542d2a3f5b446",
        "version_major": 2,
        "version_minor": 0
       },
@@ -834,7 +836,7 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "d477cc0cdc6b44579f1f02b608d60135",
+       "model_id": "afc9b535bc65424dbe5d15e90d064e88",
        "version_major": 2,
        "version_minor": 0
       },
@@ -850,41 +852,41 @@
      "output_type": "stream",
      "text": [
       "tennis-court\n",
-      "1601\n",
+      "2396\n",
       "container-crane\n",
-      "1597\n",
+      "1996\n",
       "storage-tank\n",
-      "11553\n",
+      "13247\n",
       "baseball-diamond\n",
-      "395\n",
+      "928\n",
       "plane\n",
-      "1913\n",
+      "2773\n",
       "ground-track-field\n",
-      "1106\n",
+      "1821\n",
       "helicopter\n",
-      "33\n",
+      "150\n",
       "airport\n",
-      "799\n",
+      "911\n",
       "harbor\n",
-      "5915\n",
+      "6487\n",
       "ship\n",
-      "27450\n",
+      "34723\n",
       "large-vehicle\n",
-      "10992\n",
+      "13078\n",
       "swimming-pool\n",
-      "2001\n",
+      "2878\n",
       "soccer-ball-field\n",
-      "907\n",
+      "1178\n",
       "roundabout\n",
-      "1641\n",
+      "4086\n",
       "basketball-court\n",
-      "825\n",
+      "1709\n",
       "bridge\n",
-      "4434\n",
+      "9126\n",
       "small-vehicle\n",
-      "54831\n",
+      "53164\n",
       "helipad\n",
-      "121\n"
+      "824\n"
      ]
     }
    ],
@@ -903,13 +905,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 115,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "b7cc2c111be44a69b5f2a9981e8007e0",
+       "model_id": "5e1958ec16d84c75967bb32d69d32513",
        "version_major": 2,
        "version_minor": 0
       },
@@ -925,41 +927,41 @@
      "output_type": "stream",
      "text": [
       "tennis-court\n",
-      "1601\n",
+      "2396\n",
       "container-crane\n",
-      "1597\n",
+      "1996\n",
       "storage-tank\n",
-      "11553\n",
+      "13247\n",
       "baseball-diamond\n",
-      "395\n",
+      "928\n",
       "plane\n",
-      "1913\n",
+      "2773\n",
       "ground-track-field\n",
-      "1106\n",
+      "1821\n",
       "helicopter\n",
-      "33\n",
+      "150\n",
       "airport\n",
-      "799\n",
+      "911\n",
       "harbor\n",
-      "5915\n",
+      "6487\n",
       "ship\n",
-      "27450\n",
+      "34723\n",
       "large-vehicle\n",
-      "10992\n",
+      "13078\n",
       "swimming-pool\n",
-      "2001\n",
+      "2878\n",
       "soccer-ball-field\n",
-      "907\n",
+      "1178\n",
       "roundabout\n",
-      "1641\n",
+      "4086\n",
       "basketball-court\n",
-      "825\n",
+      "1709\n",
       "bridge\n",
-      "4434\n",
+      "9126\n",
       "small-vehicle\n",
-      "54831\n",
+      "53164\n",
       "helipad\n",
-      "121\n"
+      "824\n"
      ]
     }
    ],
diff --git a/tools/demo.py b/tools/demo.py
index 9d0afcc..5788776 100644
--- a/tools/demo.py
+++ b/tools/demo.py
@@ -1,5 +1,5 @@
-from mmdet.apis.multi_inference import init_detector, inference_detector, show_result
-#from mmdet.apis.inference import init_detector, inference_detector, show_result
+# from mmdet.apis.multi_inference import init_detector, inference_detector, show_result
+from mmdet.apis.inference import init_detector, inference_detector, show_result
 import os
 import argparse
 import sys
diff --git a/tools/test.py b/tools/test.py
index e33a0c4..69c3d13 100644
--- a/tools/test.py
+++ b/tools/test.py
@@ -150,7 +150,7 @@ def main():
     dataset = build_dataset(cfg.data.test)
     data_loader = build_dataloader(
         dataset,
-        imgs_per_gpu=1,
+        imgs_per_gpu=2,
         workers_per_gpu=cfg.data.workers_per_gpu,
         dist=distributed,
         shuffle=False)