nirs_cnn_model.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "7cFTU1lUl0dh"
   },
   "source": [
    "## Importing working packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 255,
   "metadata": {
    "id": "ad1Yi_B8l5bd"
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import time\n",
    "from datetime import datetime\n",
    "from datetime import datetime\n",
    "from collections import Counter\n",
    "import os\n",
    "import numpy as np\n",
    "from sklearn.model_selection import train_test_split, KFold, RepeatedKFold\n",
    "from sklearn.preprocessing import MinMaxScaler,StandardScaler\n",
    "import tensorflow as tf\n",
    "from tensorflow import keras\n",
    "from tensorflow.keras.callbacks import TensorBoard, EarlyStopping, ModelCheckpoint, ReduceLROnPlateau\n",
    "from tensorflow.keras.models import Sequential, Model\n",
    "from tensorflow.keras.layers import Dense, Dropout, MaxPooling1D, Conv1D, Flatten, Concatenate, concatenate, Input\n",
    "from tensorflow.keras.layers import BatchNormalization, Bidirectional, Input, LocallyConnected1D, Activation\n",
    "from tensorflow.keras.layers import LSTM, GRU, TimeDistributed, GaussianDropout, AlphaDropout, GaussianNoise\n",
    "from tensorflow.keras.layers import SpatialDropout1D\n",
    "from tensorflow.keras.models import model_from_json\n",
    "from tensorflow.keras.optimizers import SGD, RMSprop, Adam, Adamax, Adadelta\n",
    "from tensorflow.keras.utils import plot_model\n",
    "\n",
    "#import tensorflow_docs as tfdocs\n",
    "#import tensorflow_docs.plots\n",
    "#import tensorflow_docs.modeling\n",
    "\n",
    "from hyperopt import Trials, STATUS_OK, tpe\n",
    "from hyperas import optim\n",
    "from hyperas.distributions import choice, uniform\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import math\n",
    "\n",
    "from sklearn.metrics import r2_score, mean_squared_error\n",
    "from scipy.stats import pearsonr\n",
    "import scipy\n",
    "\n",
    "\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "warnings.warn(\"deprecated\", DeprecationWarning)\n",
    "import sys"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "yeLYp_-Ek7w_"
   },
   "source": [
    "# Data preprocessing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "b6C0QLes5pLJ"
   },
   "source": [
    "## Preprocessing methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1141,
   "metadata": {
    "id": "lLcodc6RyD65"
   },
   "outputs": [],
   "source": [
    "def msc(input_data, reference=None):\n",
    "    ''' Perform Multiplicative scatter correction'''\n",
    "    input_data = input_data.copy()\n",
    "     # mean centre correction\n",
    "    for i in range(input_data.shape[0]):\n",
    "        input_data[i,:] -= input_data[i,:].mean()\n",
    " \n",
    "    # Get the reference spectrum. If not given, estimate it from the mean    \n",
    "    if reference is None:    \n",
    "        ref = np.mean(input_data, axis=0)\n",
    "    else:\n",
    "        ref = reference\n",
    " \n",
    "    # Define a new array and populate it with the corrected data    \n",
    "    data_msc = np.zeros_like(input_data)\n",
    "    for i in range(input_data.shape[0]):\n",
    "        # Run regression\n",
    "        fit = np.polyfit(ref, input_data[i,:], 1, full=True)\n",
    "        # Apply correction\n",
    "        data_msc[i,:] = (input_data[i,:] - fit[0][1]) / fit[0][0] \n",
    " \n",
    "    return data_msc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 443,
   "metadata": {},
   "outputs": [],
   "source": [
    "def snv(input_data):\n",
    "    \"\"\"\n",
    "    Performs a Standard Normal Variate (SNV) correction.\n",
    "    \n",
    "    \"\"\"\n",
    "    # Define a new array and populate it with the corrected data  \n",
    "    output_data = np.zeros_like(input_data)\n",
    "    for i in range(input_data.shape[0]):\n",
    " \n",
    "        # Apply correction\n",
    "        output_data[i,:] = (input_data[i,:] - np.mean(input_data[i,:])) / np.std(input_data[i,:])\n",
    " \n",
    "    return output_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 626,
   "metadata": {},
   "outputs": [],
   "source": [
    "def detrend(spectra, bp=0):\n",
    "    \"\"\" Perform spectral detrending to remove linear trend from data.\n",
    "    Args:\n",
    "        spectra <numpy.ndarray>: NIRS data matrix.\n",
    "        bp <list>: A sequence of break points. If given, an individual linear fit is performed for each part of data\n",
    "        between two break points. Break points are specified as indices into data.\n",
    "    Returns:\n",
    "        spectra <numpy.ndarray>: Detrended NIR spectra\n",
    "    \"\"\"\n",
    "    return scipy.signal.detrend(spectra,axis=0, bp=bp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {
    "id": "JRv8Q0mV5x2M"
   },
   "outputs": [],
   "source": [
    "import scipy.signal\n",
    "import scipy.io as io\n",
    "import scipy.ndimage as nd\n",
    "import numpy as np\n",
    "from sklearn.preprocessing import normalize, scale\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1421,
   "metadata": {},
   "outputs": [],
   "source": [
    "def smooth(spectra, filter_win=11, window_type='flat', mode='reflect'):\n",
    "    \"\"\" Smooths the spectra using convolution.\n",
    "    Args:\n",
    "        spectra <numpy.ndarray>: NIRS data matrix.\n",
    "        filter_win <float>: length of the filter window in samples.\n",
    "        window_type <str>: filtering window to use for convolution (see scipy.signal.windows)\n",
    "        mode <str>: convolution mode\n",
    "    Returns:\n",
    "        spectra <numpy.ndarray>: Smoothed NIR spectra.\n",
    "    \"\"\"\n",
    "\n",
    "    if window_type == 'flat':\n",
    "        window = np.ones(filter_win)\n",
    "    else:\n",
    "        window = scipy.signal.windows.get_window(window_type, filter_win)\n",
    "    window = window / np.sum(window)\n",
    "\n",
    "    for row in range(spectra.shape[0]):\n",
    "        spectra[row,:] = nd.convolve(spectra[row,:], window, mode=mode)\n",
    "\n",
    "    return spectra"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1547,
   "metadata": {
    "id": "FdxPJjb4Bruq"
   },
   "outputs": [],
   "source": [
    "def savgol(spectra, filter_win=15, poly_order=2, deriv_order=0, delta=1.0):\n",
    "    \"\"\" Perform Savitzky–Golay filtering on the data (also calculates derivatives). This function is a wrapper for\n",
    "    scipy.signal.savgol_filter.\n",
    "\n",
    "    Args:\n",
    "        spectra <numpy.ndarray>: NIRS data matrix.\n",
    "        filter_win <int>: Size of the filter window in samples (default 11).\n",
    "        poly_order <int>: Order of the polynomial estimation (default 3).\n",
    "        deriv_order <int>: Order of the derivation (default 0).\n",
    "\n",
    "    Returns:\n",
    "        spectra <numpy.ndarray>: NIRS data smoothed with Savitzky-Golay filtering\n",
    "    \"\"\"\n",
    "    return scipy.signal.savgol_filter(spectra, filter_win, poly_order, deriv_order, delta=delta, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "id": "SODFizZC5-nQ"
   },
   "outputs": [],
   "source": [
    "def derivate(spectra, order=1, delta=1):\n",
    "    \"\"\" Computes Nth order derivates with the desired spacing using numpy.gradient.\n",
    "    Args:\n",
    "        spectra <numpy.ndarray>: NIRS data matrix.\n",
    "        order <float>: Order of the derivation.\n",
    "        delta <int>: Delta of the derivate (in samples).\n",
    "\n",
    "    Returns:\n",
    "        spectra <numpy.ndarray>: Derivated NIR spectra.\n",
    "    \"\"\"\n",
    "    for n in range(order):\n",
    "        spectra = np.gradient(spectra, delta, axis=1)\n",
    "    return spectra"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1560,
   "metadata": {
    "id": "1hxUMQyBFJaS"
   },
   "outputs": [],
   "source": [
    "def preprocess(x):\n",
    "    \n",
    "  #Then compute first derivative\n",
    "  #x = derivate(x,order=2)\n",
    "  #Apply a Savitzky-Golay filter\n",
    "  #x = savgol(x)\n",
    "    \n",
    "  # Smooth data\n",
    "  #x = smooth(x)\n",
    "\n",
    "  #Then compute first derivative\n",
    "  x = derivate(x)\n",
    "    \n",
    "  #Perform SNV\n",
    "  #x = snv(x)\n",
    "    \n",
    "  #Detrend the signal\n",
    "  #x = detrend(x)\n",
    "  \n",
    "  return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1549,
   "metadata": {
    "id": "PIQKWyy-k8RA"
   },
   "outputs": [],
   "source": [
    "from scipy.stats import pearsonr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "id": "NzmZFPq94UdW"
   },
   "outputs": [],
   "source": [
    "def plot_spectra(wl,spectra):\n",
    "    plt.figure(figsize=(8,9))\n",
    "    with plt.style.context(('ggplot')):\n",
    "        plt.plot(wl, spectra)\n",
    "        plt.title('Original data')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "id": "kwi6O-GvpZWn"
   },
   "outputs": [],
   "source": [
    "def weight_predictors(x,y):\n",
    "  wls = np.array([int(l) for l in x.columns])\n",
    "\n",
    "  data = pd.DataFrame(x.to_numpy(),columns=wls)\n",
    "  important_factors = []\n",
    "\n",
    "  M = len(wls)\n",
    "\n",
    "  corr_xy = data.apply(lambda x: x.corr(y),axis=0)\n",
    "  corr_xx = data.corr()\n",
    "\n",
    "  for wl in wls:\n",
    "    a = corr_xy[wl]\n",
    "    b = corr_xx[wl].sum()\n",
    "\n",
    "    result = M * (a / b)\n",
    "\n",
    "    important_factors.append(result)\n",
    "  \n",
    "  weighted_data = data.to_numpy()\n",
    "  # for i in range(data.shape[1]):\n",
    "  #   weighted_data[:,i] *= important_factors[i]\n",
    "  weight_data =  np.diag(np.array(important_factors)) * data.to_numpy()\n",
    "  weighted_x = weighted_data\n",
    "\n",
    "  return weighted_x\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1576,
   "metadata": {
    "id": "mPbSFDnMk0Eu"
   },
   "outputs": [],
   "source": [
    "\n",
    "def load_data(fname=None, target=None, sensor=None):\n",
    "  if sensor==\"hone_ag\":\n",
    "    d = pd.read_csv(fname, sep=\";\")\n",
    "    \n",
    "  if sensor==\"foss\":\n",
    "    d = pd.read_csv(fname, sep=\";\")\n",
    "  \n",
    "\n",
    "  # Convert Protein to float\n",
    "  #d[target] = pd.to_numeric(d[target], errors='coerce', downcast='float')\n",
    "\n",
    "  #Gather response and predictors in dataframe\n",
    "  #d_corr = pd.concat([d[\"Species\"].to_frame(), d[target].to_frame(), d.loc[:,'1350.155463':]], axis = 1)\n",
    "\n",
    "  # Delete na\n",
    "  #d_corr = d_corr.dropna(axis=0)\n",
    "\n",
    "  train = d[d['Set']=='Training']\n",
    "  test = d[d['Set']=='Validation']\n",
    "  #train, test = train_test_split(d, test_size=0.2, random_state=42, shuffle=True)\n",
    "  #export shuffled data\n",
    "  #train['Set']='Training'\n",
    "  #test['Set']='Validation'\n",
    "  #new=pd.concat([train,test],axis=0)\n",
    "  #new.to_excel('./data/shuffled_multicereal_evt5_2021.xlsx',index=False)\n",
    "\n",
    "  #Build predictors\n",
    "  if sensor==\"hone_ag\":\n",
    "      x_train = train.loc[:,'1350.1554633964':] \n",
    "      #xcolnames = x_train.columns\n",
    "      x_test = test.loc[:,'1350.1554633964':]\n",
    "    \n",
    "  elif sensor==\"foss\":\n",
    "      x_train = train.loc[:,'400':] \n",
    "      #xcolnames = x_train.columns\n",
    "      x_test = test.loc[:,'400':]\n",
    "\n",
    "  #Extract targets\n",
    "  y_train = train[target]\n",
    "  y_test = test[target]\n",
    "\n",
    "  #Create weighted predictors based on feature importance\n",
    "  # x_train = weight_predictors(x_train,y_train)\n",
    "  # x_test = weight_predictors(x_test,y_test)\n",
    "\n",
    "  #Extract sample metadata from test set\n",
    "  if sensor==\"hone_ag\":\n",
    "        train_set_metadata = train[[\"Record Name\"]]\n",
    "        test_set_metadata = test[[\"Record Name\"]]\n",
    "  else:\n",
    "        train_set_metadata = train[[\"Species2\",\"Record Name\"]]\n",
    "        test_set_metadata = test[[\"Species2\",\"Record Name\"]]\n",
    "    \n",
    "\n",
    "  #Apply preprocessing operations\n",
    "  x_train = preprocess(x_train)\n",
    "  x_test = preprocess(x_test)\n",
    "\n",
    "  #Convert to numpy arrays\n",
    "  y_train = y_train.to_numpy()\n",
    "  y_test = y_test.to_numpy()\n",
    "\n",
    "  #Minmax Normalization of x and y\n",
    "  xscaler = MinMaxScaler(feature_range=(0.1,0.9))\n",
    "  x_train = xscaler.fit_transform(x_train)\n",
    "  x_test = xscaler.transform(x_test)\n",
    "\n",
    "\n",
    "  yscaler = MinMaxScaler(feature_range=(0.1,0.9))\n",
    "  y_train = yscaler.fit_transform(y_train.reshape(-1,1))\n",
    "  y_test = yscaler.transform(y_test.reshape(-1,1))\n",
    " \n",
    "\n",
    "\n",
    "  ##Reshaping arrays\n",
    "  x_train,x_test = np.expand_dims(x_train,axis=2),np.expand_dims(x_test,axis=2)\n",
    "  #y_train,y_test = y_train.reshape(-1,1),y_test.reshape(-1,1)\n",
    "\n",
    "      \n",
    "  return x_train, y_train, x_test, y_test,yscaler, train_set_metadata, test_set_metadata"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "H8_to4RvBP5o"
   },
   "source": [
    "## Definition of deep learning models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1343,
   "metadata": {
    "id": "WXUfvnnPPCIv"
   },
   "outputs": [],
   "source": [
    "from keras.regularizers import l1,l2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1344,
   "metadata": {
    "id": "4HoHm35HHIzJ"
   },
   "outputs": [],
   "source": [
    "#Define a deep belief network for feature extraction\n",
    "#from dbn.models import UnsupervisedDBN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1345,
   "metadata": {
    "id": "-TMhhKVWHl6p"
   },
   "outputs": [],
   "source": [
    "def dbn_feature_extraction(x_train,y_train,x_test):\n",
    "  \"\"\"\n",
    "    Reduce dimensionality using deep belief net\n",
    "  \"\"\"\n",
    "  dbn_model = UnsupervisedDBN(hidden_layers_structure=[100,100],\n",
    "                      batch_size=120,\n",
    "                      learning_rate_rbm=0.01,\n",
    "                      n_epochs_rbm=100,\n",
    "                      activation_function='sigmoid')\n",
    "  \n",
    "  x_train = dbn_model.fit_transform(x_train,y_train)\n",
    "  x_test = dbn_model.transform(x_test)\n",
    "\n",
    "  return x_train,x_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1346,
   "metadata": {
    "id": "R4_bAadtOvE2"
   },
   "outputs": [],
   "source": [
    "\n",
    "def denseModel(feature_count, x_dim):\n",
    "    model = Sequential()\n",
    "    model.add(Dropout(0.02, input_shape=(feature_count, x_dim)))\n",
    "    model.add(GaussianDropout(0.3, input_shape=(feature_count, x_dim)))\n",
    "    model.add(Dense(32))\n",
    "    model.add(Dense(16))\n",
    "    model.add(Flatten())\n",
    "    return model\n",
    "\n",
    "\n",
    "inputs_layers = []\n",
    "encoded_models = []\n",
    "input_data = []\n",
    "\n",
    "def convModel(feature_count, x_dim):\n",
    "    model = Sequential()\n",
    "    model.add(Dropout(0.002, input_shape=(feature_count, x_dim)))\n",
    "    # model.add(GaussianDropout(0.2))\n",
    "    # model.add(GaussianNoise(0.2))\n",
    "    model.add(Conv1D (filters=32, kernel_size=15, strides=1, activation='relu'))\n",
    "    model.add(BatchNormalization())\n",
    "    model.add(SpatialDropout1D(0.02))\n",
    "    \n",
    "    model.add(Conv1D (filters=64, kernel_size=15, strides=1, activation='relu'))\n",
    "    model.add(BatchNormalization())\n",
    "    model.add(SpatialDropout1D(0.02))\n",
    "    \n",
    "    model.add(Conv1D (filters=128, kernel_size=15, strides=1, activation='relu'))\n",
    "    model.add(SpatialDropout1D(0.02))\n",
    "    model.add(BatchNormalization())\n",
    "    \n",
    "    model.add(Conv1D (filters=256, kernel_size=15, strides=1, activation='relu'))\n",
    "    model.add(SpatialDropout1D(0.2))\n",
    "    model.add(BatchNormalization())\n",
    "\n",
    "    model.add(Flatten())\n",
    "    model.add(Dense(100, kernel_regularizer=l1(1e-7), bias_regularizer=l1(1e-7), activation='relu'))\n",
    "\n",
    "\n",
    "    model.add(Dense(1,activation='linear'))\n",
    "    return model\n",
    "\n",
    "\n",
    "def convModel2(feature_count,x_dim):\n",
    "    model = Sequential()\n",
    "    model.add(Dropout(0.002, input_shape=(feature_count, x_dim)))\n",
    "    model.add(Conv1D(filters=24, kernel_size=15, use_bias=False, strides=2, kernel_initializer=\"he_normal\"))\n",
    "    model.add(BatchNormalization())\n",
    "    model.add(Activation(\"relu\"))\n",
    "    model.add(MaxPooling1D(pool_size=2,strides=1))\n",
    "    model.add(SpatialDropout1D(0.02))\n",
    "\n",
    "    model.add(Conv1D(filters=48,kernel_size=15 , use_bias=False, strides=2, kernel_initializer=\"he_normal\"))\n",
    "    model.add(BatchNormalization())\n",
    "    model.add(Activation(\"relu\"))\n",
    "    model.add(MaxPooling1D(pool_size=2, strides=1))\n",
    "    model.add(SpatialDropout1D(0.02))\n",
    "\n",
    "    model.add(Conv1D(filters=96,kernel_size=15, use_bias=False, strides=2, kernel_initializer=\"he_normal\"))\n",
    "    model.add(BatchNormalization())\n",
    "    model.add(Activation(\"relu\"))\n",
    "    model.add(MaxPooling1D(pool_size=2,strides=1))\n",
    "    model.add(SpatialDropout1D(0.02))\n",
    "\n",
    "\n",
    "    model.add(Flatten())\n",
    "    model.add(Dense(512, kernel_regularizer=l1(1e-7), bias_regularizer=l1(1e-7)))\n",
    "    model.add(BatchNormalization())\n",
    "    model.add(Activation(\"relu\"))\n",
    "\n",
    "    \n",
    "    model.add(Dense(128, kernel_regularizer=l1(1e-7), bias_regularizer=l1(1e-7)))\n",
    "    model.add(BatchNormalization())\n",
    "    model.add(Activation(\"relu\"))\n",
    "    model.add(Dropout(0.02))\n",
    "\n",
    "    model.add(Dense(1,activation='sigmoid'))\n",
    "    return model\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1347,
   "metadata": {},
   "outputs": [],
   "source": [
    "def convModel3(feature_count,x_dim):\n",
    "    model = Sequential()\n",
    "    model.add(Dropout(0.002, input_shape=(feature_count, x_dim)))\n",
    "    model.add(Conv1D(filters=16, kernel_size=5, use_bias=False, strides=2, kernel_initializer=\"he_normal\"))\n",
    "    model.add(BatchNormalization())\n",
    "    model.add(Activation(\"relu\"))\n",
    "    model.add(MaxPooling1D(pool_size=2,strides=1))\n",
    "    model.add(SpatialDropout1D(0.02))\n",
    "\n",
    "    model.add(Conv1D(filters=36,kernel_size=15 , use_bias=False, strides=2, kernel_initializer=\"he_normal\"))\n",
    "    model.add(BatchNormalization())\n",
    "    model.add(Activation(\"relu\"))\n",
    "    model.add(MaxPooling1D(pool_size=2, strides=1))\n",
    "    model.add(SpatialDropout1D(0.02))\n",
    "\n",
    "    model.add(Conv1D(filters=56,kernel_size=20, use_bias=False, strides=2, kernel_initializer=\"he_normal\"))\n",
    "    model.add(BatchNormalization())\n",
    "    model.add(Activation(\"relu\"))\n",
    "    model.add(MaxPooling1D(pool_size=2,strides=1))\n",
    "    model.add(SpatialDropout1D(0.02))\n",
    "\n",
    "\n",
    "    model.add(Flatten())\n",
    "    model.add(Dense(512, kernel_regularizer=l1(1e-7), bias_regularizer=l1(1e-8)))\n",
    "    model.add(BatchNormalization())\n",
    "    model.add(Activation(\"relu\"))\n",
    "\n",
    "\n",
    "    \n",
    "    model.add(Dense(128, kernel_regularizer=l1(1e-7), bias_regularizer=l1(1e-8)))\n",
    "    model.add(BatchNormalization())\n",
    "    model.add(Activation(\"relu\"))\n",
    "\n",
    "    model.add(Dense(1,activation='sigmoid'))\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1348,
   "metadata": {},
   "outputs": [],
   "source": [
    "def convModel4(feature_count,x_dim):\n",
    "    model = Sequential()\n",
    "    model.add(Conv1D(filters=24, input_shape=(feature_count, x_dim), kernel_size=20, use_bias=False, strides=2, kernel_initializer=\"he_normal\"))\n",
    "    model.add(BatchNormalization())\n",
    "    model.add(Activation(\"relu\"))\n",
    "    model.add(MaxPooling1D(pool_size=2,strides=1))\n",
    "\n",
    "    model.add(Conv1D(filters=48,kernel_size=20 , use_bias=False, strides=2, kernel_initializer=\"he_normal\"))\n",
    "    model.add(BatchNormalization())\n",
    "    model.add(Activation(\"relu\"))\n",
    "    model.add(MaxPooling1D(pool_size=5, strides=1))\n",
    "\n",
    "    model.add(Conv1D(filters=96,kernel_size=20, use_bias=False, strides=2, kernel_initializer=\"he_normal\"))\n",
    "    model.add(BatchNormalization())\n",
    "    model.add(Activation(\"relu\"))\n",
    "    model.add(MaxPooling1D(pool_size=5,strides=1))\n",
    "    \n",
    "    model.add(Conv1D(filters=192,kernel_size=20, use_bias=False, strides=2, kernel_initializer=\"he_normal\"))\n",
    "    model.add(BatchNormalization())\n",
    "    model.add(Activation(\"relu\"))\n",
    "    model.add(MaxPooling1D(pool_size=5,strides=1))\n",
    "    model.add(Dropout(0.4))\n",
    "\n",
    "\n",
    "    model.add(Flatten())\n",
    "    model.add(Dense(100, kernel_regularizer=l1(1e-7), bias_regularizer=l1(1e-7)))\n",
    "    model.add(BatchNormalization())\n",
    "    model.add(Activation(\"relu\"))\n",
    "    model.add(Dropout(0.2))\n",
    "\n",
    "    model.add(Dense(1,activation='sigmoid'))\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1349,
   "metadata": {},
   "outputs": [],
   "source": [
    "def convModel5(feature_count,x_dim):\n",
    "    model = Sequential()\n",
    "    model.add(Conv1D(filters=8, input_shape=(feature_count, x_dim), kernel_size=10, use_bias=False, strides=5, kernel_initializer=\"he_normal\"))\n",
    "    model.add(BatchNormalization())\n",
    "    model.add(Activation(\"relu\"))\n",
    "    model.add(MaxPooling1D(pool_size=3,strides=2))\n",
    "\n",
    "    model.add(Conv1D(filters=32,kernel_size=4 , use_bias=False, strides=2, kernel_initializer=\"he_normal\"))\n",
    "    model.add(BatchNormalization())\n",
    "    model.add(Activation(\"relu\"))\n",
    "    model.add(MaxPooling1D(pool_size=3, strides=2))\n",
    "\n",
    "    model.add(Conv1D(filters=64,kernel_size=5, use_bias=False, strides=2, kernel_initializer=\"he_normal\"))\n",
    "    model.add(BatchNormalization())\n",
    "    model.add(Activation(\"relu\"))\n",
    "    model.add(MaxPooling1D(pool_size=3,strides=2))\n",
    "    \n",
    "\n",
    "\n",
    "    model.add(Flatten())\n",
    "    model.add(Dense(1,activation='sigmoid'))\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1350,
   "metadata": {
    "id": "Sr5IgKyZBt2s"
   },
   "outputs": [],
   "source": [
    "def add_model(generator, data, feature_count, dim):\n",
    "    model = generator(feature_count, dim)\n",
    "    input_layer = Input(shape = (feature_count, dim))\n",
    "    encoded_model = model(input_layer)\n",
    "    inputs_layers.append(input_layer)\n",
    "    encoded_models.append(encoded_model)\n",
    "    input_data.append(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Gz2XV7DeJ10-"
   },
   "source": [
    "## Prepare data, models and train "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1577,
   "metadata": {},
   "outputs": [],
   "source": [
    "fn = './data/foss_reference_data.csv'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1578,
   "metadata": {},
   "outputs": [],
   "source": [
    "target = \"Protein\"\n",
    "sensor = None\n",
    "if \"foss\" in os.path.basename(fn):\n",
    "    sensor=\"foss\"\n",
    "if \"evt5\" in os.path.basename(fn):\n",
    "    sensor=\"hone_ag\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1579,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, y_train, X_val, y_val,yscaler, train_metadata, test_meta = load_data(fname=fn, target =target, sensor=sensor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1580,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Sqve data loading\n",
    "x_tr, y_tr, x_v, y_v, ysc, tr_meta, val_meta = X_train, y_train, X_val, y_val,yscaler, train_metadata, test_meta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1586,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, y_train, X_val, y_val,yscaler, train_metadata, test_meta = x_tr, y_tr, x_v, y_v, ysc, tr_meta, val_meta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1587,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(262, 1050, 1) (66, 1050, 1) (262, 2)\n"
     ]
    }
   ],
   "source": [
    "print(X_train.shape, X_val.shape, train_metadata.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1588,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 1588,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.isnan(X_train).sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1589,
   "metadata": {
    "id": "JPjxhDASQng6"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-Prepare models...\n",
      "\n",
      "Number of devices: 1\n",
      "-Number of parameters:  1273561\n",
      "Model compilation\n",
      "\n",
      "Start model training...\n"
     ]
    }
   ],
   "source": [
    "#X_train, y_train, X_val, y_val, xscaler, yscaler, meta_train, meta_test = data()\n",
    "\n",
    "#Clean our lists\n",
    "# inputs_layers.clear()\n",
    "# encoded_models.clear()\n",
    "# input_data.clear()\n",
    "\n",
    "#print('-Dimensionality reduction using autoencoder')\n",
    "#X_train, X_val = dbn_feature_extraction(X_train,y_train,X_val)\n",
    "\n",
    "#Reshaping arrays\n",
    "#X_train,X_val = np.expand_dims(X_train,axis=2),np.expand_dims(X_val,axis=2)\n",
    "\n",
    "#Retrieve feature number and dimension\n",
    "NIRS_feature_count = X_train.shape[1]\n",
    "NIRS_dim = X_train.shape[2]\n",
    "NIRS = X_train.copy()\n",
    "Ydim = 1\n",
    "\n",
    "VALIDATION_ACCURACY = []\n",
    "VALIDAITON_LOSS = []\n",
    "\n",
    "# Split for cross validation\n",
    "kfold = RepeatedKFold(n_splits=2, n_repeats=1, random_state=1234)\n",
    "\n",
    "reduce_lr_loss = ReduceLROnPlateau(monitor='val_loss', factor=0.5, patience=30, verbose=0, min_delta=1e-4, mode='min')\n",
    "earlyStopping = EarlyStopping(monitor='val_loss', patience=100, verbose=0, mode='min')\n",
    "\n",
    "# Prepare models\n",
    "print('-Prepare models...\\n')\n",
    "# add_model(convModel, NIRS, NIRS_feature_count, NIRS_dim)\n",
    "# add_model(localModel2, NIRS, NIRS_feature_count, NIRS_dim)\n",
    "# #add_model(localModel, NIRS, NIRS_feature_count, NIRS_dim)\n",
    "# print('-Concatenating models...\\n')\n",
    "# merged = concatenate(encoded_models)\n",
    "# output = Dense(16, activation='relu')(merged)\n",
    "# output = Dense(Ydim, activation='sigmoid')(output)\n",
    "# training_model = Model(inputs=inputs_layers, outputs=[output])\n",
    "\n",
    "from tensorflow.keras.utils import plot_model\n",
    "# plot_model(training_model,show_shapes=True ,to_file=os.path.join('/content/gdrive/My Drive/Results','DL_model_architecture.png'))\n",
    "\n",
    "\n",
    "# Create a MirroredStrategy.\n",
    "strategy = tf.distribute.MirroredStrategy([\"GPU:0\"])\n",
    "print('Number of devices: {}'.format(strategy.num_replicas_in_sync))\n",
    "\n",
    "# Open a strategy scope.\n",
    "with strategy.scope():\n",
    "    training_model = convModel4(NIRS_feature_count, NIRS_dim)\n",
    "    print(\"-Number of parameters: \", training_model.count_params())\n",
    "    #Save model architecture\n",
    "    plot_model(training_model, to_file='./results/model_architecture.png', show_shapes=True, show_layer_names=True)\n",
    "    #Compile model\n",
    "    print('Model compilation\\n')\n",
    "    opt = keras.optimizers.Adam(lr=3e-3)\n",
    "    training_model.compile(loss='mean_squared_error', metrics=['mse'], optimizer=opt)\n",
    "\n",
    "\n",
    "\n",
    "print('Start model training...')\n",
    "history = training_model.fit(X_train, y_train, \n",
    "                    epochs=5000, \n",
    "                    batch_size=128, \n",
    "                    validation_data=(X_val,y_val), \n",
    "                    verbose=0, \n",
    "                    callbacks=[reduce_lr_loss,earlyStopping])\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1590,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training ended\n",
      "Saving model..\n",
      "Saving ended\n",
      "Making predictions\n",
      "\n",
      "\n",
      "\n",
      "==============================\n",
      "\n",
      "\n",
      "\n",
      " Evaluation metrics\n",
      "\n",
      "\n",
      "R2 train:  0.6885825288668119\n",
      "RMSE train:  1.8111778224393649\n",
      "RPD train:  1.7919609932574943\n",
      "R2 val:  0.5881962144765968\n",
      "RMSE val:  2.1428429815964813\n",
      "RPD val:  1.558313628310344\n",
      "\n",
      "\n",
      "\n",
      "==============================\n"
     ]
    }
   ],
   "source": [
    "print('Training ended')\n",
    "print('Saving model..')\n",
    "now = datetime.now()\n",
    "time = now.strftime(\"%Y-%m-%d\")\n",
    "savefn = target+'_DLmodel_'+sensor+time\n",
    "training_model.save(os.path.join('./saved_models/',savefn),save_format='h5')\n",
    "print('Saving ended')\n",
    "#Use model to make predictions\n",
    "print('Making predictions')\n",
    "y_train_pred = training_model.predict(X_train)\n",
    "y_val_pred = training_model.predict(X_val)\n",
    "\n",
    "#Compute R2 \n",
    "r2_train = r2_score(y_train.flatten(),y_train_pred.flatten())\n",
    "r2_val = r2_score(y_val.flatten(),y_val_pred.flatten())\n",
    "\n",
    "#Recompute to original scale\n",
    "y_train_orig = yscaler.inverse_transform(y_train)\n",
    "y_train_pred_orig = yscaler.inverse_transform(y_train_pred)\n",
    "y_val_orig = yscaler.inverse_transform(y_val)\n",
    "y_val_pred_orig = yscaler.inverse_transform(y_val_pred)\n",
    "\n",
    "#Compute RMSE\n",
    "rmse_train = np.sqrt(mean_squared_error(y_train_orig,y_train_pred_orig))\n",
    "rmse_val = np.sqrt(mean_squared_error(y_val_orig,y_val_pred_orig))\n",
    "\n",
    "#Compute RPD = std(reference data) / RMSE\n",
    "rpd_train = np.std(y_train_orig)/rmse_train\n",
    "rpd_val = np.std(y_val_orig)/rmse_val\n",
    "\n",
    "#Print metrics\n",
    "print(\"\\n\\n\\n==============================\")\n",
    "print(\"\\n\\n\\n Evaluation metrics\")\n",
    "print(\"\\n\\nR2 train: \",r2_train)\n",
    "print(\"RMSE train: \",rmse_train)\n",
    "print(\"RPD train: \",rpd_train)\n",
    "print(\"R2 val: \",r2_val)\n",
    "print(\"RMSE val: \",rmse_val)\n",
    "print(\"RPD val: \",rpd_val)\n",
    "print(\"\\n\\n\\n==============================\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Export predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1517,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Calibration\n",
    "exports_cal = {'Genotype':train_metadata[\"Record Name\"], 'Species':train_metadata[\"Species2\"],'ytrain':y_train_orig.flatten(),'ytrain_pred':y_train_pred_orig.flatten()}\n",
    "exports_cal = pd.DataFrame(exports_cal)\n",
    "filename_cal = target+'_cal_cnn_'+sensor+'_'+time+'_.xlsx'\n",
    "exports_cal.to_excel(os.path.join('./results/{}'.format(sensor),filename_cal),index=False)\n",
    "\n",
    "#Validation\n",
    "exports_val = {'Genotype':test_meta[\"Record Name\"],'Species':test_meta[\"Species2\"],'yval':y_val_orig.flatten(),'yval_pred':y_val_pred_orig.flatten()}\n",
    "exports_val = pd.DataFrame(exports_val)\n",
    "filename_val = target+'_val_cnn_'+sensor+'_'+time+'_.xlsx'\n",
    "exports_val.to_excel(os.path.join('./results/{}'.format(sensor),filename_val),index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1518,
   "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>Genotype</th>\n",
       "      <th>ytrain</th>\n",
       "      <th>ytrain_pred</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2055</th>\n",
       "      <td>19LF-R-SG-MC-95</td>\n",
       "      <td>15.58</td>\n",
       "      <td>15.619668</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2056</th>\n",
       "      <td>19LF-R-SG-MC-95</td>\n",
       "      <td>15.58</td>\n",
       "      <td>16.026358</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2057</th>\n",
       "      <td>19LF-R-SG-MC-95</td>\n",
       "      <td>15.58</td>\n",
       "      <td>16.343649</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2058</th>\n",
       "      <td>19LF-R-SG-MC-95</td>\n",
       "      <td>15.58</td>\n",
       "      <td>14.635710</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2059</th>\n",
       "      <td>19LF-R-SG-MC-95</td>\n",
       "      <td>15.58</td>\n",
       "      <td>15.331110</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             Genotype  ytrain  ytrain_pred\n",
       "2055  19LF-R-SG-MC-95   15.58    15.619668\n",
       "2056  19LF-R-SG-MC-95   15.58    16.026358\n",
       "2057  19LF-R-SG-MC-95   15.58    16.343649\n",
       "2058  19LF-R-SG-MC-95   15.58    14.635710\n",
       "2059  19LF-R-SG-MC-95   15.58    15.331110"
      ]
     },
     "execution_count": 1518,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "exports_cal.tail()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1519,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1b350d17dc0>"
      ]
     },
     "execution_count": 1519,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn as sns\n",
    "sns.set_theme()\n",
    "#Calibration\n",
    "sns.regplot(x='yval', y='yval_pred', data=exports_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "name": "NirsDLModel.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}