examples/pzmmModelImportExampleH2O.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "Copyright © 2021, SAS Institute Inc., Cary, NC, USA.  All Rights Reserved.\n",
    "SPDX-License-Identifier: Apache-2.0"
   ],
   "metadata": {
    "Collapsed": "false"
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# HMEQ Dataset : Build and Import Trained Models into SAS Model Manager on SAS Viya 3.5\r\n",
    "\r\n",
    "This notebook provides an example of how to build and train a Python model and then import the model into SAS Model Manager using the fleet maintenance data set. Lines of code that must be modified by the user, such as directory paths are noted with the comment \"_Changes required by user._\".\r\n",
    "\r\n",
    "_**Note:** If you download only this notebook and not the rest of the repository, you must also download the hmeq.csv file from the data folder in the examples directory. These files are used when executing this notebook example._\r\n",
    "\r\n",
    "Here are the steps shown in this notebook:\r\n",
    "\r\n",
    "1. Import and review data and preprocess for model training.\r\n",
    "2. Build, train, and access an H2O.ai generalized linear estimator model.\r\n",
    "3. Serialize the model into pickle or MOJO files.\r\n",
    "4. Write the metadata JSON files needed for importing into SAS Model Manager.\r\n",
    "4. Write a score code Python file for model scoring.\r\n",
    "5. Zip the model, JSON, and score code files into an archive file.\r\n",
    "6. Import the ZIP archive file to SAS Model Manager via the Session object and relevant function call."
   ],
   "metadata": {
    "Collapsed": "false"
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Python Package Imports"
   ],
   "metadata": {
    "Collapsed": "false"
   }
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "source": [
    "# Dataframes for data manipulations\r\n",
    "import pandas as pd\r\n",
    "pd.options.mode.chained_assignment = None  # default='warn'\r\n",
    "# Mathematical calculations and array handling\r\n",
    "import numpy as np\r\n",
    "\r\n",
    "# Pathing support\r\n",
    "from pathlib import Path\r\n",
    "\r\n",
    "# Import H2O and check the version\r\n",
    "import h2o\r\n",
    "from h2o.estimators.glm import H2OGeneralizedLinearEstimator\r\n",
    "\r\n",
    "# sasctl interface for importing models\r\n",
    "import sasctl.pzmm as pzmm\r\n",
    "from sasctl import Session"
   ],
   "outputs": [],
   "metadata": {
    "Collapsed": "false"
   }
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "source": [
    "h2o.__version__"
   ],
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "'3.22.1.1'"
      ]
     },
     "metadata": {},
     "execution_count": 2
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "On SAS Viya 3.5, models created in H2O versions 3.24 and under are only compatible in the binary model format. For H2O versions 3.26+, models can be in the MOJO or binary model format. If using a binary model, the H2O version on the SAS Viya server must match the version of H2O used to create the model."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "source": [
    "h2o.init()"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Checking whether there is an H2O instance running at http://localhost:54321. connected.\n",
      "Warning: Your H2O cluster version is too old (2 years, 9 months and 7 days)! Please download and install the latest version from http://h2o.ai/download/\n"
     ]
    },
    {
     "output_type": "display_data",
     "data": {
      "text/html": [
       "<div style=\"overflow:auto\"><table style=\"width:50%\"><tr><td>H2O cluster uptime:</td>\n",
       "<td>6 hours 0 mins</td></tr>\n",
       "<tr><td>H2O cluster timezone:</td>\n",
       "<td>America/New_York</td></tr>\n",
       "<tr><td>H2O data parsing timezone:</td>\n",
       "<td>UTC</td></tr>\n",
       "<tr><td>H2O cluster version:</td>\n",
       "<td>3.22.1.1</td></tr>\n",
       "<tr><td>H2O cluster version age:</td>\n",
       "<td>2 years, 9 months and 7 days !!!</td></tr>\n",
       "<tr><td>H2O cluster name:</td>\n",
       "<td>H2O_from_python_sclind_i4ws71</td></tr>\n",
       "<tr><td>H2O cluster total nodes:</td>\n",
       "<td>1</td></tr>\n",
       "<tr><td>H2O cluster free memory:</td>\n",
       "<td>15.93 Gb</td></tr>\n",
       "<tr><td>H2O cluster total cores:</td>\n",
       "<td>16</td></tr>\n",
       "<tr><td>H2O cluster allowed cores:</td>\n",
       "<td>16</td></tr>\n",
       "<tr><td>H2O cluster status:</td>\n",
       "<td>locked, healthy</td></tr>\n",
       "<tr><td>H2O connection url:</td>\n",
       "<td>http://localhost:54321</td></tr>\n",
       "<tr><td>H2O connection proxy:</td>\n",
       "<td>None</td></tr>\n",
       "<tr><td>H2O internal security:</td>\n",
       "<td>False</td></tr>\n",
       "<tr><td>H2O API Extensions:</td>\n",
       "<td>Algos, AutoML, Core V3, Core V4</td></tr>\n",
       "<tr><td>Python version:</td>\n",
       "<td>3.8.3 final</td></tr></table></div>"
      ],
      "text/plain": [
       "--------------------------  --------------------------------\n",
       "H2O cluster uptime:         6 hours 0 mins\n",
       "H2O cluster timezone:       America/New_York\n",
       "H2O data parsing timezone:  UTC\n",
       "H2O cluster version:        3.22.1.1\n",
       "H2O cluster version age:    2 years, 9 months and 7 days !!!\n",
       "H2O cluster name:           H2O_from_python_sclind_i4ws71\n",
       "H2O cluster total nodes:    1\n",
       "H2O cluster free memory:    15.93 Gb\n",
       "H2O cluster total cores:    16\n",
       "H2O cluster allowed cores:  16\n",
       "H2O cluster status:         locked, healthy\n",
       "H2O connection url:         http://localhost:54321\n",
       "H2O connection proxy:\n",
       "H2O internal security:      False\n",
       "H2O API Extensions:         Algos, AutoML, Core V3, Core V4\n",
       "Python version:             3.8.3 final\n",
       "--------------------------  --------------------------------"
      ]
     },
     "metadata": {}
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Import and Review Data Set"
   ],
   "metadata": {
    "Collapsed": "false"
   }
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "source": [
    "hmeqData = h2o.import_file('data/hmeq.csv',sep= ',')\r\n",
    "hmeqData.shape"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Parse progress: |█████████████████████████████████████████████████████████| 100%\n"
     ]
    },
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "(5960, 13)"
      ]
     },
     "metadata": {},
     "execution_count": 4
    }
   ],
   "metadata": {
    "Collapsed": "false"
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Preprocess Data"
   ],
   "metadata": {
    "Collapsed": "false"
   }
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "source": [
    "hmeqData['BAD'] = hmeqData['BAD'].asfactor()\r\n",
    "\r\n",
    "train, validation, test = hmeqData.split_frame(ratios=[.6, .2], seed=42)\r\n",
    "\r\n",
    "y = 'BAD'\r\n",
    "x = list(hmeqData.columns)\r\n",
    "x.remove(y)"
   ],
   "outputs": [],
   "metadata": {
    "Collapsed": "false"
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Create, Train, and Assess Model"
   ],
   "metadata": {
    "Collapsed": "false"
   }
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "source": [
    "glmFit = H2OGeneralizedLinearEstimator(family='binomial', model_id='glmfit', lambda_search=True)\r\n",
    "glmFit.train(x=x, y=y, training_frame=train, validation_frame=validation)"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "glm Model Build progress: |███████████████████████████████████████████████| 100%\n"
     ]
    }
   ],
   "metadata": {
    "Collapsed": "false"
   }
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "source": [
    "# Check the model performance and print its accuracy\r\n",
    "glmPerf = glmFit.model_performance(test)\r\n",
    "print(glmPerf.accuracy())"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "[[0.551348008992684, 0.8486897717666948]]\n"
     ]
    }
   ],
   "metadata": {
    "Collapsed": "false"
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Choice Point\r\n",
    "The next two cells represent the saving process for binary and MOJO H2O models respectively. "
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "source": [
    "h2o.save_model(glmFit, path='data/hmeqModels/H2OBinaryGLM')"
   ],
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "'C:\\\\Users\\\\sclind\\\\Documents\\\\Python Scripts\\\\GitHub\\\\sassoftware\\\\python-sasctl\\\\examples\\\\data\\\\hmeqModels\\\\H2OBinaryGLM\\\\glmfit'"
      ]
     },
     "metadata": {},
     "execution_count": 8
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "source": [
    "#glmFit.save_mojo(path='data/hmeqModels/H2OMOJOGLM')"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Register Model in SAS Model Manager with pzmm\r\n",
    "*Commented out lines are for MOJO models*"
   ],
   "metadata": {
    "Collapsed": "false"
   }
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "source": [
    "modelPrefix = 'glmFit'\r\n",
    "zipFolder = Path.cwd() / 'data/hmeqModels/H2OBinaryGLM/'\r\n",
    "pzmm.PickleModel.pickleTrainedModel(_, glmFit, modelPrefix, zipFolder, isH2OModel=True, isBinaryModel=True)\r\n",
    "#pzmm.PickleModle.pickleTrainedModel(_, glmFit, modelPrefix, zipFolder, isH2OModel=True)"
   ],
   "outputs": [],
   "metadata": {
    "Collapsed": "false"
   }
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "source": [
    "trainDF = train.as_data_frame()\r\n",
    "J = pzmm.JSONFiles()\r\n",
    "\r\n",
    "# Write input variable mapping to a json file\r\n",
    "J.writeVarJSON(trainDF[x], isInput=True, jPath=zipFolder)\r\n",
    "\r\n",
    "# Set output variables and assign an event threshold, then write output variable mapping\r\n",
    "outputVar = pd.DataFrame(columns=['EM_EVENTPROBABILITY', 'EM_CLASSIFICATION'])\r\n",
    "outputVar['EM_CLASSIFICATION'] = trainDF[y].astype('category').cat.categories.astype('str')\r\n",
    "outputVar['EM_EVENTPROBABILITY'] = 0.5 # Event threshold\r\n",
    "J.writeVarJSON(outputVar, isInput=False, jPath=zipFolder)\r\n",
    "\r\n",
    "# Write model properties to a json file\r\n",
    "J.writeModelPropertiesJSON(modelName=modelPrefix,\r\n",
    "                            modelDesc='',\r\n",
    "                            targetVariable=y,\r\n",
    "                            modelType='',\r\n",
    "                            modelPredictors=x,\r\n",
    "                            targetEvent=1,\r\n",
    "                            numTargetCategories=1,\r\n",
    "                            eventProbVar='EM_EVENTPROBABILITY',\r\n",
    "                            jPath=zipFolder,\r\n",
    "                            modeler='sasdemo')\r\n",
    "\r\n",
    "# Write model metadata to a json file\r\n",
    "J.writeFileMetadataJSON(modelPrefix, jPath=zipFolder)"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "inputVar.json was successfully written and saved to c:\\Users\\sclind\\Documents\\Python Scripts\\GitHub\\sassoftware\\python-sasctl\\examples\\data\\hmeqModels\\H2OBinaryGLM\\inputVar.json\n",
      "outputVar.json was successfully written and saved to c:\\Users\\sclind\\Documents\\Python Scripts\\GitHub\\sassoftware\\python-sasctl\\examples\\data\\hmeqModels\\H2OBinaryGLM\\outputVar.json\n",
      "ModelProperties.json was successfully written and saved to c:\\Users\\sclind\\Documents\\Python Scripts\\GitHub\\sassoftware\\python-sasctl\\examples\\data\\hmeqModels\\H2OBinaryGLM\\ModelProperties.json\n",
      "fileMetaData.json was successfully written and saved to c:\\Users\\sclind\\Documents\\Python Scripts\\GitHub\\sassoftware\\python-sasctl\\examples\\data\\hmeqModels\\H2OBinaryGLM\\fileMetaData.json\n"
     ]
    }
   ],
   "metadata": {
    "Collapsed": "false"
   }
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "source": [
    "import getpass\r\n",
    "username = getpass.getpass()\r\n",
    "password = getpass.getpass()\r\n",
    "host = 'sas.demo.com'\r\n",
    "sess = Session(host, username, password, protocol='http')"
   ],
   "outputs": [],
   "metadata": {
    "Collapsed": "false"
   }
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "source": [
    "pzmm.ImportModel.pzmmImportModel(zipFolder, modelPrefix, 'BinaryH2OExample', trainDF[x], trainDF[y], predictmethod=None, isH2OModel=True, force=True)\r\n",
    "#pzmm.ImportModel.pzmmImportModel(zipFolder, modelPrefix, 'MOJOH2OExample', trainDF[x], trainDF[y], predictMethod='{}.predict({})', isH2OModel=True, force=True)"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "All model files were zipped to c:\\Users\\sclind\\Documents\\Python Scripts\\GitHub\\sassoftware\\python-sasctl\\examples\\data\\hmeqModels\\H2OBinaryGLM.\n",
      "Model was successfully imported into SAS Model Manager as glmFit with UUID: e34d30a4-66dd-4648-ad75-c6e92f0b01f1.\n",
      "Model score code was written successfully to c:\\Users\\sclind\\Documents\\Python Scripts\\GitHub\\sassoftware\\python-sasctl\\examples\\data\\hmeqModels\\H2OBinaryGLM\\glmFitScore.py and uploaded to SAS Model Manager\n"
     ]
    }
   ],
   "metadata": {
    "Collapsed": "false"
   }
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "f9708d3f38eeab835578f0695c8890716ee809285281a28db6e379a5abca1310"
  },
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3.8.3 64-bit ('dev-sasctl': conda)"
  },
  "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.3"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": true,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": 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": 4
}