Train_Neural_Network_Chase2021.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Train_Neural_Network_Chase2020.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-WPwLuIVaSyP",
        "colab_type": "text"
      },
      "source": [
        "This notebook is associated with the AMS JAMC manuscript titled: ![image.png](data:image/png;base64,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)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OnfGIzPYaOFF",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#download needed packages \n",
        "!pip install netCDF4\n",
        "!pip install colorcet\n",
        "!pip install git+https://github.com/dopplerchase/DRpy.git"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "t8M278_-bEAG",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import xarray as xr\n",
        "from google.colab import drive\n",
        "import os\n",
        "import pandas as pd\n",
        "import sklearn\n",
        "from sklearn.linear_model import LinearRegression\n",
        "import netCDF4\n",
        "%pylab inline\n",
        "drive.mount('/content/gdrive')\n",
        "os.chdir('/content/gdrive/My Drive/Colab Notebooks/DDA_Scattering/')\n",
        "import colorcet as cc\n",
        "import sklearn\n",
        "\n",
        "#load unrimed database (training)\n",
        "unrimed = xr.open_dataset('/content/gdrive/My Drive/Colab Notebooks/DDA_Scattering/Unrimed_simulation_wholespecturm_train_V2.nc',engine='netcdf4')\n",
        "print(unrimed.IWC.shape)\n",
        "#load unrimed database (testing)\n",
        "unrimed_test = xr.open_dataset('/content/gdrive/My Drive/Colab Notebooks/DDA_Scattering/Unrimed_simulation_wholespecturm_test_V2.nc',engine='netcdf4')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JtDgRBNPbV0M",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#make feature matrix \n",
        "X = np.zeros([unrimed['Z'].values.shape[0],3])\n",
        "X[:,0] = unrimed['Z'].values #Ku \n",
        "X[:,1] = unrimed['Z'].values - unrimed['Z2'].values #DFR \n",
        "X[:,2] = unrimed['T_env'].values\n",
        "\n",
        "\n",
        "#scale data (mean=0,std=1)\n",
        "from sklearn.preprocessing import StandardScaler\n",
        "import sklearn.model_selection\n",
        "scaler_X = StandardScaler()\n",
        "X_scaled = scaler_X.fit_transform(X)\n",
        "y = np.hstack([np.log10(unrimed['Nw'].values).reshape([unrimed['IWC'].values.shape[0],1]),np.log10(unrimed['Dm'].values.reshape([unrimed['IWC'].values.shape[0],1])*1000),np.log10(unrimed['Dm_frozen'].values.reshape([unrimed['IWC'].values.shape[0],1])*1000)])\n",
        "\n",
        "#normally we do not scale Y, but here I want to make sure it is not perfering one perceptron or another based on scale \n",
        "scaler_y = StandardScaler()\n",
        "y_scaled = scaler_y.fit_transform(y)\n",
        "\n",
        "X_train = X_scaled[:,:]\n",
        "y_train  = y_scaled[:,:]\n",
        "\n",
        "\n",
        "#make X test matrix\n",
        "X_test = np.zeros([unrimed_test['Z'].values.shape[0],3])\n",
        "X_test[:,0] = unrimed_test['Z'].values #Ku \n",
        "X_test[:,1] = unrimed_test['Z'].values - unrimed_test['Z2'].values #DFR\n",
        "X_test[:,2] = unrimed_test['T_env'].values\n",
        "\n",
        "#scale it \n",
        "X_test = scaler_X.transform(X_test)\n",
        "y_test = np.hstack([np.log10(unrimed_test['Nw'].values).reshape([unrimed_test['IWC'].values.shape[0],1]),np.log10(unrimed_test['Dm'].values.reshape([unrimed_test['IWC'].values.shape[0],1])*1000),np.log10(unrimed_test['Dm_frozen'].values.reshape([unrimed_test['IWC'].values.shape[0],1])*1000)])\n",
        "y_test = scaler_y.transform(y_test)\n",
        "\n",
        "#save the scaling for operartional use\n",
        "from pickle import dump \n",
        "dump(scaler_X, open('./scaler_X.pkl', 'wb'))\n",
        "dump(scaler_y, open('./scaler_y.pkl', 'wb'))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b8fee8pE5VcS",
        "colab_type": "text"
      },
      "source": [
        "## Load Tensorflow"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8ccPMaKMxn4f",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "%load_ext tensorboard\n",
        "# Use some functions from tensorflow_docs\n",
        "!pip install -q git+https://github.com/tensorflow/docs\n",
        "\n",
        "import tensorflow as tf\n",
        "\n",
        "from tensorflow import keras\n",
        "from tensorflow.keras import layers\n",
        "\n",
        "print(tf.__version__)\n",
        "\n",
        "import tensorflow_docs as tfdocs\n",
        "import tensorflow_docs.plots\n",
        "import tensorflow_docs.modeling\n",
        "from tensorflow.keras import regularizers\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Dq_xtQMApz_z",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#set the seed so model weights all start in the sameish place \n",
        "tf.random.set_seed(42)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5-vdI2QwvSA-",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def build_model(input_shape=3,output_shape=3,n_hidden_layers=2,layer_size=8,p=0.35,verbose=True,dropout=False,batch_norm=False,layer_norm=False):\n",
        "\n",
        "  inner_list = []\n",
        "  for i in np.arange(0,n_hidden_layers):\n",
        "    if i == 0:\n",
        "      inner_list.append(layers.Dense(layer_size, activation='relu', input_shape=[input_shape]))\n",
        "    else:\n",
        "      inner_list.append(layers.Dense(layer_size, activation='relu',))\n",
        "\n",
        "    if batch_norm:\n",
        "      inner_list.append(tf.keras.layers.BatchNormalization())\n",
        "    elif layer_norm:\n",
        "      inner_list.append(tf.keras.layers.LayerNormalization())\n",
        "\n",
        "    if dropout:\n",
        "      inner_list.append(tf.keras.layers.Dropout(p))\n",
        "\n",
        "  inner_list.append(layers.Dense(output_shape,activation='linear'))\n",
        "  model = keras.Sequential(inner_list)\n",
        "\n",
        "  if verbose:\n",
        "    print(model.summary())\n",
        "\n",
        "  return model\n",
        "\n",
        "def build_model_Sekelsky1999(input_shape=3):\n",
        "  model = keras.Sequential([\n",
        "    layers.Dense(7, activation='relu', input_shape=[input_shape]),\n",
        "    layers.Dense(4, activation='relu', input_shape=[input_shape]),\n",
        "    layers.Dense(2)])\n",
        "  return model\n",
        "\n",
        "def train_model(epochs = 250,lr = 0.001,input_shape=3,output_shape=3,n_hidden_layers=2,loss='mse',optim='RMSprop',layer_size=8,early_stop=True,batch_size=512,dropout=False,p=0.35,layer_norm=False,batch_norm=False):\n",
        "  \n",
        "  model = build_model(input_shape=input_shape,output_shape=output_shape,n_hidden_layers=n_hidden_layers,layer_size=layer_size,dropout=dropout,batch_norm=batch_norm,layer_norm=layer_norm,p=p)\n",
        "\n",
        "  if optim=='RMSprop':\n",
        "    optimizer = tf.keras.optimizers.RMSprop(lr)\n",
        "  else:\n",
        "    optimizer = tf.keras.optimizers.Adam(lr)\n",
        "\n",
        "  model.compile(loss=loss,\n",
        "                optimizer=optimizer,\n",
        "                metrics=['mae'])\n",
        "  \n",
        "  logdir = os.path.join(\"logs\", datetime.datetime.now().strftime(\"%Y%m%d-%H%M%S\")+'.log')\n",
        "  tensorboard_callback = tf.keras.callbacks.TensorBoard(logdir)\n",
        "\n",
        "  callback = []\n",
        "  callback.append(tensorboard_callback)\n",
        "  callback.append(tf.keras.callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=10,min_lr=1e-15))\n",
        "\n",
        "  if early_stop: \n",
        "    callback.append(tf.keras.callbacks.EarlyStopping(monitor='val_loss', patience=50))\n",
        "\n",
        "  device_name = tf.test.gpu_device_name()\n",
        "  if device_name == '/device:GPU:0':\n",
        "    with tf.device('/device:GPU:0'):\n",
        "        print(\"Using GPU\")\n",
        "        model.fit(x=X_train[:,0:input_shape], \n",
        "                  y=y_train, \n",
        "                  epochs=epochs, \n",
        "                  validation_data=(X_test[:,0:input_shape], y_test), \n",
        "                  callbacks=[callback],batch_size=batch_size)\n",
        "  else:\n",
        "      print(\"Using CPU\")\n",
        "      model.fit(x=X_train[:,0:input_shape], \n",
        "                y=y_train, \n",
        "                epochs=epochs, \n",
        "                validation_data=(X_test[:,0:input_shape], y_test), \n",
        "                callbacks=[callback],batch_size=batch_size)\n",
        "      \n",
        "  model.n_hidden_layers = n_hidden_layers\n",
        "  return model "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wc1y_vXfbz1U",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#train model\n",
        "model = train_model(epochs=250,lr=0.001,batch_norm=True,n_hidden_layers=6,layer_size=8,dropout=False)"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}