predict_installation_year_from_image_sequences.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import os.path\n",
    "import pickle\n",
    "import shutil\n",
    "import pandas as pd\n",
    "import random\n",
    "import math\n",
    "import matplotlib.pyplot as plt\n",
    "from os.path import join, exists\n",
    "import numpy as np\n",
    "from tqdm import tqdm\n",
    "import random\n",
    "import copy\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook takes the prediction scores of HR model, LR model, and blur detection model (ood model) as inputs, and outputs the installation year prediction for each image sequence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "dir_list = ['demo_sequences']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "root_data_dir = 'data/sequences'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Load prob dicts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('results/HR_prob_dict.pickle', 'rb') as f:\n",
    "    HR_prob_dict = pickle.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('results/LR_prob_dict.pickle', 'rb') as f:\n",
    "    LR_prob_dict = pickle.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('results/ood_prob_dict.pickle', 'rb') as f:\n",
    "    ood_prob_dict = pickle.load(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Installation year detection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "LR_threshold = 0.97\n",
    "blur_threshold = 0.29\n",
    "ood_threshold = 0.09"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Given LR prediction score, and the info of OOD (blur), return the year of installation.\n",
    "# Using OOD prediction (multiclass: [whether it is ood, whether it is HR]).\n",
    "# In this function, reference list (HR_prob > thres) is assumed to be the key values of LR_prob_dict.\n",
    "def hybrid_model_5(LR_prob_dict, blur_info, LR_threshold=0.5, ood_threshold=0.5, blur_threshold=0.5):\n",
    "    \"\"\"\n",
    "    LR_prob_dict: key1: anchor_filename, key2: target_filename, value: prob produced by LR model\n",
    "    blur_info: key: filename, value: an array of two scores (OOD score and blur score)\n",
    "    LR_threshold: to determine whether a LR image is positive or not.\n",
    "    ood_threshold: to determint whether a image is out-of-distribution (\"impossible to detect\") or not.\n",
    "    blur_threshold: to determine whether a image is HR or LR.\n",
    "    \"\"\" \n",
    "    def is_anchor_candidate(f):\n",
    "        \"\"\" Determine whether an image can be a candidate of the \"positive anchor\" based on its blur \n",
    "        score and OOD score. \"\"\"\n",
    "        if  blur_info[f][1] >= blur_threshold and blur_info[f][0] >= ood_threshold:\n",
    "            return True  # HR\n",
    "        else:\n",
    "            return False  # LR or OOD\n",
    "    \n",
    "    # reference list: a list of image filenames with its HR prediction score >= HR_threshold\n",
    "    reference_list = sorted(LR_prob_dict.keys()) # sorted in the time order\n",
    "    \n",
    "    # determine the \"positive anchor\"\n",
    "    selected_anchors = [f for f in reference_list if is_anchor_candidate(f)]\n",
    "    if selected_anchors:\n",
    "        positive_anchor = selected_anchors[0] # use the earliest anchor image as the \"positive anchor\"\n",
    "    else:\n",
    "        positive_anchor = reference_list[-1]\n",
    "    \n",
    "    # determine the first target (LR) that surpass the threshold based on all referenced anchors\n",
    "    for target in sorted(LR_prob_dict[positive_anchor].keys()): # go through all images\n",
    "        if is_anchor_candidate(target): # skip those images with is HR\n",
    "            continue\n",
    "        if int(target.split('_')[0]) > int(positive_anchor.split('_')[0]): # skip those images later than positive anchor\n",
    "            continue\n",
    "        if blur_info[target][0] < ood_threshold: # don't consider OOD images but record them\n",
    "            continue\n",
    "        for ref in reference_list:\n",
    "            if LR_prob_dict[ref][target] > LR_threshold:\n",
    "                return max(min(2017, int(target.split('_')[0])), 2005), positive_anchor\n",
    "        \n",
    "    return max(min(2017, int(positive_anchor.split('_')[0])), 2005), positive_anchor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# To gather all \"critial\" years that are missing but may change the year prediction.\n",
    "# \"critical\" means that it is RIGHT before the predicted installation year\n",
    "def backtrack_missing_critical_years(LR_prob_dict, \n",
    "                                     blur_info, \n",
    "                                     positive_anchor, \n",
    "                                     installation_year,\n",
    "                                     LR_threshold,\n",
    "                                     ood_threshold,\n",
    "                                     blur_threshold):\n",
    "    \"\"\"\n",
    "    LR_prob_dict: key1: anchor_filename, key2: target_filename, value: prob produced by LR model\n",
    "    blur_info: key: filename, value: an array of two scores (OOD score and blur score)\n",
    "    ood_images: a list of image filenames which are identified as OOD and thus can be regarded as missing\n",
    "    positive_anchor: the anchor image filename which is the earliest HR positive sample\n",
    "    installation_year: the predicted year of installation\n",
    "    LR_threshold: to determine whether a LR image is positive or not\n",
    "    ood_threshold: to determint whether a image is out-of-distribution (\"impossible to detect\") or not.\n",
    "    blur_threshold: to determine whether a image is HR or LR.\n",
    "    \"\"\"\n",
    "    all_images = sorted(LR_prob_dict[positive_anchor].keys()) # all image filenames in that sequence in the time order\n",
    "    \n",
    "    # reference list: a list of image filenames with its HR prediction score >= HR_threshold\n",
    "    reference_list = set(sorted(LR_prob_dict.keys())) # sorted in the time order\n",
    "    \n",
    "    all_downloaded_years = {} # Note: only consider those years no later than installation_year\n",
    "    for f in all_images:\n",
    "        year = int(f.split('_')[0])\n",
    "        if blur_info[f][0] >= ood_threshold or f in reference_list:  # OOD images are regarded as missing\n",
    "            if year not in all_downloaded_years:\n",
    "                all_downloaded_years[year] = []\n",
    "            all_downloaded_years[year].append(f)\n",
    "            \n",
    "    missing_critial_years = []\n",
    "    # backtracking\n",
    "    curr_year = installation_year - 1\n",
    "    while curr_year >= 2005 and curr_year not in all_downloaded_years:\n",
    "        missing_critial_years.append(curr_year)\n",
    "        curr_year -= 1\n",
    "    \n",
    "    if not missing_critial_years:  # no missing\n",
    "        return missing_critial_years\n",
    "    \n",
    "    if installation_year not in all_downloaded_years:  # it indicates that the actual predicted year is 2018 but restricted to 2017\n",
    "        assert installation_year == 2017\n",
    "        return missing_critial_years + [2017]\n",
    "    \n",
    "#     if len(all_downloaded_years[installation_year]) == 1:  # only one image in that year\n",
    "#         return missing_critial_years\n",
    "    \n",
    "    for f in all_downloaded_years[installation_year]:  \n",
    "        # if any one of the images in the installtion year is negative (HR negative and LR negative), \n",
    "        # then we can infer one sample is positive and another is negative in that year, \n",
    "        # thus the solar panel must be installed in that year\n",
    "        # then there is no missing critical year\n",
    "        if blur_info[f][1] >= blur_threshold and f not in reference_list:\n",
    "            return []\n",
    "        if blur_info[f][1] < blur_threshold and f not in reference_list and all([LR_prob_dict[x][f] < LR_threshold for x in reference_list]):\n",
    "            return []\n",
    "    \n",
    "    return missing_critial_years # a list of missing critial years"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "installation_year_dict = {} # sequence idx -> predicted installation year\n",
    "missing_years_dict = {} # sequence idx -> a list of missing critial years\n",
    "for idx in tqdm(HR_prob_dict):\n",
    "    LR_prob_dict_sub = LR_prob_dict[idx]\n",
    "    blur_info = ood_prob_dict[idx]\n",
    "    installation_year, positive_anchor = hybrid_model_5(LR_prob_dict_sub, blur_info, LR_threshold, \n",
    "                                                    ood_threshold, blur_threshold)\n",
    "    missing_years = backtrack_missing_critical_years(LR_prob_dict_sub, blur_info, positive_anchor, \n",
    "                                                     installation_year,\n",
    "                                                     LR_threshold, ood_threshold, blur_threshold)\n",
    "    installation_year_dict[int(idx)] = installation_year\n",
    "    if missing_years:\n",
    "#         if not installation_year in missing_years:\n",
    "#             missing_years_dict[int(idx)] = missing_years + [installation_year]\n",
    "#         else:\n",
    "        missing_years_dict[int(idx)] = missing_years\n",
    "print(len(installation_year_dict))\n",
    "print(len(missing_years_dict))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('results/installation_year_prediction_dict.pickle', 'wb') as f:\n",
    "    pickle.dump(installation_year_dict, f) \n",
    "with open('results/missing_years_dict.pickle', 'wb') as f:\n",
    "    pickle.dump(missing_years_dict, f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Environment (conda_tensorflow_p36)",
   "language": "python",
   "name": "conda_tensorflow_p36"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}