jupyterNotebooks/lungCancerClassifier.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lung Cancer Binary Classifier Model\n",
    "- Andrew E. Davidson\n",
    "- [aedavids@ucsc.edu](mailto:aedavids@edu?subject=lungCancerBinaryClassifier.ipynb)\n",
    "- ?? what is the attribution for the kim lab\n",
    "\n",
    "Use logistic regression to classify lung vs. 'not lung' from gene expression\n",
    "\n",
    "## Overview\n",
    "* lung cancer vs. normal classifier using logistic regression\n",
    "* model is save to disk $rootDir/models/logisticRegressionLungNotLung.h5\n",
    "* training set comprised of gene expression values from Xena data set. The data was randomly split into 80/20 train/test sets\n",
    "* surprisingly all example appear to be from people that are sick. Examples labeled as as normal does not imply the person was healthy. Notice figure 1 does not have a \"health class\". It might be very useful to create a data set that contains both health and sick people\n",
    "* model summary\n",
    "    ```\n",
    "    total data set size 19,126 example each with 58,581 features\n",
    "\n",
    "AEDWIP !!!!!! wrong stats\n",
    "    training set accuracy = 0.9994\n",
    "        test set accuracy = 0.9929\n",
    "\n",
    "    confusion matrix\n",
    "    [[1701   19]\n",
    "     [   8 2098]]\n",
    "    False positive rate: (predicting tumor while normal) 0.011\n",
    "    False negative rate: (predicting normal while tumor) 0.004\n",
    "    ```\n",
    "    \n",
    "TODO: explore example that are not classified correctly\n",
    "    \n",
    "see \n",
    "- [lungCancerClassifierExploration.ipynb](lungCancerClassifierExploration.ipynb)\n",
    "- [lungCancerClassifierEvaluation.ipynb](lungCancerClassifierEvaluation.ipynb)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO <ipython-input-1-cb04d083fd9c>:8 - <module>()] using logging configuration file:../src/logging.test.ini.json\n"
     ]
    }
   ],
   "source": [
    "import pathlib as pl\n",
    "\n",
    "import logging\n",
    "from   setupLogging import setupLogging\n",
    "configFilePath = setupLogging( default_path=pl.Path('../src/logging.ini.json'))\n",
    "configFilePath = setupLogging( default_path=pl.Path('../src/logging.test.ini.json'))\n",
    "logger = logging.getLogger(\"notebook\")\n",
    "logger.info(\"using logging configuration file:{}\".format(configFilePath))\n",
    "\n",
    "from dataUtilities.lungCancerData import LungCancerData\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import os\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "import tensorflow as tf\n",
    "from tensorflow import keras\n",
    "\n",
    "from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint, TensorBoard\n",
    "from tensorflow.keras.models import Sequential, Model\n",
    "\n",
    "from tensorflow.keras import layers\n",
    "from tensorflow.keras.layers import Activation, BatchNormalization, Dense, Input\n",
    "\n",
    "from tensorflow.keras import optimizers\n",
    "from tensorflow.keras.optimizers import Adam\n",
    "\n",
    "# fix random seed for reproducibility\n",
    "theMeaningOfLife = 42\n",
    "np.random.seed(theMeaningOfLife)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load Data\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO lungCancerData.py:257 - loadTrainingData()] BEGIN\n",
      "[INFO lungCancerData.py:265 - loadTrainingData()] store.info():<class 'pandas.io.pytables.HDFStore'>\n",
      "File path: ../data/lungCancerData/machineLeaning.h5\n",
      "/XTestDF                 frame        (shape->[3826,58581]) \n",
      "/XTrainDF                frame        (shape->[15300,58581])\n",
      "/yTestSeries             series       (shape->[3826])       \n",
      "/yTrainSeries            series       (shape->[15300])      \n",
      "[INFO lungCancerData.py:266 - loadTrainingData()] store.keys():['/XTestDF', '/XTrainDF', '/yTestSeries', '/yTrainSeries']\n",
      "[INFO lungCancerData.py:272 - loadTrainingData()] (15300, 58581)\n",
      "[INFO lungCancerData.py:273 - loadTrainingData()] (15300,)\n",
      "[INFO lungCancerData.py:278 - loadTrainingData()] END\n",
      "[INFO lungCancerData.py:286 - loadTestData()] BEGIN\n",
      "[INFO lungCancerData.py:294 - loadTestData()] store.info():<class 'pandas.io.pytables.HDFStore'>\n",
      "File path: ../data/lungCancerData/machineLeaning.h5\n",
      "/XTestDF                 frame        (shape->[3826,58581]) \n",
      "/XTrainDF                frame        (shape->[15300,58581])\n",
      "/yTestSeries             series       (shape->[3826])       \n",
      "/yTrainSeries            series       (shape->[15300])      \n",
      "[INFO lungCancerData.py:295 - loadTestData()] store.keys():['/XTestDF', '/XTrainDF', '/yTestSeries', '/yTrainSeries']\n",
      "[INFO lungCancerData.py:302 - loadTestData()] (15300, 58581)\n",
      "[INFO lungCancerData.py:303 - loadTestData()] (15300,)\n",
      "[INFO lungCancerData.py:305 - loadTestData()] (3826, 58581)\n",
      "[INFO lungCancerData.py:306 - loadTestData()] (3826,)\n",
      "[INFO lungCancerData.py:308 - loadTestData()] END\n",
      "CPU times: user 14.3 s, sys: 7.36 s, total: 21.7 s\n",
      "Wall time: 21.8 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "dataDir = pl.Path(\"../data\")\n",
    "TCGADataFile = pl.Path(\"tcga_target_gtex.h5\".format(dataDir))\n",
    "lcData = LungCancerData(dataDir, TCGADataFile)\n",
    "lcData.loadTrainingData(theMeaningOfLife)\n",
    "lcData.loadTestData(theMeaningOfLife)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(15300, 58581)\n",
      "(15300,)\n",
      "\n",
      "(3826, 58581)\n",
      "(3826,)\n"
     ]
    }
   ],
   "source": [
    "print(lcData.XTrainNP.shape)\n",
    "print(lcData.yTrainSeries.values.shape)\n",
    "print()\n",
    "print(lcData.XTestNP.shape)\n",
    "print(lcData.yTestSeries.values.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7fada85a68d0>"
      ]
     },
     "execution_count": 7,
     "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": [
    "# checking if class balance is maintained\n",
    "# AEDWIP do these graphs make sence?\n",
    "labels = {'train': (lcData.yTrainSeries), 'test': (lcData.yTestSeries)}\n",
    "label_df = pd.DataFrame(labels)\n",
    "label_df.plot.hist(stacked=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train Classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this is a neural network with a single activation node\n",
    "def logisticRegression(input_dim=None, output_dim=None, lr=0.001):\n",
    "    '''\n",
    "    implement a neural network with a single activation node. Uses a\n",
    "    Adam optimizer with the binary_crossentropy function\n",
    "    \n",
    "    Includes a batch normalization preprocess step. normalizaton \n",
    "    typically reduces training time.\n",
    "    \n",
    "    arguments:\n",
    "        input_dim:\n",
    "           type int: the number of features in each sample\n",
    "        \n",
    "        outputDim: \n",
    "            type int the number of classes\n",
    "        \n",
    "        lr: \n",
    "            type float: scaling factor for adjusting weight. larger\n",
    "            values may train faster how ever can cause optimization \n",
    "            algorithm to diverge if to large. Use loss curver plot\n",
    "            to evaluate    \n",
    "    \n",
    "    return:\n",
    "        keras.models\n",
    "    '''\n",
    "    classify = [\n",
    "        Input(shape=(input_dim, )),\n",
    "\n",
    "        # TODO: Is Keras smart? only need to run preprocessing step\n",
    "        # once\n",
    "        BatchNormalization(),\n",
    "        Dense(output_dim),  # dot(input, kernel) + bias\n",
    "        Activation('sigmoid')\n",
    "    ]\n",
    "\n",
    "    model = Sequential(classify)\n",
    "\n",
    "    model.compile(\n",
    "        loss='binary_crossentropy',\n",
    "        optimizer=Adam(lr=lr),\n",
    "        metrics=['accuracy'])\n",
    "\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 15300 samples\n",
      "Epoch 1/20\n",
      "14336/15300 [===========================>..] - ETA: 1s - loss: 0.7783 - accuracy: 0.7692[WARNING deprecation.py:506 - new_func()] From /Users/andrewdavidson/anaconda3/envs/findBiomarkers/lib/python3.7/site-packages/tensorflow_core/python/ops/resource_variable_ops.py:1786: calling BaseResourceVariable.__init__ (from tensorflow.python.ops.resource_variable_ops) with constraint is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "If using Keras pass *_constraint arguments to layers.\n",
      "[INFO builder_impl.py:775 - copy_assets_to_destination_dir()] Assets written to: ./models/logisticRegressionCancerNotCancer.chkPt/assets\n",
      "15300/15300 [==============================] - 24s 2ms/sample - loss: 0.7359 - accuracy: 0.7820\n",
      "Epoch 2/20\n",
      "14336/15300 [===========================>..] - ETA: 0s - loss: 0.0345 - accuracy: 0.9894[INFO builder_impl.py:775 - copy_assets_to_destination_dir()] Assets written to: ./models/logisticRegressionCancerNotCancer.chkPt/assets\n",
      "15300/15300 [==============================] - 9s 587us/sample - loss: 0.0339 - accuracy: 0.9897\n",
      "Epoch 3/20\n",
      "14336/15300 [===========================>..] - ETA: 0s - loss: 0.0098 - accuracy: 0.9968[INFO builder_impl.py:775 - copy_assets_to_destination_dir()] Assets written to: ./models/logisticRegressionCancerNotCancer.chkPt/assets\n",
      "15300/15300 [==============================] - 7s 439us/sample - loss: 0.0095 - accuracy: 0.9969\n",
      "Epoch 4/20\n",
      "14336/15300 [===========================>..] - ETA: 0s - loss: 0.0044 - accuracy: 0.9990[INFO builder_impl.py:775 - copy_assets_to_destination_dir()] Assets written to: ./models/logisticRegressionCancerNotCancer.chkPt/assets\n",
      "15300/15300 [==============================] - 7s 444us/sample - loss: 0.0042 - accuracy: 0.9990\n",
      "Epoch 5/20\n",
      "14336/15300 [===========================>..] - ETA: 0s - loss: 0.0031 - accuracy: 0.9997[INFO builder_impl.py:775 - copy_assets_to_destination_dir()] Assets written to: ./models/logisticRegressionCancerNotCancer.chkPt/assets\n",
      "15300/15300 [==============================] - 7s 441us/sample - loss: 0.0030 - accuracy: 0.9997\n",
      "Epoch 6/20\n",
      "14336/15300 [===========================>..] - ETA: 0s - loss: 0.0024 - accuracy: 0.9999[INFO builder_impl.py:775 - copy_assets_to_destination_dir()] Assets written to: ./models/logisticRegressionCancerNotCancer.chkPt/assets\n",
      "15300/15300 [==============================] - 6s 396us/sample - loss: 0.0023 - accuracy: 0.9999\n",
      "Epoch 7/20\n",
      "14336/15300 [===========================>..] - ETA: 0s - loss: 0.0022 - accuracy: 0.9999[INFO builder_impl.py:775 - copy_assets_to_destination_dir()] Assets written to: ./models/logisticRegressionCancerNotCancer.chkPt/assets\n",
      "15300/15300 [==============================] - 6s 414us/sample - loss: 0.0021 - accuracy: 0.9999\n",
      "Epoch 8/20\n",
      "14336/15300 [===========================>..] - ETA: 0s - loss: 0.0023 - accuracy: 0.9999[INFO builder_impl.py:775 - copy_assets_to_destination_dir()] Assets written to: ./models/logisticRegressionCancerNotCancer.chkPt/assets\n",
      "15300/15300 [==============================] - 7s 431us/sample - loss: 0.0022 - accuracy: 0.9999\n",
      "Epoch 9/20\n",
      "14336/15300 [===========================>..] - ETA: 0s - loss: 0.0020 - accuracy: 0.9999[INFO builder_impl.py:775 - copy_assets_to_destination_dir()] Assets written to: ./models/logisticRegressionCancerNotCancer.chkPt/assets\n",
      "15300/15300 [==============================] - 6s 407us/sample - loss: 0.0019 - accuracy: 0.9999\n",
      "Epoch 10/20\n",
      "14336/15300 [===========================>..] - ETA: 0s - loss: 0.0046 - accuracy: 0.9999[INFO builder_impl.py:775 - copy_assets_to_destination_dir()] Assets written to: ./models/logisticRegressionCancerNotCancer.chkPt/assets\n",
      "15300/15300 [==============================] - 7s 447us/sample - loss: 0.0043 - accuracy: 0.9999\n",
      "Epoch 11/20\n",
      "14336/15300 [===========================>..] - ETA: 0s - loss: 8.9512e-04 - accuracy: 0.9999[INFO builder_impl.py:775 - copy_assets_to_destination_dir()] Assets written to: ./models/logisticRegressionCancerNotCancer.chkPt/assets\n",
      "15300/15300 [==============================] - 6s 392us/sample - loss: 8.6661e-04 - accuracy: 0.9999\n",
      "Epoch 12/20\n",
      "14336/15300 [===========================>..] - ETA: 0s - loss: 0.0041 - accuracy: 0.9997[INFO builder_impl.py:775 - copy_assets_to_destination_dir()] Assets written to: ./models/logisticRegressionCancerNotCancer.chkPt/assets\n",
      "15300/15300 [==============================] - 7s 459us/sample - loss: 0.0039 - accuracy: 0.9997\n",
      "Epoch 13/20\n",
      "14336/15300 [===========================>..] - ETA: 0s - loss: 0.0087 - accuracy: 0.9998[INFO builder_impl.py:775 - copy_assets_to_destination_dir()] Assets written to: ./models/logisticRegressionCancerNotCancer.chkPt/assets\n",
      "15300/15300 [==============================] - 6s 406us/sample - loss: 0.0082 - accuracy: 0.9998\n",
      "CPU times: user 10min 54s, sys: 2min 49s, total: 13min 44s\n",
      "Wall time: 2min 5s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "modelName = \"logisticRegressionCancerNotCancer\"\n",
    "logisticRegressionModel = logisticRegression(\n",
    "    input_dim=lcData.XTrainNP.shape[1], output_dim=1)\n",
    "\n",
    "# https://keras.io/callbacks/\n",
    "checkPointPath = \"./models/{}.chkPt\".format(modelName)\n",
    "callbacks = [\n",
    "    # monitor valuse either 'acc' for accuracy or 'loss'\n",
    "    # 'val_loss' is loss on hold if valaidation_split is set\n",
    "    # 'loss' is loss on training\n",
    "    # same for 'acc' and 'val_acc'\n",
    "    EarlyStopping(monitor='loss', patience=2, verbose=0),\n",
    "    ModelCheckpoint(\n",
    "        checkPointPath, monitor='loss', save_best_only=False, verbose=0)\n",
    "    # FIXME: progbar generates run time error\n",
    "    #,ProgbarLogger(count_mode='samples', stateful_metrics=None)\n",
    "]\n",
    "\n",
    "history = logisticRegressionModel.fit(\n",
    "    lcData.XTrainNP,\n",
    "    lcData.yTrainSeries.values,\n",
    "    shuffle=None,  # we already shuffled\n",
    "    epochs=20,  #100\n",
    "    batch_size=1024,\n",
    "    # we already split the data\n",
    "    validation_split=0.0,\n",
    "    verbose=1,\n",
    "    callbacks=callbacks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "batch_normalization (BatchNo (None, 58581)             234324    \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 1)                 58582     \n",
      "_________________________________________________________________\n",
      "activation (Activation)      (None, 1)                 0         \n",
      "=================================================================\n",
      "Total params: 292,906\n",
      "Trainable params: 175,744\n",
      "Non-trainable params: 117,162\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "logisticRegressionModel.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AEDWIP look at last training lost loss: 0.0068 - accuracy: 0.9999\n",
      "train\n",
      "Loss    : 70.4687\n",
      "Accuracy: 0.0737\n",
      "\n",
      "test\n",
      "Loss    : 70.5374\n",
      "Accuracy: 0.0737\n",
      "CPU times: user 35.5 s, sys: 1min 26s, total: 2min 1s\n",
      "Wall time: 56.4 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# evaluate() computes the loss based on the input you pass\n",
    "# predict() generates output predictions based on the input you pass it\n",
    "evalTrain = logisticRegressionModel.evaluate(lcData.XTrainNP, lcData.yTrainSeries.values, verbose=0)\n",
    "evalTest  = logisticRegressionModel.evaluate(lcData.XTestNP,  lcData.yTestSeries.values,  verbose=0)\n",
    "\n",
    "print(\"AEDWIP look at last training lost loss: 0.0068 - accuracy: 0.9999\")\n",
    "\n",
    "print(\"train\")\n",
    "print(\"Loss    : {:.4f}\".format(evalTrain[0]))\n",
    "print(\"Accuracy: {:.4f}\".format(evalTrain[1]))\n",
    "\n",
    "print(\"\\ntest\")\n",
    "print(\"Loss    : {:.4f}\".format(evalTest[0]))\n",
    "print(\"Accuracy: {:.4f}\".format(evalTest[1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[7.836662e-34]\n",
      " [2.584138e-27]\n",
      " [0.000000e+00]]\n",
      "[0, 0, 0]\n",
      "[[ 282    0]\n",
      " [3544    0]]\n",
      "False positive rate: (predicting tumor while normal) 0.0\n",
      "False negative rate: (predicting normal while tumor) 1.0\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "\n",
    "yTestPredict = logisticRegressionModel.predict(lcData.XTestNP)\n",
    "print(yTestPredict[0:3])\n",
    "yTestPredict = [1 if p > 0.5 else 0 for p in yTestPredict]\n",
    "print(yTestPredict[0:3])\n",
    "\n",
    "# lcData.yTrainSeries.values\n",
    "yTest = lcData.yTestSeries.values\n",
    "print(confusion_matrix(yTest, yTestPredict))\n",
    "\n",
    "\n",
    "# confusion matrix  C is such that C_i,j  is equal to the number of observations \n",
    "# known to be in group i  and predicted to be in group j.\n",
    "tn, fp, fn, tp = confusion_matrix(yTest, yTestPredict).ravel()\n",
    "fpr = fp * 1.0 / (fp + tn)\n",
    "fnr = fn * 1.0 / (tp + fn)\n",
    "print(\"False positive rate: (predicting tumor while normal)\", fpr)\n",
    "print(\"False negative rate: (predicting normal while tumor)\", fnr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "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": [
    "# summarize history for accuracy\n",
    "plt.plot(history.history['accuracy'])\n",
    "# plt.plot(history.history['val_acc'])\n",
    "plt.title('model accuracy')\n",
    "plt.ylabel('accuracy')\n",
    "plt.xlabel('epoch')\n",
    "plt.legend(['train', 'test'], loc='upper left')\n",
    "plt.show()\n",
    "# # summarize history for loss\n",
    "plt.plot(history.history['loss'])\n",
    "# plt.plot(history.history['val_loss'])\n",
    "plt.title('model loss')\n",
    "plt.ylabel('loss')\n",
    "plt.xlabel('epoch')\n",
    "plt.legend(['train', 'test'], loc='upper left')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "create modle directory:../models\n",
      "Saved ../models/logisticRegressionCancerNotCancer.h5 to disk\n"
     ]
    }
   ],
   "source": [
    "# import os\n",
    "# AEDWIP: FIXME: switch to PathLib it is OS independent\n",
    "modelRootDir = pl.Path(\"../models\")\n",
    "fullModelPath = pl.Path(\"{}/{}.h5\".format(modelRootDir, modelName))\n",
    "\n",
    "# if not os.path.exists(modelRootDir):\n",
    "if not modelRootDir.exists():\n",
    "    print(\"create modle directory:{}\".format(modelRootDir))\n",
    "    #os.makedirs(modelRootDir)\n",
    "    modelRootDir.mkdir()\n",
    "\n",
    "# if not os.path.isfile(fullModelPath):\n",
    "if not fullModelPath.exists():\n",
    "    logisticRegressionModel.save(fullModelPath)\n",
    "    print(\"Saved {} to disk\".format(fullModelPath))\n",
    "else:\n",
    "    print(\"ERROR: model was not save. files already exist {}\".format(\n",
    "        fullModelPath))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pwd\n",
    "!ls -l $fullModelPath"
   ]
  },
  {
   "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.7.6"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}