landsat8_B4_prediction.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pprint import pprint           # Pretty printing library\n",
    "import time                         # library for time based functions\n",
    "import ee                           # Earth Engine\n",
    "import folium                       # GIS data visualization and mapping library\n",
    "import csv                          # library to deal with CSV I/O\n",
    "import sys                          # to retrieve system and interpreter information\n",
    "import tensorflow as tf             # machine learning and deep learning library\n",
    "import json                         # library for JSON I/O\n",
    "import numpy as np                  # Scientific computing library for matrix algebra\n",
    "import matplotlib.pyplot as plt     # Data visualization library\n",
    "from pandas import DataFrame        # Pandas dataframe data structure \n",
    "from sklearn import linear_model    # linear regression models from machine learning library scikit-learn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "BQJFPBtmq1tf",
    "outputId": "b5be211f-5096-483d-8942-5edcc251c0f4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0.0\n",
      "3.7.6 (default, Jan  8 2020, 19:59:22) \n",
      "[GCC 7.3.0]\n"
     ]
    }
   ],
   "source": [
    "print(tf.__version__)\n",
    "print(sys.version)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ywUUxW3Rmear"
   },
   "outputs": [],
   "source": [
    "ee.Initialize()                     # Grabs credentials from credentials.json and authenticates with Earth Engine"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 637
    },
    "colab_type": "code",
    "id": "cQ9Z1Ecsmh1-",
    "outputId": "778b0ac0-f503-44d2-e8e6-620f13b6136b"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"width:100%;\"><div style=\"position:relative;width:100%;height:0;padding-bottom:60%;\"><iframe src=\"about:blank\" style=\"position:absolute;width:100%;height:100%;left:0;top:0;border:none !important;\" data-html=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 onload=\"this.contentDocument.open();this.contentDocument.write(atob(this.getAttribute('data-html')));this.contentDocument.close();\" allowfullscreen webkitallowfullscreen mozallowfullscreen></iframe></div></div>"
      ],
      "text/plain": [
       "<folium.folium.Map at 0x7f74787b2850>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Use these bands for prediction.\n",
    "bands = ['B2', 'B3', 'B4', 'B5', 'B6', 'B7']\n",
    "# Use Landsat 8 surface reflectance data.\n",
    "l8sr = ee.ImageCollection('LANDSAT/LC08/C01/T1_SR')\n",
    "\n",
    "# Cloud masking function.\n",
    "def maskL8sr(image):\n",
    "  cloudShadowBitMask = ee.Number(2).pow(3).int()\n",
    "  cloudsBitMask = ee.Number(2).pow(5).int()\n",
    "  qa = image.select('pixel_qa')\n",
    "  mask = qa.bitwiseAnd(cloudShadowBitMask).eq(0).And(\n",
    "    qa.bitwiseAnd(cloudsBitMask).eq(0))\n",
    "  return image.updateMask(mask).select(bands).divide(10000)\n",
    "\n",
    "# The image input data is a 2018 cloud-masked median composite.\n",
    "image = l8sr.filterDate('2018-01-01', '2018-12-31').map(maskL8sr).median()\n",
    "\n",
    "# Use folium to visualize the imagery.\n",
    "mapIdDict = image.getMapId({'bands': ['B4', 'B3', 'B2'], 'min': 0, 'max': 0.3})\n",
    "map = folium.Map(location=[45.4, -75.7])\n",
    "folium.TileLayer(\n",
    "    tiles=mapIdDict['tile_fetcher'].url_format,\n",
    "    attr='Map Data &copy; <a href=\"https://earthengine.google.com/\">Google Earth Engine</a>',\n",
    "    overlay=True,\n",
    "    name='median composite',\n",
    "  ).add_to(map)\n",
    "map.add_child(folium.LayerControl())\n",
    "map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found training file.\n",
      "Found testing file.\n"
     ]
    }
   ],
   "source": [
    "# See if files exported from data_exports.ipynb exist in the expected folder\n",
    "\n",
    "trainFileCSV = '../TFData/Training Export.csv'\n",
    "testFileCSV = '../TFData/Testing Export.csv'\n",
    "\n",
    "print('Found training file.' if tf.io.gfile.exists(trainFileCSV) \n",
    "    else 'No training file found.')\n",
    "print('Found testing file.' if tf.io.gfile.exists(testFileCSV) \n",
    "    else 'No testing file found.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>B3</th>\n",
       "      <th>B5</th>\n",
       "      <th>B6</th>\n",
       "      <th>B7</th>\n",
       "      <th>B4</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.05630</td>\n",
       "      <td>0.19920</td>\n",
       "      <td>0.13325</td>\n",
       "      <td>0.08235</td>\n",
       "      <td>0.05220</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.05790</td>\n",
       "      <td>0.27850</td>\n",
       "      <td>0.15070</td>\n",
       "      <td>0.07750</td>\n",
       "      <td>0.03885</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.04130</td>\n",
       "      <td>0.22070</td>\n",
       "      <td>0.08350</td>\n",
       "      <td>0.04080</td>\n",
       "      <td>0.02430</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.05230</td>\n",
       "      <td>0.24485</td>\n",
       "      <td>0.13105</td>\n",
       "      <td>0.06895</td>\n",
       "      <td>0.03510</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.05910</td>\n",
       "      <td>0.31160</td>\n",
       "      <td>0.13560</td>\n",
       "      <td>0.07590</td>\n",
       "      <td>0.03910</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>21329</th>\n",
       "      <td>0.05570</td>\n",
       "      <td>0.22230</td>\n",
       "      <td>0.07560</td>\n",
       "      <td>0.04870</td>\n",
       "      <td>0.04160</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>21330</th>\n",
       "      <td>0.05560</td>\n",
       "      <td>0.20435</td>\n",
       "      <td>0.05960</td>\n",
       "      <td>0.04425</td>\n",
       "      <td>0.03825</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>21331</th>\n",
       "      <td>0.06415</td>\n",
       "      <td>0.21725</td>\n",
       "      <td>0.07755</td>\n",
       "      <td>0.04775</td>\n",
       "      <td>0.04945</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>21332</th>\n",
       "      <td>0.18335</td>\n",
       "      <td>0.32295</td>\n",
       "      <td>0.09425</td>\n",
       "      <td>0.06630</td>\n",
       "      <td>0.16990</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>21333</th>\n",
       "      <td>0.13560</td>\n",
       "      <td>0.24900</td>\n",
       "      <td>0.08020</td>\n",
       "      <td>0.05105</td>\n",
       "      <td>0.11725</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>21334 rows × 5 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "            B3       B5       B6       B7       B4\n",
       "0      0.05630  0.19920  0.13325  0.08235  0.05220\n",
       "1      0.05790  0.27850  0.15070  0.07750  0.03885\n",
       "2      0.04130  0.22070  0.08350  0.04080  0.02430\n",
       "3      0.05230  0.24485  0.13105  0.06895  0.03510\n",
       "4      0.05910  0.31160  0.13560  0.07590  0.03910\n",
       "...        ...      ...      ...      ...      ...\n",
       "21329  0.05570  0.22230  0.07560  0.04870  0.04160\n",
       "21330  0.05560  0.20435  0.05960  0.04425  0.03825\n",
       "21331  0.06415  0.21725  0.07755  0.04775  0.04945\n",
       "21332  0.18335  0.32295  0.09425  0.06630  0.16990\n",
       "21333  0.13560  0.24900  0.08020  0.05105  0.11725\n",
       "\n",
       "[21334 rows x 5 columns]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Generate dataframe for exported training data (retrieved from BC regions)\n",
    "\n",
    "trainCSV = np.genfromtxt(trainFileCSV, delimiter=',', names=True)\n",
    "trainFrame = DataFrame(trainCSV, columns=['B3', 'B5', 'B6', 'B7', 'B4'])\n",
    "trainFrame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f2b95091c88>]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "# By plotting each band against B4, the response variable, I was able to find B3 to be the most correlated band to B4\n",
    "# This would be the ideal behaviour of our final regressor\n",
    "plt.plot(trainFrame['B3'], trainFrame['B4'], 'ro')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9911845882505922\n",
      "[0.92859647 0.         0.         0.        ]\n"
     ]
    }
   ],
   "source": [
    "# Separate the input variables from the response variable into separate DataFrames\n",
    "X = trainFrame[['B3', 'B5', 'B6', 'B7']]\n",
    "Y = trainFrame['B4']\n",
    "\n",
    "# Generate a linear model by fitting a LARs regression model with the LASSO constraint to our training data\n",
    "lars = linear_model.LassoLars(alpha=0.0001)\n",
    "lars.fit(X, Y)\n",
    "print(lars.score(X, Y))     # Print the R^2 score of our regressor\n",
    "print(lars.coef_)           # Print the coefficients of our regression algorithm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see above that only B3 has a nonzero coefficient. This is because LARs (with LASSO) performs variable selection and regression at the same time by selecting the inputs most correlated with the response variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>B3</th>\n",
       "      <th>B5</th>\n",
       "      <th>B6</th>\n",
       "      <th>B7</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.02930</td>\n",
       "      <td>0.15870</td>\n",
       "      <td>0.05980</td>\n",
       "      <td>0.02865</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.05800</td>\n",
       "      <td>0.25490</td>\n",
       "      <td>0.14685</td>\n",
       "      <td>0.08475</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.03860</td>\n",
       "      <td>0.22190</td>\n",
       "      <td>0.09080</td>\n",
       "      <td>0.04120</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.04065</td>\n",
       "      <td>0.17350</td>\n",
       "      <td>0.08980</td>\n",
       "      <td>0.04655</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.04940</td>\n",
       "      <td>0.18380</td>\n",
       "      <td>0.10275</td>\n",
       "      <td>0.05945</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9061</th>\n",
       "      <td>0.45450</td>\n",
       "      <td>0.46765</td>\n",
       "      <td>0.08490</td>\n",
       "      <td>0.07265</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9062</th>\n",
       "      <td>0.04655</td>\n",
       "      <td>0.17545</td>\n",
       "      <td>0.07310</td>\n",
       "      <td>0.03795</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9063</th>\n",
       "      <td>0.06980</td>\n",
       "      <td>0.21670</td>\n",
       "      <td>0.10840</td>\n",
       "      <td>0.06720</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9064</th>\n",
       "      <td>0.15555</td>\n",
       "      <td>0.26230</td>\n",
       "      <td>0.08210</td>\n",
       "      <td>0.04835</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9065</th>\n",
       "      <td>0.07180</td>\n",
       "      <td>0.23910</td>\n",
       "      <td>0.07590</td>\n",
       "      <td>0.04420</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>9066 rows × 4 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "           B3       B5       B6       B7\n",
       "0     0.02930  0.15870  0.05980  0.02865\n",
       "1     0.05800  0.25490  0.14685  0.08475\n",
       "2     0.03860  0.22190  0.09080  0.04120\n",
       "3     0.04065  0.17350  0.08980  0.04655\n",
       "4     0.04940  0.18380  0.10275  0.05945\n",
       "...       ...      ...      ...      ...\n",
       "9061  0.45450  0.46765  0.08490  0.07265\n",
       "9062  0.04655  0.17545  0.07310  0.03795\n",
       "9063  0.06980  0.21670  0.10840  0.06720\n",
       "9064  0.15555  0.26230  0.08210  0.04835\n",
       "9065  0.07180  0.23910  0.07590  0.04420\n",
       "\n",
       "[9066 rows x 4 columns]"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Generate DataFrame for the exported testing data\n",
    "\n",
    "testCSV = np.genfromtxt(testFileCSV, delimiter=',', names = True)\n",
    "testFrame = DataFrame(testCSV, columns=['B3', 'B5', 'B6', 'B7'])\n",
    "testFrame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>B4</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.01780</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.04605</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.02260</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.02950</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.03245</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9061</th>\n",
       "      <td>0.44185</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9062</th>\n",
       "      <td>0.02655</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9063</th>\n",
       "      <td>0.06420</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9064</th>\n",
       "      <td>0.15595</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9065</th>\n",
       "      <td>0.05275</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>9066 rows × 1 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "           B4\n",
       "0     0.01780\n",
       "1     0.04605\n",
       "2     0.02260\n",
       "3     0.02950\n",
       "4     0.03245\n",
       "...       ...\n",
       "9061  0.44185\n",
       "9062  0.02655\n",
       "9063  0.06420\n",
       "9064  0.15595\n",
       "9065  0.05275\n",
       "\n",
       "[9066 rows x 1 columns]"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Use the fitted model from earlier to predict the response, B4, for the testing data\n",
    "predictions = lars.predict(testFrame)\n",
    "\n",
    "# Generate validation data and the R^2 value for testing data from the true values of B4\n",
    "validationFrame = DataFrame(testCSV, columns=['B4'])\n",
    "r2 = lars.score(testFrame, validationFrame)\n",
    "validationFrame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.996478007226406\n",
      "0.01167436982069765\n"
     ]
    }
   ],
   "source": [
    "# Add predictions to the validation frame for easier inspection\n",
    "validationFrame['Predicted'] = predictions\n",
    "\n",
    "# Calculate the RMSE for the regressor and print the two metrics generated so far\n",
    "RMSE = ((validationFrame.Predicted - validationFrame.B4) ** 2).mean() ** .5\n",
    "print(r2)\n",
    "print(RMSE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found training file.\n",
      "Found testing file.\n"
     ]
    }
   ],
   "source": [
    "# See if the other two data files exported using data_exports.ipynb exist at the expected location\n",
    "\n",
    "BCexport = '../TFData/BC Image Export.csv'\n",
    "SaharaExport = '../TFData/Sahara Image Export.csv'\n",
    "\n",
    "print('Found training file.' if tf.io.gfile.exists(trainFileCSV) \n",
    "    else 'No training file found.')\n",
    "print('Found testing file.' if tf.io.gfile.exists(testFileCSV) \n",
    "    else 'No testing file found.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>B3</th>\n",
       "      <th>B5</th>\n",
       "      <th>B6</th>\n",
       "      <th>B7</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.04100</td>\n",
       "      <td>0.18895</td>\n",
       "      <td>0.05830</td>\n",
       "      <td>0.03805</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.06710</td>\n",
       "      <td>0.20605</td>\n",
       "      <td>0.07260</td>\n",
       "      <td>0.04690</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.05265</td>\n",
       "      <td>0.17895</td>\n",
       "      <td>0.05620</td>\n",
       "      <td>0.03485</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.06755</td>\n",
       "      <td>0.18925</td>\n",
       "      <td>0.05565</td>\n",
       "      <td>0.03770</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.04570</td>\n",
       "      <td>0.22380</td>\n",
       "      <td>0.08320</td>\n",
       "      <td>0.04780</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1239036</th>\n",
       "      <td>0.05420</td>\n",
       "      <td>0.21785</td>\n",
       "      <td>0.11640</td>\n",
       "      <td>0.07620</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1239037</th>\n",
       "      <td>0.05420</td>\n",
       "      <td>0.21785</td>\n",
       "      <td>0.11640</td>\n",
       "      <td>0.07620</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1239038</th>\n",
       "      <td>0.08110</td>\n",
       "      <td>0.22755</td>\n",
       "      <td>0.11685</td>\n",
       "      <td>0.07555</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1239039</th>\n",
       "      <td>0.04795</td>\n",
       "      <td>0.19290</td>\n",
       "      <td>0.05970</td>\n",
       "      <td>0.04095</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1239040</th>\n",
       "      <td>0.05180</td>\n",
       "      <td>0.21800</td>\n",
       "      <td>0.06610</td>\n",
       "      <td>0.05420</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>1239041 rows × 4 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "              B3       B5       B6       B7\n",
       "0        0.04100  0.18895  0.05830  0.03805\n",
       "1        0.06710  0.20605  0.07260  0.04690\n",
       "2        0.05265  0.17895  0.05620  0.03485\n",
       "3        0.06755  0.18925  0.05565  0.03770\n",
       "4        0.04570  0.22380  0.08320  0.04780\n",
       "...          ...      ...      ...      ...\n",
       "1239036  0.05420  0.21785  0.11640  0.07620\n",
       "1239037  0.05420  0.21785  0.11640  0.07620\n",
       "1239038  0.08110  0.22755  0.11685  0.07555\n",
       "1239039  0.04795  0.19290  0.05970  0.04095\n",
       "1239040  0.05180  0.21800  0.06610  0.05420\n",
       "\n",
       "[1239041 rows x 4 columns]"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Generate the testing data from the region exported from BC\n",
    "BCdata = np.genfromtxt(BCexport, delimiter=',', names = True)\n",
    "BCtest = DataFrame(BCdata, columns=['B3', 'B5', 'B6', 'B7']).sample(n=20000).reset_index(drop=True)\n",
    "BCtest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>B4</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.04220</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.07160</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.04415</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.05825</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.04350</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1239036</th>\n",
       "      <td>0.07220</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1239037</th>\n",
       "      <td>0.07220</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1239038</th>\n",
       "      <td>0.09805</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1239039</th>\n",
       "      <td>0.04560</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1239040</th>\n",
       "      <td>0.04780</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>1239041 rows × 1 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "              B4\n",
       "0        0.04220\n",
       "1        0.07160\n",
       "2        0.04415\n",
       "3        0.05825\n",
       "4        0.04350\n",
       "...          ...\n",
       "1239036  0.07220\n",
       "1239037  0.07220\n",
       "1239038  0.09805\n",
       "1239039  0.04560\n",
       "1239040  0.04780\n",
       "\n",
       "[1239041 rows x 1 columns]"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Predict the response, B4, using the trained model\n",
    "BCpredictions = lars.predict(BCtest)\n",
    "\n",
    "# Generate a validation DataFrame and the R^2 value for the data using the true values of B4\n",
    "BCvalidations = DataFrame(BCdata, columns=['B4'])\n",
    "BC_r2 = lars.score(BCtest, BCvalidations)\n",
    "BCvalidations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9831095041964283\n",
      "0.011124098430193356\n"
     ]
    }
   ],
   "source": [
    "# Add the predictions to the validation DataFrame for easier inspection\n",
    "BCvalidations['Predicted'] = BCpredictions\n",
    "\n",
    "# Generate the RMSE for the regressor and print the two metrics\n",
    "BC_RMSE = ((BCvalidations.Predicted - BCvalidations.B4) ** 2).mean() ** .5\n",
    "print(BC_r2)\n",
    "print(BC_RMSE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/hshah/anaconda3/envs/eeAlr/lib/python3.6/site-packages/ipykernel_launcher.py:2: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "  \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": [
    "# Plot the predictions on the y-axis against the true values of the response on the x-axis\n",
    "plt.plot(BCvalidations['B4'], BCvalidations['Predicted'], 'ro')\n",
    "ax = plt.axes()\n",
    "x = np.linspace(0, 1, 1000)\n",
    "# The ideal regressor would follow the y=x line plotted\n",
    "ax.plot(x, x)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Repeating the same procedure for the data exported from the image in the Sahara region as a test dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>B3</th>\n",
       "      <th>B5</th>\n",
       "      <th>B6</th>\n",
       "      <th>B7</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.30815</td>\n",
       "      <td>0.60645</td>\n",
       "      <td>0.73485</td>\n",
       "      <td>0.65110</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.31225</td>\n",
       "      <td>0.61735</td>\n",
       "      <td>0.75595</td>\n",
       "      <td>0.67270</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.31285</td>\n",
       "      <td>0.61405</td>\n",
       "      <td>0.75040</td>\n",
       "      <td>0.66865</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.31175</td>\n",
       "      <td>0.60985</td>\n",
       "      <td>0.74485</td>\n",
       "      <td>0.65835</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.31085</td>\n",
       "      <td>0.60645</td>\n",
       "      <td>0.74045</td>\n",
       "      <td>0.65450</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1239028</th>\n",
       "      <td>0.32260</td>\n",
       "      <td>0.63885</td>\n",
       "      <td>0.78160</td>\n",
       "      <td>0.69070</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1239029</th>\n",
       "      <td>0.31665</td>\n",
       "      <td>0.62295</td>\n",
       "      <td>0.75735</td>\n",
       "      <td>0.67125</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1239030</th>\n",
       "      <td>0.31505</td>\n",
       "      <td>0.62255</td>\n",
       "      <td>0.75515</td>\n",
       "      <td>0.67310</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1239031</th>\n",
       "      <td>0.31500</td>\n",
       "      <td>0.61590</td>\n",
       "      <td>0.75145</td>\n",
       "      <td>0.66805</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1239032</th>\n",
       "      <td>0.30895</td>\n",
       "      <td>0.60450</td>\n",
       "      <td>0.73765</td>\n",
       "      <td>0.65090</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>1239033 rows × 4 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "              B3       B5       B6       B7\n",
       "0        0.30815  0.60645  0.73485  0.65110\n",
       "1        0.31225  0.61735  0.75595  0.67270\n",
       "2        0.31285  0.61405  0.75040  0.66865\n",
       "3        0.31175  0.60985  0.74485  0.65835\n",
       "4        0.31085  0.60645  0.74045  0.65450\n",
       "...          ...      ...      ...      ...\n",
       "1239028  0.32260  0.63885  0.78160  0.69070\n",
       "1239029  0.31665  0.62295  0.75735  0.67125\n",
       "1239030  0.31505  0.62255  0.75515  0.67310\n",
       "1239031  0.31500  0.61590  0.75145  0.66805\n",
       "1239032  0.30895  0.60450  0.73765  0.65090\n",
       "\n",
       "[1239033 rows x 4 columns]"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "SaharaData = np.genfromtxt(SaharaExport, delimiter=',', names = True)\n",
    "\n",
    "SaharaTest = DataFrame(SaharaData, columns=['B3', 'B5', 'B6', 'B7'])\n",
    "SaharaTest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>B4</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.49710</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.50615</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.50415</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.50105</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.49795</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1239028</th>\n",
       "      <td>0.52655</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1239029</th>\n",
       "      <td>0.51155</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1239030</th>\n",
       "      <td>0.51055</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1239031</th>\n",
       "      <td>0.50730</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1239032</th>\n",
       "      <td>0.49795</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>1239033 rows × 1 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "              B4\n",
       "0        0.49710\n",
       "1        0.50615\n",
       "2        0.50415\n",
       "3        0.50105\n",
       "4        0.49795\n",
       "...          ...\n",
       "1239028  0.52655\n",
       "1239029  0.51155\n",
       "1239030  0.51055\n",
       "1239031  0.50730\n",
       "1239032  0.49795\n",
       "\n",
       "[1239033 rows x 1 columns]"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "SaharaPredictions = lars.predict(SaharaTest)\n",
    "\n",
    "SaharaValidations = DataFrame(SaharaData, columns=['B4'])\n",
    "Sahara_r2 = lars.score(SaharaTest, SaharaValidations)\n",
    "SaharaValidations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-43.66089306540057\n",
      "0.12259647777144031\n"
     ]
    }
   ],
   "source": [
    "SaharaValidations['Predicted'] = SaharaPredictions\n",
    "Sahara_RMSE = ((SaharaValidations.Predicted - SaharaValidations.B4) ** 2).mean() ** .5\n",
    "\n",
    "print(Sahara_r2)\n",
    "print(Sahara_RMSE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/hshah/anaconda3/envs/eeAlr/lib/python3.6/site-packages/ipykernel_launcher.py:2: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "  \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": [
    "plt.plot(SaharaValidations['B4'], SaharaValidations['Predicted'], 'ro')\n",
    "axes = plt.axes()\n",
    "axes.plot(x, x)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As can be seen above from the predictions for the response, B4, in the Sahara desert plotted against the true values of B4, the model suffers from a severe bias due to dataset shift. \n",
    "\n",
    "Being trained on a dataset that was vastly different (it was trained on data from solely the province of BC where there is much more vegetation and the reflectance characteristics for each band are vastly different from a desert) it is biased when predicting the response for a dataset with a different relation between the input bands and the response bands."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Keras NNet Predictions\n",
    "\n",
    "The rest of the code gathers the same input data as above, but in the formate of tensors that can be processed by the neural network built using Keras, the front-end interface for Tensorflow. The predictions are made using the band selected by the LARs regression earlier, which in this case means only B3.\n",
    "\n",
    "A neural network is clearly not necessary for such a linear relationship between the inputs and outputs, but for the sake of argument we can show how little of a difference the addition of a neural network makes to the accuracy of the machine learning model for linearly related inputs and outputs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Input features, the 4 bands other than B4\n",
    "featureBands = ['B3', 'B5', 'B6', 'B7']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Selecting the most correlated bands using the coefficients from the LARS regression model built earlier\n",
    "selectBands = [featureBands[i] for i in np.nonzero(lars.coef_)[0].tolist()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['B3']"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "selectBands"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found training file.\n",
      "Found testing file.\n"
     ]
    }
   ],
   "source": [
    "# Test if the training and testing data from data_exports.ipynb exist at the expected location\n",
    "\n",
    "trainFilePath = '../TFData/Training Export.tfrecord.gz'\n",
    "testFilePath = '../TFData/Testing Export.tfrecord.gz'\n",
    "\n",
    "print('Found training file.' if tf.io.gfile.exists(trainFilePath) \n",
    "    else 'No training file found.')\n",
    "print('Found testing file.' if tf.io.gfile.exists(testFilePath) \n",
    "    else 'No testing file found.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor(b'\\n`\\n\\x0e\\n\\x02B2\\x12\\x08\\x12\\x06\\n\\x04vO\\x1e=\\n\\x0e\\n\\x02B3\\x12\\x08\\x12\\x06\\n\\x04\\xd4\\x9af=\\n\\x0e\\n\\x02B4\\x12\\x08\\x12\\x06\\n\\x04\\xab\\xcfU=\\n\\x0e\\n\\x02B5\\x12\\x08\\x12\\x06\\n\\x04\\x16\\xfbK>\\n\\x0e\\n\\x02B6\\x12\\x08\\x12\\x06\\n\\x04\\xb0r\\x08>\\n\\x0e\\n\\x02B7\\x12\\x08\\x12\\x06\\n\\x04\\x1e\\xa7\\xa8=', shape=(), dtype=string)\n"
     ]
    }
   ],
   "source": [
    "# Create a dataset from the TFRecord file in Google Drive.\n",
    "trainDataset = tf.data.TFRecordDataset(trainFilePath, compression_type='GZIP')\n",
    "# Print the first record to check.\n",
    "print(iter(trainDataset).next())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'B3': FixedLenFeature(shape=[1], dtype=tf.float32, default_value=None),\n",
      " 'B4': FixedLenFeature(shape=[1], dtype=tf.float32, default_value=None)}\n"
     ]
    }
   ],
   "source": [
    "# This is list of all the properties we want to export.\n",
    "featureNames = list(selectBands)\n",
    "featureNames.append('B4')   # Append B4, we want to export the response variable at the same time as well\n",
    "\n",
    "# List of fixed-length features, all of which are float32.\n",
    "columns = [\n",
    "  tf.io.FixedLenFeature(shape=[1], dtype=tf.float32) for k in featureNames\n",
    "]\n",
    "\n",
    "# Dictionary with names as keys, features as values.\n",
    "featuresDict = dict(zip(featureNames, columns))\n",
    "\n",
    "pprint(featuresDict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "({'B3': <tf.Tensor: id=35, shape=(1,), dtype=float32, numpy=array([0.0563], dtype=float32)>},\n",
      " <tf.Tensor: id=36, shape=(1,), dtype=float32, numpy=array([0.0522], dtype=float32)>)\n"
     ]
    }
   ],
   "source": [
    "# Parse tfrecord file into a tuple that can be passed into the model.fit function later on\n",
    "def parse_tfrecord(example_proto):\n",
    "  parsed_features = tf.io.parse_single_example(example_proto, featuresDict)\n",
    "  band4 = parsed_features.pop('B4')\n",
    "  return parsed_features, band4\n",
    "\n",
    "# Map the function over the dataset.\n",
    "parsedDataset = trainDataset.map(parse_tfrecord, num_parallel_calls=5)\n",
    "\n",
    "# Print the first parsed record to check.\n",
    "pprint(iter(parsedDataset).next())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(<tf.Tensor: id=69, shape=(1, 1), dtype=float32, numpy=array([[0.0563]], dtype=float32)>,\n",
      " <tf.Tensor: id=70, shape=(1,), dtype=float32, numpy=array([0.0522], dtype=float32)>)\n"
     ]
    }
   ],
   "source": [
    "def toTuple(dict, label):\n",
    "  return tf.transpose(list(dict.values())), label\n",
    "\n",
    "# Define the layers in the model.\n",
    "model = tf.keras.models.Sequential([\n",
    "  tf.keras.layers.Dense(1),\n",
    "  tf.keras.layers.Dense(10, activation=tf.nn.sigmoid),\n",
    "  tf.keras.layers.Dense(1)\n",
    "])\n",
    "\n",
    "inputDataset = parsedDataset.map(toTuple)\n",
    "pprint(iter(inputDataset).next())\n",
    "\n",
    "# Compile the model with the specified loss function.\n",
    "model.compile(optimizer=tf.keras.optimizers.Nadam(),\n",
    "              loss='mse',\n",
    "              metrics=['mse', 'mae'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "21334/21334 [==============================] - 116s 5ms/step - loss: 0.0012 - mse: 0.0012 - mae: 0.0134\n",
      "Epoch 2/10\n",
      "21334/21334 [==============================] - 71s 3ms/step - loss: 2.0002e-04 - mse: 2.0001e-04 - mae: 0.0089\n",
      "Epoch 3/10\n",
      "21334/21334 [==============================] - 74s 3ms/step - loss: 1.8935e-04 - mse: 1.8934e-04 - mae: 0.0088\n",
      "Epoch 4/10\n",
      "21334/21334 [==============================] - 68s 3ms/step - loss: 1.8422e-04 - mse: 1.8421e-04 - mae: 0.0087\n",
      "Epoch 5/10\n",
      "21334/21334 [==============================] - 70s 3ms/step - loss: 1.8152e-04 - mse: 1.8151e-04 - mae: 0.0087\n",
      "Epoch 6/10\n",
      "21334/21334 [==============================] - 71s 3ms/step - loss: 1.7979e-04 - mse: 1.7978e-04 - mae: 0.0087\n",
      "Epoch 7/10\n",
      "21334/21334 [==============================] - 71s 3ms/step - loss: 1.7850e-04 - mse: 1.7850e-04 - mae: 0.0087\n",
      "Epoch 8/10\n",
      "21334/21334 [==============================] - 73s 3ms/step - loss: 1.7744e-04 - mse: 1.7743e-04 - mae: 0.0087\n",
      "Epoch 9/10\n",
      "21334/21334 [==============================] - 70s 3ms/step - loss: 1.7660e-04 - mse: 1.7660e-04 - mae: 0.0087\n",
      "Epoch 10/10\n",
      "21334/21334 [==============================] - 70s 3ms/step - loss: 1.7607e-04 - mse: 1.7606e-04 - mae: 0.0087\n",
      "9066/9066 [==============================] - 35s 4ms/step - loss: 1.9936e-04 - mse: 1.9936e-04 - mae: 0.0099\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.00019936198320333893, 0.00019936214, 0.009897066]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Fit the model to the training data.\n",
    "model.fit(x=inputDataset, epochs=10)\n",
    "\n",
    "testDataset = (\n",
    "  tf.data.TFRecordDataset(testFilePath, compression_type='GZIP')\n",
    "    .map(parse_tfrecord, num_parallel_calls=5)\n",
    "    .map(toTuple)\n",
    ")\n",
    "\n",
    "model.evaluate(testDataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['../TFData/BC Image Export-00000.tfrecord.gz',\n",
      " '../TFData/BC Image Export-00001.tfrecord.gz',\n",
      " '../TFData/BC Image Export-00002.tfrecord.gz']\n",
      "../TFData/BC Image Export-mixer.json\n"
     ]
    }
   ],
   "source": [
    "filesList = !ls '../TFData'\n",
    "exportFilesList = [s for s in filesList if 'BC Image Export' in s]\n",
    "\n",
    "imageFilesList=[]\n",
    "jsonFile = None\n",
    "for f in exportFilesList:\n",
    "    if f.endswith('.tfrecord.gz'):\n",
    "        imageFilesList.append('../TFData/'+f)\n",
    "    elif f.endswith('.json'):\n",
    "        jsonFile = '../TFData/'+f\n",
    "        \n",
    "imageFilesList.sort()\n",
    "\n",
    "pprint(imageFilesList)\n",
    "print(jsonFile)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'patchDimensions': [256, 256],\n",
      " 'patchesPerRow': 14,\n",
      " 'projection': {'affine': {'doubleMatrix': [0.00026949458523585647,\n",
      "                                            0.0,\n",
      "                                            -122.00019873627222,\n",
      "                                            0.0,\n",
      "                                            -0.00026949458523585647,\n",
      "                                            59.00098853485653]},\n",
      "                'crs': 'EPSG:4326'},\n",
      " 'totalPatches': 196}\n"
     ]
    }
   ],
   "source": [
    "jsonText = !cat '{jsonFile}'\n",
    "mixer = json.loads(jsonText.nlstr)\n",
    "pprint(mixer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get relevant info from the JSON mixer file.\n",
    "PATCH_WIDTH = mixer['patchDimensions'][0]\n",
    "PATCH_HEIGHT = mixer['patchDimensions'][1]\n",
    "PATCHES = mixer['totalPatches']\n",
    "PATCH_DIMENSIONS_FLAT = [PATCH_WIDTH * PATCH_HEIGHT, 1]\n",
    "\n",
    "testBands = featureNames\n",
    "\n",
    "# Note that the tensors are in the shape of a patch, one patch for each band.\n",
    "imageColumns = [\n",
    "  tf.io.FixedLenFeature(shape=PATCH_DIMENSIONS_FLAT, dtype=tf.float32) \n",
    "    for k in testBands\n",
    "]\n",
    "\n",
    "# Parsing dictionary.\n",
    "imageFeaturesDict = dict(zip(testBands, imageColumns))\n",
    "\n",
    "# Note that you can make one dataset from many files by specifying a list.\n",
    "imageDataset = tf.data.TFRecordDataset(imageFilesList, compression_type='GZIP')\n",
    "\n",
    "# Parsing function.\n",
    "def parse_image(example_proto):\n",
    "    parsed_image = tf.io.parse_single_example(example_proto, imageFeaturesDict)\n",
    "    band4 = parsed_image.pop('B4')\n",
    "    return parsed_image\n",
    "\n",
    "def parse_output(example_proto):\n",
    "    parsed_output = tf.io.parse_single_example(example_proto, imageFeaturesDict)\n",
    "    band4 = parsed_output.pop('B4')\n",
    "    return band4\n",
    "\n",
    "outputDataset = imageDataset.map(parse_output, num_parallel_calls=5)\n",
    "\n",
    "# Parse the data into tensors, one long tensor per patch.\n",
    "imageDataset = imageDataset.map(parse_image, num_parallel_calls=5)\n",
    "\n",
    "\n",
    "# Break our long tensors into many little ones.\n",
    "imageDataset = imageDataset.flat_map(\n",
    "  lambda features: tf.data.Dataset.from_tensor_slices(features)\n",
    ")\n",
    "\n",
    "# Turn the dictionary in each record into a tuple without a label.\n",
    "imageDataset = imageDataset.map(\n",
    "  lambda dataDict: (tf.transpose(list(dataDict.values())), )\n",
    ")\n",
    "\n",
    "# Turn each patch into a batch.\n",
    "imageDataset = imageDataset.batch(PATCH_WIDTH * PATCH_HEIGHT)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(<tf.Tensor: id=891726, shape=(65536, 1, 1), dtype=float32, numpy=\n",
      "array([[[0.14685]],\n",
      "\n",
      "       [[0.14685]],\n",
      "\n",
      "       [[0.05795]],\n",
      "\n",
      "       ...,\n",
      "\n",
      "       [[0.043  ]],\n",
      "\n",
      "       [[0.0476 ]],\n",
      "\n",
      "       [[0.0476 ]]], dtype=float32)>,)\n"
     ]
    }
   ],
   "source": [
    "print(iter(imageDataset).next())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Run prediction in batches, with as many steps as there are patches.\n",
    "predictions = model.predict(imageDataset, steps=PATCHES, verbose=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "outputted = np.vstack(list(outputDataset.as_numpy_iterator()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/hshah/anaconda3/envs/eeAlr/lib/python3.6/site-packages/ipykernel_launcher.py:2: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "  \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": [
    "plt.plot(predicted.flatten(), outputted, 'ro')\n",
    "axs = plt.axes()\n",
    "axs.plot(x, x)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "name": "Landsat 8 'B4' Prediction Task.ipynb",
   "provenance": [],
   "toc_visible": true
  },
  "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}