Main.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Keep it simple s..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The autoreload extension is already loaded. To reload it, use:\n",
      "  %reload_ext autoreload\n"
     ]
    }
   ],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "%matplotlib inline\n",
    "\n",
    "from collections import Counter\n",
    "from modules.negative_set import generate_negative_set, get_box_parameters\n",
    "from modules import data, models, descriptor_vector, validation, selection\n",
    "from modules.selection import try_classifiers, try_params\n",
    "from modules.window import compute_no_windows\n",
    "import numpy as np\n",
    "from skimage.transform import resize\n",
    "from skimage.color import rgb2gray\n",
    "import pickle\n",
    "from pprint import pprint as pp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Store\n",
    "store = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using 1000/1000 images & 1284/1284 labels\n"
     ]
    }
   ],
   "source": [
    "# Load data directly\n",
    "GRAY = True\n",
    "OFFSET = 0\n",
    "LIMIT = None\n",
    "\n",
    "full_images = images = data.load_images(limit=LIMIT, offset=OFFSET, gray=GRAY)\n",
    "full_labels = labels = data.load_labels(limit=LIMIT, offset=OFFSET)\n",
    "print(f\"Using {len(images)}/1000 images & {len(labels)}/1284 labels\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1000\n"
     ]
    }
   ],
   "source": [
    "# Limit if needed\n",
    "LIMIT = None\n",
    "if LIMIT:\n",
    "   images = full_images[OFFSET:OFFSET+LIMIT]\n",
    "   labels = full_labels[full_labels[:,0] <= OFFSET+LIMIT]\n",
    "   labels = labels[labels[:,0] > OFFSET]\n",
    "else:\n",
    "   images = full_images\n",
    "   labels = full_labels\n",
    "print(len(images))\n",
    "#if GRAY:\n",
    "#    images = np.array([ rgb2gray(img) for img in images ])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adapt data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using 1000/1000 images & 1284/1284 labels\n",
      "Generating 4000 negatives...\n",
      "Creating train & validation sets with negatives...\n",
      "Train: 750, Valid: 250\n",
      "Counter({-1: 3014, 1: 978}) Counter({-1: 986, 1: 306})\n"
     ]
    }
   ],
   "source": [
    "# Label sets\n",
    "NEG_SIZE = 4000\n",
    "NEG_SUP = 1000\n",
    "TRAIN_RATE = 0.75\n",
    "\n",
    "print(f\"Using {len(images)}/1000 images & {len(labels)}/1284 labels\")\n",
    "print(f\"Generating {NEG_SIZE} negatives...\")\n",
    "negatives = generate_negative_set(images, labels, set_size=NEG_SIZE)\n",
    "\n",
    "print(\"Creating train & validation sets with negatives...\")\n",
    "all_labels = np.concatenate([labels, negatives])\n",
    "train_labels, valid_labels = data.train_valid_sets(len(images), all_labels, TRAIN_RATE)\n",
    "\n",
    "# Validation with additional negatives\n",
    "pvalid_labels = np.concatenate([ valid_labels, generate_negative_set(images, labels, set_size=NEG_SIZE) ])\n",
    "label_sets = train_labels, pvalid_labels\n",
    "\n",
    "print(f\"Train: {len(np.unique(train_labels[:,0]))}, Valid: {len(np.unique(valid_labels[:,0]))}\")\n",
    "print(Counter(train_labels[:,5]), Counter(valid_labels[:,5]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## Now Try !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Main Single"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Global params\n",
    "only_one_training = False\n",
    "limit_score = 0.5\n",
    "slide_step = (60,50)\n",
    "downscale_step = 30\n",
    "box_size = (150, 90)\n",
    "\n",
    "# Model\n",
    "CLASSIFIER = 'random_forest'\n",
    "MODEL_PARAMS = {\n",
    "    'n_estimators': 200,\n",
    "#    'max_depth': None,\n",
    "#    'max_features': 100,\n",
    "    'class_weight': { -1: 1, 1: 1}\n",
    "}\n",
    "VECTORIZATION_PARAMS = {\n",
    "    'vectorize': descriptor_vector.hog,\n",
    "#    'vectorize_kwargs': [6],\n",
    "} "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training...\n",
      "Vectorizing data...\n",
      "First training with (3926, 4040) rows...\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f17ce95185e94b3bbf3116730e3c23eb",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, description='Predicting windows', max=1000, style=ProgressStyle(descriptio…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Adding 641 false positives / 1035 predictions\n",
      "Vectorizing data...\n",
      "Second training with (4567, 4040) rows...\n"
     ]
    }
   ],
   "source": [
    "# ( 1 ) --- Single --- Train, predict, validate\n",
    "clf = models.create_model(CLASSIFIER, MODEL_PARAMS)\n",
    "kwargs = { 'limit_score': limit_score, 'slide_step': slide_step, 'downscale_step': downscale_step }\n",
    "\n",
    "print(\"Training...\")\n",
    "train_results = models.train(clf, images, box_size, train_labels, **VECTORIZATION_PARAMS,\n",
    "                             only_one_training=only_one_training, **kwargs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [],
   "source": [
    "#data.save_model(clf, path='model_haar.pickle')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A target rate of 0.7 is realized by the 1455 first best features\n",
      "A target rate of 0.8 is realized by the 1930 first best features\n",
      "A target rate of 0.9 is realized by the 2672 first best features\n",
      "A target rate of 0.95 is realized by the 3198 first best features\n",
      "A target rate of 0.99 is realized by the 3784 first best features\n",
      "A target rate of 0.999 is realized by the 4040 first best features\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": [
    "# Select features\n",
    "feat_indexes_sorted = np.argsort(clf.feature_importances_)[::-1]\n",
    "feat_importances_rates = np.cumsum(clf.feature_importances_[feat_indexes_sorted])\n",
    "feat_importances_rates /= np.max(feat_importances_rates)\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "plt.plot(feat_importances)\n",
    "for r in (0.7, 0.8, 0.9, 0.95, 0.99, 0.999):\n",
    "    print(f\"A target rate of {r} is realized by the {np.sum(feat_importances_rates < r)} first best features\")\n",
    "#np.savetxt('haar_best_indexes.txt', feat_indexes_sorted[:np.sum(feat_importances_rates < 0.999)], fmt='%d')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Predictions\n",
    "print(\"Predicting with windows...\")\n",
    "valid_indexes = np.unique(valid_labels[:,0]) - 1\n",
    "predictions, scores = models.predict(clf, images, box_size, **VECTORIZATION_PARAMS,\n",
    "                                     only=valid_indexes, with_scores=True,**kwargs)\n",
    "\n",
    "results = validation.rate_predictions(predictions, valid_labels)\n",
    "print(\"Done\")\n",
    "\n",
    "print(\"\\n------\\n\")\n",
    "if results not in store: store.append(results)\n",
    "pp(results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LinearSVC(C=2, class_weight=None, dual=True, fit_intercept=True,\n",
      "     intercept_scaling=1, loss='squared_hinge', max_iter=10000,\n",
      "     multi_class='ovr', penalty='l2', random_state=None, tol=0.0001,\n",
      "     verbose=0)\n",
      "Predict with additional negatives...\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": [
      "{'avg_precision': 0.8366363538879605,\n",
      " 'f1-score': 0.9055258467023173,\n",
      " 'false_neg': 52,\n",
      " 'false_pos': 1,\n",
      " 'n_test': 5292,\n",
      " 'precision': array([0.05782313, 0.99607843, 1.        ]),\n",
      " 'recall': array([1.        , 0.83006536, 0.        ]),\n",
      " 'roc_auc_score': 0.9149323989523608,\n",
      " 'true_neg': 4985,\n",
      " 'true_pos': 254}\n"
     ]
    }
   ],
   "source": [
    "# Validation with additional negatives\n",
    "clf = data.load_model()\n",
    "print(clf)\n",
    "NEG_SUP = 10000\n",
    "pvalid_labels = np.concatenate([ valid_labels, generate_negative_set(images, labels, set_size=NEG_SIZE) ])\n",
    "\n",
    "print(\"Predict with additional negatives...\")\n",
    "pvalid_indexes = np.unique(valid_labels[:,0]) - 1\n",
    "scores, results = models.predict_and_validate(clf, images, box_size, pvalid_labels,\n",
    "                                              **VECTORIZATION_PARAMS, only=pvalid_indexes,**kwargs)\n",
    "pp(results)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Multiple Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using 1000 images\n",
      "## Trying parameter `vectorization_params`...\n",
      "### with value `{'vectorize': <function hog at 0x000001AD0A31D268>}`\n",
      "Vectorizing data...\n",
      "First training with (3992, 243) rows...\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "cbccac9666484e3bb952498ec0038db0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, description='Predicting windows', max=1000, style=ProgressStyle(descriptio…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Adding 270 false positives / 918 predictions\n",
      "Vectorizing data...\n",
      "Second training with (4262, 243) rows...\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": [
      "\n",
      "------\n",
      "\n",
      "{'classifier': 'random_forest',\n",
      " 'global_params': {'n_estimators': 200},\n",
      " 'results': [{'name': 'vectorization_params',\n",
      "              'result': {'avg_precision': 0.8304784364338621,\n",
      "                         'f1-score': 0.9016100178890877,\n",
      "                         'false_neg': 54,\n",
      "                         'false_pos': 1,\n",
      "                         'n_test': 5292,\n",
      "                         'precision': array([0.05782313, 0.99604743, 1.        ]),\n",
      "                         'recall': array([1.        , 0.82352941, 0.        ]),\n",
      "                         'roc_auc_score': 0.9116644250961515,\n",
      "                         'true_neg': 4985,\n",
      "                         'true_pos': 252},\n",
      "              'value': {'vectorize': <function hog at 0x000001AD0A31D268>}}]}\n"
     ]
    }
   ],
   "source": [
    "# ( 2 ) --- Multiple --- Try multiple params\n",
    "clf_name = 'random_forest'\n",
    "global_params = {\n",
    "    # General\n",
    "    'box_size': (150, 90),\n",
    "\n",
    "    'n_estimators': 200,\n",
    "#     'C': 0.75,\n",
    "#     'max_iter': 1000,\n",
    "    \n",
    "    'vectorization_params': {\n",
    "        'vectorize': descriptor_vector.hog,\n",
    "#        'vectorize_kwargs': { 'orientations': 6},\n",
    "    },\n",
    "}\n",
    "\n",
    "kw_params = {\n",
    "    'limit_score': 0.5,\n",
    "    'slide_step': (60,50),\n",
    "    'downscale_step': 30,\n",
    "    'only_one_training': False,\n",
    "}\n",
    "\n",
    "changing_params = {\n",
    "    'vectorization_params': [\n",
    "#         { 'vectorize': descriptor_vector.haar }, \n",
    "#         {\n",
    "#             'vectorize': descriptor_vector.daisy,\n",
    "#             'vectorize_kwargs': { 'radius': 5 },\n",
    "#         }, \n",
    "        { 'vectorize': descriptor_vector.hog }, \n",
    "    ]\n",
    "}\n",
    "\n",
    "print(f\"Using {len(images)} images\")\n",
    "results = try_params(images, (train_labels, pvalid_labels), clf_name, global_params, changing_params, **kw_params)\n",
    "\n",
    "print(\"\\n------\\n\")\n",
    "if results not in store: store.append(results)\n",
    "pp(results)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Multiple Classifiers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using 300 images\n",
      "\n",
      "# Trying classifier `svc`...\n",
      "Vectorizing data...\n",
      "First training with (3308, 243) rows...\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "83de221b96fa4968bc05f2f5c46307e0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, description='Predicting windows', max=300, style=ProgressStyle(description…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Adding 3 false positives / 70 predictions\n",
      "Vectorizing data...\n",
      "Second training with (3311, 243) rows...\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": [
      "\n",
      "# Trying classifier `linear_svc`...\n",
      "Vectorizing data...\n",
      "First training with (3308, 243) rows...\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7e707f0a465c46aeb14aaeaacbdc68d8",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, description='Predicting windows', max=300, style=ProgressStyle(description…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Adding 87 false positives / 242 predictions\n",
      "Vectorizing data...\n",
      "Second training with (3395, 243) rows...\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEWCAYAAACJ0YulAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzt3XucXWV97/HPd+6DhFAMeCAEwlWNFBUi6kurWCgHqIK1VoOgYikpWqrW2/Gc9mjEeqx61HrBo7QgiggCR21UlKOIolY04XDRgLEBBSIoBJPJfZKZ/PrHs/aw2dkze81k1l778n2/XvuVvS6z1m/tmezvXs+z17MUEZiZmQH0lF2AmZm1DoeCmZlNcCiYmdkEh4KZmU1wKJiZ2QSHgpmZTXAo2IxIWiXpxAbrHCJps6TeJpVVOEm/lnRy9nyZpC+UXZPZbHIodJjsTWtb9mb8O0mflbT3bO8nIp4WEd9rsM79EbF3RIzP9v6zN+Sd2XFukPTvkp472/vpFpIulzQm6aCa+bPyOkt6laT7JG2R9FVJ+02x7h9L+v+SNkq6V9LSSdb7rKSQdOR067HJORQ600siYm/gOOBZwD/UrqCk3X//X8qOcx5wE3BtyfXMOkl9TdjHE4A/B0aAs+usUnmd9wd+CHxZkqax/acBnwFeDTwJ2Ap8apJ1+4GvZOvPBV4JfETS02vWez5wRN4aLL92f1OwKUTEb4BvAscASPqepPdJ+hHpP+bhkuZKulTSQ5J+I+kfq5t7JJ0v6W5JmyTdJem4bH51M8oJklZmn+x+J+kj2fyF2Se5vmz6IEnLJf1e0hpJ51ftZ5mkayR9PtvXKkmLcx7nGHAlMF/S/lXbfLGk26s+4R5btWyBpC9LekTSo5I+mc0/QtJ3s3nrJF0pad+ZvP6Szsz2v1HSPZJOrX3tqo79CzWv2XmS7ge+K+lbki6s2fYdkl6WPX+KpG9nr+tqSa+YZql/DmwALgJeO9lKEbET+BzwX4AnTmP7ZwNfi4ibI2Iz8D+Bl0maU2fd/YB9gCsiWQHcDSyqrJD9PX0CuLDOz9secih0MEkLgNOB26pmvxpYCswB7iP9Jx8DjgSeCZwC/FX2838BLANeQ/qPegbwaJ1dfQz4WETsQ/r0ds0kJV0FrAUOAl4O/C9JJ1UtPwO4GtgXWA58MudxDmQ1Pgqsz+YdB1wG/DXpDewzwHJJg1nofT07/oXA/Gy/AALen9X4VGBB9hpMi6QTgM8Db8+O5wXAr6exiRdm+/+vwBeBs6q2vQg4FPhG9in/29k6B2TrfSr7dF5ptrmzwb5eS/rdXA08pRL8dY5pEDgXWBsR6yQ9PwvcyR7Pz370acAdle1ExD3ADuDo2n1ExO+yWl4nqVepqepQ0hlKxd8BN0dEo+OymYgIPzroQXrj2Uz65Hcf6TR9OFv2PeCiqnWfBIxWlmfzzgJuyp7fALxpiv2cnD2/GXgPMK9mnYVAAH2kN9dxYE7V8vcDl2fPlwHfqVq2CNg2xXEuI72xbMi2+yhwYtXy/wO8t+ZnVpPebJ8LPAL05Xg9XwrcNslxLwO+MMnPfQb4aKPXrnY7Va/Z4VXL5wBbgEOz6fcBl2XPXwn8oM6+353z7+UQYBfwjKrf+ccmeZ0fBr4LHD/Nv8kbgQtq5v2m+vdVs+wlwO9IH1bGgPOrli0A1gBzs+kAjizj/1qnPnym0JleGhH7RsShEfGGiNhWteyBqueHAv3AQ5VPd6Q3lAOy5QuAe3Ls7zzSp75fSFoh6cV11jkI+H1EbKqadx/pU3rFb6uebwWGJPVJOlupo3OzpG9WrXNNROxLCrefA8fXHNtbqz+5ZsdzUPbvfZGanR5H0gGSrs6a0jYCXyD1WUxX3tduMhO/p+w1+wawJJu1hNRcBuk4n11znGeTmnjyeDVwd0Tcnk1fCbwqa9uvuCb7ezogIv44Im6d5rFsJp1pVtsH2FS7oqSnAF8infkNkM4y3iHpT7NV/pn0wWZkmjVYTg6F7lM9LO4DpDOFedl/+n0jYp+IeFrV8oadeRHxHxFxFilMPgBclzVrVHsQ2K+mHfkQ0ifGRtu/MtK3mPaOiNPqLF9HaiZaJunAqtrfV3Vc+0bEXhFxVbbsENXvxH0/6TU6NlJz2DmkJqXpmuq12wLsVTVd7w28dvjiq4CzsuaUYVLHemU/3685zr0j4vU563wNqW/pt5J+C3yEFIK7vc61JP1RVVjXe/xRtuoq4OlVP3c4MAj8ss5mjwFWR8QNEbErIlaTArFSz0nAh6rqBfixpFflPF5rwKHQxSLiIeD/AR+WtI+knqyj9YXZKv8KvE3S8UqOlHRo7XYknSNp/4jYRWpmgNSkU72vB4B/B94vaSjr9D2Pxz7x7umx/ILU9PGObNa/ABdIenZW+xMk/WkWSj8FHgL+KZs/JOl52c/NIWt+kzSf1CcwE5eS2sVPyl7X+dmnYIDbgSWS+pU601+eY3vXk84KLiJ9G2hXNv/rwNGSXp1tr1/SsyQ9tdEGs4A5AjgBeEb2OIbUPzFph3NFRPygKqzrPX6QrXol8JIsRJ6QHcOXa84aK24DjlL6WqokHQG8mMf6JI4mBUylXkjNTV9pVK/l41Cwymn6XaRO2uuAAwEi4lpS+/UXSaf6XyV9O6TWqcAqSZtJnc5LImJ7nfXOIrWZP0j6T/zuiPj2LB7Lh4Clkg6IiJXA+aTO6vWkduhzASJdN/ESUuf6/aTO71dm23gP6au8I6RPqF+eSSER8VPgdcBHs219n/SmDunbN0dkdb2H9Po22t5oVsvJ1etnb6ynkJqUHiQ1wX2A9EmcrOlt1SSbfS3wbxHxs4j4beVB+h2+WFNcSzAdEbEKuIAUDg+TgvcNleWSvinpf2Tr3gP8JfBxYCPpdfu/pJAlIh6uqRVgXU0Tqe0BRfgmO2ZmlvhMwczMJjgUzMxsgkPBzMwmOBTMzGxC4YNtzbZ58+bFwoULyy7DzKyt3HrrresiYv9G67VdKCxcuJCVK1eWXYaZWVuRdF+e9dx8ZGZmExwKZmY2waFgZmYTHApmZjbBoWBmZhMcCmZmNqGwUJB0maSHJf18kuWS9HGle/XeOdktAM3MrHmKPFO4nDSk8mROA47KHktJt080M7MSFXbxWkTcLGnhFKucCXw+0tjdt0jaV9KB2Y1fJrV9O2zaBD096SE99rzyMDOzmSnziub5PP5+wWuzebuFgqSlpLMJnvjEw/nhD1MY7L4eRKRg6OuD3t7H/q1+VC+rXl4bLpOFTu0yM7NOUWYo1Lvvbd07/kTEJcAlAIcdtjj22y+9mU9m1670iEiP8XEYG3tsXmV57boThenx01MehHYPndrgqQROJYSq500VPPXm1wtDM7PZUmYorAUWVE0fTLqd4B5rZjNSJXiqA2d8HHbufPyy6uWVwKkXPJMFUmV+dQhNFTz1zpKmcyZUme8QMusuZYbCcuBCSVcDzwZGGvUntCKpuc1ItQEUkQJodHT3+bXPG6kXSJWg6el5fBhVB05lefWZ0HSa39wfZNY6CgsFSVcBJwLzJK0F3g30A0TEp4HrgdNJN1TfSrrJuTVQOVNoltoQ2rULduxIHf71zpIqzXLTOQuqNp3+oNqzJPcHme25Ir99dFaD5QH8TVH7t9nR7BDK0x9Ur1mukXqBtKf9QdM9C3JTnLWDtrufgnW2dugPyvslhIqp+oNqwyhvf1CeQHII2Uw4FKxrldkfVHk+Npaa4/L0B03nW3GQrz+odn6e/qDJ5ltncCiYNUmr9AfV+1JCEf1B1dP1muWq15vut+IcQsVpu1CIgPvvb+5/LjNrrPrMpvZMp/br2NPpD6qnErCVgKg986kEkrR7UNU2sVXmzZsHhxwye69Hu2q7UHA7qVlrauan9+qwqe4PGhurH0qN+oNGR2F4GM4+GwYHm3ccrajtQmFgIKX5VFc0m5lNx333we9/D1u2OBTcMmdmRjrT2by57CrK51AwMyO1QqxbV3YV5XMomJkBQ0OpCWmmnd+dwqFgZkZqPhobS0O4dDOHgplZla1by66gXA4FM7NMTw+MjJRdRbkcCmZmmeFhePTRsqsol0PBzCwzNATr13d3Z7NDwcws09OTrn7u5n4Fh4KZWQ2HgpmZAWkInQ0byq6iPA4FM7Mq3d7Z7FAwM6syOJi+llq5v0S3cSiYmVWp3FCoW/sVHApmZjUi0jDa3cihYGZWY2AgDY7XjRwKZmY1hocdCmZmlhkYSDfcGRsru5LmcyiYmdXo5s5mh4KZ2SS68facDgUzszoGB9PgeN3GoWBmVsfQUHfes9mhYGZWx8AAbNsGO3eWXUlzORTMzCbRjRexORTMzCbR09N9nc0OBTOzSQwNdd+IqYWGgqRTJa2WtEbSO+ssP0TSTZJuk3SnpNOLrMfMbDocCrNIUi9wMXAasAg4S9KimtX+AbgmIp4JLAE+VVQ9ZmbT1dcHO3bA6GjZlTRPkWcKJwBrIuLeiNgBXA2cWbNOAPtkz+cCDxZYj5nZtHVbZ3ORoTAfeKBqem02r9oy4BxJa4Hrgb+ttyFJSyWtlLRyZOSRImo1M6ur2zqbiwwF1ZkXNdNnAZdHxMHA6cAVknarKSIuiYjFEbF47tz9CyjVzKy+bruIrchQWAssqJo+mN2bh84DrgGIiB8DQ8C8AmsyM5uWyjDaUfuRtkMVGQorgKMkHSZpgNSRvLxmnfuBkwAkPZUUCm4fMrOW0dubrmrevr3sSpqjsFCIiDHgQuAG4G7St4xWSbpI0hnZam8Fzpd0B3AVcG5Et+SxmbULqXs6m/uK3HhEXE/qQK6e966q53cBzyuyBjOzPdXbCxs3wrwuaNz2Fc1mZg1000VsDgUzswaGhtK9FbqhcduhYGbWQE8PjI93x+05HQpmZjlIDgUzM8v09XXH7TkdCmZmOQwPd0dns0PBzCyHwcH0tdTx8bIrKZZDwcwsByl9+6jT+xUcCmZm0+BQMDMzAPr70+B4ncyhYGaWU2XE1E7mUDAzy2lwEDZtgrGxsispjkPBzGyaOrlfwaFgZjZNnXx7ToeCmdk0DA52dr+CQ8HMbBo6/cpmh4KZ2TT098O2bbBjR9mVFMOhYGY2A53a2exQMDObJqlzO5sdCmZm09TJt+d0KJiZTZNDwczMJvT1pY7m0dGyK5l9DgUzsxmIgC1byq5i9jkUzMxmoKcn3XSn0zgUzMxmoFNHTHUomJnNwNBQCoWIsiuZXQ4FM7MZ6O1NQ2hv3152JbPLoWBmNkOd2NnsUDAzm6G+vs7rbHYomJnN0NAQrFtXdhWzy6FgZjZDQ0OwYQPs2lV2JbOnL++KkuYDh1b/TETcXERRZmbtoKcnBcK2bfCEJ5RdzezIFQqSPgC8ErgLGM9mBzBlKEg6FfgY0Av8a0T8U511XgEsy7Z3R0S8Km/xZmatYMuWLgsF4KXAkyMi90gfknqBi4E/AdYCKyQtj4i7qtY5CvjvwPMiYr2kA/KXbmZWvv7+1IR0QIe8e+XtU7gX6J/mtk8A1kTEvRGxA7gaOLNmnfOBiyNiPUBEPDzNfZiZlarTRkzNe6awFbhd0o3AxNlCRLxxip+ZDzxQNb0WeHbNOkcDSPoRqYlpWUR8K2dNZmalGxxMoTA+ni5oa3d5Q2F59pgO1ZlXe0F4H3AUcCJwMPADScdExIbHbUhaCiwFeNKTDplmGWZmxZFSZ/PWrTBnTtnV7LlcoRARn5M0QPbJHlgdETsb/NhaYEHV9MHAg3XWuSXb1q8krSaFxIqa/V8CXALw5Ccv7rCRRsys3UmdEwq5+hQknQj8B6nj+FPALyW9oMGPrQCOknRYFihL2P1s46vAi7J9zCOFzr25qzczawEDA50zYmre5qMPA6dExGoASUcDVwHHT/YDETEm6ULgBlJ/wWURsUrSRcDKiFieLTtFUuWrrm+PiA7qsjGzbtBJnc15Q6G/EggAEfFLSQ2/jRQR1wPX18x7V9XzAN6SPczM2tLgIDzySBo1tS/3JcGtKW/5KyVdClyRTZ8N3FpMSWZm7WnLFpg7t+wq9kze6xReD6wC3gi8iXRl8wVFFWVm1m6kzhhGO++3j0aBj2QPMzOrUelsPuigsivZM1OGgqRrIuIVkn7G7tcYEBHHFlaZmVkbGR7ujM7mRmcKb8r+fXHRhZiZtbP+fli/HnbsSGcN7WrKPoWIeCh7ug54ICLuAwaBp7P7hWhmZl2tchFbO8vb0XwzMJTdU+FG4HXA5UUVZWbWjiTYtKnsKvZM3lBQRGwFXgZ8IiL+DFhUXFlmZu2nEy5iyx0Kkp5Luj7hG9m8Nr9Ew8xsdg0Ntf9wF3lD4c2km+F8JRuq4nDgpuLKMjNrP319MDoK27eXXcnM5b1O4fvA96um7yVdyGZmZlUqnc1DQ2VXMjONrlP454h4s6SvUf86hTMKq8zMrA1JsHEj7Ldf2ZXMTKMzhcpYR/+76ELMzDpB5SK2hQvLrmRmpgyFiKgMercS2BYRuwAk9ZKuVzAzsyqVzuaIdNbQbvJ2NN8I7FU1PQx8Z/bLMTNrb7296X7N27aVXcnM5A2FoYjYXJnInu81xfpmZl2tXa9szhsKWyQdV5mQdDzQpjloZlas3l4YGSm7ipnJewHam4FrJVXGOzoQeGUxJZmZtbdKZ/MRR5RdyfTlvU5hhaSnAE8GBPwiInYWWpmZWZsaHEwjpu7aBT1522NaRK5yJe0F/DfgTRHxM2ChJA+nbWZWR09PCoR27GzOm2GfBXYAz82m1wL/WEhFZmYdIKI9b8+ZNxSOiIgPAjsBImIbqRnJzMzqGBhITUjtJm8o7JA0TDbUhaQjgNHCqjIza3PtOox23m8fvRv4FrBA0pXA84BziyrKzKzdDQ6mUBgfT19RbRcNQ0GSgF+QbrDzHFKz0ZsiYl3BtZmZtS0p9Sts3Qpz5pRdTX4NQyEiQtJXI+J4HrvBjpmZ5bBlS3uFQt4+hVskPavQSszMOkw7djbn7VN4EXCBpF8DW0hNSBERxxZVmJlZuxsagnVt1tCeNxROK7QKM7MONDgIjzwCY2PpVp3toNGd14aAC4AjgZ8Bl0bEWDMKMzPrBJWL2ObOLbuSfBr1KXwOWEwKhNOADxdekZlZB+npgc2bG6/XKhqd0CyKiD8EkHQp8NPiSzIz6xyDg+lObPPnl11JPo3OFCZGQnWzkZnZ9LXblc2NQuHpkjZmj03AsZXnkjY22rikUyWtlrRG0junWO/lkkLS4ukegJlZK+vvh+3bYceOsivJZ8rmo4iY8cXZknqBi4E/IY2qukLS8oi4q2a9OcAbgZ/MdF9mZq2s0tk8MFB2JY0VefuHE4A1EXFvROwArgbOrLPee4EPAtsLrMXMrDTt1NlcZCjMBx6oml6bzZsg6ZnAgoj4+lQbkrRU0kpJK0dGHpn9Ss3MCtROF7EVGQr17rcQEwulHuCjwFsbbSgiLomIxRGxeO7c/WexRDOz4g0Ntc9wF0WGwlpgQdX0wcCDVdNzgGOA72XDZzwHWO7OZjPrNH19MDqaOpxbXZGhsAI4StJhkgaAJcDyysKIGImIeRGxMCIWArcAZ0TEygJrMjMrhdQet+csLBSy6xouBG4A7gauiYhVki6SdEZR+zUza0U9PbBpU9lVNFboEE0RcT1wfc28d02y7olF1mJmVqbKRWwLF5ZdydSKbD4yM7PM0FAa7iKi8bplciiYmTVBb28aQnvbtrIrmZpDwcysSaR0z+ZW5lAwM2uS3l7YsKHsKqbmUDAza5Lh4dYfMdWhYGbWJIODMDICu3aVXcnkHApmZk3S05MCoZX7FRwKZmZN5lAwMzMg3XSnlQfHcyiYmTVRq9+e06FgZtZEg4OwcSOMj5ddSX0OBTOzJlJ2p5lW7VdwKJiZlaBVh9F2KJiZNdnAQBocrxU5FMzMmqyVr2x2KJiZNdnAQGo+2rmz7Ep251AwMytJK3Y2OxTMzEqyeXPZFezOoWBmVoLKndhajUPBzKwEw8Owbl3ZVezOoWBmVoK+PhgdhR07yq7k8RwKZmYlarWL2BwKZmYlkWDTprKreDyHgplZSVpxxFSHgplZSYaGWu/eCg4FM7OS9PWljubt28uu5DEOBTOzEkW0VmezQ8HMrES9va3V2exQMDMrUatdxOZQMDMrUaWzOaLsShKHgplZiXp60v2at20ru5LEoWBm1gJapbO50FCQdKqk1ZLWSHpnneVvkXSXpDsl3Sjp0CLrMTNrRX19MDJSdhVJYaEgqRe4GDgNWAScJWlRzWq3AYsj4ljgOuCDRdVjZtaqWunK5iLPFE4A1kTEvRGxA7gaOLN6hYi4KSIq9x66BTi4wHrMzFrS0FA6U9i1q+xKig2F+cADVdNrs3mTOQ/4Zr0FkpZKWilp5cjII7NYoplZ+aTU2dwKt+csMhRUZ17dL11JOgdYDHyo3vKIuCQiFkfE4rlz95/FEs3MWoPU+aGwFlhQNX0w8GDtSpJOBv4eOCMiRgusx8ysZfX3t8btOYsMhRXAUZIOkzQALAGWV68g6ZnAZ0iB8HCBtZiZtbRW6WwuLBQiYgy4ELgBuBu4JiJWSbpI0hnZah8C9gaulXS7pOWTbM7MrKMNDqYxkMbHy62jr8iNR8T1wPU1895V9fzkIvdvZtYupMdGTN1nn/Lq8BXNZmYtohU6mx0KZmYtYmCg/H4Fh4KZWYsYHi7/G0gOBTOzFjEwkPoUdu4srwaHgplZiymzX8GhYGbWQiTYvLm8/TsUzMxayOBguZ3NDgUzsxYyPOxQMDOzTF8fbN8OoyWNBOdQMDNrMWVexOZQMDNrMVIaB6kMDgUzsxZT5oipDgUzsxYzNJSubI66tyUrlkPBzKzF9PWlq5rL6Gx2KJiZtagtW5q/T4eCmVkL6umBkZES9tv8XZqZWSNljZjqUDAza0FldTY7FMzMWlBPD+zaBdu2NXm/zd2dmZnlVblnczM5FMzMWlR/f/M7mx0KZmYtangY1q1r7j4dCmZmLWpwEDZuTH0LzeJQMDNrUVIKhGaOmOpQMDNrcc3sbHYomJm1sP5+WL++eftzKJiZtbBmD6PtUDAza2GDg7B5M4yPN2d/DgUzsxZW6WxuVr+CQ8HMrMVJzQuFvubsxsystW3fDvfdV3YV9W3eDKtWwYEHFr8vh4KZdb25c8uuYGqDg7BhQ3P25VAws663777p0arGx9PZQjMU2qcg6VRJqyWtkfTOOssHJX0pW/4TSQuLrMfMzKZWWChI6gUuBk4DFgFnSVpUs9p5wPqIOBL4KPCBouoxM7PGimw+OgFYExH3Aki6GjgTuKtqnTOBZdnz64BPSlLE1PcaGh2FsbHZL9jMrBU16xoFKDYU5gMPVE2vBZ492ToRMSZpBHgi8LjBYiUtBZZmUzte+MI59xRTcjvY+QfQ38SL3ltNNx9/Nx87+PhH58LOh/ZgA4fmWanIUFCdebVnAHnWISIuAS4BkLQyYtPiPS+vPaXj3+7j70LdfOzg40/HH4Uff5EdzWuBBVXTBwMPTraOpD5gLvD7AmsyM7MpFBkKK4CjJB0maQBYAiyvWWc58Nrs+cuB7zbqTzAzs+IU1nyU9RFcCNwA9AKXRcQqSRcBKyNiOXApcIWkNaQzhCU5Nn1JUTW3CR9/9+rmYwcff1OOX/5gbmZmFR4Qz8zMJjgUzMxsQsuGQrcPkZHj+N8i6S5Jd0q6UVKu7yC3g0bHXrXeyyWFpI76mmKe45f0iuz3v0rSF5tdY5Fy/O0fIukmSbdlf/+nl1FnESRdJulhST+fZLkkfTx7be6UdNysFxERLfcgdUzfAxwODAB3AItq1nkD8Ons+RLgS2XX3eTjfxGwV/b89Z1y/HmOPVtvDnAzcAuwuOy6m/y7Pwq4DfiDbPqAsutu8vFfArw+e74I+HXZdc/i8b8AOA74+STLTwe+SbrG6znAT2a7hlY9U5gYIiMidgCVITKqnQl8Lnt+HXCSpHoXw7WjhscfETdFxNZs8hbSdSCdIM/vHuC9wAeB7c0srgnyHP/5wMURsR4gIh5uco1FynP8AeyTPZ/L7tc/ta2IuJmpr9U6E/h8JLcA+0qa1bsstGoo1BsiY/5k60TEGFAZIqMT5Dn+aueRPj10gobHLumZwIKI+HozC2uSPL/7o4GjJf1I0i2STm1adcXLc/zLgHMkrQWuB/62OaW1hOm+N0xbq95PYdaGyGhTuY9N0jnAYuCFhVbUPFMeu6Qe0oi65zaroCbL87vvIzUhnUg6Q/yBpGMiokm3YSlUnuM/C7g8Ij4s6bmka52OiYhdxZdXusLf91r1TKHbh8jIc/xIOhn4e+CMiBhtUm1Fa3Tsc4BjgO9J+jWpXXV5B3U25/3b/7eI2BkRvwJWk0KiE+Q5/vOAawAi4sfAEDCvKdWVL9d7w55o1VDo9iEyGh5/1oTyGVIgdFKb8pTHHhEjETEvIhZGxEJSf8oZEbGynHJnXZ6//a+SvmiApHmk5qR7m1plcfIc//3ASQCSnkoKhUeaWmV5lgOvyb6F9BxgJCL2ZOTU3bRk81EUN0RGW8h5/B8C9gauzfrX74+IM0orepbkPPaOlfP4bwBOkXQXMA68PSIeLa/q2ZPz+N8K/IukvyM1nZzbKR8IJV1Fahacl/WZvBvoB4iIT5P6UE4H1gBbgdfNeg0d8lqamdksaNXmIzMzK4FDwczMJjgUzMxsgkPBzMwmOBTMzGyCQ8GshqRxSbdL+rmkr0nad5a3f66kT2bPl0l622xu32xPOBTMdrctIp4REceQroH5m7ILMmsWh4LZ1H5M1YBjkt4uaUU2lv17qua/Jpt3h6Qrsnkvye71cZuk70h6Ugn1m01LS17RbNYKJPWShlO4NJs+hTTG0AmkgcmWS3oB8ChpDKrnRcQ6Sftlm/gh8JyICEl/BbyDdDWuWctyKJjtbljS7cBC4Fbg29n8U7LHbdn03qSQeDpwXUSsA4iIysCMBwNfysa7HwB+1ZTqzfaAm4/MdrctIp4BHEp6M6/0KQh4f9bf8IyIODIiLs3m1xsv5hPAJyPiD4G/Jg3cZtbSHApmk4iIEeCNwNsk9ZMGaftLSXsDSJov6QDgRuAVkp6Yza80H80FfpM9fy1mbcCpzAtqAAAAaUlEQVTNR2ZTiIjbJN0BLImIK7Khmn+cjUy7GTgnG8XzfcD3JY2TmpfOJd0h7FpJvyEN8X1YGcdgNh0eJdXMzCa4+cjMzCY4FMzMbIJDwczMJjgUzMxsgkPBzMwmOBTMzGyCQ8HMzCb8J7NpYJ9BMRj1AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "# Trying classifier `adaboost`...\n",
      "Vectorizing data...\n",
      "First training with (3308, 243) rows...\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0db10a332dae4dd0a5bed4775f90d55a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, description='Predicting windows', max=300, style=ProgressStyle(description…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "!! No false positives given out of 12 predictions, add more images or reduce negatives\n",
      "Adding 0 false positives / 12 predictions\n",
      "Vectorizing data...\n",
      "Second training with (3308, 243) rows...\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": [
      "\n",
      "# Trying classifier `random_forest`...\n",
      "Vectorizing data...\n",
      "First training with (3308, 243) rows...\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e803460dac784da9ac61674e73c674a2",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, description='Predicting windows', max=300, style=ProgressStyle(description…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Adding 6 false positives / 51 predictions\n",
      "Vectorizing data...\n",
      "Second training with (3314, 243) rows...\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": [
      "\n",
      "------\n",
      "\n",
      "{'adaboost': {'classifier': 'adaboost',\n",
      "              'global_params': {'base_estimator': RandomForestClassifier(bootstrap=True, class_weight=None, criterion='gini',\n",
      "            max_depth=30, max_features='auto', max_leaf_nodes=None,\n",
      "            min_impurity_decrease=0.0, min_impurity_split=None,\n",
      "            min_samples_leaf=1, min_samples_split=2,\n",
      "            min_weight_fraction_leaf=0.0, n_estimators=10, n_jobs=None,\n",
      "            oob_score=False, random_state=None, verbose=0,\n",
      "            warm_start=False),\n",
      "                                'box_size': (150, 90),\n",
      "                                'vectorization_params': {'vectorize': <function hog at 0x000001AD36D93C80>}},\n",
      "              'results': [{'result': {'avg_precision': 0.32761879049676024,\n",
      "                                      'f1-score': 0.47619047619047616,\n",
      "                                      'false_neg': 77,\n",
      "                                      'false_pos': 0,\n",
      "                                      'n_test': 5093,\n",
      "                                      'precision': array([0.02199097, 1.        , 1.        ]),\n",
      "                                      'recall': array([1.    , 0.3125, 0.    ]),\n",
      "                                      'roc_auc_score': 0.65625,\n",
      "                                      'true_neg': 35,\n",
      "                                      'true_pos': 4981}}]},\n",
      " 'linear_svc': {'classifier': 'linear_svc',\n",
      "                'global_params': {'box_size': (150, 90),\n",
      "                                  'vectorization_params': {'vectorize': <function hog at 0x000001AD36D93C80>}},\n",
      "                'results': [{'result': {'avg_precision': 0.8352731428440711,\n",
      "                                        'f1-score': 0.9116279069767441,\n",
      "                                        'false_neg': 14,\n",
      "                                        'false_pos': 5,\n",
      "                                        'n_test': 5093,\n",
      "                                        'precision': array([0.02199097, 0.95145631, 1.        ]),\n",
      "                                        'recall': array([1.   , 0.875, 0.   ]),\n",
      "                                        'roc_auc_score': 0.9369980927524594,\n",
      "                                        'true_neg': 98,\n",
      "                                        'true_pos': 4976}}]},\n",
      " 'random_forest': {'classifier': 'random_forest',\n",
      "                   'global_params': {'box_size': (150, 90),\n",
      "                                     'n_estimators': 100,\n",
      "                                     'vectorization_params': {'vectorize': <function hog at 0x000001AD36D93C80>}},\n",
      "                   'results': [{'result': {'avg_precision': 0.6594432834983591,\n",
      "                                           'f1-score': 0.7891891891891891,\n",
      "                                           'false_neg': 39,\n",
      "                                           'false_pos': 0,\n",
      "                                           'n_test': 5093,\n",
      "                                           'precision': array([0.02199097, 1.        , 1.        ]),\n",
      "                                           'recall': array([1.        , 0.65178571, 0.        ]),\n",
      "                                           'roc_auc_score': 0.8258928571428572,\n",
      "                                           'true_neg': 73,\n",
      "                                           'true_pos': 4981}}]},\n",
      " 'svc': {'classifier': 'svc',\n",
      "         'global_params': {'box_size': (150, 90),\n",
      "                           'gamma': 'scale',\n",
      "                           'vectorization_params': {'vectorize': <function hog at 0x000001AD36D93C80>}},\n",
      "         'results': [{'result': {'avg_precision': 0.8166233064991164,\n",
      "                                 'f1-score': 0.896551724137931,\n",
      "                                 'false_neg': 21,\n",
      "                                 'false_pos': 0,\n",
      "                                 'n_test': 5093,\n",
      "                                 'precision': array([0.02199097, 1.        , 1.        ]),\n",
      "                                 'recall': array([1.    , 0.8125, 0.    ]),\n",
      "                                 'roc_auc_score': 0.90625,\n",
      "                                 'true_neg': 91,\n",
      "                                 'true_pos': 4981}}]}}\n"
     ]
    }
   ],
   "source": [
    "# ( 3 ) --- Multiple --- Try multiple classifiers\n",
    "common_params = {\n",
    "    # General\n",
    "    'box_size': (150, 90),\n",
    "    'vectorization_params': {\n",
    "        'vectorize': descriptor_vector.hog,\n",
    "#        'vectorize_kwargs': { 'orientations': 6},\n",
    "    },\n",
    "}\n",
    "\n",
    "kw_params = {\n",
    "    'limit_score': 0.5,\n",
    "    'slide_step': (60,50),\n",
    "    'downscale_step': 30,\n",
    "    'only_one_training': False,\n",
    "}\n",
    "\n",
    "global_params = {\n",
    "    'svc': {\n",
    "        **common_params,\n",
    "        'gamma': 'scale',\n",
    "    },\n",
    "    'linear_svc': {\n",
    "        **common_params,\n",
    "    },\n",
    "    'decision_tree': {\n",
    "        **common_params,\n",
    "    },\n",
    "    'adaboost': {\n",
    "        **common_params,\n",
    "        'base_estimator': models.create_model('random_forest', { 'n_estimators': 10, 'max_depth': 30 })\n",
    "    },\n",
    "    'random_forest': {\n",
    "        **common_params,\n",
    "        'n_estimators': 100,\n",
    "    },\n",
    "}\n",
    "\n",
    "changing_params = {\n",
    "}\n",
    "\n",
    "only_clf = ('svc', 'adaboost', 'linear_svc', 'random_forest')\n",
    "global_params = { key: value for key, value in global_params.items() if key in only_clf }\n",
    "\n",
    "print(f\"Using {len(images)} images\")\n",
    "results = try_classifiers(images, label_sets, global_params, changing_params, **kw_params)\n",
    "\n",
    "print(\"\\n------\\n\")\n",
    "pp(results)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-----\n",
    "-----\n",
    "-----"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. Test predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Got 65 predictions\n"
     ]
    }
   ],
   "source": [
    "# Import predictions\n",
    "from modules.window import show_boxes\n",
    "from config import PREDICTION_PATH, GRAY, TEST_LIMIT, VERSION\n",
    "\n",
    "test_images = data.load_images('test', limit=None)\n",
    "test_labels = data.load_labels(path=PREDICTION_PATH)[:,:6]\n",
    "print(f\"Got {len(test_labels)} predictions\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "32c80e8d6da64bc3ac86d00ebf90a795",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, description='Processing images', max=500, style=ProgressStyle(description_…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Alexandre\\Miniconda3\\lib\\site-packages\\skimage\\util\\dtype.py:141: UserWarning: Possible precision loss when converting from float64 to uint8\n",
      "  .format(dtypeobj_in, dtypeobj_out))\n"
     ]
    }
   ],
   "source": [
    "# Display predictions on each image and save it\n",
    "from collections import Counter\n",
    "#print(Counter(test_labels[:,0]))\n",
    "show_boxes(test_images, test_labels, only=None, display=False, save=True, path=f\"detected/{1}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. Tests"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ( 5 ) --- Haar features optimized\n",
    "int_images = descriptor_vector.compute_integral_images(images)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8743\n",
      "67280\n"
     ]
    }
   ],
   "source": [
    "from skimage.feature import haar_like_feature, haar_like_feature_coord\n",
    "slide_step = (10, 10)\n",
    "box_size = (30, 30)\n",
    "feature_type = 'type-3-x'\n",
    "\n",
    "iimg = int_images[0]\n",
    "h, l = iimg.shape[:2]\n",
    "\n",
    "ft_coord, ft_type = haar_like_feature_coord(*box_size[::-1], feature_type=feature_type)\n",
    "ft_rate = 0.7\n",
    "n_features = int(ft_coord.shape[0] * ft_rate)\n",
    "\n",
    "print(compute_no_windows(iimg, box_size, slide_step, downscale_step))\n",
    "print(ft_coord.shape[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(42, 67280)\n",
      "[[-4.76427451e-01 -9.58526275e-01 -1.40833608e+00 ... -1.14430980e-01\n",
      "  -1.02941176e-01 -1.04347843e-01]\n",
      " [-5.26036745e+00 -5.65385373e+00 -5.88058431e+00 ... -9.26435294e-02\n",
      "  -9.65650980e-02 -9.26435294e-02]\n",
      " [-8.54944745e+00 -8.72380314e+00 -8.85191059e+00 ... -9.65650980e-02\n",
      "  -9.34541176e-02 -9.65650980e-02]\n",
      " ...\n",
      " [-1.46704142e+02 -1.47185064e+02 -1.47689516e+02 ... -5.48482745e-01\n",
      "  -5.41747843e-01 -5.37826275e-01]\n",
      " [-1.51608354e+02 -1.52125441e+02 -1.52634685e+02 ... -5.26061569e-01\n",
      "  -5.26061569e-01 -5.26061569e-01]\n",
      " [-1.56751777e+02 -1.57288473e+02 -1.57823592e+02 ... -5.17087451e-01\n",
      "  -5.17087451e-01 -5.17087451e-01]]\n"
     ]
    }
   ],
   "source": [
    "def compute_haar(iimg, ft_set, box_size, slide_step, downscale_step):\n",
    "    assert all([ len(x) == 2 for x in (ft_set, slide_step, box_size)])\n",
    "    ft_coord, ft_type = ft_set\n",
    "    slide_h, slide_l = slide_step\n",
    "    box_h, box_l = box_size\n",
    "    \n",
    "    n_windows = compute_no_windows(iimg, box_size, slide_step, downscale_step)\n",
    "    n_features = ft_coord.shape[0]\n",
    "\n",
    "    features = np.empty((, n_features))\n",
    "    for x in range(0, h - box_h, slide_h):\n",
    "        for y in range(0, l - box_l, slide_l):\n",
    "            ft = haar_like_feature(iimg, x, y, *box_size[::-1], feature_type=ft_type, feature_coord=ft_coord)\n",
    "            r.append(ft)\n",
    "        break\n",
    "\n",
    "    return features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Display false_positives\n",
    "from skimage.io import imshow_collection\n",
    "imgs = []\n",
    "for falpos in train_results:\n",
    "    img_id = falpos[0]\n",
    "    x,y,h,l = falpos[1:5]\n",
    "    img = images[img_id-1]\n",
    "    imgs.append(img[x:x+h,y:y+l])\n",
    "imshow_collection(imgs)"
   ]
  }
 ],
 "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.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}