Precipitation prediction using convLSTM submission notebook.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Data Manipulation\n",
    "\n",
    "The Radar data for this project was downloaded from the CIKM 2017 competition at the link below https://tianchi.aliyun.com/competition/information.htm?raceId=231596&_lang=en_US\n",
    "The solution of this notebook is inspired by the solution given by:\n",
    "https://github.com/TeaPearce/precipitation-prediction-convLSTM-keras which is itself an inspiration of the paper that uses convLSTM: \n",
    "https://arxiv.org/abs/1506.04214\n",
    "\n",
    "The data consisted of 1 training set, 2 testing sets which was 3.5GB in total when in compressed format. After uncompressing the data, the data which was stored in string format in text files came up to ~ 24GB of data. To work on the project though we need to feed the deep neural networks images - this requires to change the data to a HDF5 format which is essentially data cubes where each slice is an image. Transforming data to this format means that the images takes even more disk space. The training set would amount to > 50 GB of data with each testing set being ~ 10 GB of memory space. Below are a few functions that would transform the data from text format to the HDF5 format that is needed to train any tensorflow based model. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import datetime\n",
    "import os\n",
    "import sys\n",
    "from datetime import datetime\n",
    "from datetime import timedelta\n",
    "import matplotlib.pyplot as plt\n",
    "import h5py\n",
    "\n",
    "\n",
    "#### Function to just give some printing on the screen during conversion of file formats \n",
    "def fn_print(string):\n",
    "\tprint(\"\\n-- \", string, \": \",datetime.now().strftime('%H:%M:%S'),\"--\")\n",
    "\n",
    "def fn_load_data(path_in, no_import, start_line):\n",
    "\tid_no = []\n",
    "\tlabel = []\n",
    "\tdata = []\n",
    "\n",
    "\t# scan through file line by line\n",
    "\twith open(path_in) as infile:\n",
    "\t\ti=-1\n",
    "\t\tfor line in infile:\n",
    "\t\t\ti+=1\n",
    "\t\t\tif i % 500 == 0:\n",
    "\t\t\t\tfn_print((\"considering line:\" + str(i)))\n",
    "\t\t\t\t#print(\"considering line:\",i)\n",
    "\t\t\tif i < start_line:\n",
    "\t\t\t\tcontinue\n",
    "\t\t\tif i >= no_import + start_line:\n",
    "\t\t\t\tbreak\n",
    "\t\t\ttemp = line.split(\",\")\n",
    "\t\t\tid_no.append(str(temp[0]))\n",
    "\t\t\tlabel.append(float(temp[1]))\n",
    "\t\t\tdata_temp = temp[2].split(\" \")\n",
    "\t\t\t# data_temp = [int(x) for x in data_temp] # prob slowest part\n",
    "\t\t\tdata_temp = list(map(int, data_temp)) # slightly quicker\n",
    "\t\t\tdata.append(data_temp)\n",
    "\n",
    "\t# save results\n",
    "\tnp_id = np.array(id_no)\n",
    "\tnp_label = np.array(label)\n",
    "\tnp_data = np.array(data)\n",
    "\n",
    "\t# clear memory\n",
    "\tdel id_no, label, data\n",
    "\n",
    "\t# reshape data\n",
    "\tnp_data = np.reshape(np_data, newshape=-1)\n",
    "\tT,H,Y,X = 15,4,101,101\n",
    "\tnp_data = np.reshape(np_data, newshape=(-1,T,H,Y,X), order='C')\n",
    "\n",
    "\treturn np_id, np_label, np_data\n",
    "\n",
    "## Function to append to a HDF5 file since keeping everything in memory would probably freeze computer. \n",
    "def fn_h5_append(h5f_name, name_in, data_in):\n",
    "\th5f = h5py.File(h5f_name, 'a')\n",
    "\th5f.create_dataset(name_in, data=data_in)\n",
    "\th5f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now convert all the files to HDF5 now by using the functions writen above. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "########## converting testA to HDF5 using the functions given above\n",
    "step_size = 2000\n",
    "path_in = '/home/ubuntu/data_new/CIKM2017_testA/testA.txt'\n",
    "h5f_name = '/home/ubuntu/data_new/CIKM2017_testA/data_testA.h5'\n",
    "h5f = h5py.File(h5f_name, 'w')\n",
    "grp = h5f.create_group('test_A')\n",
    "h5f.close()\n",
    "\n",
    "for i in np.arange(0,2000,step_size):\n",
    "\n",
    "\tfn_print((\"convert to h5, outter loop:\"+str(i)))\n",
    "\tnp_train_id, np_train_label, np_train_data = fn_load_data(path_in, start_line=i, no_import=step_size)\n",
    "\tfilename_id = ('/test_A/test_id_'+str(i)+\"_to_\"+str(i+step_size-1))\n",
    "\tfilename_label = ('/test_A/test_label_'+str(i)+\"_to_\"+str(i+step_size-1))\n",
    "\tfilename_data = ('/test_A/test_data_'+str(i)+\"_to_\"+str(i+step_size-1))\n",
    "\tascii_id = [n.encode(\"ascii\", \"ignore\") for n in np_train_id.tolist()]\n",
    "\n",
    "\tfn_h5_append(h5f_name, filename_id, ascii_id)\n",
    "\tfn_h5_append(h5f_name, filename_label, np_train_label)\n",
    "\tfn_h5_append(h5f_name, filename_data, np_train_data)\n",
    "\n",
    "\tdel np_train_id, np_train_label, np_train_data\n",
    "\n",
    "\n",
    "########## converting testB to HDF5\n",
    "path_in = '/home/ubuntu/data_new/CIKM2017_testB/testB.txt'\n",
    "h5f_name = '/home/ubuntu/data_new/CIKM2017_testB/data_testB.h5'\n",
    "h5f = h5py.File(h5f_name, 'w')\n",
    "grp = h5f.create_group('test_B')\n",
    "h5f.close()\n",
    "\n",
    "for i in np.arange(0,2000,step_size):\n",
    "\n",
    "\tfn_print((\"convert to h5, outter loop:\"+str(i)))\n",
    "\tnp_train_id, np_train_label, np_train_data = fn_load_data(path_in, start_line=i, no_import=step_size)\n",
    "\tfilename_id = ('/test_B/test_id_'+str(i)+\"_to_\"+str(i+step_size-1))\n",
    "\tfilename_label = ('/test_B/test_label_'+str(i)+\"_to_\"+str(i+step_size-1))\n",
    "\tfilename_data = ('/test_B/test_data_'+str(i)+\"_to_\"+str(i+step_size-1))\n",
    "\tascii_id = [n.encode(\"ascii\", \"ignore\") for n in np_train_id.tolist()]\n",
    "\n",
    "\tfn_h5_append(h5f_name, filename_id, ascii_id)\n",
    "\tfn_h5_append(h5f_name, filename_label, np_train_label)\n",
    "\tfn_h5_append(h5f_name, filename_data, np_train_data)\n",
    "\n",
    "\tdel np_train_id, np_train_label, np_train_data\n",
    "\n",
    "\n",
    "########## converting train set to HDF5 using only 4,000 samples instead of the total 10,000\n",
    "step_size = 4000\n",
    "path_in = '/home/ubuntu/data_new/CIKM2017_train/train.txt'\n",
    "h5f_name = '/home/ubuntu/data_new/CIKM2017_train/train.h5'\n",
    "h5f = h5py.File(h5f_name, 'w')\n",
    "grp = h5f.create_group('train')\n",
    "h5f.close()\n",
    "\n",
    "for i in np.arange(0,4000,step_size):\n",
    "\n",
    "\tfn_print((\"convert to h5, outter loop:\"+str(i)))\n",
    "\tnp_train_id, np_train_label, np_train_data = fn_load_data(path_in, start_line=i, no_import=step_size)\n",
    "\tfilename_id = ('/train/train_id_'+str(i)+\"_to_\"+str(i+step_size-1))\n",
    "\tfilename_label = ('/train/train_label_'+str(i)+\"_to_\"+str(i+step_size-1))\n",
    "\tfilename_data = ('/train/train_data_'+str(i)+\"_to_\"+str(i+step_size-1))\n",
    "\tascii_id = [n.encode(\"ascii\", \"ignore\") for n in np_train_id.tolist()]\n",
    "\n",
    "\tfn_h5_append(h5f_name, filename_id, ascii_id)\n",
    "\tfn_h5_append(h5f_name, filename_label, np_train_label)\n",
    "\tfn_h5_append(h5f_name, filename_data, np_train_data)\n",
    "\n",
    "\tdel np_train_id, np_train_label, np_train_data\n",
    "\n",
    "############# creating a validation set from the training set\n",
    "#### using a portion of data that does not overlap with the reduced test set. taking 500 sequencial samples\n",
    "#### as the validation set.\n",
    "\n",
    "path_in = '/home/ubuntu/data_new/CIKM2017_train/train.txt'\n",
    "h5f_name = '/home/ubuntu/data_new/CIKM2017_train/val.h5'\n",
    "h5f = h5py.File(h5f_name, 'w')\n",
    "grp = h5f.create_group('val')\n",
    "h5f.close()\n",
    "step_size = 500\n",
    "for i in np.arange(5000,5500,step_size):\n",
    "\n",
    "\tfn_print((\"convert to h5, outter loop:\"+str(i)))\n",
    "\tnp_train_id, np_train_label, np_train_data = fn_load_data(path_in, start_line=i, no_import=step_size)\n",
    "\tfilename_id = ('/train/val_id_'+str(i)+\"_to_\"+str(i+step_size-1))\n",
    "\tfilename_label = ('/train/val_label_'+str(i)+\"_to_\"+str(i+step_size-1))\n",
    "\tfilename_data = ('/train/val_data_'+str(i)+\"_to_\"+str(i+step_size-1))\n",
    "\tascii_id = [n.encode(\"ascii\", \"ignore\") for n in np_train_id.tolist()]\n",
    "\n",
    "\tfn_h5_append(h5f_name, filename_id, ascii_id)\n",
    "\tfn_h5_append(h5f_name, filename_label, np_train_label)\n",
    "\tfn_h5_append(h5f_name, filename_data, np_train_data)\n",
    "\n",
    "\tdel np_train_id, np_train_label, np_train_data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now have the data in the format we wanted, we can focus on some data preparation and the modelling part of the work."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#### Data loader function - use to select which HDF5 file to read and load\n",
    "def fn_h5_to_np(test_train, i=0):\n",
    "\n",
    "    if test_train == \"testA\":\n",
    "        filename_id = ('/test_A/test_id_0_to_1999')\n",
    "        filename_label = ('/test_A/test_label_0_to_1999')\n",
    "        filename_data = ('/test_A/test_data_0_to_1999')\n",
    "        h5f_name = '/home/ubuntu/data_new/CIKM2017_testA/data_testA.h5'\n",
    "        \n",
    "    elif test_train == \"testB\":\n",
    "        filename_id = ('/test_B/test_id_0_to_1999')\n",
    "        filename_label = ('/test_B/test_label_0_to_1999')\n",
    "        filename_data = ('/test_B/test_data_0_to_1999')\n",
    "        h5f_name = '/home/ubuntu/data_new/CIKM2017_testB/data_testB.h5'\n",
    "\n",
    "    elif test_train == \"train\":\n",
    "        filename_id = ('/train/train_id_0_to_3999')\n",
    "        filename_label = ('/train/train_label_0_to_3999')\n",
    "        filename_data = ('/train/train_data_0_to_3999')\n",
    "        h5f_name = '/home/ubuntu/data_new/CIKM2017_train/train.h5'\n",
    "\n",
    "    elif test_train == \"val\":\n",
    "        filename_id = ('/train/val_id_5000_to_5499')\n",
    "        filename_label = ('/train/val_label_5000_to_5499')\n",
    "        filename_data = ('/train/val_data_5000_to_5499')\n",
    "        h5f_name = '/home/ubuntu/data_new/CIKM2017_train/val.h5'\n",
    "\n",
    "    h5f = h5py.File(h5f_name,'r')\n",
    "    np_id = h5f[filename_id][:]\n",
    "    np_label = h5f[filename_label][:]\n",
    "    np_data = h5f[filename_data][:]\n",
    "    h5f.close()\n",
    "    \n",
    "    return np_id, np_label, np_data\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "#setting a few global parameters that are used to scale the data\n",
    "y_std = 15.\n",
    "y_mean = 15.\n",
    "X_std = 50.\n",
    "X_mean = 60.\n",
    "\n",
    "# normalise input and output \n",
    "def fn_norm_Xy(X,y,is_graph=False):\n",
    "    # normalise X and y values\n",
    "    X = X / X_std\n",
    "    y = y / y_std \n",
    "    if is_graph:\n",
    "        fig, (ax1,ax2) = plt.subplots(2,1)\n",
    "        ax1.hist(X.reshape(-1),bins=100)\n",
    "        ax2.hist(y.reshape(-1),bins=100)\n",
    "    return X, y\n",
    "\n",
    "# remove negative values in images - clipping every negative value to be zero\n",
    "def fn_minus_ones(X):\n",
    "    X[(X < 0)] = 0\n",
    "    return X\n",
    "\n",
    "\n",
    "# convert np arrays to X and y\n",
    "def fn_np_to_Xy(np_data, np_label, h_select = 3, t_select = 14):\n",
    "    \n",
    "    X = np_data[:,t_select,h_select,:,:] # select all samples, all data\n",
    "    X = X.reshape(X.shape[0], X.shape[1], X.shape[2], 1)\n",
    "    \n",
    "    y = np_label\n",
    "    y = y.reshape(y.shape[0], 1)\n",
    "    \n",
    "    return X, y\n",
    "\n",
    "# from h5 file to Xy 2D, at one height - This function is use to load data that matches radar image with\n",
    "## recorded amount of rainfall\n",
    "def fn_h5_to_Xy(test_train,i=0,h_select = 3, t_select = 14):\n",
    "    ###### using data loader function to load data\n",
    "    np_id, np_label, np_data = fn_h5_to_np(test_train=test_train,i=i) \n",
    "    X, y = fn_np_to_Xy(np_data, np_label, h_select = h_select, t_select = t_select)\n",
    "    X = fn_minus_ones(X)\n",
    "    X, y = fn_norm_Xy(X,y,is_graph=False) # normalise\n",
    "    return X,y\n",
    "\n",
    "\n",
    "# convert np arrays to X and y - 2D + timeD, at one height\n",
    "def fn_np_to_Xy_2D_timeD(np_data, np_label, h_select = 3):\n",
    "    X = np_data[:,:,h_select,:,:] # select all samples, all data\n",
    "    X = X.reshape(X.shape[0], X.shape[1], X.shape[2], X.shape[3], 1)\n",
    "    y = np_label\n",
    "    y = y.reshape(y.shape[0], 1)\n",
    "    \n",
    "    return X, y\n",
    "\n",
    "# from h5 file to Xy - 2D + timeD, at one height\n",
    "# function to load images both for X and Y - used for next radar image prediction\n",
    "def fn_h5_to_Xy_2D_timeD(test_train,i=0,h_select = 3):\n",
    "    np_id, np_label, np_data = fn_h5_to_np(test_train=test_train,i=i) # load data from h5\n",
    "    X, y = fn_np_to_Xy_2D_timeD(np_data, np_label, h_select = h_select) # convert to X,y format\n",
    "    X = fn_minus_ones(X) \n",
    "    X, y = fn_norm_Xy(X,y,is_graph=False) # normalise\n",
    "    return X,y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now have all the tools to do the modelling. Here the work is splitted into 2 sections. First we want to predict the amount of rainfall at the desired location (centre of images) when given a sequence of radar images. The other, part of the work which is the visualisation of the radar images i.e predicting the next radar image given a sequence of images. This is carries less weight in the prediction of rainfall but gives a direct visual feedback on how good this model works. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "#### loading the keras libraries\n",
    "from keras.models import Model\n",
    "from keras.layers import Input, Dense, MaxPooling2D, MaxPooling3D, Dropout, BatchNormalization, Flatten, Conv2D, Conv3D, AveragePooling3D, LSTM, Reshape\n",
    "from keras import backend as K\n",
    "from keras.callbacks import History \n",
    "\n",
    "from keras import backend as K\n",
    "import tensorflow as tf\n",
    "from keras.callbacks import ModelCheckpoint\n",
    "from keras.layers import AveragePooling2D\n",
    "from keras.models import Sequential\n",
    "from keras.layers.convolutional import Conv3D\n",
    "from keras.layers.convolutional_recurrent import ConvLSTM2D\n",
    "\n",
    "\n",
    "\n",
    "#  convLSTM model to predict the LSTM network\n",
    "def fn_get_model_convLSTM_2():\n",
    "    \n",
    "    model = Sequential()\n",
    "    \n",
    "    model.add(ConvLSTM2D(filters=32, kernel_size=(7, 7),\n",
    "                         input_shape=(None, 101, 101, 1),\n",
    "                         return_sequences=True,\n",
    "                         go_backwards=True,\n",
    "                         activation='tanh', recurrent_activation='hard_sigmoid',\n",
    "                         kernel_initializer='glorot_uniform', unit_forget_bias=True, \n",
    "                         dropout=0.4, recurrent_dropout=0.2\n",
    "                         ))\n",
    "    model.add(BatchNormalization())\n",
    "    \n",
    "    model.add(ConvLSTM2D(filters=16, kernel_size=(7, 7),\n",
    "                         return_sequences=True,\n",
    "                         go_backwards=True,\n",
    "                         activation='tanh', recurrent_activation='hard_sigmoid',\n",
    "                         kernel_initializer='glorot_uniform', unit_forget_bias=True, \n",
    "                         dropout=0.4, recurrent_dropout=0.2\n",
    "                         ))\n",
    "    model.add(BatchNormalization())\n",
    "    \n",
    "    model.add(ConvLSTM2D(filters=8, kernel_size=(7, 7),\n",
    "                         return_sequences=False,\n",
    "                         go_backwards=True,\n",
    "                         activation='tanh', recurrent_activation='hard_sigmoid',\n",
    "                         kernel_initializer='glorot_uniform', unit_forget_bias=True, \n",
    "                         dropout=0.3, recurrent_dropout=0.2\n",
    "                         ))\n",
    "    model.add(BatchNormalization())\n",
    "    \n",
    "    model.add(Conv2D(filters=1, kernel_size=(1, 1),\n",
    "                   activation='relu',\n",
    "                   data_format='channels_last')) \n",
    "    \n",
    "    model.add(MaxPooling2D(pool_size=(4, 4), padding='same'))\n",
    "    model.add(Flatten())\n",
    "    model.add(BatchNormalization())\n",
    "    model.add(Dropout(0.25))\n",
    "    \n",
    "    model.add(Dense(512, activation='relu'))\n",
    "    model.add(BatchNormalization())\n",
    "    model.add(Dropout(0.4))\n",
    "    \n",
    "    model.add(Dense(512, activation='relu'))\n",
    "    model.add(BatchNormalization())\n",
    "    model.add(Dropout(0.4))\n",
    "    \n",
    "    model.add(Dense(128, activation='relu'))\n",
    "    model.add(BatchNormalization())\n",
    "    model.add(Dropout(0.4))\n",
    "    \n",
    "    model.add(Dense(1, activation='linear'))\n",
    "    \n",
    "    print(model.summary())\n",
    "\n",
    "    return model\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "####### RUNNING THE MODEL\n",
    "\n",
    "print ('loading data')\n",
    "X_train, y_train = fn_h5_to_Xy_2D_timeD(test_train=\"train\",i=0,h_select = my_height)\n",
    "X_t_val, y_t_val = fn_h5_to_Xy_2D_timeD(test_train=\"val\",i=4,h_select = my_height)\n",
    "\n",
    "print('loading model')\n",
    "model = fn_get_model_convLSTM_2()\n",
    "\n",
    "print(model.summary())\n",
    "model.compile(loss='mean_squared_error', optimizer='adam')\n",
    "\n",
    "print('Training model')\n",
    "fn_run_model(model, X_train, y_train, X_t_val, y_t_val, batch_size=8, nb_epoch=15,verbose=1,is_graph=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Evaluating the model\n",
    "\n",
    "To evaluate the model we created, we load back the weights of the model and then send the test data to the model and get rainfall prediction. From there we use the same RMSE metric as was used in the CIKM 2017 competition to evaluate the accuracy of the model created"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### loading weights\n",
    "model.load_weights('model_convLSTM_2_train4000_val500.h5')\n",
    "\n",
    "\n",
    "### Loop to evaluate the model at each height for test set A\n",
    "testA  = []\n",
    "for i in range(4):\n",
    "\theight_rem = [0,1,2,3]\n",
    "\tprint(i)\n",
    "\tdel X_test\n",
    "\tdel y_test\n",
    "\n",
    "\tmy_height=height_rem[i]\n",
    "\tX_test, y_test = fn_h5_to_Xy_2D_timeD(test_train=\"testA\",i=0,h_select = my_height)\n",
    "\ty_pred = model.predict(X_test)\n",
    "\ttestA.append(fn_keras_rmse(y_test, y_pred).eval())\n",
    "print(testA)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "testA = [13.5037568326104, 13.569423492251511, 13.654292392613222, 13.208109666576338]\n",
    "\n",
    "mean RMSE for test A = 13.48389\n",
    "\n",
    "testB = [13.544123493977148, 13.478812867719338, 13.37080457808451, 13.08367986944559]\n",
    "\n",
    "mean RMSE for test B = 13.36935\n",
    "\n",
    "Overall RMSE for all the different all test data sets at all height is \n",
    "\n",
    "Overall RMSE = 13.43 (done by averaging all the 8 different RMSE)\n",
    "\n",
    "This score would be ranked in the top 20 for the CIKM 2017 competition!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Predicting the next Radar image\n",
    "\n",
    "As an aside to this project, one could use the same principle of convLSTM deep NN model to predict the next radar images after feeding the algorithm a sequence of images. This follows the same principle as the moving digit of MNIST challenge (http://www.cs.toronto.edu/~nitish/unsupervised_video/)\n",
    "\n",
    "Below is the model that we settle to use for this section of the project\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fn_get_model_convLSTM_tframe_5():\n",
    "    \n",
    "    model = Sequential()\n",
    "    model.add(ConvLSTM2D(filters=64, kernel_size=(7, 7),\n",
    "                         input_shape=(None, 101, 101, 1), padding='same', return_sequences=True, \n",
    "                         activation='tanh', recurrent_activation='hard_sigmoid',\n",
    "                         kernel_initializer='glorot_uniform', unit_forget_bias=True, \n",
    "                         dropout=0.3, recurrent_dropout=0.3, go_backwards=True ))\n",
    "    model.add(BatchNormalization())\n",
    "\n",
    "    model.add(ConvLSTM2D(filters=32, kernel_size=(7, 7), padding='same', return_sequences=True, \n",
    "                         activation='tanh', recurrent_activation='hard_sigmoid', \n",
    "                         kernel_initializer='glorot_uniform', unit_forget_bias=True, \n",
    "                         dropout=0.4, recurrent_dropout=0.3, go_backwards=True ))\n",
    "    model.add(BatchNormalization())\n",
    "    \n",
    "    model.add(ConvLSTM2D(filters=32, kernel_size=(7, 7), padding='same', return_sequences=True, \n",
    "                         activation='tanh', recurrent_activation='hard_sigmoid', \n",
    "                         kernel_initializer='glorot_uniform', unit_forget_bias=True, \n",
    "                         dropout=0.4, recurrent_dropout=0.3, go_backwards=True ))\n",
    "    model.add(BatchNormalization())\n",
    "\n",
    "\n",
    "    model.add(ConvLSTM2D(filters=32, kernel_size=(7, 7), padding='same', return_sequences=False, \n",
    "                         activation='tanh', recurrent_activation='hard_sigmoid', \n",
    "                         kernel_initializer='glorot_uniform', unit_forget_bias=True, \n",
    "                         dropout=0.4, recurrent_dropout=0.3, go_backwards=True ))\n",
    "    model.add(BatchNormalization())\n",
    "    \n",
    "    model.add(Conv2D(filters=1, kernel_size=(1, 1),\n",
    "                   activation='sigmoid',\n",
    "                   padding='same', data_format='channels_last')) \n",
    "    \n",
    "    print(model.summary())\n",
    "    return model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The idea here is to feed 5 images to the network and the network is suppose to predict the 6th image of the sequence. Hence the Y input to this part need to be the 6th image in any sequence. Therefore another function needs to be written that would take the training set and give a sequence of 5 images to X_input and 1 image to Y_input. The following function does that:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fn_Xy_to_tframe(X_in):\n",
    "\n",
    "    n_frames = 5\n",
    "    n_frames_out = 1\n",
    "    X0 = np.zeros(X_in.shape, dtype=np.float)\n",
    "    X0 = X0[:,0:n_frames,:,:,:] # only use 5 frames each\n",
    "    X1 = np.zeros(X_in.shape, dtype=np.float)\n",
    "    X1 = X1[:,0:n_frames_out,:,:,:]\n",
    "    \n",
    "    for sample in range(0,X_in.shape[0]):\n",
    "        \n",
    "        \n",
    "        X0[sample] = X_in[sample,0:n_frames,:,:,:]\n",
    "        X1[sample] = X_in[sample,n_frames:n_frames+n_frames_out,:,:,:]\n",
    "        \n",
    "        # blur inputs\n",
    "        for i in range(n_frames):\n",
    "            X0[sample,i,:,:,0] = filters.gaussian_filter(X0[sample,i,:,:,0],sigma=1.8)\n",
    "        for i in range(n_frames_out):\n",
    "            X1[sample,i,:,:,0] = filters.gaussian_filter(X1[sample,i,:,:,0],sigma=1.8)\n",
    "    \n",
    "    X_max = 3.0\n",
    "    X0 = np.clip(X0,0,X_max) # clip\n",
    "    X1 = np.clip(X1,0,X_max)\n",
    "    X0 = X0/X_max\n",
    "    X1 = X1/X_max\n",
    "    \n",
    "    \n",
    "    return X0,X1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The only problem with this function is that it only takes the first 5 images of every sequence of the training set. Each of the training set sequence are 15 images long. We therefore rewrite the same function to pick the start 5+1 (X=5, Y=1) image sequence, the middle 5+1 sequence and the last 5+1 image sequence. In this way we sample more or less the entire sequences without losing data - allowing the algorithm to generalise in principle. The following function is an extension of the above one"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fn_Xy_to_tframe_v2(X_in):\n",
    "    \n",
    "    n_frames = 5  # X frames\n",
    "    n_frames_out = 1 # Y frames\n",
    "    \n",
    "    X0_0 = np.zeros(X_in.shape, dtype=np.float)\n",
    "    X0_0 = X0_0[:,0:n_frames,:,:,:] \n",
    "    X0_1 = np.copy(X0_0)\n",
    "    X0_2 = np.copy(X0_0)\n",
    "    \n",
    "    X1_0 = np.zeros(X_in.shape, dtype=np.float)\n",
    "    X1_0 = X1_0[:,0:n_frames_out,:,:,:]\n",
    "    X1_1 = np.copy(X1_0)\n",
    "    X1_2 = np.copy(X1_0)\n",
    "    \n",
    "    for sample in range(0,X_in.shape[0]):\n",
    "\n",
    "        X0_0[sample] = X_in[sample,0:n_frames,:,:,:]\n",
    "        X0_1[sample] = X_in[sample,5:5+n_frames,:,:,:]\n",
    "        X0_2[sample] = X_in[sample,9:9+n_frames,:,:,:]\n",
    "\n",
    "        X1_0[sample] = X_in[sample,n_frames:n_frames+n_frames_out,:,:,:]\n",
    "        X1_1[sample] = X_in[sample,5+n_frames:5+n_frames+n_frames_out,:,:,:]\n",
    "        X1_2[sample] = X_in[sample,9+n_frames:9+n_frames+n_frames_out,:,:,:]\n",
    "        \n",
    "        \n",
    "        for i in range(n_frames):\n",
    "            X0_0[sample,i,:,:,0] = filters.gaussian_filter(X0_0[sample,i,:,:,0],sigma=1.0)\n",
    "            X0_1[sample,i,:,:,0] = filters.gaussian_filter(X0_1[sample,i,:,:,0],sigma=1.0)\n",
    "            X0_2[sample,i,:,:,0] = filters.gaussian_filter(X0_2[sample,i,:,:,0],sigma=1.0)\n",
    "        for i in range(n_frames_out):\n",
    "            X1_0[sample,i,:,:,0] = filters.gaussian_filter(X1_0[sample,i,:,:,0],sigma=1.0)\n",
    "            X1_1[sample,i,:,:,0] = filters.gaussian_filter(X1_1[sample,i,:,:,0],sigma=1.0)\n",
    "            X1_2[sample,i,:,:,0] = filters.gaussian_filter(X1_2[sample,i,:,:,0],sigma=1.0)\n",
    "    \n",
    "    X_max = 3.0\n",
    "    X0_0 = np.clip(X0_0,0,X_max) # clip\n",
    "    X0_1 = np.clip(X0_1,0,X_max)\n",
    "    X0_2 = np.clip(X0_2,0,X_max)\n",
    "\n",
    "    X1_0 = np.clip(X1_0,0,X_max)\n",
    "    X1_1 = np.clip(X1_1,0,X_max)\n",
    "    X1_2 = np.clip(X1_2,0,X_max)\n",
    "\n",
    "    X0_0 = X0_0/X_max\n",
    "    X0_1 = X0_1/X_max\n",
    "    X0_2 = X0_2/X_max\n",
    "\n",
    "    X1_0 = X1_0/X_max\n",
    "    X1_1 = X1_1/X_max\n",
    "    X1_2 = X1_2/X_max    \n",
    "    \n",
    "    ### combining all 3 arrays together\n",
    "    X0 = np.copy(X0_0)\n",
    "    X0 = np.concatenate((X0,X0_1,X0_2),axis=1)\n",
    "\n",
    "    X1 = np.copy(X1_0)\n",
    "    X1 = np.concatenate((X1,X1_1,X1_2),axis=1)\n",
    "    return X0,X1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By using this method instead of having 4000 sequences (from the 4000 training samples) we get 12000 image sequences.\n",
    "To properly randomise the input to the algorithm, sklearn shuffle is used. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following code was run to train the algorithm at all the heights of the radar images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(0,4):\n",
    "\n",
    "\tprint ('loading data')\n",
    "\tmy_height = i\n",
    "\tX_train, y_train = fn_h5_to_Xy_2D_timeD(test_train=\"train\",i=0,h_select = my_height)\n",
    "\tX_t_val, y_t_val = fn_h5_to_Xy_2D_timeD(test_train=\"val\",i=4,h_select = my_height)\n",
    "\n",
    "\tX0_train, X1_train = fn_Xy_to_tframe_v2(X_train)\n",
    "\tX0_t_val, X1_t_val = fn_Xy_to_tframe_v2(X_t_val)\n",
    "\n",
    "\tprint('Shuffling')\n",
    "\tX0_train, X1_train = shuffle(X0_train, X1_train, random_state=0)\n",
    "\tX0_t_val, X1_t_val = shuffle(X0_t_val, X1_t_val, random_state=0)\n",
    "\n",
    "\tprint('loading model')\n",
    "\tmodel = fn_get_model_convLSTM_tframe_5()\n",
    "\n",
    "\tprint(model.summary())\n",
    "\t#model.compile(loss='binary_crossentropy', optimizer='adam')\n",
    "\t#model.compile(loss='mean_squared_error', optimizer='adam')\n",
    "\tmodel.compile(loss=fn_keras_rmse, optimizer='adam')\n",
    "\n",
    "\tprint('Training model')\n",
    "\tfn_run_model(model, X0_train, X1_train[:,0,:,:,:], X0_t_val, X1_t_val[:,0,:,:,:], batch_size=10, nb_epoch=3,verbose=1,is_graph=True)\n",
    "\tmodel.save_weights(\"model_convLSTM_tframe5_train4000_val500_height\"+str(i)+\"gauss_1_mse.h5\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From the results we can create a little animation of the predicted motion of clouds. This is done using the code below"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.animation as animation\n",
    "\n",
    "input_frames = 5\n",
    "s_select = 0\n",
    "output_frames = 10\n",
    "X_input = X0_train[s_select,:input_frames, :, :, :]\n",
    "X_input1 = np.zeros((X_input.shape[0]+output_frames,X_input.shape[1],X_input.shape[2],X_input.shape[3]),float)\n",
    "X_input1[0:5] = X_input\n",
    "for i in range(0,output_frames):\n",
    "\tprint(i)\n",
    "\tX_pred = model.predict(X_input1[i:i+5,:,:,:].reshape(1,5,101,101,1)) # predict\n",
    "\tX_input1[5+i] = X_pred[0,:,:,:]\n",
    "\n",
    "fig = plt.figure()\n",
    "ims = []; title = []\n",
    "for i in range(10):\n",
    "    im = plt.imshow(X_input1[i,:,:,0], animated=True)\n",
    "    title = plt.title('Frame %f' % (i))\n",
    "    ims.append([im,title])\n",
    "ani = animation.ArtistAnimation(fig, ims, interval=500, blit=True)\n",
    "#ani.save(\"movie.gif\", writer='imagemagick')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![SegmentLocal](Prediction0_Height2.gif \"segment\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below is a comparison between the real frame and the predicted frames. Do keep in mind that Prediction frame 1 uses 5 real observations (not shown here) to be generated and hence is the most accurate. Prediction Frame 2 uses 4 real images and prediction frame 1 to make a prediction adn prediction frame 3 uses the 2 previous predicted frames. Hence the error is propagated leading to more divergence from reality."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import Image\n",
    "Image('Prediction0_Height2_3ims.png')  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}