week2_rf_iris.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Week 3 - Random Forest with the Iris Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import h2o"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Checking whether there is an H2O instance running at http://localhost:54321 ..... not found.\n",
      "Attempting to start a local H2O server...\n",
      "  Java Version: openjdk version \"1.8.0_232\"; OpenJDK Runtime Environment (build 1.8.0_232-8u232-b09-0ubuntu1~19.04.1-b09); OpenJDK 64-Bit Server VM (build 25.232-b09, mixed mode)\n",
      "  Starting server from /home/megan/Projects/h2oclass/lib/python3.7/site-packages/h2o/backend/bin/h2o.jar\n",
      "  Ice root: /tmp/tmpwhn6tg5e\n",
      "  JVM stdout: /tmp/tmpwhn6tg5e/h2o_megan_started_from_python.out\n",
      "  JVM stderr: /tmp/tmpwhn6tg5e/h2o_megan_started_from_python.err\n",
      "  Server is running at http://127.0.0.1:54321\n",
      "Connecting to H2O server at http://127.0.0.1:54321 ... successful.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div style=\"overflow:auto\"><table style=\"width:50%\"><tr><td>H2O cluster uptime:</td>\n",
       "<td>01 secs</td></tr>\n",
       "<tr><td>H2O cluster timezone:</td>\n",
       "<td>America/Chicago</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.28.0.3</td></tr>\n",
       "<tr><td>H2O cluster version age:</td>\n",
       "<td>9 days </td></tr>\n",
       "<tr><td>H2O cluster name:</td>\n",
       "<td>H2O_from_python_megan_aoordc</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>1.520 Gb</td></tr>\n",
       "<tr><td>H2O cluster total cores:</td>\n",
       "<td>3</td></tr>\n",
       "<tr><td>H2O cluster allowed cores:</td>\n",
       "<td>3</td></tr>\n",
       "<tr><td>H2O cluster status:</td>\n",
       "<td>accepting new members, healthy</td></tr>\n",
       "<tr><td>H2O connection url:</td>\n",
       "<td>http://127.0.0.1:54321</td></tr>\n",
       "<tr><td>H2O connection proxy:</td>\n",
       "<td>{'http': None, 'https': None}</td></tr>\n",
       "<tr><td>H2O internal security:</td>\n",
       "<td>False</td></tr>\n",
       "<tr><td>H2O API Extensions:</td>\n",
       "<td>Amazon S3, XGBoost, Algos, AutoML, Core V3, TargetEncoder, Core V4</td></tr>\n",
       "<tr><td>Python version:</td>\n",
       "<td>3.7.3 final</td></tr></table></div>"
      ],
      "text/plain": [
       "--------------------------  ------------------------------------------------------------------\n",
       "H2O cluster uptime:         01 secs\n",
       "H2O cluster timezone:       America/Chicago\n",
       "H2O data parsing timezone:  UTC\n",
       "H2O cluster version:        3.28.0.3\n",
       "H2O cluster version age:    9 days\n",
       "H2O cluster name:           H2O_from_python_megan_aoordc\n",
       "H2O cluster total nodes:    1\n",
       "H2O cluster free memory:    1.520 Gb\n",
       "H2O cluster total cores:    3\n",
       "H2O cluster allowed cores:  3\n",
       "H2O cluster status:         accepting new members, healthy\n",
       "H2O connection url:         http://127.0.0.1:54321\n",
       "H2O connection proxy:       {'http': None, 'https': None}\n",
       "H2O internal security:      False\n",
       "H2O API Extensions:         Amazon S3, XGBoost, Algos, AutoML, Core V3, TargetEncoder, Core V4\n",
       "Python version:             3.7.3 final\n",
       "--------------------------  ------------------------------------------------------------------"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# check to see if H2O is running already and connect, or start it up\n",
    "h2o.init()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parse progress: |█████████████████████████████████████████████████████████| 100%\n"
     ]
    }
   ],
   "source": [
    "# import the iris dataset\n",
    "url = 'http://h2o-public-test-data.s3.amazonaws.com/smalldata/iris/iris_wheader.csv'\n",
    "iris = h2o.import_file(url)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# split the data into 80% train and 20% test\n",
    "train, test = iris.split_frame([0.8])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table>\n",
       "<thead>\n",
       "<tr><th>       </th><th>sepal_len         </th><th>sepal_wid          </th><th>petal_len         </th><th>petal_wid         </th><th>class      </th></tr>\n",
       "</thead>\n",
       "<tbody>\n",
       "<tr><td>type   </td><td>real              </td><td>real               </td><td>real              </td><td>real              </td><td>enum       </td></tr>\n",
       "<tr><td>mins   </td><td>4.4               </td><td>2.3                </td><td>1.0               </td><td>0.1               </td><td>           </td></tr>\n",
       "<tr><td>mean   </td><td>5.831896551724137 </td><td>3.087068965517241  </td><td>3.7482758620689656</td><td>1.21551724137931  </td><td>           </td></tr>\n",
       "<tr><td>maxs   </td><td>7.9               </td><td>4.2                </td><td>6.7               </td><td>2.5               </td><td>           </td></tr>\n",
       "<tr><td>sigma  </td><td>0.8334943872355857</td><td>0.40271473826989534</td><td>1.785179701519329 </td><td>0.7960340224623198</td><td>           </td></tr>\n",
       "<tr><td>zeros  </td><td>0                 </td><td>0                  </td><td>0                 </td><td>0                 </td><td>           </td></tr>\n",
       "<tr><td>missing</td><td>0                 </td><td>0                  </td><td>0                 </td><td>0                 </td><td>0          </td></tr>\n",
       "<tr><td>0      </td><td>5.1               </td><td>3.5                </td><td>1.4               </td><td>0.2               </td><td>Iris-setosa</td></tr>\n",
       "<tr><td>1      </td><td>4.9               </td><td>3.0                </td><td>1.4               </td><td>0.2               </td><td>Iris-setosa</td></tr>\n",
       "<tr><td>2      </td><td>4.7               </td><td>3.2                </td><td>1.3               </td><td>0.2               </td><td>Iris-setosa</td></tr>\n",
       "<tr><td>3      </td><td>4.6               </td><td>3.1                </td><td>1.5               </td><td>0.2               </td><td>Iris-setosa</td></tr>\n",
       "<tr><td>4      </td><td>5.0               </td><td>3.6                </td><td>1.4               </td><td>0.2               </td><td>Iris-setosa</td></tr>\n",
       "<tr><td>5      </td><td>5.4               </td><td>3.9                </td><td>1.7               </td><td>0.4               </td><td>Iris-setosa</td></tr>\n",
       "<tr><td>6      </td><td>4.6               </td><td>3.4                </td><td>1.4               </td><td>0.3               </td><td>Iris-setosa</td></tr>\n",
       "<tr><td>7      </td><td>5.0               </td><td>3.4                </td><td>1.5               </td><td>0.2               </td><td>Iris-setosa</td></tr>\n",
       "<tr><td>8      </td><td>4.4               </td><td>2.9                </td><td>1.4               </td><td>0.2               </td><td>Iris-setosa</td></tr>\n",
       "<tr><td>9      </td><td>4.9               </td><td>3.1                </td><td>1.5               </td><td>0.1               </td><td>Iris-setosa</td></tr>\n",
       "</tbody>\n",
       "</table>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# review a summary of our training data\n",
    "train.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "116"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train.nrows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "34"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test.nrows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import the RF estimator\n",
    "from h2o.estimators.random_forest import H2ORandomForestEstimator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "drf Model Build progress: |███████████████████████████████████████████████| 100%\n"
     ]
    }
   ],
   "source": [
    "mRF = H2ORandomForestEstimator()\n",
    "mRF.train(['sepal_len', 'sepal_wid', 'petal_len', 'petal_wid'], 'class', train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model Details\n",
      "=============\n",
      "H2ORandomForestEstimator :  Distributed Random Forest\n",
      "Model Key:  DRF_model_python_1581737587262_1\n",
      "\n",
      "\n",
      "Model Summary: \n"
     ]
    },
    {
     "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></th>\n",
       "      <th>number_of_trees</th>\n",
       "      <th>number_of_internal_trees</th>\n",
       "      <th>model_size_in_bytes</th>\n",
       "      <th>min_depth</th>\n",
       "      <th>max_depth</th>\n",
       "      <th>mean_depth</th>\n",
       "      <th>min_leaves</th>\n",
       "      <th>max_leaves</th>\n",
       "      <th>mean_leaves</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td></td>\n",
       "      <td>50.0</td>\n",
       "      <td>150.0</td>\n",
       "      <td>17779.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>7.0</td>\n",
       "      <td>3.013333</td>\n",
       "      <td>2.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>4.793334</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     number_of_trees  number_of_internal_trees  model_size_in_bytes  \\\n",
       "0               50.0                     150.0              17779.0   \n",
       "\n",
       "   min_depth  max_depth  mean_depth  min_leaves  max_leaves  mean_leaves  \n",
       "0        1.0        7.0    3.013333         2.0        10.0     4.793334  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "ModelMetricsMultinomial: drf\n",
      "** Reported on train data. **\n",
      "\n",
      "MSE: 0.029837744639468793\n",
      "RMSE: 0.1727360548335778\n",
      "LogLoss: 0.09365054487556494\n",
      "Mean Per-Class Error: 0.043437862950058075\n",
      "\n",
      "Confusion Matrix: Row labels: Actual class; Column labels: Predicted class\n"
     ]
    },
    {
     "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>Iris-setosa</th>\n",
       "      <th>Iris-versicolor</th>\n",
       "      <th>Iris-virginica</th>\n",
       "      <th>Error</th>\n",
       "      <th>Rate</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>40.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0 / 40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.0</td>\n",
       "      <td>33.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.057143</td>\n",
       "      <td>2 / 35</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>38.0</td>\n",
       "      <td>0.073171</td>\n",
       "      <td>3 / 41</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>40.0</td>\n",
       "      <td>36.0</td>\n",
       "      <td>40.0</td>\n",
       "      <td>0.043103</td>\n",
       "      <td>5 / 116</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Iris-setosa  Iris-versicolor  Iris-virginica     Error     Rate\n",
       "0         40.0              0.0             0.0  0.000000   0 / 40\n",
       "1          0.0             33.0             2.0  0.057143   2 / 35\n",
       "2          0.0              3.0            38.0  0.073171   3 / 41\n",
       "3         40.0             36.0            40.0  0.043103  5 / 116"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Top-3 Hit Ratios: \n"
     ]
    },
    {
     "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>k</th>\n",
       "      <th>hit_ratio</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>0.956897</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   k  hit_ratio\n",
       "0  1   0.956897\n",
       "1  2   1.000000\n",
       "2  3   1.000000"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Scoring History: \n"
     ]
    },
    {
     "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></th>\n",
       "      <th>timestamp</th>\n",
       "      <th>duration</th>\n",
       "      <th>number_of_trees</th>\n",
       "      <th>training_rmse</th>\n",
       "      <th>training_logloss</th>\n",
       "      <th>training_classification_error</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td></td>\n",
       "      <td>2020-02-14 21:34:48</td>\n",
       "      <td>0.050 sec</td>\n",
       "      <td>0.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td></td>\n",
       "      <td>2020-02-14 21:34:48</td>\n",
       "      <td>0.163 sec</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.279862</td>\n",
       "      <td>1.937735</td>\n",
       "      <td>0.078947</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td></td>\n",
       "      <td>2020-02-14 21:34:48</td>\n",
       "      <td>0.201 sec</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.188522</td>\n",
       "      <td>0.641789</td>\n",
       "      <td>0.031746</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td></td>\n",
       "      <td>2020-02-14 21:34:48</td>\n",
       "      <td>0.227 sec</td>\n",
       "      <td>3.0</td>\n",
       "      <td>0.263278</td>\n",
       "      <td>1.983895</td>\n",
       "      <td>0.066667</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td></td>\n",
       "      <td>2020-02-14 21:34:48</td>\n",
       "      <td>0.248 sec</td>\n",
       "      <td>4.0</td>\n",
       "      <td>0.269406</td>\n",
       "      <td>2.112576</td>\n",
       "      <td>0.069307</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td></td>\n",
       "      <td>2020-02-14 21:34:48</td>\n",
       "      <td>0.273 sec</td>\n",
       "      <td>5.0</td>\n",
       "      <td>0.239524</td>\n",
       "      <td>1.402944</td>\n",
       "      <td>0.057692</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td></td>\n",
       "      <td>2020-02-14 21:34:48</td>\n",
       "      <td>0.291 sec</td>\n",
       "      <td>6.0</td>\n",
       "      <td>0.214583</td>\n",
       "      <td>1.048630</td>\n",
       "      <td>0.047170</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td></td>\n",
       "      <td>2020-02-14 21:34:48</td>\n",
       "      <td>0.303 sec</td>\n",
       "      <td>7.0</td>\n",
       "      <td>0.197343</td>\n",
       "      <td>0.706496</td>\n",
       "      <td>0.045455</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td></td>\n",
       "      <td>2020-02-14 21:34:48</td>\n",
       "      <td>0.315 sec</td>\n",
       "      <td>8.0</td>\n",
       "      <td>0.201131</td>\n",
       "      <td>0.695253</td>\n",
       "      <td>0.053097</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td></td>\n",
       "      <td>2020-02-14 21:34:48</td>\n",
       "      <td>0.324 sec</td>\n",
       "      <td>9.0</td>\n",
       "      <td>0.202010</td>\n",
       "      <td>0.691358</td>\n",
       "      <td>0.052632</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td></td>\n",
       "      <td>2020-02-14 21:34:48</td>\n",
       "      <td>0.333 sec</td>\n",
       "      <td>10.0</td>\n",
       "      <td>0.202275</td>\n",
       "      <td>0.686542</td>\n",
       "      <td>0.052174</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td></td>\n",
       "      <td>2020-02-14 21:34:48</td>\n",
       "      <td>0.341 sec</td>\n",
       "      <td>11.0</td>\n",
       "      <td>0.200456</td>\n",
       "      <td>0.686766</td>\n",
       "      <td>0.043478</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td></td>\n",
       "      <td>2020-02-14 21:34:48</td>\n",
       "      <td>0.348 sec</td>\n",
       "      <td>12.0</td>\n",
       "      <td>0.191371</td>\n",
       "      <td>0.399129</td>\n",
       "      <td>0.043478</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td></td>\n",
       "      <td>2020-02-14 21:34:48</td>\n",
       "      <td>0.356 sec</td>\n",
       "      <td>13.0</td>\n",
       "      <td>0.188101</td>\n",
       "      <td>0.393347</td>\n",
       "      <td>0.043103</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td></td>\n",
       "      <td>2020-02-14 21:34:48</td>\n",
       "      <td>0.365 sec</td>\n",
       "      <td>14.0</td>\n",
       "      <td>0.184461</td>\n",
       "      <td>0.389860</td>\n",
       "      <td>0.043103</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td></td>\n",
       "      <td>2020-02-14 21:34:48</td>\n",
       "      <td>0.372 sec</td>\n",
       "      <td>15.0</td>\n",
       "      <td>0.186823</td>\n",
       "      <td>0.391009</td>\n",
       "      <td>0.043103</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td></td>\n",
       "      <td>2020-02-14 21:34:48</td>\n",
       "      <td>0.382 sec</td>\n",
       "      <td>16.0</td>\n",
       "      <td>0.186867</td>\n",
       "      <td>0.392273</td>\n",
       "      <td>0.043103</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17</th>\n",
       "      <td></td>\n",
       "      <td>2020-02-14 21:34:48</td>\n",
       "      <td>0.390 sec</td>\n",
       "      <td>17.0</td>\n",
       "      <td>0.182602</td>\n",
       "      <td>0.388491</td>\n",
       "      <td>0.043103</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>18</th>\n",
       "      <td></td>\n",
       "      <td>2020-02-14 21:34:48</td>\n",
       "      <td>0.401 sec</td>\n",
       "      <td>18.0</td>\n",
       "      <td>0.181605</td>\n",
       "      <td>0.387720</td>\n",
       "      <td>0.043103</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>19</th>\n",
       "      <td></td>\n",
       "      <td>2020-02-14 21:34:48</td>\n",
       "      <td>0.422 sec</td>\n",
       "      <td>19.0</td>\n",
       "      <td>0.179864</td>\n",
       "      <td>0.386122</td>\n",
       "      <td>0.034483</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                timestamp    duration  number_of_trees  training_rmse  \\\n",
       "0     2020-02-14 21:34:48   0.050 sec              0.0            NaN   \n",
       "1     2020-02-14 21:34:48   0.163 sec              1.0       0.279862   \n",
       "2     2020-02-14 21:34:48   0.201 sec              2.0       0.188522   \n",
       "3     2020-02-14 21:34:48   0.227 sec              3.0       0.263278   \n",
       "4     2020-02-14 21:34:48   0.248 sec              4.0       0.269406   \n",
       "5     2020-02-14 21:34:48   0.273 sec              5.0       0.239524   \n",
       "6     2020-02-14 21:34:48   0.291 sec              6.0       0.214583   \n",
       "7     2020-02-14 21:34:48   0.303 sec              7.0       0.197343   \n",
       "8     2020-02-14 21:34:48   0.315 sec              8.0       0.201131   \n",
       "9     2020-02-14 21:34:48   0.324 sec              9.0       0.202010   \n",
       "10    2020-02-14 21:34:48   0.333 sec             10.0       0.202275   \n",
       "11    2020-02-14 21:34:48   0.341 sec             11.0       0.200456   \n",
       "12    2020-02-14 21:34:48   0.348 sec             12.0       0.191371   \n",
       "13    2020-02-14 21:34:48   0.356 sec             13.0       0.188101   \n",
       "14    2020-02-14 21:34:48   0.365 sec             14.0       0.184461   \n",
       "15    2020-02-14 21:34:48   0.372 sec             15.0       0.186823   \n",
       "16    2020-02-14 21:34:48   0.382 sec             16.0       0.186867   \n",
       "17    2020-02-14 21:34:48   0.390 sec             17.0       0.182602   \n",
       "18    2020-02-14 21:34:48   0.401 sec             18.0       0.181605   \n",
       "19    2020-02-14 21:34:48   0.422 sec             19.0       0.179864   \n",
       "\n",
       "    training_logloss  training_classification_error  \n",
       "0                NaN                            NaN  \n",
       "1           1.937735                       0.078947  \n",
       "2           0.641789                       0.031746  \n",
       "3           1.983895                       0.066667  \n",
       "4           2.112576                       0.069307  \n",
       "5           1.402944                       0.057692  \n",
       "6           1.048630                       0.047170  \n",
       "7           0.706496                       0.045455  \n",
       "8           0.695253                       0.053097  \n",
       "9           0.691358                       0.052632  \n",
       "10          0.686542                       0.052174  \n",
       "11          0.686766                       0.043478  \n",
       "12          0.399129                       0.043478  \n",
       "13          0.393347                       0.043103  \n",
       "14          0.389860                       0.043103  \n",
       "15          0.391009                       0.043103  \n",
       "16          0.392273                       0.043103  \n",
       "17          0.388491                       0.043103  \n",
       "18          0.387720                       0.043103  \n",
       "19          0.386122                       0.034483  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "See the whole table with table.as_data_frame()\n",
      "\n",
      "Variable Importances: \n"
     ]
    },
    {
     "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>variable</th>\n",
       "      <th>relative_importance</th>\n",
       "      <th>scaled_importance</th>\n",
       "      <th>percentage</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>petal_wid</td>\n",
       "      <td>1660.316772</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.489417</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>petal_len</td>\n",
       "      <td>1481.302979</td>\n",
       "      <td>0.892181</td>\n",
       "      <td>0.436648</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>sepal_len</td>\n",
       "      <td>203.898743</td>\n",
       "      <td>0.122807</td>\n",
       "      <td>0.060104</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>sepal_wid</td>\n",
       "      <td>46.922153</td>\n",
       "      <td>0.028261</td>\n",
       "      <td>0.013831</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    variable  relative_importance  scaled_importance  percentage\n",
       "0  petal_wid          1660.316772           1.000000    0.489417\n",
       "1  petal_len          1481.302979           0.892181    0.436648\n",
       "2  sepal_len           203.898743           0.122807    0.060104\n",
       "3  sepal_wid            46.922153           0.028261    0.013831"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": []
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# see the model results\n",
    "mRF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "ModelMetricsMultinomial: drf\n",
      "** Reported on test data. **\n",
      "\n",
      "MSE: 0.06157779435278852\n",
      "RMSE: 0.24814873433646306\n",
      "LogLoss: 0.17624219729076127\n",
      "Mean Per-Class Error: 0.1111111111111111\n",
      "\n",
      "Confusion Matrix: Row labels: Actual class; Column labels: Predicted class\n"
     ]
    },
    {
     "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>Iris-setosa</th>\n",
       "      <th>Iris-versicolor</th>\n",
       "      <th>Iris-virginica</th>\n",
       "      <th>Error</th>\n",
       "      <th>Rate</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>10.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0 / 10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.0</td>\n",
       "      <td>15.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0 / 15</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>6.0</td>\n",
       "      <td>0.333333</td>\n",
       "      <td>3 / 9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>10.0</td>\n",
       "      <td>18.0</td>\n",
       "      <td>6.0</td>\n",
       "      <td>0.088235</td>\n",
       "      <td>3 / 34</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Iris-setosa  Iris-versicolor  Iris-virginica     Error    Rate\n",
       "0         10.0              0.0             0.0  0.000000  0 / 10\n",
       "1          0.0             15.0             0.0  0.000000  0 / 15\n",
       "2          0.0              3.0             6.0  0.333333   3 / 9\n",
       "3         10.0             18.0             6.0  0.088235  3 / 34"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Top-3 Hit Ratios: \n"
     ]
    },
    {
     "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>k</th>\n",
       "      <th>hit_ratio</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>0.911765</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   k  hit_ratio\n",
       "0  1   0.911765\n",
       "1  2   1.000000\n",
       "2  3   1.000000"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": []
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# see results on the test set\n",
    "mRF.model_performance(test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class H2ORandomForestEstimator in module h2o.estimators.random_forest:\n",
      "\n",
      "class H2ORandomForestEstimator(h2o.estimators.estimator_base.H2OEstimator)\n",
      " |  H2ORandomForestEstimator(**kwargs)\n",
      " |  \n",
      " |  Distributed Random Forest\n",
      " |  \n",
      " |  Builds a Distributed Random Forest (DRF) on a parsed dataset, for regression or \n",
      " |  classification.\n",
      " |  \n",
      " |  Method resolution order:\n",
      " |      H2ORandomForestEstimator\n",
      " |      h2o.estimators.estimator_base.H2OEstimator\n",
      " |      h2o.model.model_base.ModelBase\n",
      " |      h2o.model.model_base.ModelBase\n",
      " |      h2o.base.Keyed\n",
      " |      builtins.object\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __init__(self, **kwargs)\n",
      " |      Construct a new model instance.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  balance_classes\n",
      " |      Balance training data class counts via over/under-sampling (for imbalanced data).\n",
      " |      \n",
      " |      Type: ``bool``  (default: ``False``).\n",
      " |      \n",
      " |      :examples:\n",
      " |      \n",
      " |      >>> covtype = h2o.import_file(\"https://s3.amazonaws.com/h2o-public-test-data/smalldata/covtype/covtype.20k.data\")\n",
      " |      >>> covtype[54] = covtype[54].asfactor()\n",
      " |      >>> predictors = covtype.columns[0:54]\n",
      " |      >>> response = 'C55'\n",
      " |      >>> train, valid = covtype.split_frame(ratios=[.8], seed=1234)\n",
      " |      >>> cov_drf = H2ORandomForestEstimator(balance_classes=True,\n",
      " |      ...                                    seed=1234)\n",
      " |      >>> cov_drf.train(x=predictors,\n",
      " |      ...               y=response,\n",
      " |      ...               training_frame=train,\n",
      " |      ...               validation_frame=valid)\n",
      " |      >>> print('logloss', cov_drf.logloss(valid=True))\n",
      " |  \n",
      " |  binomial_double_trees\n",
      " |      For binary classification: Build 2x as many trees (one per class) - can lead to higher accuracy.\n",
      " |      \n",
      " |      Type: ``bool``  (default: ``False``).\n",
      " |      \n",
      " |      :examples:\n",
      " |      \n",
      " |      >>> cars = h2o.import_file(\"https://s3.amazonaws.com/h2o-public-test-data/smalldata/junit/cars_20mpg.csv\")\n",
      " |      >>> cars[\"economy_20mpg\"] = cars[\"economy_20mpg\"].asfactor()\n",
      " |      >>> predictors = [\"displacement\",\"power\",\"weight\",\"acceleration\",\"year\"]\n",
      " |      >>> response = \"economy_20mpg\"\n",
      " |      >>> train, valid = cars.split_frame(ratios=[.8], seed=1234)\n",
      " |      >>> cars_drf = H2ORandomForestEstimator(binomial_double_trees=False,\n",
      " |      ...                                     seed=1234)\n",
      " |      >>> cars_drf.train(x=predictors,\n",
      " |      ...                y=response,\n",
      " |      ...                training_frame=train,\n",
      " |      ...                validation_frame=valid)\n",
      " |      >>> print('without binomial_double_trees:',\n",
      " |      ...        cars_drf.auc(valid=True))\n",
      " |      >>> cars_drf_2 = H2ORandomForestEstimator(binomial_double_trees=True,\n",
      " |      ...                                       seed=1234)\n",
      " |      >>> cars_drf_2.train(x=predictors,\n",
      " |      ...                  y=response,\n",
      " |      ...                  training_frame=train,\n",
      " |      ...                  validation_frame=valid)\n",
      " |      >>> print('with binomial_double_trees:', cars_drf_2.auc(valid=True))\n",
      " |  \n",
      " |  build_tree_one_node\n",
      " |      Run on one node only; no network overhead but fewer cpus used.  Suitable for small datasets.\n",
      " |      \n",
      " |      Type: ``bool``  (default: ``False``).\n",
      " |      \n",
      " |      :examples:\n",
      " |      \n",
      " |      >>> cars = h2o.import_file(\"https://s3.amazonaws.com/h2o-public-test-data/smalldata/junit/cars_20mpg.csv\")\n",
      " |      >>> cars[\"economy_20mpg\"] = cars[\"economy_20mpg\"].asfactor()\n",
      " |      >>> predictors = [\"displacement\",\"power\",\"weight\",\"acceleration\",\"year\"]\n",
      " |      >>> response = \"economy_20mpg\"\n",
      " |      >>> train, valid = cars.split_frame(ratios=[.8], seed=1234)\n",
      " |      >>> cars_drf = H2ORandomForestEstimator(build_tree_one_node=True,\n",
      " |      ...                                     seed=1234)\n",
      " |      >>> cars_drf.train(x=predictors,\n",
      " |      ...                y=response,\n",
      " |      ...                training_frame=train,\n",
      " |      ...                validation_frame=valid)\n",
      " |      >>> cars_drf.auc(valid=True)\n",
      " |  \n",
      " |  calibrate_model\n",
      " |      Use Platt Scaling to calculate calibrated class probabilities. Calibration can provide more accurate estimates\n",
      " |      of class probabilities.\n",
      " |      \n",
      " |      Type: ``bool``  (default: ``False``).\n",
      " |      \n",
      " |      :examples:\n",
      " |      \n",
      " |      >>> ecology = h2o.import_file(\"https://s3.amazonaws.com/h2o-public-test-data/smalldata/gbm_test/ecology_model.csv\")\n",
      " |      >>> ecology['Angaus'] = ecology['Angaus'].asfactor()\n",
      " |      >>> from h2o.estimators.random_forest import H2ORandomForestEstimator\n",
      " |      >>> response = 'Angaus'\n",
      " |      >>> predictors = ecology.columns[3:13]\n",
      " |      >>> train, calib = ecology.split_frame(seed=12354)\n",
      " |      >>> w = h2o.create_frame(binary_fraction=1,\n",
      " |      ...                      binary_ones_fraction=0.5,\n",
      " |      ...                      missing_fraction=0,\n",
      " |      ...                      rows=744, cols=1)\n",
      " |      >>> w.set_names([\"weight\"])\n",
      " |      >>> train = train.cbind(w)\n",
      " |      >>> ecology_drf = H2ORandomForestEstimator(ntrees=10,\n",
      " |      ...                                        max_depth=5,\n",
      " |      ...                                        min_rows=10,\n",
      " |      ...                                        distribution=\"multinomial\",\n",
      " |      ...                                        weights_column=\"weight\",\n",
      " |      ...                                        calibrate_model=True,\n",
      " |      ...                                        calibration_frame=calib)\n",
      " |      >>> ecology_drf.train(x=predictors,\n",
      " |      ...                   y=\"Angaus\",\n",
      " |      ...                   training_frame=train)\n",
      " |      >>> predicted = ecology_drf.predict(calib)\n",
      " |  \n",
      " |  calibration_frame\n",
      " |      Calibration frame for Platt Scaling\n",
      " |      \n",
      " |      Type: ``H2OFrame``.\n",
      " |      \n",
      " |      :examples:\n",
      " |      \n",
      " |      >>> ecology = h2o.import_file(\"https://s3.amazonaws.com/h2o-public-test-data/smalldata/gbm_test/ecology_model.csv\")\n",
      " |      >>> ecology['Angaus'] = ecology['Angaus'].asfactor()\n",
      " |      >>> response = 'Angaus'\n",
      " |      >>> predictors = ecology.columns[3:13]\n",
      " |      >>> train, calib = ecology.split_frame(seed = 12354)\n",
      " |      >>> w = h2o.create_frame(binary_fraction=1,\n",
      " |      ...                      binary_ones_fraction=0.5,\n",
      " |      ...                      missing_fraction=0,\n",
      " |      ...                      rows=744, cols=1)\n",
      " |      >>> w.set_names([\"weight\"])\n",
      " |      >>> train = train.cbind(w)\n",
      " |      >>> ecology_drf = H2ORandomForestEstimator(ntrees=10,\n",
      " |      ...                                        max_depth=5,\n",
      " |      ...                                        min_rows=10,\n",
      " |      ...                                        distribution=\"multinomial\",\n",
      " |      ...                                        calibrate_model=True,\n",
      " |      ...                                        calibration_frame=calib)\n",
      " |      >>> ecology_drf.train(x=predictors,\n",
      " |      ...                   y=\"Angaus,\n",
      " |      ...                   training_frame=train,\n",
      " |      ...                   weights_column=\"weight\")\n",
      " |      >>> predicted = ecology_drf.predict(train)\n",
      " |  \n",
      " |  categorical_encoding\n",
      " |      Encoding scheme for categorical features\n",
      " |      \n",
      " |      One of: ``\"auto\"``, ``\"enum\"``, ``\"one_hot_internal\"``, ``\"one_hot_explicit\"``, ``\"binary\"``, ``\"eigen\"``,\n",
      " |      ``\"label_encoder\"``, ``\"sort_by_response\"``, ``\"enum_limited\"``  (default: ``\"auto\"``).\n",
      " |      \n",
      " |      :examples:\n",
      " |      \n",
      " |      >>> airlines= h2o.import_file(\"https://s3.amazonaws.com/h2o-public-test-data/smalldata/airlines/allyears2k_headers.zip\") \n",
      " |      >>> airlines[\"Year\"] = airlines[\"Year\"].asfactor()\n",
      " |      >>> airlines[\"Month\"] = airlines[\"Month\"].asfactor()\n",
      " |      >>> airlines[\"DayOfWeek\"] = airlines[\"DayOfWeek\"].asfactor()\n",
      " |      >>> airlines[\"Cancelled\"] = airlines[\"Cancelled\"].asfactor()\n",
      " |      >>> airlines['FlightNum'] = airlines['FlightNum'].asfactor()\n",
      " |      >>> predictors = [\"Origin\", \"Dest\", \"Year\", \"UniqueCarrier\",\n",
      " |      ...               \"DayOfWeek\", \"Month\", \"Distance\", \"FlightNum\"]\n",
      " |      >>> response = \"IsDepDelayed\"\n",
      " |      >>> train, valid= airlines.split_frame(ratios=[.8], seed=1234)\n",
      " |      >>> encoding = \"one_hot_explicit\"\n",
      " |      >>> airlines_drf = H2ORandomForestEstimator(categorical_encoding=encoding,\n",
      " |      ...                                         seed=1234)\n",
      " |      >>> airlines_drf.train(x=predictors,\n",
      " |      ...                    y=response,\n",
      " |      ...                    training_frame=train,\n",
      " |      ...                    validation_frame=valid)\n",
      " |      >>> airlines_drf.auc(valid=True)\n",
      " |  \n",
      " |  check_constant_response\n",
      " |      Check if response column is constant. If enabled, then an exception is thrown if the response column is a\n",
      " |      constant value.If disabled, then model will train regardless of the response column being a constant value or\n",
      " |      not.\n",
      " |      \n",
      " |      Type: ``bool``  (default: ``True``).\n",
      " |      \n",
      " |      :examples:\n",
      " |      \n",
      " |      >>> train = h2o.import_file(\"https://s3.amazonaws.com/h2o-public-test-data/smalldata/iris/iris_train.csv\")\n",
      " |      >>> train[\"constantCol\"] = 1\n",
      " |      >>> my_drf = H2ORandomForestEstimator(check_constant_response=False)\n",
      " |      >>> my_drf.train(x=list(range(1,5)),\n",
      " |      ...              y=\"constantCol\",\n",
      " |      ...              training_frame=train)\n",
      " |  \n",
      " |  checkpoint\n",
      " |      Model checkpoint to resume training with.\n",
      " |      \n",
      " |      Type: ``str``.\n",
      " |      \n",
      " |      :examples:\n",
      " |      \n",
      " |      >>> cars = h2o.import_file(\"https://s3.amazonaws.com/h2o-public-test-data/smalldata/junit/cars_20mpg.csv\")\n",
      " |      >>> cars[\"economy_20mpg\"] = cars[\"economy_20mpg\"].asfactor()\n",
      " |      >>> predictors = [\"displacement\",\"power\",\"weight\",\"acceleration\",\"year\"]\n",
      " |      >>> response = \"economy_20mpg\"\n",
      " |      >>> train, valid = cars.split_frame(ratios=[.8],\n",
      " |      ...                                 seed=1234)\n",
      " |      >>> cars_drf = H2ORandomForestEstimator(ntrees=1,\n",
      " |      ...                                     seed=1234)\n",
      " |      >>> cars_drf.train(x=predictors,\n",
      " |      ...                y=response,\n",
      " |      ...                training_frame=train,\n",
      " |      ...                validation_frame=valid)\n",
      " |      >>> print(cars_drf.auc(valid=True))\n",
      " |  \n",
      " |  class_sampling_factors\n",
      " |      Desired over/under-sampling ratios per class (in lexicographic order). If not specified, sampling factors will\n",
      " |      be automatically computed to obtain class balance during training. Requires balance_classes.\n",
      " |      \n",
      " |      Type: ``List[float]``.\n",
      " |      \n",
      " |      :examples:\n",
      " |      \n",
      " |      >>> covtype = h2o.import_file(\"https://s3.amazonaws.com/h2o-public-test-data/smalldata/covtype/covtype.20k.data\")\n",
      " |      >>> covtype[54] = covtype[54].asfactor()\n",
      " |      >>> predictors = covtype.columns[0:54]\n",
      " |      >>> response = 'C55'\n",
      " |      >>> train, valid = covtype.split_frame(ratios=[.8], seed=1234)\n",
      " |      >>> print(covtype[54].table())\n",
      " |      >>> sample_factors = [1., 0.5, 1., 1., 1., 1., 1.]\n",
      " |      >>> cov_drf = H2ORandomForestEstimator(balance_classes=True,\n",
      " |      ...                                    class_sampling_factors=sample_factors,\n",
      " |      ...                                    seed=1234)\n",
      " |      >>> cov_drf.train(x=predictors,\n",
      " |      ...               y=response,\n",
      " |      ...               training_frame=train,\n",
      " |      ...               validation_frame=valid)\n",
      " |      >>> print('logloss', cov_drf.logloss(valid=True))\n",
      " |  \n",
      " |  col_sample_rate_change_per_level\n",
      " |      Relative change of the column sampling rate for every level (must be > 0.0 and <= 2.0)\n",
      " |      \n",
      " |      Type: ``float``  (default: ``1``).\n",
      " |      \n",
      " |      :examples:\n",
      " |      \n",
      " |      >>> airlines= h2o.import_file(\"https://s3.amazonaws.com/h2o-public-test-data/smalldata/airlines/allyears2k_headers.zip\")\n",
      " |      >>> airlines[\"Year\"] = airlines[\"Year\"].asfactor()\n",
      " |      >>> airlines[\"Month\"] = airlines[\"Month\"].asfactor()\n",
      " |      >>> airlines[\"DayOfWeek\"] = airlines[\"DayOfWeek\"].asfactor()\n",
      " |      >>> airlines[\"Cancelled\"] = airlines[\"Cancelled\"].asfactor()\n",
      " |      >>> airlines['FlightNum'] = airlines['FlightNum'].asfactor()\n",
      " |      >>> predictors = [\"Origin\", \"Dest\", \"Year\", \"UniqueCarrier\",\n",
      " |      ...               \"DayOfWeek\", \"Month\", \"Distance\", \"FlightNum\"]\n",
      " |      >>> response = \"IsDepDelayed\"\n",
      " |      >>> train, valid= airlines.split_frame(ratios=[.8], seed=1234)\n",
      " |      >>> airlines_drf = H2ORandomForestEstimator(col_sample_rate_change_per_level=.9,\n",
      " |      ...                                         seed=1234)\n",
      " |      >>> airlines_drf.train(x=predictors,\n",
      " |      ...                    y=response,\n",
      " |      ...                    training_frame=train,\n",
      " |      ...                    validation_frame=valid)\n",
      " |      >>>  print(airlines_drf.auc(valid=True))\n",
      " |  \n",
      " |  col_sample_rate_per_tree\n",
      " |      Column sample rate per tree (from 0.0 to 1.0)\n",
      " |      \n",
      " |      Type: ``float``  (default: ``1``).\n",
      " |      \n",
      " |      :examples:\n",
      " |      \n",
      " |      >>> airlines= h2o.import_file(\"https://s3.amazonaws.com/h2o-public-test-data/smalldata/airlines/allyears2k_headers.zip\")\n",
      " |      >>> airlines[\"Year\"] = airlines[\"Year\"].asfactor()\n",
      " |      >>> airlines[\"Month\"] = airlines[\"Month\"].asfactor()\n",
      " |      >>> airlines[\"DayOfWeek\"] = airlines[\"DayOfWeek\"].asfactor()\n",
      " |      >>> airlines[\"Cancelled\"] = airlines[\"Cancelled\"].asfactor()\n",
      " |      >>> airlines['FlightNum'] = airlines['FlightNum'].asfactor()\n",
      " |      >>> predictors = [\"Origin\", \"Dest\", \"Year\", \"UniqueCarrier\",\n",
      " |      ...               \"DayOfWeek\", \"Month\", \"Distance\", \"FlightNum\"]\n",
      " |      >>> response = \"IsDepDelayed\"\n",
      " |      >>> train, valid= airlines.split_frame(ratios=[.8], seed=1234)\n",
      " |      >>> airlines_drf = H2ORandomForestEstimator(col_sample_rate_per_tree=.7,\n",
      " |      ...                                         seed=1234)\n",
      " |      >>> airlines_drf.train(x=predictors,\n",
      " |      ...                    y=response,\n",
      " |      ...                    training_frame=train,\n",
      " |      ...                    validation_frame=valid)\n",
      " |      >>> print(airlines_drf.auc(valid=True))\n",
      " |  \n",
      " |  custom_metric_func\n",
      " |      Reference to custom evaluation function, format: `language:keyName=funcName`\n",
      " |      \n",
      " |      Type: ``str``.\n",
      " |  \n",
      " |  distribution\n",
      " |      [Deprecated] Distribution function\n",
      " |      \n",
      " |      One of: ``\"auto\"``, ``\"bernoulli\"``, ``\"multinomial\"``, ``\"gaussian\"``, ``\"poisson\"``, ``\"gamma\"``,\n",
      " |      ``\"tweedie\"``, ``\"laplace\"``, ``\"quantile\"``, ``\"huber\"``  (default: ``\"auto\"``).\n",
      " |      \n",
      " |      :examples:\n",
      " |      \n",
      " |      >>> cars = h2o.import_file(\"https://s3.amazonaws.com/h2o-public-test-data/smalldata/junit/cars_20mpg.csv\")\n",
      " |      >>> predictors = [\"displacement\",\"power\",\"weight\",\"acceleration\",\"year\"]\n",
      " |      >>> response = \"cylinders\"\n",
      " |      >>> train, valid = cars.split_frame(ratios=[.8], seed=1234)\n",
      " |      >>> cars_drf = H2ORandomForestEstimator(distribution=\"poisson\",\n",
      " |      ...                                     seed=1234)\n",
      " |      >>> cars_drf.train(x=predictors,\n",
      " |      ...                y=response,\n",
      " |      ...                training_frame=train,\n",
      " |      ...                validation_frame=valid)\n",
      " |      >>> cars_drf.mse(valid=True)\n",
      " |  \n",
      " |  export_checkpoints_dir\n",
      " |      Automatically export generated models to this directory.\n",
      " |      \n",
      " |      Type: ``str``.\n",
      " |      \n",
      " |      :examples:\n",
      " |      \n",
      " |      >>> import tempfile\n",
      " |      >>> from os import listdir\n",
      " |      >>> from h2o.grid.grid_search import H2OGridSearch\n",
      " |      >>> airlines = h2o.import_file(\"http://s3.amazonaws.com/h2o-public-test-data/smalldata/airlines/allyears2k_headers.zip\", destination_frame=\"air.hex\")\n",
      " |      >>> predictors = [\"DayofMonth\", \"DayOfWeek\"]\n",
      " |      >>> response = \"IsDepDelayed\"\n",
      " |      >>> hyper_parameters = {'ntrees': [5,10]}\n",
      " |      >>> search_crit = {'strategy': \"RandomDiscrete\",\n",
      " |      ...                'max_models': 5,\n",
      " |      ...                'seed': 1234,\n",
      " |      ...                'stopping_rounds': 3,\n",
      " |      ...                'stopping_metric': \"AUTO\",\n",
      " |      ...                'stopping_tolerance': 1e-2}\n",
      " |      >>> checkpoints_dir = tempfile.mkdtemp()\n",
      " |      >>> air_grid = H2OGridSearch(H2ORandomForestEstimator,\n",
      " |      ...                          hyper_params=hyper_parameters,\n",
      " |      ...                          search_criteria=search_crit)\n",
      " |      >>> air_grid.train(x=predictors,\n",
      " |      ...                y=response,\n",
      " |      ...                training_frame=airlines,\n",
      " |      ...                distribution=\"bernoulli\",\n",
      " |      ...                max_depth=3,\n",
      " |      ...                export_checkpoints_dir=checkpoints_dir)\n",
      " |      >>> num_files = len(listdir(checkpoints_dir))\n",
      " |      >>> num_files\n",
      " |  \n",
      " |  fold_assignment\n",
      " |      Cross-validation fold assignment scheme, if fold_column is not specified. The 'Stratified' option will stratify\n",
      " |      the folds based on the response variable, for classification problems.\n",
      " |      \n",
      " |      One of: ``\"auto\"``, ``\"random\"``, ``\"modulo\"``, ``\"stratified\"``  (default: ``\"auto\"``).\n",
      " |      \n",
      " |      :examples:\n",
      " |      \n",
      " |      >>> cars = h2o.import_file(\"https://s3.amazonaws.com/h2o-public-test-data/smalldata/junit/cars_20mpg.csv\")\n",
      " |      >>> cars[\"economy_20mpg\"] = cars[\"economy_20mpg\"].asfactor()\n",
      " |      >>> predictors = [\"displacement\",\"power\",\"weight\",\"acceleration\",\"year\"]\n",
      " |      >>> response = \"economy_20mpg\"\n",
      " |      >>> assignment_type = \"Random\"\n",
      " |      >>> cars_drf = H2ORandomForestEstimator(fold_assignment=assignment_type,\n",
      " |      ...                                     nfolds=5,\n",
      " |      ...                                     seed=1234)\n",
      " |      >>> cars_drf.train(x=predictors,\n",
      " |      ...                y=response,\n",
      " |      ...                training_frame=cars)\n",
      " |      >>> cars_drf.auc(xval=True)\n",
      " |  \n",
      " |  fold_column\n",
      " |      Column with cross-validation fold index assignment per observation.\n",
      " |      \n",
      " |      Type: ``str``.\n",
      " |      \n",
      " |      :examples:\n",
      " |      \n",
      " |      >>> cars = h2o.import_file(\"https://s3.amazonaws.com/h2o-public-test-data/smalldata/junit/cars_20mpg.csv\")\n",
      " |      >>> cars[\"economy_20mpg\"] = cars[\"economy_20mpg\"].asfactor()\n",
      " |      >>> predictors = [\"displacement\",\"power\",\"weight\",\"acceleration\",\"year\"]\n",
      " |      >>> response = \"economy_20mpg\"\n",
      " |      >>> fold_numbers = cars.kfold_column(n_folds=5, seed=1234)\n",
      " |      >>> fold_numbers.set_names([\"fold_numbers\"])\n",
      " |      >>> cars = cars.cbind(fold_numbers)\n",
      " |      >>> print(cars['fold_numbers'])\n",
      " |      >>> cars_drf = H2ORandomForestEstimator(seed=1234)\n",
      " |      >>> cars_drf.train(x=predictors,\n",
      " |      ...                y=response,\n",
      " |      ...                training_frame=cars,\n",
      " |      ...                fold_column=\"fold_numbers\")\n",
      " |      >>> cars_drf.auc(xval=True)\n",
      " |  \n",
      " |  histogram_type\n",
      " |      What type of histogram to use for finding optimal split points\n",
      " |      \n",
      " |      One of: ``\"auto\"``, ``\"uniform_adaptive\"``, ``\"random\"``, ``\"quantiles_global\"``, ``\"round_robin\"``  (default:\n",
      " |      ``\"auto\"``).\n",
      " |      \n",
      " |      :examples:\n",
      " |      \n",
      " |      >>> airlines= h2o.import_file(\"https://s3.amazonaws.com/h2o-public-test-data/smalldata/airlines/allyears2k_headers.zip\")\n",
      " |      >>> airlines[\"Year\"] = airlines[\"Year\"].asfactor()\n",
      " |      >>> airlines[\"Month\"] = airlines[\"Month\"].asfactor()\n",
      " |      >>> airlines[\"DayOfWeek\"] = airlines[\"DayOfWeek\"].asfactor()\n",
      " |      >>> airlines[\"Cancelled\"] = airlines[\"Cancelled\"].asfactor()\n",
      " |      >>> airlines['FlightNum'] = airlines['FlightNum'].asfactor()\n",
      " |      >>> predictors = [\"Origin\", \"Dest\", \"Year\", \"UniqueCarrier\",\n",
      " |      ...               \"DayOfWeek\", \"Month\", \"Distance\", \"FlightNum\"]\n",
      " |      >>> response = \"IsDepDelayed\"\n",
      " |      >>> train, valid= airlines.split_frame(ratios=[.8], seed=1234)\n",
      " |      >>> airlines_drf = H2ORandomForestEstimator(histogram_type=\"UniformAdaptive\",\n",
      " |      ...                                         seed=1234)\n",
      " |      >>> airlines_drf.train(x=predictors,\n",
      " |      ...                    y=response,\n",
      " |      ...                    training_frame=train,\n",
      " |      ...                    validation_frame=valid)\n",
      " |      >>> print(airlines_drf.auc(valid=True))\n",
      " |  \n",
      " |  ignore_const_cols\n",
      " |      Ignore constant columns.\n",
      " |      \n",
      " |      Type: ``bool``  (default: ``True``).\n",
      " |      \n",
      " |      :examples:\n",
      " |      \n",
      " |      >>> cars = h2o.import_file(\"https://s3.amazonaws.com/h2o-public-test-data/smalldata/junit/cars_20mpg.csv\")\n",
      " |      >>> cars[\"economy_20mpg\"] = cars[\"economy_20mpg\"].asfactor()\n",
      " |      >>> predictors = [\"displacement\",\"power\",\"weight\",\"acceleration\",\"year\"]\n",
      " |      >>> response = \"economy_20mpg\"\n",
      " |      >>> cars[\"const_1\"] = 6\n",
      " |      >>> cars[\"const_2\"] = 7\n",
      " |      >>> train, valid = cars.split_frame(ratios=[.8], seed=1234)\n",
      " |      >>> cars_drf = H2ORandomForestEstimator(seed=1234,\n",
      " |      ...                                     ignore_const_cols=True)\n",
      " |      >>> cars_drf.train(x=predictors,\n",
      " |      ...                y=response,\n",
      " |      ...                training_frame=train,\n",
      " |      ...                validation_frame=valid)\n",
      " |      >>> cars_drf.auc(valid=True)\n",
      " |  \n",
      " |  ignored_columns\n",
      " |      Names of columns to ignore for training.\n",
      " |      \n",
      " |      Type: ``List[str]``.\n",
      " |  \n",
      " |  keep_cross_validation_fold_assignment\n",
      " |      Whether to keep the cross-validation fold assignment.\n",
      " |      \n",
      " |      Type: ``bool``  (default: ``False``).\n",
      " |      \n",
      " |      :examples:\n",
      " |      \n",
      " |      >>> cars = h2o.import_file(\"https://s3.amazonaws.com/h2o-public-test-data/smalldata/junit/cars_20mpg.csv\")\n",
      " |      >>> cars[\"economy_20mpg\"] = cars[\"economy_20mpg\"].asfactor()\n",
      " |      >>> predictors = [\"displacement\",\"power\",\"weight\",\"acceleration\",\"year\"]\n",
      " |      >>> response = \"economy_20mpg\"\n",
      " |      >>> train, valid = cars.split_frame(ratios=[.8], seed=1234)\n",
      " |      >>> cars_drf = H2ORandomForestEstimator(keep_cross_validation_fold_assignment=True,\n",
      " |      ...                                     nfolds=5,\n",
      " |      ...                                     seed=1234)\n",
      " |      >>> cars_drf.train(x=predictors,\n",
      " |      ...                y=response,\n",
      " |      ...                training_frame=train)\n",
      " |      >>> cars_drf.cross_validation_fold_assignment()\n",
      " |  \n",
      " |  keep_cross_validation_models\n",
      " |      Whether to keep the cross-validation models.\n",
      " |      \n",
      " |      Type: ``bool``  (default: ``True``).\n",
      " |      \n",
      " |      :examples:\n",
      " |      \n",
      " |      >>> cars = h2o.import_file(\"https://s3.amazonaws.com/h2o-public-test-data/smalldata/junit/cars_20mpg.csv\")\n",
      " |      >>> cars[\"economy_20mpg\"] = cars[\"economy_20mpg\"].asfactor()\n",
      " |      >>> predictors = [\"displacement\",\"power\",\"weight\",\"acceleration\",\"year\"]\n",
      " |      >>> response = \"economy_20mpg\"\n",
      " |      >>> train, valid = cars.split_frame(ratios=[.8], seed=1234)\n",
      " |      >>> cars_drf = H2ORandomForestEstimator(keep_cross_validation_models=True,\n",
      " |      ...                                     nfolds=5,\n",
      " |      ...                                     seed=1234)\n",
      " |      >>> cars_drf.train(x=predictors,\n",
      " |      ...                y=response,\n",
      " |      ...                training_frame=train)\n",
      " |      >>> cars_drf.auc()\n",
      " |  \n",
      " |  keep_cross_validation_predictions\n",
      " |      Whether to keep the predictions of the cross-validation models.\n",
      " |      \n",
      " |      Type: ``bool``  (default: ``False``).\n",
      " |      \n",
      " |      :examples:\n",
      " |      \n",
      " |      >>> cars = h2o.import_file(\"https://s3.amazonaws.com/h2o-public-test-data/smalldata/junit/cars_20mpg.csv\")\n",
      " |      >>> cars[\"economy_20mpg\"] = cars[\"economy_20mpg\"].asfactor()\n",
      " |      >>> predictors = [\"displacement\",\"power\",\"weight\",\"acceleration\",\"year\"]\n",
      " |      >>> response = \"economy_20mpg\"\n",
      " |      >>> train, valid = cars.split_frame(ratios=[.8], seed=1234)\n",
      " |      >>> cars_drf = H2ORandomForestEstimator(keep_cross_validation_predictions=True,\n",
      " |      ...                                     nfolds=5,\n",
      " |      ...                                     seed=1234)\n",
      " |      >>> cars_drf.train(x=predictors,\n",
      " |      ...                y=response,\n",
      " |      ...                training_frame=train)\n",
      " |      >>> cars_drf.cross_validation_predictions()\n",
      " |  \n",
      " |  max_after_balance_size\n",
      " |      Maximum relative size of the training data after balancing class counts (can be less than 1.0). Requires\n",
      " |      balance_classes.\n",
      " |      \n",
      " |      Type: ``float``  (default: ``5``).\n",
      " |      \n",
      " |      :examples:\n",
      " |      \n",
      " |      >>> covtype = h2o.import_file(\"https://s3.amazonaws.com/h2o-public-test-data/smalldata/covtype/covtype.20k.data\")\n",
      " |      >>> covtype[54] = covtype[54].asfactor()\n",
      " |      >>> predictors = covtype.columns[0:54]\n",
      " |      >>> response = 'C55'\n",
      " |      >>> train, valid = covtype.split_frame(ratios=[.8], seed=1234)\n",
      " |      >>> print(covtype[54].table())\n",
      " |      >>> max = .85\n",
      " |      >>> cov_drf = H2ORandomForestEstimator(balance_classes=True,\n",
      " |      ...                                    max_after_balance_size=max,\n",
      " |      ...                                    seed=1234)\n",
      " |      >>> cov_drf.train(x=predictors,\n",
      " |      ...               y=response,\n",
      " |      ...               training_frame=train,\n",
      " |      ...               validation_frame=valid)\n",
      " |      >>> print('logloss', cov_drf.logloss(valid=True))\n",
      " |  \n",
      " |  max_confusion_matrix_size\n",
      " |      [Deprecated] Maximum size (# classes) for confusion matrices to be printed in the Logs\n",
      " |      \n",
      " |      Type: ``int``  (default: ``20``).\n",
      " |  \n",
      " |  max_depth\n",
      " |      Maximum tree depth.\n",
      " |      \n",
      " |      Type: ``int``  (default: ``20``).\n",
      " |      \n",
      " |      :examples:\n",
      " |      \n",
      " |      >>> df = h2o.import_file(path = \"http://s3.amazonaws.com/h2o-public-test-data/smalldata/gbm_test/titanic.csv\")\n",
      " |      >>> response = \"survived\"\n",
      " |      >>> df[response] = df[response].asfactor()\n",
      " |      >>> predictors = df.columns\n",
      " |      >>> del predictors[1:3]\n",
      " |      >>> train, valid, test = df.split_frame(ratios=[0.6,0.2],\n",
      " |      ...                                     seed=1234,\n",
      " |      ...                                     destination_frames=\n",
      " |      ...                                     ['train.hex','valid.hex','test.hex'])\n",
      " |      >>> drf = H2ORandomForestEstimator()\n",
      " |      >>> drf.train(x=predictors,\n",
      " |      ...           y=response,\n",
      " |      ...           training_frame=train)\n",
      " |      >>> perf = drf.model_performance(valid)\n",
      " |      >>> print perf.auc()\n",
      " |  \n",
      " |  max_hit_ratio_k\n",
      " |      Max. number (top K) of predictions to use for hit ratio computation (for multi-class only, 0 to disable)\n",
      " |      \n",
      " |      Type: ``int``  (default: ``0``).\n",
      " |      \n",
      " |      :examples:\n",
      " |      \n",
      " |      >>> covtype = h2o.import_file(\"https://s3.amazonaws.com/h2o-public-test-data/smalldata/covtype/covtype.20k.data\")\n",
      " |      >>> covtype[54] = covtype[54].asfactor()\n",
      " |      >>> predictors = covtype.columns[0:54]\n",
      " |      >>> response = 'C55'\n",
      " |      >>> train, valid = covtype.split_frame(ratios=[.8], seed=1234)\n",
      " |      >>> cov_drf = H2ORandomForestEstimator(max_hit_ratio_k=3,\n",
      " |      ...                                    seed=1234)\n",
      " |      >>> cov_drf.train(x=predictors,\n",
      " |      ...               y=response,\n",
      " |      ...               training_frame=train,\n",
      " |      ...               validation_frame=valid)\n",
      " |      >>> cov_drf.show()\n",
      " |  \n",
      " |  max_runtime_secs\n",
      " |      Maximum allowed runtime in seconds for model training. Use 0 to disable.\n",
      " |      \n",
      " |      Type: ``float``  (default: ``0``).\n",
      " |      \n",
      " |      :examples:\n",
      " |      \n",
      " |      >>> cars = h2o.import_file(\"https://s3.amazonaws.com/h2o-public-test-data/smalldata/junit/cars_20mpg.csv\")\n",
      " |      >>> cars[\"economy_20mpg\"] = cars[\"economy_20mpg\"].asfactor()\n",
      " |      >>> predictors = [\"displacement\",\"power\",\"weight\",\"acceleration\",\"year\"]\n",
      " |      >>> response = \"economy_20mpg\"\n",
      " |      >>> train, valid = cars.split_frame(ratios=[.8], seed=1234)\n",
      " |      >>> cars_drf = H2ORandomForestEstimator(max_runtime_secs=10,\n",
      " |      ...                                     ntrees=10000,\n",
      " |      ...                                     max_depth=10,\n",
      " |      ...                                     seed=1234)\n",
      " |      >>> cars_drf.train(x=predictors,\n",
      " |      ...                y=response,\n",
      " |      ...                training_frame=train,\n",
      " |      ...                validation_frame=valid)\n",
      " |      >>> cars_drf.auc(valid = True)\n",
      " |  \n",
      " |  min_rows\n",
      " |      Fewest allowed (weighted) observations in a leaf.\n",
      " |      \n",
      " |      Type: ``float``  (default: ``1``).\n",
      " |      \n",
      " |      :examples:\n",
      " |      \n",
      " |      >>> cars = h2o.import_file(\"https://s3.amazonaws.com/h2o-public-test-data/smalldata/junit/cars_20mpg.csv\")\n",
      " |      >>> cars[\"economy_20mpg\"] = cars[\"economy_20mpg\"].asfactor()\n",
      " |      >>> predictors = [\"displacement\",\"power\",\"weight\",\"acceleration\",\"year\"]\n",
      " |      >>> response = \"economy_20mpg\"\n",
      " |      >>> train, valid = cars.split_frame(ratios=[.8], seed=1234)\n",
      " |      >>> cars_drf = H2ORandomForestEstimator(min_rows=16,\n",
      " |      ...                                     seed=1234)\n",
      " |      >>> cars_drf.train(x=predictors,\n",
      " |      ...                y=response,\n",
      " |      ...                training_frame=train,\n",
      " |      ...                validation_frame=valid)\n",
      " |      >>> print(cars_drf.auc(valid=True))\n",
      " |  \n",
      " |  min_split_improvement\n",
      " |      Minimum relative improvement in squared error reduction for a split to happen\n",
      " |      \n",
      " |      Type: ``float``  (default: ``1e-05``).\n",
      " |      \n",
      " |      :examples:\n",
      " |      \n",
      " |      >>> cars = h2o.import_file(\"https://s3.amazonaws.com/h2o-public-test-data/smalldata/junit/cars_20mpg.csv\")\n",
      " |      >>> cars[\"economy_20mpg\"] = cars[\"economy_20mpg\"].asfactor()\n",
      " |      >>> predictors = [\"displacement\",\"power\",\"weight\",\"acceleration\",\"year\"]\n",
      " |      >>> response = \"economy_20mpg\"\n",
      " |      >>> train, valid = cars.split_frame(ratios=[.8], seed=1234)\n",
      " |      >>> cars_drf = H2ORandomForestEstimator(min_split_improvement=1e-3,\n",
      " |      ...                                     seed=1234)\n",
      " |      >>> cars_drf.train(x=predictors,\n",
      " |      ...                y=response,\n",
      " |      ...                training_frame=train,\n",
      " |      ...                validation_frame=valid)\n",
      " |      >>> print(cars_drf.auc(valid=True))\n",
      " |  \n",
      " |  mtries\n",
      " |      Number of variables randomly sampled as candidates at each split. If set to -1, defaults to sqrt{p} for\n",
      " |      classification and p/3 for regression (where p is the # of predictors\n",
      " |      \n",
      " |      Type: ``int``  (default: ``-1``).\n",
      " |      \n",
      " |      :examples:\n",
      " |      \n",
      " |      >>> covtype = h2o.import_file(\"https://s3.amazonaws.com/h2o-public-test-data/smalldata/covtype/covtype.20k.data\")\n",
      " |      >>> covtype[54] = covtype[54].asfactor()\n",
      " |      >>> predictors = covtype.columns[0:54]\n",
      " |      >>> response = 'C55'\n",
      " |      >>> train, valid = covtype.split_frame(ratios=[.8], seed=1234)\n",
      " |      >>> cov_drf = H2ORandomForestEstimator(mtries=30, seed=1234)\n",
      " |      >>> cov_drf.train(x=predictors,\n",
      " |      ...               y=response,\n",
      " |      ...               training_frame=train,\n",
      " |      ...               validation_frame=valid)\n",
      " |      >>> print('logloss', cov_drf.logloss(valid=True))\n",
      " |  \n",
      " |  nbins\n",
      " |      For numerical columns (real/int), build a histogram of (at least) this many bins, then split at the best point\n",
      " |      \n",
      " |      Type: ``int``  (default: ``20``).\n",
      " |      \n",
      " |      :examples:\n",
      " |      \n",
      " |      >>> eeg = h2o.import_file(\"https://h2o-public-test-data.s3.amazonaws.com/smalldata/eeg/eeg_eyestate.csv\")\n",
      " |      >>> eeg['eyeDetection'] = eeg['eyeDetection'].asfactor()\n",
      " |      >>> predictors = eeg.columns[:-1]\n",
      " |      >>> response = 'eyeDetection'\n",
      " |      >>> train, valid = eeg.split_frame(ratios=[.8], seed=1234)\n",
      " |      >>> bin_num = [16, 32, 64, 128, 256, 512]\n",
      " |      >>> label = [\"16\", \"32\", \"64\", \"128\", \"256\", \"512\"]\n",
      " |      >>> for key, num in enumerate(bin_num):\n",
      " |      #              Insert integer for 'num' and 'key'\n",
      " |      >>> eeg_drf = H2ORandomForestEstimator(nbins=num, seed=1234)\n",
      " |      >>> eeg_drf.train(x=predictors,\n",
      " |      ...               y=response,\n",
      " |      ...               training_frame=train,\n",
      " |      ...               validation_frame=valid)\n",
      " |      >>> print(label[key], 'training score',\n",
      " |      ...       eeg_drf.auc(train=True))\n",
      " |      >>> print(label[key], 'validation score',\n",
      " |      ...       eeg_drf.auc(train=True))\n",
      " |  \n",
      " |  nbins_cats\n",
      " |      For categorical columns (factors), build a histogram of this many bins, then split at the best point. Higher\n",
      " |      values can lead to more overfitting.\n",
      " |      \n",
      " |      Type: ``int``  (default: ``1024``).\n",
      " |      \n",
      " |      :examples:\n",
      " |      \n",
      " |      >>> airlines= h2o.import_file(\"https://s3.amazonaws.com/h2o-public-test-data/smalldata/airlines/allyears2k_headers.zip\")\n",
      " |      >>> airlines[\"Year\"] = airlines[\"Year\"].asfactor()\n",
      " |      >>> airlines[\"Month\"] = airlines[\"Month\"].asfactor()\n",
      " |      >>> airlines[\"DayOfWeek\"] = airlines[\"DayOfWeek\"].asfactor()\n",
      " |      >>> airlines[\"Cancelled\"] = airlines[\"Cancelled\"].asfactor()\n",
      " |      >>> airlines['FlightNum'] = airlines['FlightNum'].asfactor()\n",
      " |      >>> predictors = [\"Origin\", \"Dest\", \"Year\", \"UniqueCarrier\",\n",
      " |      ...               \"DayOfWeek\", \"Month\", \"Distance\", \"FlightNum\"]\n",
      " |      >>> response = \"IsDepDelayed\"\n",
      " |      >>> train, valid= airlines.split_frame(ratios=[.8], seed=1234)\n",
      " |      >>> bin_num = [8, 16, 32, 64, 128, 256,\n",
      " |      ...            512, 1024, 2048, 4096]\n",
      " |      >>> label = [\"8\", \"16\", \"32\", \"64\", \"128\",\n",
      " |      ...          \"256\", \"512\", \"1024\", \"2048\", \"4096\"]\n",
      " |      >>> for key, num in enumerate(bin_num):\n",
      " |      #              Insert integer for 'num' and 'key'\n",
      " |      >>> airlines_drf = H2ORandomForestEstimator(nbins_cats=num,\n",
      " |      ...                                         seed=1234)\n",
      " |      >>> airlines_drf.train(x=predictors,\n",
      " |      ...                    y=response,\n",
      " |      ...                    training_frame=train,\n",
      " |      ...                    validation_frame=valid)\n",
      " |      >>> print(label[key], 'training score',\n",
      " |      ...       airlines_gbm.auc(train=True))\n",
      " |      >>> print(label[key], 'validation score',\n",
      " |      ...       airlines_gbm.auc(valid=True))\n",
      " |  \n",
      " |  nbins_top_level\n",
      " |      For numerical columns (real/int), build a histogram of (at most) this many bins at the root level, then decrease\n",
      " |      by factor of two per level\n",
      " |      \n",
      " |      Type: ``int``  (default: ``1024``).\n",
      " |      \n",
      " |      :examples:\n",
      " |      \n",
      " |      >>> eeg = h2o.import_file(\"https://h2o-public-test-data.s3.amazonaws.com/smalldata/eeg/eeg_eyestate.csv\")\n",
      " |      >>> eeg['eyeDetection'] = eeg['eyeDetection'].asfactor()\n",
      " |      >>> predictors = eeg.columns[:-1]\n",
      " |      >>> response = 'eyeDetection'\n",
      " |      >>> train, valid = eeg.split_frame(ratios=[.8],\n",
      " |      ...                                seed=1234)\n",
      " |      >>> bin_num = [32, 64, 128, 256, 512,\n",
      " |      ...            1024, 2048, 4096]\n",
      " |      >>> label = [\"32\", \"64\", \"128\", \"256\",\n",
      " |      ...          \"512\", \"1024\", \"2048\", \"4096\"]\n",
      " |      >>> for key, num in enumerate(bin_num):\n",
      " |      #              Insert integer for 'num' and 'key'\n",
      " |      >>> eeg_drf = H2ORandomForestEstimator(nbins_top_level=32,\n",
      " |      ...                                    seed=1234)\n",
      " |      >>> eeg_drf.train(x=predictors,\n",
      " |      ...               y=response,\n",
      " |      ...               training_frame=train,\n",
      " |      ...               validation_frame=valid)\n",
      " |      >>> print(label[key], 'training score',\n",
      " |      ...       eeg_gbm.auc(train=True))\n",
      " |      >>> print(label[key], 'validation score',\n",
      " |      ...       eeg_gbm.auc(valid=True))\n",
      " |  \n",
      " |  nfolds\n",
      " |      Number of folds for K-fold cross-validation (0 to disable or >= 2).\n",
      " |      \n",
      " |      Type: ``int``  (default: ``0``).\n",
      " |      \n",
      " |      :examples:\n",
      " |      \n",
      " |      >>> cars = h2o.import_file(\"https://s3.amazonaws.com/h2o-public-test-data/smalldata/junit/cars_20mpg.csv\")\n",
      " |      >>> cars[\"economy_20mpg\"] = cars[\"economy_20mpg\"].asfactor()\n",
      " |      >>> predictors = [\"displacement\",\"power\",\"weight\",\"acceleration\",\"year\"]\n",
      " |      >>> response = \"economy_20mpg\"\n",
      " |      >>> folds = 5\n",
      " |      >>> cars_drf = H2ORandomForestEstimator(nfolds=folds,\n",
      " |      ...                                     seed=1234)\n",
      " |      >>> cars_drf.train(x=predictors,\n",
      " |      ...                y=response,\n",
      " |      ...                training_frame=cars)\n",
      " |      >>> cars_drf.auc(xval=True)\n",
      " |  \n",
      " |  ntrees\n",
      " |      Number of trees.\n",
      " |      \n",
      " |      Type: ``int``  (default: ``50``).\n",
      " |      \n",
      " |      :examples:\n",
      " |      \n",
      " |      >>> titanic = h2o.import_file(\"https://s3.amazonaws.com/h2o-public-test-data/smalldata/gbm_test/titanic.csv\")\n",
      " |      >>> titanic['survived'] = titanic['survived'].asfactor()\n",
      " |      >>> predictors = titanic.columns\n",
      " |      >>> del predictors[1:3]\n",
      " |      >>> response = 'survived'\n",
      " |      >>> train, valid = titanic.split_frame(ratios=[.8],\n",
      " |      ...                                    seed=1234)\n",
      " |      >>> tree_num = [20, 50, 80, 110,\n",
      " |      ...             140, 170, 200]\n",
      " |      >>> label = [\"20\", \"50\", \"80\", \"110\",\n",
      " |      ...          \"140\", \"170\", \"200\"]\n",
      " |      >>> for key, num in enumerate(tree_num):\n",
      " |      #              Input an integer for 'num' and 'key'\n",
      " |      >>> titanic_drf = H2ORandomForestEstimator(ntrees=num,\n",
      " |      ...                                        seed=1234)\n",
      " |      >>> titanic_drf.train(x=predictors,\n",
      " |      ...                   y=response,\n",
      " |      ...                   training_frame=train,\n",
      " |      ...                   validation_frame=valid)\n",
      " |      >>> print(label[key], 'training score',\n",
      " |      ...       titanic_drf.auc(train=True))\n",
      " |      >>> print(label[key], 'validation score',\n",
      " |      ...       titanic_drf.auc(valid=True))\n",
      " |  \n",
      " |  offset_column\n",
      " |      [Deprecated] Offset column. This will be added to the combination of columns before applying the link function.\n",
      " |      \n",
      " |      Type: ``str``.\n",
      " |  \n",
      " |  r2_stopping\n",
      " |      r2_stopping is no longer supported and will be ignored if set - please use stopping_rounds, stopping_metric and\n",
      " |      stopping_tolerance instead. Previous version of H2O would stop making trees when the R^2 metric equals or\n",
      " |      exceeds this\n",
      " |      \n",
      " |      Type: ``float``  (default: ``1.797693135e+308``).\n",
      " |  \n",
      " |  response_column\n",
      " |      Response variable column.\n",
      " |      \n",
      " |      Type: ``str``.\n",
      " |  \n",
      " |  sample_rate\n",
      " |      Row sample rate per tree (from 0.0 to 1.0)\n",
      " |      \n",
      " |      Type: ``float``  (default: ``0.632``).\n",
      " |      \n",
      " |      :examples:\n",
      " |      \n",
      " |      >>> airlines= h2o.import_file(\"https://s3.amazonaws.com/h2o-public-test-data/smalldata/airlines/allyears2k_headers.zip\")\n",
      " |      >>> airlines[\"Year\"] = airlines[\"Year\"].asfactor()\n",
      " |      >>> airlines[\"Month\"] = airlines[\"Month\"].asfactor()\n",
      " |      >>> airlines[\"DayOfWeek\"] = airlines[\"DayOfWeek\"].asfactor()\n",
      " |      >>> airlines[\"Cancelled\"] = airlines[\"Cancelled\"].asfactor()\n",
      " |      >>> airlines['FlightNum'] = airlines['FlightNum'].asfactor()\n",
      " |      >>> predictors = [\"Origin\", \"Dest\", \"Year\", \"UniqueCarrier\",\n",
      " |      ...               \"DayOfWeek\", \"Month\", \"Distance\", \"FlightNum\"]\n",
      " |      >>> response = \"IsDepDelayed\"\n",
      " |      >>> train, valid= airlines.split_frame(ratios=[.8],\n",
      " |      ...                                    seed=1234)\n",
      " |      >>> airlines_drf = H2ORandomForestEstimator(sample_rate=.7,\n",
      " |      ...                                         seed=1234)\n",
      " |      >>> airlines_drf.train(x=predictors,\n",
      " |      ...                    y=response,\n",
      " |      ...                    training_frame=train,\n",
      " |      ...                    validation_frame=valid)\n",
      " |      >>> print(airlines_drf.auc(valid=True))\n",
      " |  \n",
      " |  sample_rate_per_class\n",
      " |      A list of row sample rates per class (relative fraction for each class, from 0.0 to 1.0), for each tree\n",
      " |      \n",
      " |      Type: ``List[float]``.\n",
      " |      \n",
      " |      :examples:\n",
      " |      \n",
      " |      >>> covtype = h2o.import_file(\"https://s3.amazonaws.com/h2o-public-test-data/smalldata/covtype/covtype.20k.data\")\n",
      " |      >>> covtype[54] = covtype[54].asfactor()\n",
      " |      >>> predictors = covtype.columns[0:54]\n",
      " |      >>> response = 'C55'\n",
      " |      >>> train, valid = covtype.split_frame(ratios=[.8],\n",
      " |      ...                                    seed=1234)\n",
      " |      >>> print(train[response].table())\n",
      " |      >>> rate_per_class_list = [1, .4, 1, 1, 1, 1, 1]\n",
      " |      >>> cov_drf = H2ORandomForestEstimator(sample_rate_per_class=rate_per_class_list,\n",
      " |      ...                                    seed=1234)\n",
      " |      >>> cov_drf.train(x=predictors,\n",
      " |      ...               y=response,\n",
      " |      ...               training_frame=train,\n",
      " |      ...               validation_frame=valid)\n",
      " |      >>> print('logloss', cov_drf.logloss(valid=True))\n",
      " |  \n",
      " |  score_each_iteration\n",
      " |      Whether to score during each iteration of model training.\n",
      " |      \n",
      " |      Type: ``bool``  (default: ``False``).\n",
      " |      \n",
      " |      :examples:\n",
      " |      \n",
      " |      >>> cars = h2o.import_file(\"https://s3.amazonaws.com/h2o-public-test-data/smalldata/junit/cars_20mpg.csv\")\n",
      " |      >>> cars[\"economy_20mpg\"] = cars[\"economy_20mpg\"].asfactor()\n",
      " |      >>> predictors = [\"displacement\",\"power\",\"weight\",\"acceleration\",\"year\"]\n",
      " |      >>> response = \"economy_20mpg\n",
      " |      >>> train, valid = cars.split_frame(ratios=[.8], seed=1234)\n",
      " |      >>> cars_drf = H2ORandomForestEstimator(score_each_iteration=True,\n",
      " |      ...                                     ntrees=55,\n",
      " |      ...                                     seed=1234)\n",
      " |      >>> cars_drf.train(x=predictors,\n",
      " |      ...                y=response,\n",
      " |      ...                training_frame=train,\n",
      " |      ...                validation_frame = valid)\n",
      " |      >>> cars_drf.scoring_history()\n",
      " |  \n",
      " |  score_tree_interval\n",
      " |      Score the model after every so many trees. Disabled if set to 0.\n",
      " |      \n",
      " |      Type: ``int``  (default: ``0``).\n",
      " |      \n",
      " |      :examples:\n",
      " |      \n",
      " |      >>> cars = h2o.import_file(\"https://s3.amazonaws.com/h2o-public-test-data/smalldata/junit/cars_20mpg.csv\")\n",
      " |      >>> cars[\"economy_20mpg\"] = cars[\"economy_20mpg\"].asfactor()\n",
      " |      >>> predictors = [\"displacement\",\"power\",\"weight\",\"acceleration\",\"year\"]\n",
      " |      >>> response = \"economy_20mpg\"\n",
      " |      >>> train, valid = cars.split_frame(ratios=[.8], seed=1234)\n",
      " |      >>> cars_drf = H2ORandomForestEstimator(score_tree_interval=5,\n",
      " |      ...                                     seed=1234)\n",
      " |      >>> cars_drf.train(x=predictors,\n",
      " |      ...                y=response,\n",
      " |      ...                training_frame=train,\n",
      " |      ...                validation_frame=valid)\n",
      " |      >>> cars_drf.scoring_history()\n",
      " |  \n",
      " |  seed\n",
      " |      Seed for pseudo random number generator (if applicable)\n",
      " |      \n",
      " |      Type: ``int``  (default: ``-1``).\n",
      " |      \n",
      " |      :examples:\n",
      " |      \n",
      " |      >>> airlines= h2o.import_file(\"https://s3.amazonaws.com/h2o-public-test-data/smalldata/airlines/allyears2k_headers.zip\")\n",
      " |      >>> airlines[\"Year\"] = airlines[\"Year\"].asfactor()\n",
      " |      >>> airlines[\"Month\"] = airlines[\"Month\"].asfactor()\n",
      " |      >>> airlines[\"DayOfWeek\"] = airlines[\"DayOfWeek\"].asfactor()\n",
      " |      >>> airlines[\"Cancelled\"] = airlines[\"Cancelled\"].asfactor()\n",
      " |      >>> airlines['FlightNum'] = airlines['FlightNum'].asfactor()\n",
      " |      >>> predictors = [\"Origin\", \"Dest\", \"Year\", \"UniqueCarrier\",\n",
      " |      ...               \"DayOfWeek\", \"Month\", \"Distance\", \"FlightNum\"]\n",
      " |      >>> response = \"IsDepDelayed\"\n",
      " |      >>> train, valid= airlines.split_frame(ratios=[.8], seed=1234)\n",
      " |      >>> drf_w_seed_1 = H2ORandomForestEstimator(seed=1234)\n",
      " |      >>> drf_w_seed_1.train(x=predictors,\n",
      " |      ...                    y=response,\n",
      " |      ...                    training_frame=train,\n",
      " |      ...                    validation_frame=valid)\n",
      " |      >>> print('auc for the 1st model build with a seed:',\n",
      " |      ...        drf_w_seed_1.auc(valid=True))\n",
      " |  \n",
      " |  stopping_metric\n",
      " |      Metric to use for early stopping (AUTO: logloss for classification, deviance for regression and anonomaly_score\n",
      " |      for Isolation Forest). Note that custom and custom_increasing can only be used in GBM and DRF with the Python\n",
      " |      client.\n",
      " |      \n",
      " |      One of: ``\"auto\"``, ``\"deviance\"``, ``\"logloss\"``, ``\"mse\"``, ``\"rmse\"``, ``\"mae\"``, ``\"rmsle\"``, ``\"auc\"``,\n",
      " |      ``\"aucpr\"``, ``\"lift_top_group\"``, ``\"misclassification\"``, ``\"mean_per_class_error\"``, ``\"custom\"``,\n",
      " |      ``\"custom_increasing\"``  (default: ``\"auto\"``).\n",
      " |      \n",
      " |      :examples:\n",
      " |      \n",
      " |      >>> airlines= h2o.import_file(\"https://s3.amazonaws.com/h2o-public-test-data/smalldata/airlines/allyears2k_headers.zip\")\n",
      " |      >>> airlines[\"Year\"] = airlines[\"Year\"].asfactor()\n",
      " |      >>> airlines[\"Month\"] = airlines[\"Month\"].asfactor()\n",
      " |      >>> airlines[\"DayOfWeek\"] = airlines[\"DayOfWeek\"].asfactor()\n",
      " |      >>> airlines[\"Cancelled\"] = airlines[\"Cancelled\"].asfactor()\n",
      " |      >>> airlines['FlightNum'] = airlines['FlightNum'].asfactor()\n",
      " |      >>> predictors = [\"Origin\", \"Dest\", \"Year\", \"UniqueCarrier\",\n",
      " |      ...               \"DayOfWeek\", \"Month\", \"Distance\", \"FlightNum\"]\n",
      " |      >>> response = \"IsDepDelayed\"\n",
      " |      >>> train, valid= airlines.split_frame(ratios=[.8],\n",
      " |      ...                                    seed=1234)\n",
      " |      >>> airlines_drf = H2ORandomForestEstimator(stopping_metric=\"auc\",\n",
      " |      ...                                         stopping_rounds=3,\n",
      " |      ...                                         stopping_tolerance=1e-2,\n",
      " |      ...                                         seed=1234)\n",
      " |      >>> airlines_drf.train(x=predictors,\n",
      " |      ...                    y=response,\n",
      " |      ...                    training_frame=train,\n",
      " |      ...                    validation_frame=valid)\n",
      " |      >>> airlines_drf.auc(valid=True)\n",
      " |  \n",
      " |  stopping_rounds\n",
      " |      Early stopping based on convergence of stopping_metric. Stop if simple moving average of length k of the\n",
      " |      stopping_metric does not improve for k:=stopping_rounds scoring events (0 to disable)\n",
      " |      \n",
      " |      Type: ``int``  (default: ``0``).\n",
      " |      \n",
      " |      :examples:\n",
      " |      \n",
      " |      >>> airlines= h2o.import_file(\"https://s3.amazonaws.com/h2o-public-test-data/smalldata/airlines/allyears2k_headers.zip\")\n",
      " |      >>> airlines[\"Year\"] = airlines[\"Year\"].asfactor()\n",
      " |      >>> airlines[\"Month\"] = airlines[\"Month\"].asfactor()\n",
      " |      >>> airlines[\"DayOfWeek\"] = airlines[\"DayOfWeek\"].asfactor()\n",
      " |      >>> airlines[\"Cancelled\"] = airlines[\"Cancelled\"].asfactor()\n",
      " |      >>> airlines['FlightNum'] = airlines['FlightNum'].asfactor()\n",
      " |      >>> predictors = [\"Origin\", \"Dest\", \"Year\", \"UniqueCarrier\",\n",
      " |      ...               \"DayOfWeek\", \"Month\", \"Distance\", \"FlightNum\"]\n",
      " |      >>> response = \"IsDepDelayed\"\n",
      " |      >>> train, valid= airlines.split_frame(ratios=[.8],\n",
      " |      ...                                    seed=1234)\n",
      " |      >>> airlines_drf = H2ORandomForestEstimator(stopping_metric=\"auc\",\n",
      " |      ...                                         stopping_rounds=3,\n",
      " |      ...                                         stopping_tolerance=1e-2,\n",
      " |      ...                                         seed=1234)\n",
      " |      >>> airlines_drf.train(x=predictors,\n",
      " |      ...                    y=response,\n",
      " |      ...                    training_frame=train,\n",
      " |      ...                    validation_frame=valid)\n",
      " |      >>> airlines_drf.auc(valid=True)\n",
      " |  \n",
      " |  stopping_tolerance\n",
      " |      Relative tolerance for metric-based stopping criterion (stop if relative improvement is not at least this much)\n",
      " |      \n",
      " |      Type: ``float``  (default: ``0.001``).\n",
      " |      \n",
      " |      :examples:\n",
      " |      \n",
      " |      >>> airlines= h2o.import_file(\"https://s3.amazonaws.com/h2o-public-test-data/smalldata/airlines/allyears2k_headers.zip\")\n",
      " |      >>> airlines[\"Year\"] = airlines[\"Year\"].asfactor()\n",
      " |      >>> airlines[\"Month\"] = airlines[\"Month\"].asfactor()\n",
      " |      >>> airlines[\"DayOfWeek\"] = airlines[\"DayOfWeek\"].asfactor()\n",
      " |      >>> airlines[\"Cancelled\"] = airlines[\"Cancelled\"].asfactor()\n",
      " |      >>> airlines['FlightNum'] = airlines['FlightNum'].asfactor()\n",
      " |      >>> predictors = [\"Origin\", \"Dest\", \"Year\", \"UniqueCarrier\",\n",
      " |      ...               \"DayOfWeek\", \"Month\", \"Distance\", \"FlightNum\"]\n",
      " |      >>> response = \"IsDepDelayed\"\n",
      " |      >>> train, valid= airlines.split_frame(ratios=[.8],\n",
      " |      ...                                    seed=1234)\n",
      " |      >>> airlines_drf = H2ORandomForestEstimator(stopping_metric=\"auc\",\n",
      " |      ...                                         stopping_rounds=3,\n",
      " |      ...                                         stopping_tolerance=1e-2,\n",
      " |      ...                                         seed=1234)\n",
      " |      >>> airlines_drf.train(x=predictors,\n",
      " |      ...                    y=response,\n",
      " |      ...                    training_frame=train,\n",
      " |      ...                    validation_frame=valid)\n",
      " |      >>> airlines_drf.auc(valid=True)\n",
      " |  \n",
      " |  training_frame\n",
      " |      Id of the training data frame.\n",
      " |      \n",
      " |      Type: ``H2OFrame``.\n",
      " |      \n",
      " |      :examples:\n",
      " |      \n",
      " |      >>> cars = h2o.import_file(\"https://s3.amazonaws.com/h2o-public-test-data/smalldata/junit/cars_20mpg.csv\")\n",
      " |      >>> cars[\"economy_20mpg\"] = cars[\"economy_20mpg\"].asfactor()\n",
      " |      >>> predictors = [\"displacement\",\"power\",\"weight\",\"acceleration\",\"year\"]\n",
      " |      >>> response = \"economy_20mpg\"\n",
      " |      >>> train, valid = cars.split_frame(ratios=[.8],\n",
      " |      ...                                 seed=1234)\n",
      " |      >>> cars_drf = H2ORandomForestEstimator(seed=1234)\n",
      " |      >>> cars_drf.train(x=predictors,\n",
      " |      ...                y=response,\n",
      " |      ...                training_frame=train,\n",
      " |      ...                validation_frame=valid)\n",
      " |      >>> cars_drf.auc(valid=True)\n",
      " |  \n",
      " |  validation_frame\n",
      " |      Id of the validation data frame.\n",
      " |      \n",
      " |      Type: ``H2OFrame``.\n",
      " |      \n",
      " |      :examples:\n",
      " |      \n",
      " |      >>> cars = h2o.import_file(\"https://s3.amazonaws.com/h2o-public-test-data/smalldata/junit/cars_20mpg.csv\")\n",
      " |      >>> cars[\"economy_20mpg\"] = cars[\"economy_20mpg\"].asfactor()\n",
      " |      >>> predictors = [\"displacement\",\"power\",\"weight\",\"acceleration\",\"year\"]\n",
      " |      >>> response = \"economy_20mpg\"\n",
      " |      >>> train, valid = cars.split_frame(ratios=[.8],\n",
      " |      ...                                 seed=1234)\n",
      " |      >>> cars_drf = H2ORandomForestEstimator(seed=1234)\n",
      " |      >>> cars_drf.train(x=predictors,\n",
      " |      ...                y=response,\n",
      " |      ...                training_frame=train,\n",
      " |      ...                validation_frame=valid)\n",
      " |      >>> cars_drf.auc(valid=True)\n",
      " |  \n",
      " |  weights_column\n",
      " |      Column with observation weights. Giving some observation a weight of zero is equivalent to excluding it from the\n",
      " |      dataset; giving an observation a relative weight of 2 is equivalent to repeating that row twice. Negative\n",
      " |      weights are not allowed. Note: Weights are per-row observation weights and do not increase the size of the data\n",
      " |      frame. This is typically the number of times a row is repeated, but non-integer values are supported as well.\n",
      " |      During training, rows with higher weights matter more, due to the larger loss function pre-factor.\n",
      " |      \n",
      " |      Type: ``str``.\n",
      " |      \n",
      " |      :examples:\n",
      " |      \n",
      " |      >>> cars = h2o.import_file(\"https://s3.amazonaws.com/h2o-public-test-data/smalldata/junit/cars_20mpg.csv\")\n",
      " |      >>> cars[\"economy_20mpg\"] = cars[\"economy_20mpg\"].asfactor()\n",
      " |      >>> predictors = [\"displacement\",\"power\",\"acceleration\",\"year\"]\n",
      " |      >>> response = \"economy_20mpg\"\n",
      " |      >>> train, valid = cars.split_frame(ratios=[.8],\n",
      " |      ...                                 seed=1234)\n",
      " |      >>> cars_drf = H2ORandomForestEstimator(seed=1234)\n",
      " |      >>> cars_drf.train(x=predictors,\n",
      " |      ...                y=response,\n",
      " |      ...                training_frame=train,\n",
      " |      ...                validation_frame=valid,\n",
      " |      ...                weights_column=\"weight\")\n",
      " |      >>> cars_drf.auc(valid=True)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |  \n",
      " |  algo = 'drf'\n",
      " |  \n",
      " |  param_names = {'balance_classes', 'binomial_double_trees', 'build_tree...\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from h2o.estimators.estimator_base.H2OEstimator:\n",
      " |  \n",
      " |  convert_H2OXGBoostParams_2_XGBoostParams(self)\n",
      " |      In order to use convert_H2OXGBoostParams_2_XGBoostParams and convert_H2OFrame_2_DMatrix, you must import\n",
      " |      the following toolboxes: xgboost, pandas, numpy and scipy.sparse.\n",
      " |      \n",
      " |      Given an H2OXGBoost model, this method will generate the corresponding parameters that should be used by\n",
      " |      native XGBoost in order to give exactly the same result, assuming that the same dataset\n",
      " |      (derived from h2oFrame) is used to train the native XGBoost model.\n",
      " |      \n",
      " |      Follow the steps below to compare H2OXGBoost and native XGBoost:\n",
      " |      \n",
      " |       1. Train the H2OXGBoost model with H2OFrame trainFile and generate a prediction:\n",
      " |      \n",
      " |        - h2oModelD = H2OXGBoostEstimator(\\*\\*h2oParamsD) # parameters specified as a dict()\n",
      " |        - h2oModelD.train(x=myX, y=y, training_frame=trainFile) # train with H2OFrame trainFile\n",
      " |        - h2oPredict = h2oPredictD = h2oModelD.predict(trainFile)\n",
      " |      \n",
      " |       2. Derive the DMatrix from H2OFrame:\n",
      " |       \n",
      " |        - nativeDMatrix = trainFile.convert_H2OFrame_2_DMatrix(myX, y, h2oModelD)\n",
      " |      \n",
      " |       3. Derive the parameters for native XGBoost:\n",
      " |       \n",
      " |        - nativeParams = h2oModelD.convert_H2OXGBoostParams_2_XGBoostParams()\n",
      " |      \n",
      " |       4. Train your native XGBoost model and generate a prediction:\n",
      " |       \n",
      " |        - nativeModel = xgb.train(params=nativeParams[0], dtrain=nativeDMatrix, num_boost_round=nativeParams[1])\n",
      " |        - nativePredict = nativeModel.predict(data=nativeDMatrix, ntree_limit=nativeParams[1]\n",
      " |      \n",
      " |       5. Compare the predictions h2oPredict from H2OXGBoost, nativePredict from native XGBoost.\n",
      " |      \n",
      " |      :return: nativeParams, num_boost_round\n",
      " |  \n",
      " |  fit(self, X, y=None, **params)\n",
      " |      Fit an H2O model as part of a scikit-learn pipeline or grid search.\n",
      " |      \n",
      " |      A warning will be issued if a caller other than sklearn attempts to use this method.\n",
      " |      \n",
      " |      :param H2OFrame X: An H2OFrame consisting of the predictor variables.\n",
      " |      :param H2OFrame y: An H2OFrame consisting of the response variable.\n",
      " |      :param params: Extra arguments.\n",
      " |      :returns: The current instance of H2OEstimator for method chaining.\n",
      " |  \n",
      " |  get_params(self, deep=True)\n",
      " |      Obtain parameters for this estimator.\n",
      " |      \n",
      " |      Used primarily for sklearn Pipelines and sklearn grid search.\n",
      " |      \n",
      " |      :param deep: If True, return parameters of all sub-objects that are estimators.\n",
      " |      \n",
      " |      :returns: A dict of parameters\n",
      " |  \n",
      " |  join(self)\n",
      " |      Wait until job's completion.\n",
      " |  \n",
      " |  set_params(self, **parms)\n",
      " |      Used by sklearn for updating parameters during grid search.\n",
      " |      \n",
      " |      :param parms: A dictionary of parameters that will be set on this model.\n",
      " |      :returns: self, the current estimator object with the parameters all set as desired.\n",
      " |  \n",
      " |  start(self, x, y=None, training_frame=None, offset_column=None, fold_column=None, weights_column=None, validation_frame=None, **params)\n",
      " |      Train the model asynchronously (to block for results call :meth:`join`).\n",
      " |      \n",
      " |      :param x: A list of column names or indices indicating the predictor columns.\n",
      " |      :param y: An index or a column name indicating the response column.\n",
      " |      :param H2OFrame training_frame: The H2OFrame having the columns indicated by x and y (as well as any\n",
      " |          additional columns specified by fold, offset, and weights).\n",
      " |      :param offset_column: The name or index of the column in training_frame that holds the offsets.\n",
      " |      :param fold_column: The name or index of the column in training_frame that holds the per-row fold\n",
      " |          assignments.\n",
      " |      :param weights_column: The name or index of the column in training_frame that holds the per-row weights.\n",
      " |      :param validation_frame: H2OFrame with validation data to be scored on while training.\n",
      " |  \n",
      " |  train(self, x=None, y=None, training_frame=None, offset_column=None, fold_column=None, weights_column=None, validation_frame=None, max_runtime_secs=None, ignored_columns=None, model_id=None, verbose=False)\n",
      " |      Train the H2O model.\n",
      " |      \n",
      " |      :param x: A list of column names or indices indicating the predictor columns.\n",
      " |      :param y: An index or a column name indicating the response column.\n",
      " |      :param H2OFrame training_frame: The H2OFrame having the columns indicated by x and y (as well as any\n",
      " |          additional columns specified by fold, offset, and weights).\n",
      " |      :param offset_column: The name or index of the column in training_frame that holds the offsets.\n",
      " |      :param fold_column: The name or index of the column in training_frame that holds the per-row fold\n",
      " |          assignments.\n",
      " |      :param weights_column: The name or index of the column in training_frame that holds the per-row weights.\n",
      " |      :param validation_frame: H2OFrame with validation data to be scored on while training.\n",
      " |      :param float max_runtime_secs: Maximum allowed runtime in seconds for model training. Use 0 to disable.\n",
      " |      :param bool verbose: Print scoring history to stdout. Defaults to False.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods inherited from h2o.estimators.estimator_base.H2OEstimator:\n",
      " |  \n",
      " |  mixin(obj, cls)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from h2o.model.model_base.ModelBase:\n",
      " |  \n",
      " |  __getattr__(self, name)\n",
      " |  \n",
      " |  __repr__(self)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  aic(self, train=False, valid=False, xval=False)\n",
      " |      Get the AIC (Akaike Information Criterium).\n",
      " |      \n",
      " |      If all are False (default), then return the training metric value.\n",
      " |      If more than one options is set to True, then return a dictionary of metrics where the keys are \"train\",\n",
      " |      \"valid\", and \"xval\".\n",
      " |      \n",
      " |      :param bool train: If train is True, then return the AIC value for the training data.\n",
      " |      :param bool valid: If valid is True, then return the AIC value for the validation data.\n",
      " |      :param bool xval:  If xval is True, then return the AIC value for the validation data.\n",
      " |      \n",
      " |      :returns: The AIC.\n",
      " |  \n",
      " |  auc(self, train=False, valid=False, xval=False)\n",
      " |      Get the AUC (Area Under Curve).\n",
      " |      \n",
      " |      If all are False (default), then return the training metric value.\n",
      " |      If more than one options is set to True, then return a dictionary of metrics where the keys are \"train\",\n",
      " |      \"valid\", and \"xval\".\n",
      " |      \n",
      " |      :param bool train: If train is True, then return the AUC value for the training data.\n",
      " |      :param bool valid: If valid is True, then return the AUC value for the validation data.\n",
      " |      :param bool xval:  If xval is True, then return the AUC value for the validation data.\n",
      " |      \n",
      " |      :returns: The AUC.\n",
      " |  \n",
      " |  aucpr(self, train=False, valid=False, xval=False)\n",
      " |      Get the aucPR (Area Under PRECISION RECALL Curve).\n",
      " |      \n",
      " |      If all are False (default), then return the training metric value.\n",
      " |      If more than one options is set to True, then return a dictionary of metrics where the keys are \"train\",\n",
      " |      \"valid\", and \"xval\".\n",
      " |      \n",
      " |      :param bool train: If train is True, then return the aucpr value for the training data.\n",
      " |      :param bool valid: If valid is True, then return the aucpr value for the validation data.\n",
      " |      :param bool xval:  If xval is True, then return the aucpr value for the validation data.\n",
      " |      \n",
      " |      :returns: The aucpr.\n",
      " |  \n",
      " |  biases(self, vector_id=0)\n",
      " |      Return the frame for the respective bias vector.\n",
      " |      \n",
      " |      :param: vector_id: an integer, ranging from 0 to number of layers, that specifies the bias vector to return.\n",
      " |      \n",
      " |      :returns: an H2OFrame which represents the bias vector identified by vector_id\n",
      " |  \n",
      " |  catoffsets(self)\n",
      " |      Categorical offsets for one-hot encoding.\n",
      " |  \n",
      " |  coef(self)\n",
      " |      Return the coefficients which can be applied to the non-standardized data.\n",
      " |      \n",
      " |      Note: standardize = True by default, if set to False then coef() return the coefficients which are fit directly.\n",
      " |  \n",
      " |  coef_norm(self)\n",
      " |      Return coefficients fitted on the standardized data (requires standardize = True, which is on by default).\n",
      " |      \n",
      " |      These coefficients can be used to evaluate variable importance.\n",
      " |  \n",
      " |  cross_validation_fold_assignment(self)\n",
      " |      Obtain the cross-validation fold assignment for all rows in the training data.\n",
      " |      \n",
      " |      :returns: H2OFrame\n",
      " |  \n",
      " |  cross_validation_holdout_predictions(self)\n",
      " |      Obtain the (out-of-sample) holdout predictions of all cross-validation models on the training data.\n",
      " |      \n",
      " |      This is equivalent to summing up all H2OFrames returned by cross_validation_predictions.\n",
      " |      \n",
      " |      :returns: H2OFrame\n",
      " |  \n",
      " |  cross_validation_metrics_summary(self)\n",
      " |      Retrieve Cross-Validation Metrics Summary.\n",
      " |      \n",
      " |      :returns: The cross-validation metrics summary as an H2OTwoDimTable\n",
      " |  \n",
      " |  cross_validation_models(self)\n",
      " |      Obtain a list of cross-validation models.\n",
      " |      \n",
      " |      :returns: list of H2OModel objects.\n",
      " |  \n",
      " |  cross_validation_predictions(self)\n",
      " |      Obtain the (out-of-sample) holdout predictions of all cross-validation models on their holdout data.\n",
      " |      \n",
      " |      Note that the predictions are expanded to the full number of rows of the training data, with 0 fill-in.\n",
      " |      \n",
      " |      :returns: list of H2OFrame objects.\n",
      " |  \n",
      " |  deepfeatures(self, test_data, layer)\n",
      " |      Return hidden layer details.\n",
      " |      \n",
      " |      :param test_data: Data to create a feature space on\n",
      " |      :param layer: 0 index hidden layer\n",
      " |  \n",
      " |  detach(self)\n",
      " |      Detach the Python object from the backend, usually by clearing its key\n",
      " |  \n",
      " |  download_model(self, path='')\n",
      " |      Download an H2O Model object to disk.\n",
      " |      \n",
      " |      :param model: The model object to download.\n",
      " |      :param path: a path to the directory where the model should be saved.\n",
      " |      \n",
      " |      :returns: the path of the downloaded model\n",
      " |  \n",
      " |  download_mojo(self, path='.', get_genmodel_jar=False, genmodel_name='')\n",
      " |      Download the model in MOJO format.\n",
      " |      \n",
      " |      :param path: the path where MOJO file should be saved.\n",
      " |      :param get_genmodel_jar: if True, then also download h2o-genmodel.jar and store it in folder ``path``.\n",
      " |      :param genmodel_name: Custom name of genmodel jar\n",
      " |      :returns: name of the MOJO file written.\n",
      " |  \n",
      " |  download_pojo(self, path='', get_genmodel_jar=False, genmodel_name='')\n",
      " |      Download the POJO for this model to the directory specified by path.\n",
      " |      \n",
      " |      If path is an empty string, then dump the output to screen.\n",
      " |      \n",
      " |      :param path:  An absolute path to the directory where POJO should be saved.\n",
      " |      :param get_genmodel_jar: if True, then also download h2o-genmodel.jar and store it in folder ``path``.\n",
      " |      :param genmodel_name: Custom name of genmodel jar\n",
      " |      :returns: name of the POJO file written.\n",
      " |  \n",
      " |  feature_frequencies(self, test_data)\n",
      " |      Retrieve the number of occurrences of each feature for given observations \n",
      " |      on their respective paths in a tree ensemble model.\n",
      " |      Available for GBM, Random Forest and Isolation Forest models.\n",
      " |      \n",
      " |      :param H2OFrame test_data: Data on which to calculate feature frequencies.\n",
      " |      \n",
      " |      :returns: A new H2OFrame made of feature contributions.\n",
      " |  \n",
      " |  get_xval_models(self, key=None)\n",
      " |      Return a Model object.\n",
      " |      \n",
      " |      :param key: If None, return all cross-validated models; otherwise return the model that key points to.\n",
      " |      \n",
      " |      :returns: A model or list of models.\n",
      " |  \n",
      " |  gini(self, train=False, valid=False, xval=False)\n",
      " |      Get the Gini coefficient.\n",
      " |      \n",
      " |      If all are False (default), then return the training metric value.\n",
      " |      If more than one options is set to True, then return a dictionary of metrics where the keys are \"train\",\n",
      " |      \"valid\", and \"xval\"\n",
      " |      \n",
      " |      :param bool train: If train is True, then return the Gini Coefficient value for the training data.\n",
      " |      :param bool valid: If valid is True, then return the Gini Coefficient value for the validation data.\n",
      " |      :param bool xval:  If xval is True, then return the Gini Coefficient value for the cross validation data.\n",
      " |      \n",
      " |      :returns: The Gini Coefficient for this binomial model.\n",
      " |  \n",
      " |  is_cross_validated(self)\n",
      " |      Return True if the model was cross-validated.\n",
      " |  \n",
      " |  logloss(self, train=False, valid=False, xval=False)\n",
      " |      Get the Log Loss.\n",
      " |      \n",
      " |      If all are False (default), then return the training metric value.\n",
      " |      If more than one options is set to True, then return a dictionary of metrics where the keys are \"train\",\n",
      " |      \"valid\", and \"xval\".\n",
      " |      \n",
      " |      :param bool train: If train is True, then return the log loss value for the training data.\n",
      " |      :param bool valid: If valid is True, then return the log loss value for the validation data.\n",
      " |      :param bool xval:  If xval is True, then return the log loss value for the cross validation data.\n",
      " |      \n",
      " |      :returns: The log loss for this regression model.\n",
      " |  \n",
      " |  mae(self, train=False, valid=False, xval=False)\n",
      " |      Get the Mean Absolute Error.\n",
      " |      \n",
      " |      If all are False (default), then return the training metric value.\n",
      " |      If more than one options is set to True, then return a dictionary of metrics where the keys are \"train\",\n",
      " |      \"valid\", and \"xval\".\n",
      " |      \n",
      " |      :param bool train: If train is True, then return the MAE value for the training data.\n",
      " |      :param bool valid: If valid is True, then return the MAE value for the validation data.\n",
      " |      :param bool xval:  If xval is True, then return the MAE value for the cross validation data.\n",
      " |      \n",
      " |      :returns: The MAE for this regression model.\n",
      " |  \n",
      " |  mean_residual_deviance(self, train=False, valid=False, xval=False)\n",
      " |      Get the Mean Residual Deviances.\n",
      " |      \n",
      " |      If all are False (default), then return the training metric value.\n",
      " |      If more than one options is set to True, then return a dictionary of metrics where the keys are \"train\",\n",
      " |      \"valid\", and \"xval\".\n",
      " |      \n",
      " |      :param bool train: If train is True, then return the Mean Residual Deviance value for the training data.\n",
      " |      :param bool valid: If valid is True, then return the Mean Residual Deviance value for the validation data.\n",
      " |      :param bool xval:  If xval is True, then return the Mean Residual Deviance value for the cross validation data.\n",
      " |      \n",
      " |      :returns: The Mean Residual Deviance for this regression model.\n",
      " |  \n",
      " |  model_performance(self, test_data=None, train=False, valid=False, xval=False)\n",
      " |      Generate model metrics for this model on test_data.\n",
      " |      \n",
      " |      :param H2OFrame test_data: Data set for which model metrics shall be computed against. All three of train,\n",
      " |          valid and xval arguments are ignored if test_data is not None.\n",
      " |      :param bool train: Report the training metrics for the model.\n",
      " |      :param bool valid: Report the validation metrics for the model.\n",
      " |      :param bool xval: Report the cross-validation metrics for the model. If train and valid are True, then it\n",
      " |          defaults to True.\n",
      " |      \n",
      " |      :returns: An object of class H2OModelMetrics.\n",
      " |  \n",
      " |  mse(self, train=False, valid=False, xval=False)\n",
      " |      Get the Mean Square Error.\n",
      " |      \n",
      " |      If all are False (default), then return the training metric value.\n",
      " |      If more than one options is set to True, then return a dictionary of metrics where the keys are \"train\",\n",
      " |      \"valid\", and \"xval\".\n",
      " |      \n",
      " |      :param bool train: If train is True, then return the MSE value for the training data.\n",
      " |      :param bool valid: If valid is True, then return the MSE value for the validation data.\n",
      " |      :param bool xval:  If xval is True, then return the MSE value for the cross validation data.\n",
      " |      \n",
      " |      :returns: The MSE for this regression model.\n",
      " |  \n",
      " |  normmul(self)\n",
      " |      Normalization/Standardization multipliers for numeric predictors.\n",
      " |  \n",
      " |  normsub(self)\n",
      " |      Normalization/Standardization offsets for numeric predictors.\n",
      " |  \n",
      " |  ntrees_actual(self)\n",
      " |      Returns actual number of trees in a tree model. If early stopping enabled, GBM can reset the ntrees value.\n",
      " |      In this case, the actual ntrees value is less than the original ntrees value a user set before\n",
      " |      building the model.\n",
      " |      \n",
      " |      Type: ``float``\n",
      " |  \n",
      " |  null_degrees_of_freedom(self, train=False, valid=False, xval=False)\n",
      " |      Retreive the null degress of freedom if this model has the attribute, or None otherwise.\n",
      " |      \n",
      " |      :param bool train: Get the null dof for the training set. If both train and valid are False, then train is\n",
      " |          selected by default.\n",
      " |      :param bool valid: Get the null dof for the validation set. If both train and valid are True, then train is\n",
      " |          selected by default.\n",
      " |      \n",
      " |      :returns: Return the null dof, or None if it is not present.\n",
      " |  \n",
      " |  null_deviance(self, train=False, valid=False, xval=False)\n",
      " |      Retreive the null deviance if this model has the attribute, or None otherwise.\n",
      " |      \n",
      " |      :param bool train: Get the null deviance for the training set. If both train and valid are False, then train\n",
      " |          is selected by default.\n",
      " |      :param bool valid: Get the null deviance for the validation set. If both train and valid are True, then train\n",
      " |          is selected by default.\n",
      " |      \n",
      " |      :returns: Return the null deviance, or None if it is not present.\n",
      " |  \n",
      " |  partial_plot(self, data, cols=None, destination_key=None, nbins=20, weight_column=None, plot=True, plot_stddev=True, figsize=(7, 10), server=False, include_na=False, user_splits=None, col_pairs_2dpdp=None, save_to_file=None, row_index=None)\n",
      " |      Create partial dependence plot which gives a graphical depiction of the marginal effect of a variable on the\n",
      " |      response. The effect of a variable is measured in change in the mean response.\n",
      " |      \n",
      " |      :param H2OFrame data: An H2OFrame object used for scoring and constructing the plot.\n",
      " |      :param cols: Feature(s) for which partial dependence will be calculated.\n",
      " |      :param destination_key: An key reference to the created partial dependence tables in H2O.\n",
      " |      :param nbins: Number of bins used. For categorical columns make sure the number of bins exceed the level count. If you enable add_missing_NA, the returned length will be nbin+1.\n",
      " |      :param weight_column: A string denoting which column of data should be used as the weight column.\n",
      " |      :param plot: A boolean specifying whether to plot partial dependence table.\n",
      " |      :param plot_stddev: A boolean specifying whether to add std err to partial dependence plot.\n",
      " |      :param figsize: Dimension/size of the returning plots, adjust to fit your output cells.\n",
      " |      :param server: Specify whether to activate matplotlib \"server\" mode. In this case, the plots are saved to a file instead of being rendered.\n",
      " |      :param include_na: A boolean specifying whether missing value should be included in the Feature values.\n",
      " |      :param user_splits: a dictionary containing column names as key and user defined split values as value in a list.\n",
      " |      :param col_pairs_2dpdp: list containing pairs of column names for 2D pdp\n",
      " |      :param save_to_file: Fully qualified name to an image file the resulting plot should be saved to, e.g. '/home/user/pdpplot.png'. The 'png' postfix might be omitted. If the file already exists, it will be overridden. Plot is only saved if plot = True.\n",
      " |      :param row_index: Row for which partial dependence will be calculated instead of the whole input frame.\n",
      " |      :returns: Plot and list of calculated mean response tables for each feature requested.\n",
      " |  \n",
      " |  pprint_coef(self)\n",
      " |      Pretty print the coefficents table (includes normalized coefficients).\n",
      " |  \n",
      " |  pr_auc(self, train=False, valid=False, xval=False)\n",
      " |      ModelBase.pr_auc is deprecated, please use ``ModelBase.aucpr`` instead.\n",
      " |  \n",
      " |  predict(self, test_data, custom_metric=None, custom_metric_func=None)\n",
      " |      Predict on a dataset.\n",
      " |      \n",
      " |      :param H2OFrame test_data: Data on which to make predictions.\n",
      " |      :param custom_metric:  custom evaluation function defined as class reference, the class get uploaded\n",
      " |          into the cluster\n",
      " |      :param custom_metric_func: custom evaluation function reference, e.g, result of upload_custom_metric\n",
      " |      \n",
      " |      :returns: A new H2OFrame of predictions.\n",
      " |  \n",
      " |  predict_contributions(self, test_data)\n",
      " |      Predict feature contributions - SHAP values on an H2O Model (only GBM and XGBoost models).\n",
      " |      \n",
      " |      Returned H2OFrame has shape (#rows, #features + 1) - there is a feature contribution column for each input\n",
      " |      feature, the last column is the model bias (same value for each row). The sum of the feature contributions\n",
      " |      and the bias term is equal to the raw prediction of the model. Raw prediction of tree-based model is the sum \n",
      " |      of the predictions of the individual trees before before the inverse link function is applied to get the actual\n",
      " |      prediction. For Gaussian distribution the sum of the contributions is equal to the model prediction. \n",
      " |      \n",
      " |      Note: Multinomial classification models are currently not supported.\n",
      " |      \n",
      " |      :param H2OFrame test_data: Data on which to calculate contributions.\n",
      " |      \n",
      " |      :returns: A new H2OFrame made of feature contributions.\n",
      " |  \n",
      " |  predict_leaf_node_assignment(self, test_data, type='Path')\n",
      " |      Predict on a dataset and return the leaf node assignment (only for tree-based models).\n",
      " |      \n",
      " |      :param H2OFrame test_data: Data on which to make predictions.\n",
      " |      :param Enum type: How to identify the leaf node. Nodes can be either identified by a path from to the root node\n",
      " |          of the tree to the node or by H2O's internal node id. One of: ``\"Path\"``, ``\"Node_ID\"`` (default: ``\"Path\"``).\n",
      " |      \n",
      " |      :returns: A new H2OFrame of predictions.\n",
      " |  \n",
      " |  r2(self, train=False, valid=False, xval=False)\n",
      " |      Return the R squared for this regression model.\n",
      " |      \n",
      " |      Will return R^2 for GLM Models and will return NaN otherwise.\n",
      " |      \n",
      " |      The R^2 value is defined to be 1 - MSE/var, where var is computed as sigma*sigma.\n",
      " |      \n",
      " |      If all are False (default), then return the training metric value.\n",
      " |      If more than one options is set to True, then return a dictionary of metrics where the keys are \"train\",\n",
      " |      \"valid\", and \"xval\".\n",
      " |      \n",
      " |      :param bool train: If train is True, then return the R^2 value for the training data.\n",
      " |      :param bool valid: If valid is True, then return the R^2 value for the validation data.\n",
      " |      :param bool xval:  If xval is True, then return the R^2 value for the cross validation data.\n",
      " |      \n",
      " |      :returns: The R squared for this regression model.\n",
      " |  \n",
      " |  residual_degrees_of_freedom(self, train=False, valid=False, xval=False)\n",
      " |      Retreive the residual degress of freedom if this model has the attribute, or None otherwise.\n",
      " |      \n",
      " |      :param bool train: Get the residual dof for the training set. If both train and valid are False, then train\n",
      " |          is selected by default.\n",
      " |      :param bool valid: Get the residual dof for the validation set. If both train and valid are True, then train\n",
      " |          is selected by default.\n",
      " |      \n",
      " |      :returns: Return the residual dof, or None if it is not present.\n",
      " |  \n",
      " |  residual_deviance(self, train=False, valid=False, xval=None)\n",
      " |      Retreive the residual deviance if this model has the attribute, or None otherwise.\n",
      " |      \n",
      " |      :param bool train: Get the residual deviance for the training set. If both train and valid are False, then\n",
      " |          train is selected by default.\n",
      " |      :param bool valid: Get the residual deviance for the validation set. If both train and valid are True, then\n",
      " |          train is selected by default.\n",
      " |      \n",
      " |      :returns: Return the residual deviance, or None if it is not present.\n",
      " |  \n",
      " |  respmul(self)\n",
      " |      Normalization/Standardization multipliers for numeric response.\n",
      " |  \n",
      " |  respsub(self)\n",
      " |      Normalization/Standardization offsets for numeric response.\n",
      " |  \n",
      " |  rmse(self, train=False, valid=False, xval=False)\n",
      " |      Get the Root Mean Square Error.\n",
      " |      \n",
      " |      If all are False (default), then return the training metric value.\n",
      " |      If more than one options is set to True, then return a dictionary of metrics where the keys are \"train\",\n",
      " |      \"valid\", and \"xval\".\n",
      " |      \n",
      " |      :param bool train: If train is True, then return the RMSE value for the training data.\n",
      " |      :param bool valid: If valid is True, then return the RMSE value for the validation data.\n",
      " |      :param bool xval:  If xval is True, then return the RMSE value for the cross validation data.\n",
      " |      \n",
      " |      :returns: The RMSE for this regression model.\n",
      " |  \n",
      " |  rmsle(self, train=False, valid=False, xval=False)\n",
      " |      Get the Root Mean Squared Logarithmic Error.\n",
      " |      \n",
      " |      If all are False (default), then return the training metric value.\n",
      " |      If more than one options is set to True, then return a dictionary of metrics where the keys are \"train\",\n",
      " |      \"valid\", and \"xval\".\n",
      " |      \n",
      " |      :param bool train: If train is True, then return the RMSLE value for the training data.\n",
      " |      :param bool valid: If valid is True, then return the RMSLE value for the validation data.\n",
      " |      :param bool xval:  If xval is True, then return the RMSLE value for the cross validation data.\n",
      " |      \n",
      " |      :returns: The RMSLE for this regression model.\n",
      " |  \n",
      " |  rotation(self)\n",
      " |      Obtain the rotations (eigenvectors) for a PCA model\n",
      " |      \n",
      " |      :return: H2OFrame\n",
      " |  \n",
      " |  save_model_details(self, path='', force=False)\n",
      " |      Save Model Details of an H2O Model in JSON Format to disk.\n",
      " |      \n",
      " |      :param model: The model object to save.\n",
      " |      :param path: a path to save the model details at (hdfs, s3, local)\n",
      " |      :param force: if True overwrite destination directory in case it exists, or throw exception if set to False.\n",
      " |      \n",
      " |      :returns str: the path of the saved model details\n",
      " |  \n",
      " |  save_mojo(self, path='', force=False)\n",
      " |      Save an H2O Model as MOJO (Model Object, Optimized) to disk.\n",
      " |      \n",
      " |      :param model: The model object to save.\n",
      " |      :param path: a path to save the model at (hdfs, s3, local)\n",
      " |      :param force: if True overwrite destination directory in case it exists, or throw exception if set to False.\n",
      " |      \n",
      " |      :returns str: the path of the saved model\n",
      " |  \n",
      " |  score_history(self)\n",
      " |      DEPRECATED. Use :meth:`scoring_history` instead.\n",
      " |  \n",
      " |  scoring_history(self)\n",
      " |      Retrieve Model Score History.\n",
      " |      \n",
      " |      :returns: The score history as an H2OTwoDimTable or a Pandas DataFrame.\n",
      " |  \n",
      " |  show(self)\n",
      " |      Print innards of model, without regards to type.\n",
      " |  \n",
      " |  staged_predict_proba(self, test_data)\n",
      " |      Predict class probabilities at each stage of an H2O Model (only GBM models).\n",
      " |      \n",
      " |      The output structure is analogous to the output of function predict_leaf_node_assignment. For each tree t and\n",
      " |      class c there will be a column Tt.Cc (eg. T3.C1 for tree 3 and class 1). The value will be the corresponding\n",
      " |      predicted probability of this class by combining the raw contributions of trees T1.Cc,..,TtCc. Binomial models\n",
      " |      build the trees just for the first class and values in columns Tx.C1 thus correspond to the the probability p0.\n",
      " |      \n",
      " |      :param H2OFrame test_data: Data on which to make predictions.\n",
      " |      \n",
      " |      :returns: A new H2OFrame of staged predictions.\n",
      " |  \n",
      " |  std_coef_plot(self, num_of_features=None, server=False)\n",
      " |      Plot a GLM model\"s standardized coefficient magnitudes.\n",
      " |      \n",
      " |      :param num_of_features: the number of features shown in the plot.\n",
      " |      :param server: ?\n",
      " |      \n",
      " |      :returns: None.\n",
      " |  \n",
      " |  summary(self)\n",
      " |      Print a detailed summary of the model.\n",
      " |  \n",
      " |  training_model_metrics(self)\n",
      " |      Return training model metrics for any model.\n",
      " |  \n",
      " |  varimp(self, use_pandas=False)\n",
      " |      Pretty print the variable importances, or return them in a list.\n",
      " |      \n",
      " |      :param bool use_pandas: If True, then the variable importances will be returned as a pandas data frame.\n",
      " |      \n",
      " |      :returns: A list or Pandas DataFrame.\n",
      " |  \n",
      " |  varimp_plot(self, num_of_features=None, server=False)\n",
      " |      Plot the variable importance for a trained model.\n",
      " |      \n",
      " |      :param num_of_features: the number of features shown in the plot (default is 10 or all if less than 10).\n",
      " |      :param server: ?\n",
      " |      \n",
      " |      :returns: None.\n",
      " |  \n",
      " |  weights(self, matrix_id=0)\n",
      " |      Return the frame for the respective weight matrix.\n",
      " |      \n",
      " |      :param matrix_id: an integer, ranging from 0 to number of layers, that specifies the weight matrix to return.\n",
      " |      \n",
      " |      :returns: an H2OFrame which represents the weight matrix identified by matrix_id\n",
      " |  \n",
      " |  xval_keys(self)\n",
      " |      Return model keys for the cross-validated model.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors inherited from h2o.model.model_base.ModelBase:\n",
      " |  \n",
      " |  actual_params\n",
      " |      Dictionary of actual parameters of the model.\n",
      " |  \n",
      " |  default_params\n",
      " |      Dictionary of the default parameters of the model.\n",
      " |  \n",
      " |  end_time\n",
      " |      Timestamp (milliseconds since 1970) when the model training was ended.\n",
      " |  \n",
      " |  full_parameters\n",
      " |      Dictionary of the full specification of all parameters.\n",
      " |  \n",
      " |  have_mojo\n",
      " |      True, if export to MOJO is possible\n",
      " |  \n",
      " |  have_pojo\n",
      " |      True, if export to POJO is possible\n",
      " |  \n",
      " |  key\n",
      " |      :return: the unique key representing the object on the backend\n",
      " |  \n",
      " |  model_id\n",
      " |      Model identifier.\n",
      " |  \n",
      " |  params\n",
      " |      Get the parameters and the actual/default values only.\n",
      " |      \n",
      " |      :returns: A dictionary of parameters used to build this model.\n",
      " |  \n",
      " |  run_time\n",
      " |      Model training time in milliseconds\n",
      " |  \n",
      " |  start_time\n",
      " |      Timestamp (milliseconds since 1970) when the model training was started.\n",
      " |  \n",
      " |  type\n",
      " |      The type of model built: ``\"classifier\"`` or ``\"regressor\"`` or ``\"unsupervised\"``\n",
      " |  \n",
      " |  xvals\n",
      " |      Return a list of the cross-validated models.\n",
      " |      \n",
      " |      :returns: A list of models.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors inherited from h2o.base.Keyed:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables (if defined)\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object (if defined)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "# how to access the help for the RF\n",
    "help(h2o.estimators.random_forest.H2ORandomForestEstimator)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "h2oclass",
   "language": "python",
   "name": "h2oclass"
  },
  "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}