HOG+SVM_model.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "HOG+SVM model",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 2",
      "name": "python2"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "rX4Pb9IMCQq-",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import numpy as np \n",
        "from imutils.object_detection import non_max_suppression\n",
        "import imutils\n",
        "from skimage.feature import hog\n",
        "from skimage.transform import pyramid_gaussian\n",
        "from sklearn.externals import joblib\n",
        "import cv2\n",
        "from skimage import color\n",
        "import matplotlib.pyplot as plt \n",
        "import os \n",
        "import glob\n",
        "import pickle\n",
        "\n",
        "from __future__ import absolute_import, division, print_function\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PFH1x_dLCakP",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "min_wdw_sz = [64, 128]\n",
        "step_size = [10,10]\n",
        "orientations = 9\n",
        "pixels_per_cell = [6,6]\n",
        "cells_per_block = [2, 2]\n",
        "visualize = False\n",
        "normalize = True\n",
        "model_path = '/content/drive/My Drive/Diploma/model/HOG+SVM/models'\n",
        "threshold = .3"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EAN8nH-frRhs",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def calc_iou_individual(pred_box, gt_box):\n",
        "    x1_t, y1_t, x2_t, y2_t = gt_box\n",
        "    x1_p, y1_p, x2_p, y2_p = pred_box\n",
        "\n",
        "    if (x1_p > x2_p) or (y1_p > y2_p):\n",
        "        raise AssertionError(\n",
        "            \"Prediction box is malformed? pred box: {}\".format(pred_box))\n",
        "    if (x1_t > x2_t) or (y1_t > y2_t):\n",
        "        raise AssertionError(\n",
        "            \"Ground Truth box is malformed? true box: {}\".format(gt_box))\n",
        "\n",
        "    if (x2_t < x1_p or x2_p < x1_t or y2_t < y1_p or y2_p < y1_t):\n",
        "        return 0.0\n",
        "\n",
        "    far_x = np.min([x2_t, x2_p])\n",
        "    near_x = np.max([x1_t, x1_p])\n",
        "    far_y = np.min([y2_t, y2_p])\n",
        "    near_y = np.max([y1_t, y1_p])\n",
        "\n",
        "    inter_area = (far_x - near_x + 1) * (far_y - near_y + 1)\n",
        "    true_box_area = (x2_t - x1_t + 1) * (y2_t - y1_t + 1)\n",
        "    pred_box_area = (x2_p - x1_p + 1) * (y2_p - y1_p + 1)\n",
        "    iou = inter_area / (true_box_area + pred_box_area - inter_area)\n",
        "    return iou\n",
        "\n",
        "\n",
        "def get_single_image_results(gt_boxes, pred_boxes, iou_thr):\n",
        "    all_pred_indices = range(len(pred_boxes))\n",
        "    all_gt_indices = range(len(gt_boxes))\n",
        "    if len(all_pred_indices) == 0:\n",
        "        tp = 0\n",
        "        fp = 0\n",
        "        fn = len(gt_boxes)\n",
        "        return {'true_pos': tp, 'false_pos': fp, 'false_neg': fn}\n",
        "    if len(all_gt_indices) == 0:\n",
        "        tp = 0\n",
        "        fp = len(pred_boxes)\n",
        "        fn = 0\n",
        "        return {'true_pos': tp, 'false_pos': fp, 'false_neg': fn}\n",
        "\n",
        "    gt_idx_thr = []\n",
        "    pred_idx_thr = []\n",
        "    ious = []\n",
        "    for ipb, pred_box in enumerate(pred_boxes):\n",
        "        for igb, gt_box in enumerate(gt_boxes):\n",
        "            iou = calc_iou_individual(pred_box, gt_box)\n",
        "            if iou > iou_thr:\n",
        "                gt_idx_thr.append(igb)\n",
        "                pred_idx_thr.append(ipb)\n",
        "                ious.append(iou)\n",
        "\n",
        "    args_desc = np.argsort(ious)[::-1]\n",
        "    if len(args_desc) == 0:\n",
        "        tp = 0\n",
        "        fp = len(pred_boxes)\n",
        "        fn = len(gt_boxes)\n",
        "    else:\n",
        "        gt_match_idx = []\n",
        "        pred_match_idx = []\n",
        "        for idx in args_desc:\n",
        "            gt_idx = gt_idx_thr[idx]\n",
        "            pr_idx = pred_idx_thr[idx]\n",
        "            if (gt_idx not in gt_match_idx) and (pr_idx not in pred_match_idx):\n",
        "                gt_match_idx.append(gt_idx)\n",
        "                pred_match_idx.append(pr_idx)\n",
        "        tp = len(gt_match_idx)\n",
        "        fp = len(pred_boxes) - len(pred_match_idx)\n",
        "        fn = len(gt_boxes) - len(gt_match_idx)\n",
        "\n",
        "    return {'true_pos': tp, 'false_pos': fp, 'false_neg': fn}\n",
        "\n",
        "\n",
        "f = open('/content/drive/My Drive/Diploma/model/keras-YOLOv3-model-set/val2017test.txt')\n",
        "A_tp = 0\n",
        "A_fp = 0 \n",
        "A_fn = 0\n",
        "\n",
        "for line in f: \n",
        "    line = line.split()\n",
        "    image = line[0]\n",
        "    pred_boxes = detector(image)\n",
        "    gt_boxes = np.array([np.array(list(map(int,box.split(',')))[:-1]) for box in line[1:]])\n",
        "    rez = get_single_image_results(gt_boxes, pred_boxes, 0.5)\n",
        "    A_tp += rez['true_pos']\n",
        "    A_fp +=  rez['false_pos']\n",
        "    A_fn += rez['false_neg']\n",
        "\n",
        "precision = A_tp/(A_tp + A_fp)\n",
        "recall = A_tp/(A_tp + A_fn)\n",
        "print(\"precision = \", precision)\n",
        "print(\"recall = \", recall)\n",
        "\n",
        "\n",
        "    \n",
        "\n",
        "    "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "K6_eBzrdCams",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def sliding_window(image, window_size, step_size):\n",
        "    for y in xrange(0, image.shape[0], step_size[1]):\n",
        "        for x in xrange(0, image.shape[1], step_size[0]):\n",
        "            yield (x, y, image[y: y + window_size[1], x: x + window_size[0]])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HzQeKDE7CarG",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def detector(filename):\n",
        "    im = cv2.imread(filename)\n",
        "    min_wdw_sz = (64, 128)\n",
        "    step_size = (10, 10)\n",
        "    downscale = 1.6\n",
        "\n",
        "    clf = joblib.load(os.path.join(model_path, 'svm.model')) \n",
        "\n",
        "    detections = []\n",
        "\n",
        "    scale = 0\n",
        "\n",
        "    for im_scaled in pyramid_gaussian(im, downscale = downscale):\n",
        "      \n",
        "        if im_scaled.shape[0] < min_wdw_sz[1] or im_scaled.shape[1] < min_wdw_sz[0]:\n",
        "            break\n",
        "        for (x, y, im_window) in sliding_window(im_scaled, min_wdw_sz, step_size):\n",
        "            if im_window.shape[0] != min_wdw_sz[1] or im_window.shape[1] != min_wdw_sz[0]:\n",
        "                continue\n",
        "            im_window = color.rgb2gray(im_window)\n",
        "            fd =  hog(im_window, orientations=9, pixels_per_cell=(6, 6),cells_per_block=(2, 2),block_norm='L1', visualise=False,transform_sqrt=False,feature_vector=True)\n",
        "            fd = fd.reshape(1, -1)\n",
        "            pred = clf.predict(fd)\n",
        "\n",
        "            if pred == 1:\n",
        "                \n",
        "                if clf.decision_function(fd) > 0.5:\n",
        "                    detections.append((int(x * (downscale**scale)), int(y * (downscale**scale)), clf.decision_function(fd), int(min_wdw_sz[0] * (downscale**scale)),int(min_wdw_sz[1] * (downscale**scale))))\n",
        "                 \n",
        "\n",
        "            \n",
        "        scale += 1\n",
        "\n",
        "    clone = im.copy()\n",
        "\n",
        "\n",
        "\n",
        "    rects = np.array([[x, y, x + w, y + h] for (x, y, _, w, h) in detections])\n",
        "    sc = [score[0] for (x, y, score, w, h) in detections]\n",
        "    sc = np.array(sc)\n",
        "    pick = non_max_suppression(rects, probs = sc, overlapThresh = 0.3)\n",
        "\n",
        "   \n",
        "    for (x_tl, y_tl, _, w, h) in detections:\n",
        "        cv2.rectangle(im, (x_tl, y_tl), (x_tl + w, y_tl + h), (0, 255, 0), thickness = 2)\n",
        "    for(xA, yA, xB, yB) in pick:\n",
        "        #print(xA, yA, xB, yB)\n",
        "        cv2.rectangle(clone, (xA, yA), (xB, yB), (0, 255, 0), 2)\n",
        "    \n",
        "  \n",
        "    #plt.axis(\"off\")\n",
        "    #plt.imshow(cv2.cvtColor(clone, cv2.COLOR_BGR2RGB))\n",
        "    #plt.title(\"Final Detections after applying NMS\")\n",
        "    #plt.show()\n",
        "    return pick"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-4bjxhGSCapi",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5vDhK-8zCwkq",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "foldername = '/content/drive/My Drive/Diploma/model/HOG+SVM/test_image'\n",
        "test_folder(foldername)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LVLVt_Lz2lCr",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CQuYXFMZ2uMh",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}