H2O_AutoML_IPYNB/lending_club_glm.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to H2O's GLM using Lending Club Loan Data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[H2O](http://h2o-release.s3.amazonaws.com/h2o/latest_stable.html) is a scalable, distributed machine learning platform with interfaces in Python, R, and Flow (Web)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The H2O Python Module"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The [H2O Python Module](http://docs.h2o.ai/h2o/latest-stable/h2o-py/docs/intro.html) module provides access to H2O clusters and uses conventions from [scikit-learn](http://scikit-learn.org) and [pandas](https://pandas.pydata.org). Installation instructions for this module are available on the [Install in Python](http://docs.h2o.ai/h2o/latest-stable/h2o-docs/downloading.html#install-in-python) section of H2O's on-line documentation."
   ]
  },
  {
   "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": [
      "Help on package h2o:\n",
      "\n",
      "NAME\n",
      "    h2o - :mod:`h2o` -- module for using H2O services.\n",
      "\n",
      "DESCRIPTION\n",
      "    (please add description).\n",
      "\n",
      "PACKAGE CONTENTS\n",
      "    assembly\n",
      "    astfun\n",
      "    automl (package)\n",
      "    backend (package)\n",
      "    cross_validation\n",
      "    demos\n",
      "    display\n",
      "    estimators (package)\n",
      "    exceptions\n",
      "    expr\n",
      "    expr_optimizer\n",
      "    frame\n",
      "    grid (package)\n",
      "    group_by\n",
      "    h2o\n",
      "    job\n",
      "    model (package)\n",
      "    schemas (package)\n",
      "    transforms (package)\n",
      "    two_dim_table\n",
      "    utils (package)\n",
      "\n",
      "FUNCTIONS\n",
      "    api(endpoint, data=None, json=None, filename=None, save_to=None)\n",
      "        Perform a REST API request to a previously connected server.\n",
      "        \n",
      "        This function is mostly for internal purposes, but may occasionally be useful for direct access to\n",
      "        the backend H2O server. It has same parameters as :meth:`H2OConnection.request <h2o.backend.H2OConnection.request>`.\n",
      "    \n",
      "    as_list(data, use_pandas=True, header=True)\n",
      "        Convert an H2O data object into a python-specific object.\n",
      "        \n",
      "        WARNING! This will pull all data local!\n",
      "        \n",
      "        If Pandas is available (and use_pandas is True), then pandas will be used to parse the\n",
      "        data frame. Otherwise, a list-of-lists populated by character data will be returned (so\n",
      "        the types of data will all be str).\n",
      "        \n",
      "        :param data: an H2O data object.\n",
      "        :param use_pandas: If True, try to use pandas for reading in the data.\n",
      "        :param header: If True, return column names as first element in list\n",
      "        \n",
      "        :returns: List of lists (Rows x Columns).\n",
      "    \n",
      "    assign(data, xid)\n",
      "        (internal) Assign new id to the frame.\n",
      "        \n",
      "        :param data: an H2OFrame whose id should be changed\n",
      "        :param xid: new id for the frame.\n",
      "        :returns: the passed frame.\n",
      "    \n",
      "    cluster()\n",
      "        Return :class:`H2OCluster` object describing the backend H2O cloud.\n",
      "    \n",
      "    cluster_info(*args, **kwargs)\n",
      "        Deprecated, use ``h2o.cluster().show_status()``.\n",
      "    \n",
      "    cluster_status(*args, **kwargs)\n",
      "        Deprecated, use ``h2o.cluster().show_status(True)``.\n",
      "    \n",
      "    connect(server=None, url=None, ip=None, port=None, https=None, verify_ssl_certificates=None, auth=None, proxy=None, cookies=None, verbose=True, config=None)\n",
      "        Connect to an existing H2O server, remote or local.\n",
      "        \n",
      "        There are two ways to connect to a server: either pass a `server` parameter containing an instance of\n",
      "        an H2OLocalServer, or specify `ip` and `port` of the server that you want to connect to.\n",
      "        \n",
      "        :param server: An H2OLocalServer instance to connect to (optional).\n",
      "        :param url: Full URL of the server to connect to (can be used instead of `ip` + `port` + `https`).\n",
      "        :param ip: The ip address (or host name) of the server where H2O is running.\n",
      "        :param port: Port number that H2O service is listening to.\n",
      "        :param https: Set to True to connect via https:// instead of http://.\n",
      "        :param verify_ssl_certificates: When using https, setting this to False will disable SSL certificates verification.\n",
      "        :param auth: Either a (username, password) pair for basic authentication, or one of the requests.auth\n",
      "                     authenticator objects.\n",
      "        :param proxy: Proxy server address.\n",
      "        :param cookies: Cookie (or list of) to add to request\n",
      "        :param verbose: Set to False to disable printing connection status messages.\n",
      "        :param connection_conf: Connection configuration object encapsulating connection parameters.\n",
      "        :returns: the new :class:`H2OConnection` object.\n",
      "    \n",
      "    connection()\n",
      "        Return the current :class:`H2OConnection` handler.\n",
      "    \n",
      "    create_frame(frame_id=None, rows=10000, cols=10, randomize=True, real_fraction=None, categorical_fraction=None, integer_fraction=None, binary_fraction=None, time_fraction=None, string_fraction=None, value=0, real_range=100, factors=100, integer_range=100, binary_ones_fraction=0.02, missing_fraction=0.01, has_response=False, response_factors=2, positive_response=False, seed=None, seed_for_column_types=None)\n",
      "        Create a new frame with random data.\n",
      "        \n",
      "        Creates a data frame in H2O with real-valued, categorical, integer, and binary columns specified by the user.\n",
      "        \n",
      "        :param frame_id: the destination key. If empty, this will be auto-generated.\n",
      "        :param rows: the number of rows of data to generate.\n",
      "        :param cols: the number of columns of data to generate. Excludes the response column if has_response is True.\n",
      "        :param randomize: If True, data values will be randomly generated. This must be True if either\n",
      "            categorical_fraction or integer_fraction is non-zero.\n",
      "        :param value: if randomize is False, then all real-valued entries will be set to this value.\n",
      "        :param real_range: the range of randomly generated real values.\n",
      "        :param real_fraction: the fraction of columns that are real-valued.\n",
      "        :param categorical_fraction: the fraction of total columns that are categorical.\n",
      "        :param factors: the number of (unique) factor levels in each categorical column.\n",
      "        :param integer_fraction: the fraction of total columns that are integer-valued.\n",
      "        :param integer_range: the range of randomly generated integer values.\n",
      "        :param binary_fraction: the fraction of total columns that are binary-valued.\n",
      "        :param binary_ones_fraction: the fraction of values in a binary column that are set to 1.\n",
      "        :param time_fraction: the fraction of randomly created date/time columns.\n",
      "        :param string_fraction: the fraction of randomly created string columns.\n",
      "        :param missing_fraction: the fraction of total entries in the data frame that are set to NA.\n",
      "        :param has_response: A logical value indicating whether an additional response column should be prepended to the\n",
      "            final H2O data frame. If set to True, the total number of columns will be ``cols + 1``.\n",
      "        :param response_factors: if has_response is True, then this variable controls the type of the \"response\" column:\n",
      "            setting response_factors to 1 will generate real-valued response, any value greater or equal than 2 will\n",
      "            create categorical response with that many categories.\n",
      "        :param positive_reponse: when response variable is present and of real type, this will control whether it\n",
      "            contains positive values only, or both positive and negative.\n",
      "        :param seed: a seed used to generate random values when ``randomize`` is True.\n",
      "        :param seed_for_column_types: a seed used to generate random column types when ``randomize`` is True.\n",
      "        \n",
      "        :returns: an :class:`H2OFrame` object\n",
      "    \n",
      "    deep_copy(data, xid)\n",
      "        Create a deep clone of the frame ``data``.\n",
      "        \n",
      "        :param data: an H2OFrame to be cloned\n",
      "        :param xid: (internal) id to be assigned to the new frame.\n",
      "        :returns: new :class:`H2OFrame` which is the clone of the passed frame.\n",
      "    \n",
      "    demo(funcname, interactive=True, echo=True, test=False)\n",
      "        H2O built-in demo facility.\n",
      "        \n",
      "        :param funcname: A string that identifies the h2o python function to demonstrate.\n",
      "        :param interactive: If True, the user will be prompted to continue the demonstration after every segment.\n",
      "        :param echo: If True, the python commands that are executed will be displayed.\n",
      "        :param test: If True, `h2o.init()` will not be called (used for pyunit testing).\n",
      "        \n",
      "        :example:\n",
      "            >>> import h2o\n",
      "            >>> h2o.demo(\"gbm\")\n",
      "    \n",
      "    download_all_logs(dirname='.', filename=None)\n",
      "        Download H2O log files to disk.\n",
      "        \n",
      "        :param dirname: a character string indicating the directory that the log file should be saved in.\n",
      "        :param filename: a string indicating the name that the CSV file should be. Note that the saved format is .zip, so the file name must include the .zip extension.\n",
      "        \n",
      "        :returns: path of logs written in a zip file.\n",
      "        \n",
      "        :examples: The following code will save the zip file `'autoh2o_log.zip'` in a directory that is one down from where you are currently working into a directory called `your_directory_name`. (Please note that `your_directory_name` should be replaced with the name of the directory that you've created and that already exists.)\n",
      "        \n",
      "            >>> h2o.download_all_logs(dirname='./your_directory_name/', filename = 'autoh2o_log.zip')\n",
      "    \n",
      "    download_csv(data, filename)\n",
      "        Download an H2O data set to a CSV file on the local disk.\n",
      "        \n",
      "        Warning: Files located on the H2O server may be very large! Make sure you have enough\n",
      "        hard drive space to accommodate the entire file.\n",
      "        \n",
      "        :param data: an H2OFrame object to be downloaded.\n",
      "        :param filename: name for the CSV file where the data should be saved to.\n",
      "    \n",
      "    download_pojo(model, path='', get_jar=True, jar_name='')\n",
      "        Download the POJO for this model to the directory specified by path; if path is \"\", then dump to screen.\n",
      "        \n",
      "        :param model: the model whose scoring POJO should be retrieved.\n",
      "        :param path: an absolute path to the directory where POJO should be saved.\n",
      "        :param get_jar: retrieve the h2o-genmodel.jar also (will be saved to the same folder ``path``).\n",
      "        :param jar_name: Custom name of genmodel jar.\n",
      "        :returns: location of the downloaded POJO file.\n",
      "    \n",
      "    enable_expr_optimizations(flag)\n",
      "        Enable expression tree local optimizations.\n",
      "    \n",
      "    export_file(frame, path, force=False, parts=1)\n",
      "        Export a given H2OFrame to a path on the machine this python session is currently connected to.\n",
      "        \n",
      "        :param frame: the Frame to save to disk.\n",
      "        :param path: the path to the save point on disk.\n",
      "        :param force: if True, overwrite any preexisting file with the same path\n",
      "        :param parts: enables export to multiple 'part' files instead of just a single file.\n",
      "            Convenient for large datasets that take too long to store in a single file.\n",
      "            Use parts=-1 to instruct H2O to determine the optimal number of part files or\n",
      "            specify your desired maximum number of part files. Path needs to be a directory\n",
      "            when exporting to multiple files, also that directory must be empty.\n",
      "            Default is ``parts = 1``, which is to export to a single file.\n",
      "    \n",
      "    flow()\n",
      "        Open H2O Flow in your browser.\n",
      "    \n",
      "    frame(frame_id)\n",
      "        Retrieve metadata for an id that points to a Frame.\n",
      "        \n",
      "        :param frame_id: the key of a Frame in H2O.\n",
      "        \n",
      "        :returns: dict containing the frame meta-information.\n",
      "    \n",
      "    frames()\n",
      "        Retrieve all the Frames.\n",
      "        \n",
      "        :returns: Meta information on the frames\n",
      "    \n",
      "    get_frame(frame_id, **kwargs)\n",
      "        Obtain a handle to the frame in H2O with the frame_id key.\n",
      "        \n",
      "        :param str frame_id: id of the frame to retrieve.\n",
      "        :returns: an :class:`H2OFrame` object\n",
      "    \n",
      "    get_grid(grid_id)\n",
      "        Return the specified grid.\n",
      "        \n",
      "        :param grid_id: The grid identification in h2o\n",
      "        \n",
      "        :returns: an :class:`H2OGridSearch` instance.\n",
      "    \n",
      "    get_model(model_id)\n",
      "        Load a model from the server.\n",
      "        \n",
      "        :param model_id: The model identification in H2O\n",
      "        \n",
      "        :returns: Model object, a subclass of H2OEstimator\n",
      "    \n",
      "    get_timezone(*args, **kwargs)\n",
      "        Deprecated, use ``h2o.cluster().timezone``.\n",
      "    \n",
      "    import_file(path=None, destination_frame=None, parse=True, header=0, sep=None, col_names=None, col_types=None, na_strings=None, pattern=None)\n",
      "        Import a dataset that is already on the cluster.\n",
      "        \n",
      "        The path to the data must be a valid path for each node in the H2O cluster. If some node in the H2O cluster\n",
      "        cannot see the file, then an exception will be thrown by the H2O cluster. Does a parallel/distributed\n",
      "        multi-threaded pull of the data. The main difference between this method and :func:`upload_file` is that\n",
      "        the latter works with local files, whereas this method imports remote files (i.e. files local to the server).\n",
      "        If you running H2O server on your own maching, then both methods behave the same.\n",
      "        \n",
      "        :param path: path(s) specifying the location of the data to import or a path to a directory of files to import\n",
      "        :param destination_frame: The unique hex key assigned to the imported file. If none is given, a key will be\n",
      "            automatically generated.\n",
      "        :param parse: If True, the file should be parsed after import. If False, then a list is returned containing the file path.\n",
      "        :param header: -1 means the first line is data, 0 means guess, 1 means first line is header.\n",
      "        :param sep: The field separator character. Values on each line of the file are separated by\n",
      "            this character. If not provided, the parser will automatically detect the separator.\n",
      "        :param col_names: A list of column names for the file.\n",
      "        :param col_types: A list of types or a dictionary of column names to types to specify whether columns\n",
      "            should be forced to a certain type upon import parsing. If a list, the types for elements that are\n",
      "            one will be guessed. The possible types a column may have are:\n",
      "        \n",
      "            - \"unknown\" - this will force the column to be parsed as all NA\n",
      "            - \"uuid\"    - the values in the column must be true UUID or will be parsed as NA\n",
      "            - \"string\"  - force the column to be parsed as a string\n",
      "            - \"numeric\" - force the column to be parsed as numeric. H2O will handle the compression of the numeric\n",
      "              data in the optimal manner.\n",
      "            - \"enum\"    - force the column to be parsed as a categorical column.\n",
      "            - \"time\"    - force the column to be parsed as a time column. H2O will attempt to parse the following\n",
      "              list of date time formats: (date) \"yyyy-MM-dd\", \"yyyy MM dd\", \"dd-MMM-yy\", \"dd MMM yy\", (time)\n",
      "              \"HH:mm:ss\", \"HH:mm:ss:SSS\", \"HH:mm:ss:SSSnnnnnn\", \"HH.mm.ss\" \"HH.mm.ss.SSS\", \"HH.mm.ss.SSSnnnnnn\".\n",
      "              Times can also contain \"AM\" or \"PM\".\n",
      "        :param na_strings: A list of strings, or a list of lists of strings (one list per column), or a dictionary\n",
      "            of column names to strings which are to be interpreted as missing values.\n",
      "        :param pattern: Character string containing a regular expression to match file(s) in the folder if `path` is a\n",
      "            directory.\n",
      "        \n",
      "        :returns: a new :class:`H2OFrame` instance.\n",
      "        \n",
      "        :examples:\n",
      "            >>> # Single file import\n",
      "            >>> iris = import_file(\"h2o-3/smalldata/iris.csv\")\n",
      "            >>> # Return all files in the folder iris/ matching the regex r\"iris_.*\\.csv\"\n",
      "            >>> iris_pattern = h2o.import_file(path = \"h2o-3/smalldata/iris\",\n",
      "            ...                                pattern = \"iris_.*\\.csv\")\n",
      "    \n",
      "    import_sql_select(connection_url, select_query, username, password, optimize=True)\n",
      "        Import the SQL table that is the result of the specified SQL query to H2OFrame in memory.\n",
      "        \n",
      "        Creates a temporary SQL table from the specified sql_query.\n",
      "        Runs multiple SELECT SQL queries on the temporary table concurrently for parallel ingestion, then drops the table.\n",
      "        Be sure to start the h2o.jar in the terminal with your downloaded JDBC driver in the classpath::\n",
      "        \n",
      "          java -cp <path_to_h2o_jar>:<path_to_jdbc_driver_jar> water.H2OApp\n",
      "        \n",
      "        Also see h2o.import_sql_table. Currently supported SQL databases are MySQL, PostgreSQL, and MariaDB. Support\n",
      "        for Oracle 12g and Microsoft SQL Server is forthcoming.\n",
      "        \n",
      "        :param connection_url: URL of the SQL database connection as specified by the Java Database Connectivity (JDBC)\n",
      "            Driver. For example, \"jdbc:mysql://localhost:3306/menagerie?&useSSL=false\"\n",
      "        :param select_query: SQL query starting with `SELECT` that returns rows from one or more database tables.\n",
      "        :param username: username for SQL server\n",
      "        :param password: password for SQL server\n",
      "        :param optimize: optimize import of SQL table for faster imports. Experimental.\n",
      "        \n",
      "        :returns: an :class:`H2OFrame` containing data of the specified SQL query.\n",
      "        \n",
      "        :examples:\n",
      "            >>> conn_url = \"jdbc:mysql://172.16.2.178:3306/ingestSQL?&useSSL=false\"\n",
      "            >>> select_query = \"SELECT bikeid from citibike20k\"\n",
      "            >>> username = \"root\"\n",
      "            >>> password = \"abc123\"\n",
      "            >>> my_citibike_data = h2o.import_sql_select(conn_url, select_query,\n",
      "            ...                                          username, password)\n",
      "    \n",
      "    import_sql_table(connection_url, table, username, password, columns=None, optimize=True)\n",
      "        Import SQL table to H2OFrame in memory.\n",
      "        \n",
      "        Assumes that the SQL table is not being updated and is stable.\n",
      "        Runs multiple SELECT SQL queries concurrently for parallel ingestion.\n",
      "        Be sure to start the h2o.jar in the terminal with your downloaded JDBC driver in the classpath::\n",
      "        \n",
      "            java -cp <path_to_h2o_jar>:<path_to_jdbc_driver_jar> water.H2OApp\n",
      "        \n",
      "        Also see :func:`import_sql_select`.\n",
      "        Currently supported SQL databases are MySQL, PostgreSQL, MariaDB, and Netezza. Support for Oracle 12g and Microsoft SQL\n",
      "        Server is forthcoming.\n",
      "        \n",
      "        :param connection_url: URL of the SQL database connection as specified by the Java Database Connectivity (JDBC)\n",
      "            Driver. For example, \"jdbc:mysql://localhost:3306/menagerie?&useSSL=false\"\n",
      "        :param table: name of SQL table\n",
      "        :param columns: a list of column names to import from SQL table. Default is to import all columns.\n",
      "        :param username: username for SQL server\n",
      "        :param password: password for SQL server\n",
      "        :param optimize: optimize import of SQL table for faster imports. Experimental.\n",
      "        \n",
      "        :returns: an :class:`H2OFrame` containing data of the specified SQL table.\n",
      "        \n",
      "        :examples:\n",
      "            >>> conn_url = \"jdbc:mysql://172.16.2.178:3306/ingestSQL?&useSSL=false\"\n",
      "            >>> table = \"citibike20k\"\n",
      "            >>> username = \"root\"\n",
      "            >>> password = \"abc123\"\n",
      "            >>> my_citibike_data = h2o.import_sql_table(conn_url, table, username, password)\n",
      "    \n",
      "    init(url=None, ip=None, port=None, https=None, insecure=None, username=None, password=None, cookies=None, proxy=None, start_h2o=True, nthreads=-1, ice_root=None, enable_assertions=True, max_mem_size=None, min_mem_size=None, strict_version_check=None, ignore_config=False, extra_classpath=None, **kwargs)\n",
      "        Attempt to connect to a local server, or if not successful start a new server and connect to it.\n",
      "        \n",
      "        :param url: Full URL of the server to connect to (can be used instead of `ip` + `port` + `https`).\n",
      "        :param ip: The ip address (or host name) of the server where H2O is running.\n",
      "        :param port: Port number that H2O service is listening to.\n",
      "        :param https: Set to True to connect via https:// instead of http://.\n",
      "        :param insecure: When using https, setting this to True will disable SSL certificates verification.\n",
      "        :param username: Username and\n",
      "        :param password: Password for basic authentication.\n",
      "        :param cookies: Cookie (or list of) to add to each request.\n",
      "        :param proxy: Proxy server address.\n",
      "        :param start_h2o: If False, do not attempt to start an h2o server when connection to an existing one failed.\n",
      "        :param nthreads: \"Number of threads\" option when launching a new h2o server.\n",
      "        :param ice_root: Directory for temporary files for the new h2o server.\n",
      "        :param enable_assertions: Enable assertions in Java for the new h2o server.\n",
      "        :param max_mem_size: Maximum memory to use for the new h2o server.\n",
      "        :param min_mem_size: Minimum memory to use for the new h2o server.\n",
      "        :param strict_version_check: If True, an error will be raised if the client and server versions don't match.\n",
      "        :param ignore_config: Indicates whether a processing of a .h2oconfig file should be conducted or not. Default value is False.\n",
      "        :param extra_classpath: List of paths to libraries that should be included on the Java classpath when starting H2O from Python.\n",
      "        :param kwargs: (all other deprecated attributes)\n",
      "    \n",
      "    interaction(data, factors, pairwise, max_factors, min_occurrence, destination_frame=None)\n",
      "        Categorical Interaction Feature Creation in H2O.\n",
      "        \n",
      "        Creates a frame in H2O with n-th order interaction features between categorical columns, as specified by\n",
      "        the user.\n",
      "        \n",
      "        :param data: the H2OFrame that holds the target categorical columns.\n",
      "        :param factors: factor columns (either indices or column names).\n",
      "        :param pairwise: If True, create pairwise interactions between factors (otherwise create one\n",
      "            higher-order interaction). Only applicable if there are 3 or more factors.\n",
      "        :param max_factors: Max. number of factor levels in pair-wise interaction terms (if enforced, one extra\n",
      "            catch-all factor will be made).\n",
      "        :param min_occurrence: Min. occurrence threshold for factor levels in pair-wise interaction terms\n",
      "        :param destination_frame: a string indicating the destination key. If empty, this will be auto-generated by H2O.\n",
      "        \n",
      "        :returns: :class:`H2OFrame`\n",
      "    \n",
      "    is_expr_optimizations_enabled()\n",
      "    \n",
      "    lazy_import(path, pattern=None)\n",
      "        Import a single file or collection of files.\n",
      "        \n",
      "        :param path: A path to a data file (remote or local).\n",
      "        :param pattern: Character string containing a regular expression to match file(s) in the folder.\n",
      "        :returns: either a :class:`H2OFrame` with the content of the provided file, or a list of such frames if\n",
      "            importing multiple files.\n",
      "    \n",
      "    list_timezones(*args, **kwargs)\n",
      "        Deprecated, use ``h2o.cluster().list_timezones()``.\n",
      "    \n",
      "    load_dataset(relative_path)\n",
      "        Imports a data file within the 'h2o_data' folder.\n",
      "    \n",
      "    load_model(path)\n",
      "        Load a saved H2O model from disk. (Note that ensemble binary models can now be loaded using this method.)\n",
      "        \n",
      "        :param path: the full path of the H2O Model to be imported.\n",
      "        \n",
      "        :returns: an :class:`H2OEstimator` object\n",
      "        \n",
      "        :examples:\n",
      "            >>> path = h2o.save_model(my_model, dir=my_path)\n",
      "            >>> h2o.load_model(path)\n",
      "    \n",
      "    log_and_echo(message='')\n",
      "        Log a message on the server-side logs.\n",
      "        \n",
      "        This is helpful when running several pieces of work one after the other on a single H2O\n",
      "        cluster and you want to make a notation in the H2O server side log where one piece of\n",
      "        work ends and the next piece of work begins.\n",
      "        \n",
      "        Sends a message to H2O for logging. Generally used for debugging purposes.\n",
      "        \n",
      "        :param message: message to write to the log.\n",
      "    \n",
      "    ls()\n",
      "        List keys on an H2O Cluster.\n",
      "    \n",
      "    make_metrics(predicted, actual, domain=None, distribution=None)\n",
      "        Create Model Metrics from predicted and actual values in H2O.\n",
      "        \n",
      "        :param H2OFrame predicted: an H2OFrame containing predictions.\n",
      "        :param H2OFrame actuals: an H2OFrame containing actual values.\n",
      "        :param domain: list of response factors for classification.\n",
      "        :param distribution: distribution for regression.\n",
      "    \n",
      "    network_test(*args, **kwargs)\n",
      "        Deprecated, use ``h2o.cluster().network_test()``.\n",
      "    \n",
      "    no_progress()\n",
      "        Disable the progress bar from flushing to stdout.\n",
      "        \n",
      "        The completed progress bar is printed when a job is complete so as to demarcate a log file.\n",
      "    \n",
      "    parse_raw(setup, id=None, first_line_is_header=0)\n",
      "        Parse dataset using the parse setup structure.\n",
      "        \n",
      "        :param setup: Result of ``h2o.parse_setup()``\n",
      "        :param id: an id for the frame.\n",
      "        :param first_line_is_header: -1, 0, 1 if the first line is to be used as the header\n",
      "        \n",
      "        :returns: an :class:`H2OFrame` object.\n",
      "    \n",
      "    parse_setup(raw_frames, destination_frame=None, header=0, separator=None, column_names=None, column_types=None, na_strings=None)\n",
      "        Retrieve H2O's best guess as to what the structure of the data file is.\n",
      "        \n",
      "        During parse setup, the H2O cluster will make several guesses about the attributes of\n",
      "        the data. This method allows a user to perform corrective measures by updating the\n",
      "        returning dictionary from this method. This dictionary is then fed into `parse_raw` to\n",
      "        produce the H2OFrame instance.\n",
      "        \n",
      "        :param raw_frames: a collection of imported file frames\n",
      "        :param destination_frame: The unique hex key assigned to the imported file. If none is given, a key will\n",
      "            automatically be generated.\n",
      "        :param header: -1 means the first line is data, 0 means guess, 1 means first line is header.\n",
      "        :param separator: The field separator character. Values on each line of the file are separated by\n",
      "            this character. If not provided, the parser will automatically detect the separator.\n",
      "        :param column_names: A list of column names for the file.\n",
      "        :param column_types: A list of types or a dictionary of column names to types to specify whether columns\n",
      "            should be forced to a certain type upon import parsing. If a list, the types for elements that are\n",
      "            one will be guessed. The possible types a column may have are:\n",
      "        \n",
      "            - \"unknown\" - this will force the column to be parsed as all NA\n",
      "            - \"uuid\"    - the values in the column must be true UUID or will be parsed as NA\n",
      "            - \"string\"  - force the column to be parsed as a string\n",
      "            - \"numeric\" - force the column to be parsed as numeric. H2O will handle the compression of the numeric\n",
      "              data in the optimal manner.\n",
      "            - \"enum\"    - force the column to be parsed as a categorical column.\n",
      "            - \"time\"    - force the column to be parsed as a time column. H2O will attempt to parse the following\n",
      "              list of date time formats: (date) \"yyyy-MM-dd\", \"yyyy MM dd\", \"dd-MMM-yy\", \"dd MMM yy\", (time)\n",
      "              \"HH:mm:ss\", \"HH:mm:ss:SSS\", \"HH:mm:ss:SSSnnnnnn\", \"HH.mm.ss\" \"HH.mm.ss.SSS\", \"HH.mm.ss.SSSnnnnnn\".\n",
      "              Times can also contain \"AM\" or \"PM\".\n",
      "        \n",
      "        :param na_strings: A list of strings, or a list of lists of strings (one list per column), or a dictionary\n",
      "            of column names to strings which are to be interpreted as missing values.\n",
      "        \n",
      "        :returns: a dictionary containing parse parameters guessed by the H2O backend.\n",
      "    \n",
      "    rapids(expr)\n",
      "        Execute a Rapids expression.\n",
      "        \n",
      "        :param expr: The rapids expression (ascii string).\n",
      "        \n",
      "        :returns: The JSON response (as a python dictionary) of the Rapids execution.\n",
      "    \n",
      "    remove(x)\n",
      "        Remove object(s) from H2O.\n",
      "        \n",
      "        :param x: H2OFrame, H2OEstimator, or string, or a list of those things: the object(s) or unique id(s)\n",
      "            pointing to the object(s) to be removed.\n",
      "    \n",
      "    remove_all()\n",
      "        Remove all objects from H2O.\n",
      "    \n",
      "    save_model(model, path='', force=False)\n",
      "        Save an H2O Model object to disk. (Note that ensemble binary models can now be saved using this method.)\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: the path of the saved model\n",
      "        \n",
      "        :examples:\n",
      "            >>> path = h2o.save_model(my_model, dir=my_path)\n",
      "    \n",
      "    set_timezone(*args, **kwargs)\n",
      "        Deprecated, set ``h2o.cluster().timezone`` instead.\n",
      "    \n",
      "    show_progress()\n",
      "        Enable the progress bar (it is enabled by default).\n",
      "    \n",
      "    shutdown(*args, **kwargs)\n",
      "        Deprecated, use ``h2o.cluster().shutdown()``.\n",
      "    \n",
      "    upload_custom_metric(func, func_file='metrics.py', func_name=None, class_name=None, source_provider=None)\n",
      "        Upload given metrics function into H2O cluster.\n",
      "        \n",
      "        The metrics can have different representation:\n",
      "          - method\n",
      "          - class: needs to inherit from water.udf.CFunc2 and implement method apply(actual, predict)\n",
      "          returning double\n",
      "          - string: the same as in class case, but the class is given as a string\n",
      "        \n",
      "        :param func:  metrics representation: string, class, function\n",
      "        :param func_file:  internal name of file to save given metrics representation\n",
      "        :param func_name:  name for h2o key under which the given metric is saved\n",
      "        :param class_name: name of class wrapping the metrics function\n",
      "        :param source_provider: a function which provides a source code for given function\n",
      "        :return: reference to uploaded metrics function\n",
      "    \n",
      "    upload_file(path, destination_frame=None, header=0, sep=None, col_names=None, col_types=None, na_strings=None)\n",
      "        Upload a dataset from the provided local path to the H2O cluster.\n",
      "        \n",
      "        Does a single-threaded push to H2O. Also see :meth:`import_file`.\n",
      "        \n",
      "        :param path: A path specifying the location of the data to upload.\n",
      "        :param destination_frame:  The unique hex key assigned to the imported file. If none is given, a key will\n",
      "            be automatically generated.\n",
      "        :param header: -1 means the first line is data, 0 means guess, 1 means first line is header.\n",
      "        :param sep: The field separator character. Values on each line of the file are separated by\n",
      "            this character. If not provided, the parser will automatically detect the separator.\n",
      "        :param col_names: A list of column names for the file.\n",
      "        :param col_types: A list of types or a dictionary of column names to types to specify whether columns\n",
      "            should be forced to a certain type upon import parsing. If a list, the types for elements that are\n",
      "            one will be guessed. The possible types a column may have are:\n",
      "        \n",
      "            - \"unknown\" - this will force the column to be parsed as all NA\n",
      "            - \"uuid\"    - the values in the column must be true UUID or will be parsed as NA\n",
      "            - \"string\"  - force the column to be parsed as a string\n",
      "            - \"numeric\" - force the column to be parsed as numeric. H2O will handle the compression of the numeric\n",
      "              data in the optimal manner.\n",
      "            - \"enum\"    - force the column to be parsed as a categorical column.\n",
      "            - \"time\"    - force the column to be parsed as a time column. H2O will attempt to parse the following\n",
      "              list of date time formats: (date) \"yyyy-MM-dd\", \"yyyy MM dd\", \"dd-MMM-yy\", \"dd MMM yy\", (time)\n",
      "              \"HH:mm:ss\", \"HH:mm:ss:SSS\", \"HH:mm:ss:SSSnnnnnn\", \"HH.mm.ss\" \"HH.mm.ss.SSS\", \"HH.mm.ss.SSSnnnnnn\".\n",
      "              Times can also contain \"AM\" or \"PM\".\n",
      "        :param na_strings: A list of strings, or a list of lists of strings (one list per column), or a dictionary\n",
      "            of column names to strings which are to be interpreted as missing values.\n",
      "        \n",
      "        :returns: a new :class:`H2OFrame` instance.\n",
      "        \n",
      "        :examples:\n",
      "            >>> frame = h2o.upload_file(\"/path/to/local/data\")\n",
      "\n",
      "DATA\n",
      "    __all__ = ('connect', 'init', 'api', 'connection', 'upload_file', 'laz...\n",
      "    __buildinfo__ = \"versionFromGradle='3.20.0',projectVersion='3.20....il...\n",
      "\n",
      "VERSION\n",
      "    3.20.0.3\n",
      "\n",
      "FILE\n",
      "    /anaconda3/lib/python3.6/site-packages/h2o/__init__.py\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "help(h2o)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Starting and Connecting to an H2O Cluster"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The [h2o](http://docs.h2o.ai/h2o/latest-stable/h2o-py/docs/intro.html#h2o-cluster-inspection) Python module contains the [`init`](http://docs.h2o.ai/h2o/latest-stable/h2o-py/docs/h2o.html?highlight=init#h2o.init) function to connecting and potentially starting a local H2O cluster. It also has the [`connect`](http://docs.h2o.ai/h2o/latest-stable/h2o-py/docs/h2o.html?highlight=connect#h2o.connect) function for connecting to an existing H2O cluster, remote or local."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "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: java version \"1.8.0_172\"; Java(TM) SE Runtime Environment (build 1.8.0_172-b11); Java HotSpot(TM) 64-Bit Server VM (build 25.172-b11, mixed mode)\n",
      "  Starting server from /anaconda3/lib/python3.6/site-packages/h2o/backend/bin/h2o.jar\n",
      "  Ice root: /var/folders/wk/m00ydfj52f9fl7zvx5cjztgc0000gn/T/tmpiqqupgi9\n",
      "  JVM stdout: /var/folders/wk/m00ydfj52f9fl7zvx5cjztgc0000gn/T/tmpiqqupgi9/h2o_patrickaboyoun_started_from_python.out\n",
      "  JVM stderr: /var/folders/wk/m00ydfj52f9fl7zvx5cjztgc0000gn/T/tmpiqqupgi9/h2o_patrickaboyoun_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.20.0.3</td></tr>\n",
       "<tr><td>H2O cluster version age:</td>\n",
       "<td>1 month and 17 days </td></tr>\n",
       "<tr><td>H2O cluster name:</td>\n",
       "<td>H2O_from_python_patrickaboyoun_3fq61x</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>5.333 Gb</td></tr>\n",
       "<tr><td>H2O cluster total cores:</td>\n",
       "<td>8</td></tr>\n",
       "<tr><td>H2O cluster allowed cores:</td>\n",
       "<td>8</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>None</td></tr>\n",
       "<tr><td>H2O internal security:</td>\n",
       "<td>False</td></tr>\n",
       "<tr><td>H2O API Extensions:</td>\n",
       "<td>XGBoost, Algos, AutoML, Core V3, Core V4</td></tr>\n",
       "<tr><td>Python version:</td>\n",
       "<td>3.6.6 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.20.0.3\n",
       "H2O cluster version age:    1 month and 17 days\n",
       "H2O cluster name:           H2O_from_python_patrickaboyoun_3fq61x\n",
       "H2O cluster total nodes:    1\n",
       "H2O cluster free memory:    5.333 Gb\n",
       "H2O cluster total cores:    8\n",
       "H2O cluster allowed cores:  8\n",
       "H2O cluster status:         accepting new members, healthy\n",
       "H2O connection url:         http://127.0.0.1:54321\n",
       "H2O connection proxy:\n",
       "H2O internal security:      False\n",
       "H2O API Extensions:         XGBoost, Algos, AutoML, Core V3, Core V4\n",
       "Python version:             3.6.6 final\n",
       "--------------------------  ----------------------------------------"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "h2o.init(max_mem_size = \"6g\") # use h2o.connect() for an existing h2o cluster"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data in H2O"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data Import"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The most common function for loading data into an H2O cluster is to use the [`import_file`](http://docs.h2o.ai/h2o/latest-stable/h2o-py/docs/h2o.html?highlight=import_file#h2o.import_file) on files that are visible to the cluster using either a server-side file system path, HDFS path, S3, or a URL. If the data files are local to the Python client, the [`upload_file`](http://docs.h2o.ai/h2o/latest-stable/h2o-py/docs/h2o.html?highlight=upload_file#h2o.upload_file) function uploads files based upon a local path to the H2O cluster."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This exploration of H2O will use a version of the Lending Club Loan Data that can be found on [Kaggle](https://www.kaggle.com/wendykan/lending-club-loan-data). This data consists of 15 variables:\n",
    "\n",
    "\n",
    "* **loan_amnt**: Requested loan amount (US dollars)\n",
    "* **term**: Loan term length (months)\n",
    "* **int_rate**: Recommended interest rate\n",
    "* **emp_length**: Employment length (years)\n",
    "* **home_ownership**: Housing status\n",
    "* **annual_inc**: Annual income (US dollars)\n",
    "* **purpose**: Purpose for the loan\n",
    "* **addr_state**: State of residence\n",
    "* **dti**: Debt to income ratio\n",
    "* **delinq_2yrs**: Number of delinquencies in the past 2 years\n",
    "* **revol_util**: Percent of revolving credit line utilized\n",
    "* **total_acc**: Number of active accounts\n",
    "* **bad_loan**: Bad loan indicator\n",
    "* **longest_credit_length**: Age of oldest active account\n",
    "* **verification_status**: Income verification status"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parse progress: |█████████████████████████████████████████████████████████| 100%\n"
     ]
    }
   ],
   "source": [
    "train_path = \"https://raw.githubusercontent.com/h2oai/app-consumer-loan/master/data/loan.csv\"\n",
    "train = h2o.import_file(train_path, destination_frame = \"loan_train\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The H2OFrame"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Data in an H2O cluster are represented as [`H2OFrame`](http://docs.h2o.ai/h2o/latest-stable/h2o-py/docs/frame.html) objects in Python. These objects have pandas-like methods for data manipulations. Two of the most important attributes of these objects are [`col_names`](http://docs.h2o.ai/h2o/latest-stable/h2o-py/docs/frame.html?highlight=col_names#h2o.frame.H2OFrame.col_names) attribute, which contain the column names, and\n",
    "[`types`](http://docs.h2o.ai/h2o/latest-stable/h2o-py/docs/frame.html?highlight=types#h2o.frame.H2OFrame.types), which contain the data types for each of the columns. A third important attribute is the [`frame_id`](http://docs.h2o.ai/h2o/latest-stable/h2o-py/docs/frame.html?highlight=frame_id#h2o.frame.H2OFrame.frame_id), which is the key for the H2OFrame within the H2O cluster.\n",
    "\n",
    "In the case of the lending club loan data, the binary outcome, \"bad_loan\", was interpreted as integer and so is coerced to a categorical / enum / factor using the [`asfactor`](http://docs.h2o.ai/h2o/latest-stable/h2o-py/docs/frame.html?highlight=asfactor#h2o.frame.H2OFrame.asfactor) method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "h2o.frame.H2OFrame"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class H2OFrame in module h2o.frame:\n",
      "\n",
      "class H2OFrame(builtins.object)\n",
      " |  Primary data store for H2O.\n",
      " |  \n",
      " |  H2OFrame is similar to pandas' ``DataFrame``, or R's ``data.frame``. One of the critical distinction is that the\n",
      " |  data is generally not held in memory, instead it is located on a (possibly remote) H2O cluster, and thus\n",
      " |  ``H2OFrame`` represents a mere handle to that data.\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __abs__(self)\n",
      " |      # unops\n",
      " |  \n",
      " |  __add__(self, rhs)\n",
      " |      # Binary operations\n",
      " |  \n",
      " |  __and__(self, rhs)\n",
      " |  \n",
      " |  __contains__(self, lhs)\n",
      " |  \n",
      " |  __div__(self, rhs)\n",
      " |  \n",
      " |  __eq__(self, rhs)\n",
      " |      Return self==value.\n",
      " |  \n",
      " |  __float__(self)\n",
      " |  \n",
      " |  __floordiv__(self, rhs)\n",
      " |  \n",
      " |  __ge__(self, rhs)\n",
      " |      Return self>=value.\n",
      " |  \n",
      " |  __getitem__(self, item)\n",
      " |      Frame slicing, supports row and column slicing.\n",
      " |      \n",
      " |      :param item: selector of a subframe. This can be one of the following:\n",
      " |      \n",
      " |          - an int, indicating selection of a single column at the specified index (0-based)\n",
      " |          - a string, selecting a column with the given name\n",
      " |          - a list of ints or strings, selecting several columns with the given indices / names\n",
      " |          - a slice, selecting columns with the indices within this slice\n",
      " |          - a single-column boolean frame, selecting rows for which the selector is true\n",
      " |          - a 2-element tuple, where the first element is a row selector, and the second element is the\n",
      " |            column selector. Here the row selector may be one of: an int, a list of ints, a slice, or\n",
      " |            a boolean frame. The column selector is similarly one of: an int, a list of ints, a string,\n",
      " |            a list of strings, or a slice. It is also possible to use the empty slice (``:``) to select\n",
      " |            all elements within one of the dimensions.\n",
      " |      \n",
      " |      :returns: A new frame comprised of some rows / columns of the source frame.\n",
      " |      \n",
      " |      :examples:\n",
      " |      >>> fr[2]              # All rows, 3rd column\n",
      " |      >>> fr[-2]             # All rows, 2nd column from end\n",
      " |      >>> fr[:, -1]          # All rows, last column\n",
      " |      >>> fr[0:5, :]         # First 5 rows, all columns\n",
      " |      >>> fr[fr[0] > 1, :]   # Only rows where first cell is greater than 1, all columns\n",
      " |      >>> fr[[1, 5, 6]]      # Columns 2, 6, and 7\n",
      " |      >>> fr[0:50, [1,2,3]]  # First 50 rows, columns 2, 3, and 4\n",
      " |  \n",
      " |  __gt__(self, rhs)\n",
      " |      Return self>value.\n",
      " |  \n",
      " |  __init__(self, python_obj=None, destination_frame=None, header=0, separator=',', column_names=None, column_types=None, na_strings=None)\n",
      " |      Create a new H2OFrame object, possibly from some other object.\n",
      " |      \n",
      " |      :param python_obj: object that will be converted to an ``H2OFrame``. This could have multiple types:\n",
      " |      \n",
      " |          - None: create an empty H2OFrame\n",
      " |          - A list/tuple of strings or numbers: create a single-column H2OFrame containing the contents of this list.\n",
      " |          - A dictionary of ``{name: list}`` pairs: create an H2OFrame with multiple columns, each column having the\n",
      " |              provided ``name`` and contents from ``list``. If the source dictionary is not an OrderedDict, then the\n",
      " |              columns in the H2OFrame may appear shuffled.\n",
      " |          - A list of lists of strings/numbers: construct an H2OFrame from a rectangular table of values, with inner\n",
      " |              lists treated as rows of the table. I.e. ``H2OFrame([[1, 'a'], [2, 'b'], [3, 'c']])`` will create a\n",
      " |              frame with 3 rows and 2 columns, one numeric and one string.\n",
      " |          - A Pandas dataframe, or a Numpy ndarray: create a matching H2OFrame.\n",
      " |          - A Scipy sparse matrix: create a matching sparse H2OFrame.\n",
      " |      \n",
      " |      :param int header: if ``python_obj`` is a list of lists, this parameter can be used to indicate whether the\n",
      " |          first row of the data represents headers. The value of -1 means the first row is data, +1 means the first\n",
      " |          row is the headers, 0 (default) allows H2O to guess whether the first row contains data or headers.\n",
      " |      :param List[str] column_names: explicit list of column names for the new H2OFrame. This will override any\n",
      " |          column names derived from the data. If the python_obj does not contain explicit column names, and this\n",
      " |          parameter is not given, then the columns will be named \"C1\", \"C2\", \"C3\", etc.\n",
      " |      :param column_types: explicit column types for the new H2OFrame. This could be either a list of types for\n",
      " |          each column, or a dictionary of {column name: column type} pairs. In the latter case you may override\n",
      " |          types for only few columns, and let H2O choose the types of the rest.\n",
      " |      :param na_strings: List of strings in the input data that should be interpreted as missing values. This could\n",
      " |          be given on a per-column basis, either as a list-of-lists, or as a dictionary {column name: list of nas}.\n",
      " |      :param str destination_frame: (internal) name of the target DKV key in the H2O backend.\n",
      " |      :param str separator: (deprecated)\n",
      " |  \n",
      " |  __int__(self)\n",
      " |  \n",
      " |  __invert__(self)\n",
      " |  \n",
      " |  __iter__(self)\n",
      " |  \n",
      " |  __le__(self, rhs)\n",
      " |      Return self<=value.\n",
      " |  \n",
      " |  __len__(self)\n",
      " |      Number of rows in the dataframe, same as ``self.nrows``.\n",
      " |  \n",
      " |  __lt__(self, rhs)\n",
      " |      Return self<value.\n",
      " |  \n",
      " |  __mod__(self, rhs)\n",
      " |  \n",
      " |  __mul__(self, rhs)\n",
      " |  \n",
      " |  __ne__(self, rhs)\n",
      " |      Return self!=value.\n",
      " |  \n",
      " |  __nonzero__(self)\n",
      " |  \n",
      " |  __or__(self, rhs)\n",
      " |  \n",
      " |  __pow__(self, rhs)\n",
      " |  \n",
      " |  __radd__(self, lhs)\n",
      " |  \n",
      " |  __rand__(self, lhs)\n",
      " |  \n",
      " |  __rdiv__(self, lhs)\n",
      " |  \n",
      " |  __repr__(self)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  __rfloordiv__(self, lhs)\n",
      " |  \n",
      " |  __rmod__(self, lhs)\n",
      " |      # rops\n",
      " |  \n",
      " |  __rmul__(self, lhs)\n",
      " |  \n",
      " |  __ror__(self, lhs)\n",
      " |  \n",
      " |  __rpow__(self, lhs)\n",
      " |  \n",
      " |  __rsub__(self, lhs)\n",
      " |  \n",
      " |  __rtruediv__(self, lhs)\n",
      " |  \n",
      " |  __setitem__(self, item, value)\n",
      " |      Replace, update or add column(s) in an H2OFrame.\n",
      " |      \n",
      " |      :param item: A 0-based index of a column, or a column name, or a list of column names, or a slice.\n",
      " |          Alternatively, this may also be a two-element tuple where the first element in the tuple is a row selector,\n",
      " |          and the second element is a row selector. Finally, this can also be a boolean frame indicating which\n",
      " |          rows/columns to modify. If ``item`` is a column name that does not exist in the frame, then a new column\n",
      " |          will be appended to the current frame.\n",
      " |      :param value: The value replacing elements at positions given by ``item``. This can be either a constant, or\n",
      " |          another frame.\n",
      " |  \n",
      " |  __sub__(self, rhs)\n",
      " |  \n",
      " |  __truediv__(self, rhs)\n",
      " |  \n",
      " |  __unicode__(self)\n",
      " |  \n",
      " |  abs(self)\n",
      " |      Return new H2OFrame equal to elementwise absolute value of the current frame.\n",
      " |  \n",
      " |  acos(self)\n",
      " |      Return new H2OFrame equal to elementwise arc cosine of the current frame.\n",
      " |  \n",
      " |  acosh(self)\n",
      " |      Return new H2OFrame equal to elementwise inverse hyperbolic cosine of the current frame.\n",
      " |  \n",
      " |  all(self)\n",
      " |      Return True if every element in the frame is either True, non-zero or NA.\n",
      " |  \n",
      " |  any(self)\n",
      " |      Return True if any element in the frame is either True, non-zero or NA.\n",
      " |  \n",
      " |  any_na_rm(self)\n",
      " |      Return True if any value in the frame is non-zero (disregarding all NAs).\n",
      " |  \n",
      " |  anyfactor(self)\n",
      " |      Return True if there are any categorical columns in the frame.\n",
      " |  \n",
      " |  apply(self, fun=None, axis=0)\n",
      " |      Apply a lambda expression to an H2OFrame.\n",
      " |      \n",
      " |      :param fun: a lambda expression to be applied per row or per column.\n",
      " |      :param axis: 0 = apply to each column; 1 = apply to each row\n",
      " |      :returns: a new H2OFrame with the results of applying ``fun`` to the current frame.\n",
      " |  \n",
      " |  as_data_frame(self, use_pandas=True, header=True)\n",
      " |      Obtain the dataset as a python-local object.\n",
      " |      \n",
      " |      :param bool use_pandas: If True (default) then return the H2OFrame as a pandas DataFrame (requires that the\n",
      " |          ``pandas`` library was installed). If False, then return the contents of the H2OFrame as plain nested\n",
      " |          list, in a row-wise order.\n",
      " |      :param bool header: If True (default), then column names will be appended as the first row in list\n",
      " |      \n",
      " |      :returns: A python object (a list of lists of strings, each list is a row, if use_pandas=False, otherwise\n",
      " |          a pandas DataFrame) containing this H2OFrame instance's data.\n",
      " |  \n",
      " |  as_date(self, format)\n",
      " |      Convert the frame (containing strings / categoricals) into the ``date`` format.\n",
      " |      \n",
      " |      :param str format: the format string (e.g. \"%Y-%m-%d\")\n",
      " |      :returns: new H2OFrame with \"int\" column types\n",
      " |  \n",
      " |  ascharacter(self)\n",
      " |      Convert all columns in the frame into strings.\n",
      " |      \n",
      " |      :returns: new H2OFrame with columns of \"string\" type.\n",
      " |  \n",
      " |  asfactor(self)\n",
      " |      Convert columns in the current frame to categoricals.\n",
      " |      \n",
      " |      :returns: new H2OFrame with columns of the \"enum\" type.\n",
      " |  \n",
      " |  asin(self)\n",
      " |      Return new H2OFrame equal to elementwise arc sine of the current frame.\n",
      " |  \n",
      " |  asinh(self)\n",
      " |      Return new H2OFrame equal to elementwise inverse hyperbolic sine of the current frame.\n",
      " |  \n",
      " |  asnumeric(self)\n",
      " |      Return new frame with all columns converted to numeric.\n",
      " |  \n",
      " |  atan(self)\n",
      " |      Return new H2OFrame equal to elementwise arc tangent of the current frame.\n",
      " |  \n",
      " |  atanh(self)\n",
      " |      Return new H2OFrame equal to elementwise inverse hyperbolic tangent of the current frame.\n",
      " |  \n",
      " |  bottomN(self, column=0, nPercent=10)\n",
      " |      Given a column name or one column index, a percent N, this function will return the bottom N% of the values\n",
      " |      of the column of a frame.  The column must be a numerical column.\n",
      " |      \n",
      " |      :param column: a string for column name or an integer index\n",
      " |      :param nPercent: a bottom percentage of the column values to return\n",
      " |      :returns: a H2OFrame containing two columns.  The first column contains the original row indices where\n",
      " |          the bottom values are extracted from.  The second column contains the bottom nPercent values.\n",
      " |  \n",
      " |  categories(self)\n",
      " |      Return the list of levels for an enum (categorical) column.\n",
      " |      \n",
      " |      This function can only be applied to single-column categorical frame.\n",
      " |  \n",
      " |  cbind(self, data)\n",
      " |      Append data to this frame column-wise.\n",
      " |      \n",
      " |      :param H2OFrame data: append columns of frame ``data`` to the current frame. You can also cbind a number,\n",
      " |          in which case it will get converted into a constant column.\n",
      " |      \n",
      " |      :returns: new H2OFrame with all frames in ``data`` appended column-wise.\n",
      " |  \n",
      " |  ceil(self)\n",
      " |      Apply the ceiling function to the current frame.\n",
      " |      \n",
      " |      ``ceil(x)`` is the smallest integer greater or equal to ``x``.\n",
      " |      \n",
      " |      :returns: new H2OFrame of ceiling values of the original frame.\n",
      " |  \n",
      " |  columns_by_type(self, coltype='numeric')\n",
      " |      Extract columns of the specified type from the frame.\n",
      " |      \n",
      " |      :param str coltype: A character string indicating which column type to filter by. This must be\n",
      " |          one of the following:\n",
      " |      \n",
      " |          - ``\"numeric\"``      - Numeric, but not categorical or time\n",
      " |          - ``\"categorical\"``  - Integer, with a categorical/factor String mapping\n",
      " |          - ``\"string\"``       - String column\n",
      " |          - ``\"time\"``         - Long msec since the Unix Epoch - with a variety of display/parse options\n",
      " |          - ``\"uuid\"``         - UUID\n",
      " |          - ``\"bad\"``          - No none-NA rows (triple negative! all NAs or zero rows)\n",
      " |      \n",
      " |      :returns: list of indices of columns that have the requested type\n",
      " |  \n",
      " |  concat(self, frames, axis=1)\n",
      " |      Append multiple H2OFrames to this frame, column-wise or row-wise.\n",
      " |      \n",
      " |      :param List[H2OFrame] frames: list of frames that should be appended to the current frame.\n",
      " |      :param int axis: if 1 then append column-wise (default), if 0 then append row-wise.\n",
      " |      \n",
      " |      :returns: an H2OFrame of the combined datasets.\n",
      " |  \n",
      " |  cor(self, y=None, na_rm=False, use=None)\n",
      " |      Compute the correlation matrix of one or two H2OFrames.\n",
      " |      \n",
      " |      :param H2OFrame y: If this parameter is provided, then compute correlation between the columns of ``y``\n",
      " |          and the columns of the current frame. If this parameter is not given, then just compute the correlation\n",
      " |          matrix for the columns of the current frame.\n",
      " |      :param str use: A string indicating how to handle missing values. This could be one of the following:\n",
      " |      \n",
      " |          - ``\"everything\"``: outputs NaNs whenever one of its contributing observations is missing\n",
      " |          - ``\"all.obs\"``: presence of missing observations will throw an error\n",
      " |          - ``\"complete.obs\"``: discards missing values along with all observations in their rows so that only\n",
      " |            complete observations are used\n",
      " |      :param bool na_rm: an alternative to ``use``: when this is True then default value for ``use`` is\n",
      " |          ``\"everything\"``; and if False then default ``use`` is ``\"complete.obs\"``. This parameter has no effect\n",
      " |          if ``use`` is given explicitly.\n",
      " |      \n",
      " |      :returns: An H2OFrame of the correlation matrix of the columns of this frame (if ``y`` is not given),\n",
      " |          or with the columns of ``y`` (if ``y`` is given). However when this frame and ``y`` are both single rows\n",
      " |          or single columns, then the correlation is returned as a scalar.\n",
      " |  \n",
      " |  cos(self)\n",
      " |      Return new H2OFrame equal to elementwise cosine of the current frame.\n",
      " |  \n",
      " |  cosh(self)\n",
      " |      Make new H2OFrame with values equal to the hyperbolic cosines of the values in the current frame.\n",
      " |  \n",
      " |  cospi(self)\n",
      " |      Return new H2OFrame equal to elementwise cosine of the current frame multiplied by Pi.\n",
      " |  \n",
      " |  countmatches(self, pattern)\n",
      " |      For each string in the frame, count the occurrences of the provided pattern.  If countmathces is applied to\n",
      " |      a frame, all columns of the frame must be type string, otherwise, the returned frame will contain errors.\n",
      " |      \n",
      " |      The pattern here is a plain string, not a regular expression. We will search for the occurrences of the\n",
      " |      pattern as a substring in element of the frame. This function is applicable to frames containing only\n",
      " |      string or categorical columns.\n",
      " |      \n",
      " |      :param str pattern: The pattern to count matches on in each string. This can also be a list of strings,\n",
      " |          in which case all of them will be searched for.\n",
      " |      :returns: numeric H2OFrame with the same shape as the original, containing counts of matches of the\n",
      " |          pattern for each cell in the original frame.\n",
      " |  \n",
      " |  cummax(self, axis=0)\n",
      " |      Compute cumulative maximum over rows / columns of the frame.\n",
      " |      \n",
      " |      :param int axis: 0 for column-wise, 1 for row-wise\n",
      " |      :returns: new H2OFrame with running maximums of the original frame.\n",
      " |  \n",
      " |  cummin(self, axis=0)\n",
      " |      Compute cumulative minimum over rows / columns of the frame.\n",
      " |      \n",
      " |      :param int axis: 0 for column-wise, 1 for row-wise\n",
      " |      :returns: new H2OFrame with running minimums of the original frame.\n",
      " |  \n",
      " |  cumprod(self, axis=0)\n",
      " |      Compute cumulative product over rows / columns of the frame.\n",
      " |      \n",
      " |      :param int axis: 0 for column-wise, 1 for row-wise\n",
      " |      :returns: new H2OFrame with cumulative products of the original frame.\n",
      " |  \n",
      " |  cumsum(self, axis=0)\n",
      " |      Compute cumulative sum over rows / columns of the frame.\n",
      " |      \n",
      " |      :param int axis: 0 for column-wise, 1 for row-wise\n",
      " |      :returns: new H2OFrame with cumulative sums of the original frame.\n",
      " |  \n",
      " |  cut(self, breaks, labels=None, include_lowest=False, right=True, dig_lab=3)\n",
      " |      Cut a numeric vector into categorical \"buckets\".\n",
      " |      \n",
      " |      This method is only applicable to a single-column numeric frame.\n",
      " |      \n",
      " |      :param List[float] breaks: The cut points in the numeric vector.\n",
      " |      :param List[str] labels: Labels for categorical levels produced. Defaults to set notation of\n",
      " |          intervals defined by the breaks.\n",
      " |      :param bool include_lowest: By default, cuts are defined as intervals ``(lo, hi]``. If this parameter\n",
      " |          is True, then the interval becomes ``[lo, hi]``.\n",
      " |      :param bool right: Include the high value: ``(lo, hi]``. If False, get ``(lo, hi)``.\n",
      " |      :param int dig_lab: Number of digits following the decimal point to consider.\n",
      " |      \n",
      " |      :returns: Single-column H2OFrame of categorical data.\n",
      " |  \n",
      " |  day(self)\n",
      " |      Extract the \"day\" part from a date column.\n",
      " |      \n",
      " |      :returns: a single-column H2OFrame containing the \"day\" part from the source frame.\n",
      " |  \n",
      " |  dayOfWeek(self)\n",
      " |      Extract the \"day-of-week\" part from a date column.\n",
      " |      \n",
      " |      :returns: a single-column H2OFrame containing the \"day-of-week\" part from the source frame.\n",
      " |  \n",
      " |  describe(self, chunk_summary=False)\n",
      " |      Generate an in-depth description of this H2OFrame.\n",
      " |      \n",
      " |      This will print to the console the dimensions of the frame; names/types/summary statistics for each column;\n",
      " |      and finally first ten rows of the frame.\n",
      " |      \n",
      " |      :param bool chunk_summary: Retrieve the chunk summary along with the distribution summary\n",
      " |  \n",
      " |  difflag1(self)\n",
      " |      Conduct a diff-1 transform on a numeric frame column.\n",
      " |      \n",
      " |      :returns: an H2OFrame where each element is equal to the corresponding element in the source\n",
      " |          frame minus the previous-row element in the same frame.\n",
      " |  \n",
      " |  digamma(self)\n",
      " |      Return new H2OFrame equals to elementwise digamma function of the current frame.\n",
      " |  \n",
      " |  distance(self, y, measure=None)\n",
      " |      Compute a pairwise distance measure between all rows of two numeric H2OFrames.\n",
      " |      \n",
      " |      :param H2OFrame y: Frame containing queries (small)\n",
      " |      :param str use: A string indicating what distance measure to use. Must be one of:\n",
      " |      \n",
      " |          - ``\"l1\"``:        Absolute distance (L1-norm, >=0)\n",
      " |          - ``\"l2\"``:        Euclidean distance (L2-norm, >=0)\n",
      " |          - ``\"cosine\"``:    Cosine similarity (-1...1)\n",
      " |          - ``\"cosine_sq\"``: Squared Cosine similarity (0...1)\n",
      " |      \n",
      " |      :examples:\n",
      " |        >>>\n",
      " |        >>> iris_h2o = h2o.import_file(path=pyunit_utils.locate(\"smalldata/iris/iris.csv\"))\n",
      " |        >>> references = iris_h2o[10:150,0:4\n",
      " |        >>> queries    = iris_h2o[0:10,0:4]\n",
      " |        >>> A = references.distance(queries, \"l1\")\n",
      " |        >>> B = references.distance(queries, \"l2\")\n",
      " |        >>> C = references.distance(queries, \"cosine\")\n",
      " |        >>> D = references.distance(queries, \"cosine_sq\")\n",
      " |        >>> E = queries.distance(references, \"l1\")\n",
      " |        >>> (E.transpose() == A).all()\n",
      " |      \n",
      " |      :returns: An H2OFrame of the matrix containing pairwise distance / similarity between the \n",
      " |          rows of this frame (N x p) and ``y`` (M x p), with dimensions (N x M).\n",
      " |  \n",
      " |  drop(self, index, axis=1)\n",
      " |      Drop a single column or row or a set of columns or rows from a H2OFrame.\n",
      " |      \n",
      " |      Dropping a column or row is not in-place.\n",
      " |      Indices of rows and columns are zero-based.\n",
      " |      \n",
      " |      :param index: A list of column indices, column names, or row indices to drop; or\n",
      " |          a string to drop a single column by name; or an int to drop a single column by index.\n",
      " |      \n",
      " |      :param int axis: If 1 (default), then drop columns; if 0 then drop rows.\n",
      " |      \n",
      " |      :returns: a new H2OFrame with the respective dropped columns or rows. The original H2OFrame remains\n",
      " |          unchanged.\n",
      " |  \n",
      " |  entropy(self)\n",
      " |      For each string compute its Shannon entropy, if the string is empty the entropy is 0.\n",
      " |      \n",
      " |      :returns: an H2OFrame of Shannon entropies.\n",
      " |  \n",
      " |  exp(self)\n",
      " |      Return new H2OFrame equals to elementwise exponent (i.e. ``e^x``) of the current frame.\n",
      " |  \n",
      " |  expm1(self)\n",
      " |      Return new H2OFrame equals to elementwise exponent minus 1 (i.e. ``e^x - 1``) of the current frame.\n",
      " |  \n",
      " |  fillna(self, method='forward', axis=0, maxlen=1)\n",
      " |      Return a new Frame that fills NA along a given axis and along a given direction with a maximum fill length\n",
      " |      \n",
      " |      :param method: ``\"forward\"`` or ``\"backward\"``\n",
      " |      :param axis:  0 for columnar-wise or 1 for row-wise fill\n",
      " |      :param maxlen: Max number of consecutive NA's to fill\n",
      " |      \n",
      " |      :return:\n",
      " |  \n",
      " |  filter_na_cols(self, frac=0.2)\n",
      " |      Filter columns with proportion of NAs greater or equals than ``frac``.\n",
      " |      \n",
      " |      :param float frac: Maximum fraction of NAs in the column to keep.\n",
      " |      \n",
      " |      :returns: A list of indices of columns that have fewer NAs than ``frac``. If all columns are filtered,\n",
      " |          None is returned.\n",
      " |  \n",
      " |  flatten(self)\n",
      " |      Convert a 1x1 frame into a scalar.\n",
      " |      \n",
      " |      :returns: content of this 1x1 frame as a scalar (``int``, ``float``, or ``str``).\n",
      " |      :raises H2OValueError: if current frame has shape other than 1x1\n",
      " |  \n",
      " |  floor(self)\n",
      " |      Apply the floor function to the current frame.\n",
      " |      \n",
      " |      ``floor(x)`` is the largest integer smaller or equal to ``x``.\n",
      " |      \n",
      " |      :returns: new H2OFrame of floor values of the original frame.\n",
      " |  \n",
      " |  gamma(self)\n",
      " |      Return new H2OFrame equals to elementwise gamma function of the current frame.\n",
      " |  \n",
      " |  get_frame_data(self)\n",
      " |      Get frame data as a string in csv format.\n",
      " |      \n",
      " |      This will create a multiline string, where each line will contain a separate row of frame's data, with\n",
      " |      individual values separated by commas.\n",
      " |  \n",
      " |  getrow(self)\n",
      " |      Convert a 1xn frame into an n-element list.\n",
      " |      \n",
      " |      :returns: content of this 1xn frame as a Python list.\n",
      " |      :raises H2OValueError: if current frame has more than one row.\n",
      " |  \n",
      " |  grep(self, pattern, ignore_case=False, invert=False, output_logical=False)\n",
      " |      Searches for matches to argument `pattern` within each element\n",
      " |      of a string column.\n",
      " |      \n",
      " |      Default behavior is to return indices of the elements matching the pattern. Parameter\n",
      " |      `output_logical` can be used to return a logical vector indicating if the element matches\n",
      " |      the pattern (1) or not (0).\n",
      " |      \n",
      " |      :param str pattern: A character string containing a regular expression.\n",
      " |      :param bool ignore_case: If True, then case is ignored during matching.\n",
      " |      :param bool invert:  If True, then identify elements that do not match the pattern.\n",
      " |      :param bool output_logical: If True, then return logical vector of indicators instead of list of matching positions\n",
      " |      :return: H2OFrame holding the matching positions or a logical list if `output_logical` is enabled.\n",
      " |  \n",
      " |  group_by(self, by)\n",
      " |      Return a new ``GroupBy`` object using this frame and the desired grouping columns.\n",
      " |      \n",
      " |      The returned groups are sorted by the natural group-by column sort.\n",
      " |      \n",
      " |      :param by: The columns to group on (either a single column name, or a list of column names, or\n",
      " |          a list of column indices).\n",
      " |  \n",
      " |  gsub(self, pattern, replacement, ignore_case=False)\n",
      " |      Globally substitute occurrences of pattern in a string with replacement.\n",
      " |      \n",
      " |      :param str pattern: A regular expression.\n",
      " |      :param str replacement: A replacement string.\n",
      " |      :param bool ignore_case: If True then pattern will match case-insensitively.\n",
      " |      :returns: an H2OFrame with all occurrences of ``pattern`` in all values replaced with ``replacement``.\n",
      " |  \n",
      " |  head(self, rows=10, cols=200)\n",
      " |      Return the first ``rows`` and ``cols`` of the frame as a new H2OFrame.\n",
      " |      \n",
      " |      :param int rows: maximum number of rows to return\n",
      " |      :param int cols: maximum number of columns to return\n",
      " |      :returns: a new H2OFrame cut from the top left corner of the current frame, and having dimensions at\n",
      " |          most ``rows`` x ``cols``.\n",
      " |  \n",
      " |  hist(self, breaks='sturges', plot=True, **kwargs)\n",
      " |      Compute a histogram over a numeric column.\n",
      " |      \n",
      " |      :param breaks: Can be one of ``\"sturges\"``, ``\"rice\"``, ``\"sqrt\"``, ``\"doane\"``, ``\"fd\"``, ``\"scott\"``;\n",
      " |          or a single number for the number of breaks; or a list containing the split points, e.g:\n",
      " |          ``[-50, 213.2123, 9324834]``. If breaks is \"fd\", the MAD is used over the IQR in computing bin width.\n",
      " |      :param bool plot: If True (default), then a plot will be generated using ``matplotlib``.\n",
      " |      \n",
      " |      :returns: If ``plot`` is False, return H2OFrame with these columns: breaks, counts, mids_true,\n",
      " |          mids, and density; otherwise this method draws a plot and returns nothing.\n",
      " |  \n",
      " |  hour(self)\n",
      " |      Extract the \"hour-of-day\" part from a date column.\n",
      " |      \n",
      " |      :returns: a single-column H2OFrame containing the \"hour-of-day\" part from the source frame.\n",
      " |  \n",
      " |  idxmax(self, skipna=True, axis=0)\n",
      " |      Get the index of the max value in a column or row\n",
      " |      \n",
      " |      :param bool skipna: If True (default), then NAs are ignored during the search. Otherwise presence\n",
      " |          of NAs renders the entire result NA.\n",
      " |      :param int axis: Direction of finding the max index. If 0 (default), then the max index is searched columnwise, and the\n",
      " |          result is a frame with 1 row and number of columns as in the original frame. If 1, then the max index is searched\n",
      " |          rowwise and the result is a frame with 1 column, and number of rows equal to the number of rows in the original frame.\n",
      " |      :returns: either a list of max index values per-column or an H2OFrame containing max index values\n",
      " |                per-row from the original frame.\n",
      " |  \n",
      " |  idxmin(self, skipna=True, axis=0)\n",
      " |      Get the index of the min value in a column or row\n",
      " |      \n",
      " |      :param bool skipna: If True (default), then NAs are ignored during the search. Otherwise presence\n",
      " |          of NAs renders the entire result NA.\n",
      " |      :param int axis: Direction of finding the min index. If 0 (default), then the min index is searched columnwise, and the\n",
      " |          result is a frame with 1 row and number of columns as in the original frame. If 1, then the min index is searched\n",
      " |          rowwise and the result is a frame with 1 column, and number of rows equal to the number of rows in the original frame.\n",
      " |      :returns: either a list of min index values per-column or an H2OFrame containing min index values\n",
      " |                per-row from the original frame.\n",
      " |  \n",
      " |  ifelse(self, yes, no)\n",
      " |      Equivalent to ``[y if t else n for t,y,n in zip(self,yes,no)]``.\n",
      " |      \n",
      " |      Based on the booleans in the test vector, the output has the values of the\n",
      " |      yes and no vectors interleaved (or merged together).  All Frames must have\n",
      " |      the same row count.  Single column frames are broadened to match wider\n",
      " |      Frames.  Scalars are allowed, and are also broadened to match wider frames.\n",
      " |      \n",
      " |      :param yes: Frame to use if ``test`` is true; may be a scalar or single column\n",
      " |      :param no: Frame to use if ``test`` is false; may be a scalar or single column\n",
      " |      \n",
      " |      :returns: an H2OFrame of the merged yes/no frames/scalars according to the test input frame.\n",
      " |  \n",
      " |  impute(self, column=-1, method='mean', combine_method='interpolate', by=None, group_by_frame=None, values=None)\n",
      " |      Impute missing values into the frame, modifying it in-place.\n",
      " |      \n",
      " |      :param int column: Index of the column to impute, or -1 to impute the entire frame.\n",
      " |      :param str method: The method of imputation: ``\"mean\"``, ``\"median\"``, or ``\"mode\"``.\n",
      " |      :param str combine_method: When the method is ``\"median\"``, this setting dictates how to combine quantiles\n",
      " |          for even samples. One of ``\"interpolate\"``, ``\"average\"``, ``\"low\"``, ``\"high\"``.\n",
      " |      :param by: The list of columns to group on.\n",
      " |      :param H2OFrame group_by_frame: Impute the values with this pre-computed grouped frame.\n",
      " |      :param List values: The list of impute values, one per column. None indicates to skip the column.\n",
      " |      \n",
      " |      :returns: A list of values used in the imputation or the group-by result used in imputation.\n",
      " |  \n",
      " |  insert_missing_values(self, fraction=0.1, seed=None)\n",
      " |      Insert missing values into the current frame, modifying it in-place.\n",
      " |      \n",
      " |      Randomly replaces a user-specified fraction of entries in a H2O dataset with missing\n",
      " |      values.\n",
      " |      \n",
      " |      :param float fraction: A number between 0 and 1 indicating the fraction of entries to replace with missing.\n",
      " |      :param int seed: The seed for the random number generator used to determine which values to make missing.\n",
      " |      \n",
      " |      :returns: the original H2OFrame with missing values inserted.\n",
      " |  \n",
      " |  interaction(self, factors, pairwise, max_factors, min_occurrence, destination_frame=None)\n",
      " |      Categorical Interaction Feature Creation in H2O.\n",
      " |      \n",
      " |      Creates a frame in H2O with n-th order interaction features between categorical columns, as specified by\n",
      " |      the user.\n",
      " |      \n",
      " |      :param factors: list of factor columns (either indices or column names).\n",
      " |      :param bool pairwise: Whether to create pairwise interactions between factors (otherwise create one\n",
      " |          higher-order interaction). Only applicable if there are 3 or more factors.\n",
      " |      :param int max_factors: Max. number of factor levels in pair-wise interaction terms (if enforced, one extra\n",
      " |          catch-all factor will be made).\n",
      " |      :param int min_occurrence: Min. occurrence threshold for factor levels in pair-wise interaction terms.\n",
      " |      :param str destination_frame: (internal) string indicating the key for the frame created.\n",
      " |      \n",
      " |      :returns: an H2OFrame\n",
      " |  \n",
      " |  isax(self, num_words, max_cardinality, optimize_card=False, **kwargs)\n",
      " |      Compute the iSAX index for DataFrame which is assumed to be numeric time series data.\n",
      " |      \n",
      " |      References:\n",
      " |      \n",
      " |          - http://www.cs.ucr.edu/~eamonn/SAX.pdf\n",
      " |          - http://www.cs.ucr.edu/~eamonn/iSAX_2.0.pdf\n",
      " |      \n",
      " |      :param int num_words: Number of iSAX words for the timeseries, i.e. granularity along the time series\n",
      " |      :param int max_cardinality: Maximum cardinality of the iSAX word. Each word can have less than the max\n",
      " |      :param bool optimized_card: An optimization flag that will find the max cardinality regardless of what is\n",
      " |          passed in for ``max_cardinality``.\n",
      " |      \n",
      " |      :returns: An H2OFrame with the name of time series, string representation of iSAX word, followed by\n",
      " |          binary representation.\n",
      " |  \n",
      " |  ischaracter(self)\n",
      " |      [DEPRECATED] Use ``frame.isstring()``.\n",
      " |  \n",
      " |  isfactor(self)\n",
      " |      Test which columns in the current frame are categorical.\n",
      " |      \n",
      " |      :returns: a list of True/False indicating for each column in the frame whether it is categorical.\n",
      " |  \n",
      " |  isin(self, item)\n",
      " |      Test whether elements of an H2OFrame are contained in the ``item``.\n",
      " |      \n",
      " |      :param items: An item or a list of items to compare the H2OFrame against.\n",
      " |      \n",
      " |      :returns: An H2OFrame of 0s and 1s showing whether each element in the original H2OFrame is contained in item.\n",
      " |  \n",
      " |  isna(self)\n",
      " |      For each element in an H2OFrame, determine if it is NA or not.\n",
      " |      \n",
      " |      :returns: an H2OFrame of 1s and 0s, where 1s mean the values were NAs.\n",
      " |  \n",
      " |  isnumeric(self)\n",
      " |      Test which columns in the frame are numeric.\n",
      " |      \n",
      " |      :returns: a list of True/False indicating for each column in the frame whether it is numeric.\n",
      " |  \n",
      " |  isstring(self)\n",
      " |      Test which columns in the frame are string.\n",
      " |      \n",
      " |      :returns: a list of True/False indicating for each column in the frame whether it is numeric.\n",
      " |  \n",
      " |  kfold_column(self, n_folds=3, seed=-1)\n",
      " |      Build a fold assignments column for cross-validation.\n",
      " |      \n",
      " |      This method will produce a column having the same data layout as the source frame.\n",
      " |      \n",
      " |      :param int n_folds: An integer specifying the number of validation sets to split the training data into.\n",
      " |      :param int seed: Seed for random numbers as fold IDs are randomly assigned.\n",
      " |      \n",
      " |      :returns: A single column H2OFrame with the fold assignments.\n",
      " |  \n",
      " |  kurtosis(self, na_rm=False)\n",
      " |      Compute the kurtosis of each column in the frame.\n",
      " |      \n",
      " |      We calculate the common kurtosis, such that kurtosis(normal distribution) is 3.\n",
      " |      \n",
      " |      :param bool na_rm: If True, then ignore NAs during the computation.\n",
      " |      :returns: A list containing the kurtosis for each column (NaN for non-numeric columns).\n",
      " |  \n",
      " |  levels(self)\n",
      " |      Get the factor levels.\n",
      " |      \n",
      " |      :returns: A list of lists, one list per column, of levels.\n",
      " |  \n",
      " |  lgamma(self)\n",
      " |      Return new H2OFrame equals to elementwise logarithm of the gamma function of the current frame.\n",
      " |  \n",
      " |  log(self)\n",
      " |      Return new H2OFrame equals to elementwise natural logarithm of the current frame.\n",
      " |  \n",
      " |  log10(self)\n",
      " |      Return new H2OFrame equals to elementwise decimal logarithm of the current frame.\n",
      " |  \n",
      " |  log1p(self)\n",
      " |      Return new H2OFrame equals to elementwise ``ln(1 + x)`` for each ``x`` in the current frame.\n",
      " |  \n",
      " |  log2(self)\n",
      " |      Return new H2OFrame equals to elementwise binary logarithm of the current frame.\n",
      " |  \n",
      " |  logical_negation(self)\n",
      " |      Returns new H2OFrame equal to elementwise Logical NOT applied to the current frame.\n",
      " |  \n",
      " |  lstrip(self, set=' ')\n",
      " |      Return a copy of the column with leading characters removed.\n",
      " |      \n",
      " |      The set argument is a string specifying the set of characters to be removed.\n",
      " |      If omitted, the set argument defaults to removing whitespace.\n",
      " |      \n",
      " |      :param character set: The set of characters to lstrip from strings in column.\n",
      " |      :returns: a new H2OFrame with the same shape as the original frame and having all its values\n",
      " |          trimmed from the left (equivalent of Python's ``str.lstrip()``).\n",
      " |  \n",
      " |  match(self, table, nomatch=0)\n",
      " |      Make a vector of the positions of (first) matches of its first argument in its second.\n",
      " |      \n",
      " |      Only applicable to single-column categorical/string frames.\n",
      " |      \n",
      " |      :param List table: the list of items to match against\n",
      " |      :param int nomatch: value that should be returned when there is no match.\n",
      " |      :returns: a new H2OFrame containing for each cell from the source frame the index where\n",
      " |          the pattern ``table`` first occurs within that cell.\n",
      " |  \n",
      " |  max(self)\n",
      " |      The maximum value of all frame entries.\n",
      " |  \n",
      " |  mean(self, skipna=True, axis=0, **kwargs)\n",
      " |      Compute the frame's means by-column (or by-row).\n",
      " |      \n",
      " |      :param bool skipna: If True (default), then NAs are ignored during the computation. Otherwise presence\n",
      " |          of NAs renders the entire result NA.\n",
      " |      :param int axis: Direction of mean computation. If 0 (default), then mean is computed columnwise, and the\n",
      " |          result is a frame with 1 row and number of columns as in the original frame. If 1, then mean is computed\n",
      " |          rowwise and the result is a frame with 1 column (called \"mean\"), and number of rows equal to the number\n",
      " |          of rows in the original frame.\n",
      " |      :returns: either a list of mean values per-column (old semantic); or an H2OFrame containing mean values\n",
      " |          per-column/per-row from the original frame (new semantic). The new semantic is triggered by either\n",
      " |          providing the ``return_frame=True`` parameter, or having the ``general.allow_breaking_changed`` config\n",
      " |          option turned on.\n",
      " |  \n",
      " |  median(self, na_rm=False)\n",
      " |      Compute the median of each column in the frame.\n",
      " |      \n",
      " |      :param bool na_rm: If True, then ignore NAs during the computation.\n",
      " |      :returns: A list containing the median for each column (NaN for non-numeric columns).\n",
      " |  \n",
      " |  merge(self, other, all_x=False, all_y=False, by_x=None, by_y=None, method='auto')\n",
      " |      Merge two datasets based on common column names.  We do not support all_x=True and all_y=True.\n",
      " |      Only one can be True or none is True.  The default merge method is auto and it will default to the\n",
      " |      radix method.  The radix method will return the correct merge result regardless of duplicated rows\n",
      " |       in the right frame.  In addition, the radix method can perform merge even if you have string columns\n",
      " |       in your frames.  If there are duplicated rows in your rite frame, they will not be included if you use\n",
      " |      the hash method.  The hash method cannot perform merge if you have string columns in your left frame.\n",
      " |      Hence, we consider the radix method superior to the hash method and is the default method to use.\n",
      " |      \n",
      " |      :param H2OFrame other: The frame to merge to the current one. By default, must have at least one column in common with\n",
      " |          this frame, and all columns in common are used as the merge key.  If you want to use only a subset of the\n",
      " |          columns in common, rename the other columns so the columns are unique in the merged result.\n",
      " |      :param bool all_x: If True, include all rows from the left/self frame\n",
      " |      :param bool all_y: If True, include all rows from the right/other frame\n",
      " |      :param by_x: list of columns in the current frame to use as a merge key.\n",
      " |      :param by_y: list of columns in the ``other`` frame to use as a merge key. Should have the same number of\n",
      " |          columns as in the ``by_x`` list.\n",
      " |      :param method: string representing the merge method, one of auto(default), radix or hash.\n",
      " |      \n",
      " |      :returns: New H2OFrame with the result of merging the current frame with the ``other`` frame.\n",
      " |  \n",
      " |  min(self)\n",
      " |      The minimum value of all frame entries.\n",
      " |  \n",
      " |  minute(self)\n",
      " |      Extract the \"minute\" part from a date column.\n",
      " |      \n",
      " |      :returns: a single-column H2OFrame containing the \"minute\" part from the source frame.\n",
      " |  \n",
      " |  modulo_kfold_column(self, n_folds=3)\n",
      " |      Build a fold assignments column for cross-validation.\n",
      " |      \n",
      " |      Rows are assigned a fold according to the current row number modulo ``n_folds``.\n",
      " |      \n",
      " |      :param int n_folds: An integer specifying the number of validation sets to split the training data into.\n",
      " |      :returns: A single-column H2OFrame with the fold assignments.\n",
      " |  \n",
      " |  month(self)\n",
      " |      Extract the \"month\" part from a date column.\n",
      " |      \n",
      " |      :returns: a single-column H2OFrame containing the \"month\" part from the source frame.\n",
      " |  \n",
      " |  mult(self, matrix)\n",
      " |      Multiply this frame, viewed as a matrix, by another matrix.\n",
      " |      \n",
      " |      :param matrix: another frame that you want to multiply the current frame by; must be compatible with the\n",
      " |          current frame (i.e. its number of rows must be the same as number of columns in the current frame).\n",
      " |      :returns: new H2OFrame, which is the result of multiplying the current frame by ``matrix``.\n",
      " |  \n",
      " |  na_omit(self)\n",
      " |      Remove rows with NAs from the H2OFrame.\n",
      " |      \n",
      " |      :returns: new H2OFrame with all rows from the original frame containing any NAs removed.\n",
      " |  \n",
      " |  nacnt(self)\n",
      " |      Count of NAs for each column in this H2OFrame.\n",
      " |      \n",
      " |      :returns: A list of the na counts (one entry per column).\n",
      " |  \n",
      " |  nchar(self)\n",
      " |      Count the length of each string in a single-column H2OFrame of string type.\n",
      " |      \n",
      " |      :returns: A single-column H2OFrame containing the per-row character count.\n",
      " |  \n",
      " |  nlevels(self)\n",
      " |      Get the number of factor levels for each categorical column.\n",
      " |      \n",
      " |      :returns: A list of the number of levels per column.\n",
      " |  \n",
      " |  num_valid_substrings(self, path_to_words)\n",
      " |      For each string, find the count of all possible substrings with 2 characters or more that are contained in\n",
      " |      the line-separated text file whose path is given.\n",
      " |      \n",
      " |      :param str path_to_words: Path to file that contains a line-separated list of strings considered valid.\n",
      " |      :returns: An H2OFrame with the number of substrings that are contained in the given word list.\n",
      " |  \n",
      " |  pivot(self, index, column, value)\n",
      " |      Pivot the frame designated by the three columns: index, column, and value. Index and column should be\n",
      " |      of type enum, int, or time.\n",
      " |      For cases of multiple indexes for a column label, the aggregation method is to pick the first occurrence in the data frame\n",
      " |      \n",
      " |      :param index: Index is a column that will be the row label\n",
      " |      :param column: The labels for the columns in the pivoted Frame\n",
      " |      :param value: The column of values for the given index and column label\n",
      " |      :returns:\n",
      " |  \n",
      " |  pop(self, i)\n",
      " |      Pop a column from the H2OFrame at index i.\n",
      " |      \n",
      " |      :param i: The index (int) or name (str) of the column to pop.\n",
      " |      :returns: an H2OFrame containing the column dropped from the current frame; the current frame is modified\n",
      " |          in-place and loses the column.\n",
      " |  \n",
      " |  prod(self, na_rm=False)\n",
      " |      Compute the product of all values across all rows in a single column H2O frame.  If you apply\n",
      " |      this command on a multi-column H2O frame, the answer may not be correct.\n",
      " |      \n",
      " |      :param bool na_rm: If True then NAs will be ignored during the computation.\n",
      " |      :returns: product of all values in the frame (a float)\n",
      " |  \n",
      " |  quantile(self, prob=None, combine_method='interpolate', weights_column=None)\n",
      " |      Compute quantiles.\n",
      " |      \n",
      " |      :param List[float] prob: list of probabilities for which quantiles should be computed.\n",
      " |      :param str combine_method: for even samples this setting determines how to combine quantiles. This can be\n",
      " |          one of ``\"interpolate\"``, ``\"average\"``, ``\"low\"``, ``\"high\"``.\n",
      " |      :param weights_column: optional weights for each row. If not given, all rows are assumed to have equal\n",
      " |          importance. This parameter can be either the name of column containing the observation weights in\n",
      " |          this frame, or a single-column separate H2OFrame of observation weights.\n",
      " |      \n",
      " |      :returns: a new H2OFrame containing the quantiles and probabilities.\n",
      " |  \n",
      " |  rank_within_group_by(self, group_by_cols, sort_cols, ascending=[], new_col_name='New_Rank_column', sort_cols_sorted=False)\n",
      " |      This function will add a new column rank where the ranking is produced as follows:\n",
      " |       1. sorts the H2OFrame by columns sorted in by columns specified in group_by_cols and sort_cols in the directions\n",
      " |         specified by the ascending for the sort_cols.  The sort directions for the group_by_cols are ascending only.\n",
      " |       2. A new rank column is added to the frame which will contain a rank assignment performed next.  The user can\n",
      " |         choose to assign a name to this new column.  The default name is New_Rank_column.\n",
      " |       3. For each groupby groups, a rank is assigned to the row starting from 1, 2, ... to the end of that group.\n",
      " |       4. If sort_cols_sorted is TRUE, a final sort on the frame will be performed frame according to the sort_cols and\n",
      " |          the sort directions in ascending.  If sort_cols_sorted is FALSE (by default), the frame from step 3 will be\n",
      " |          returned as is with no extra sort.  This may provide a small speedup if desired.\n",
      " |      \n",
      " |      :param group_by_cols: The columns to group on (either a single column name/index, or a list of column names\n",
      " |        or column indices\n",
      " |      :param sort_cols: The columns to sort on (either a single column name/index, or a list of column names or\n",
      " |        column indices\n",
      " |      :param ascending: Optional Boolean array to denote sorting direction for each sorting column.  True for\n",
      " |        ascending, False for descending.  Default is ascending sort.  Sort direction for enums will be ignored.\n",
      " |      :param new_col_name: Optional String to denote the new column names.  Default to New_Rank_column.\n",
      " |      :param sort_cols_sorted: Optional Boolean to denote if the returned frame should be sorted according to sort_cols\n",
      " |        and sort directions specified in ascending.  Default is False.\n",
      " |      \n",
      " |      :return: a new Frame with new rank (sorted by columns in sort_cols) column within the grouping specified\n",
      " |        by the group_by_cols.\n",
      " |      \n",
      " |       The following example is generated by Nidhi Mehta.\n",
      " |       If the input frame is train:\n",
      " |      \n",
      " |       ID Group_by_column        num data Column_to_arrange_by       num_1 fdata\n",
      " |       12               1   2941.552    1                    3  -3177.9077     1\n",
      " |       12               1   2941.552    1                    5 -13311.8247     1\n",
      " |       12               2 -22722.174    1                    3  -3177.9077     1\n",
      " |       12               2 -22722.174    1                    5 -13311.8247     1\n",
      " |       13               3 -12776.884    1                    5 -18421.6171     0\n",
      " |       13               3 -12776.884    1                    4  28080.1607     0\n",
      " |       13               1  -6049.830    1                    5 -18421.6171     0\n",
      " |       13               1  -6049.830    1                    4  28080.1607     0\n",
      " |       15               3 -16995.346    1                    1  -9781.6373     0\n",
      " |       16               1 -10003.593    0                    3 -61284.6900     0\n",
      " |       16               3  26052.495    1                    3 -61284.6900     0\n",
      " |       16               3 -22905.288    0                    3 -61284.6900     0\n",
      " |       17               2 -13465.496    1                    2  12094.4851     1\n",
      " |       17               2 -13465.496    1                    3 -11772.1338     1\n",
      " |       17               2 -13465.496    1                    3   -415.1114     0\n",
      " |       17               2  -3329.619    1                    2  12094.4851     1\n",
      " |       17               2  -3329.619    1                    3 -11772.1338     1\n",
      " |       17               2  -3329.619    1                    3   -415.1114     0\n",
      " |      \n",
      " |       If the following commands are issued:\n",
      " |       rankedF1 = h2o.rank_within_group_by(train, [\"Group_by_column\"], [\"Column_to_arrange_by\"], [TRUE])\n",
      " |       rankedF1.summary()\n",
      " |      \n",
      " |       The returned frame rankedF1 will look like this:\n",
      " |       ID Group_by_column        num fdata Column_to_arrange_by       num_1 fdata.1 New_Rank_column\n",
      " |       12               1   2941.552     1                    3  -3177.9077       1               1\n",
      " |       16               1 -10003.593     0                    3 -61284.6900       0               2\n",
      " |       13               1  -6049.830     0                    4  28080.1607       0               3\n",
      " |       12               1   2941.552     1                    5 -13311.8247       1               4\n",
      " |       13               1  -6049.830     0                    5 -18421.6171       0               5\n",
      " |       17               2 -13465.496     0                    2  12094.4851       1               1\n",
      " |       17               2  -3329.619     0                    2  12094.4851       1               2\n",
      " |       12               2 -22722.174     1                    3  -3177.9077       1               3\n",
      " |       17               2 -13465.496     0                    3 -11772.1338       1               4\n",
      " |       17               2 -13465.496     0                    3   -415.1114       0               5\n",
      " |       17               2  -3329.619     0                    3 -11772.1338       1               6\n",
      " |       17               2  -3329.619     0                    3   -415.1114       0               7\n",
      " |       12               2 -22722.174     1                    5 -13311.8247       1               8\n",
      " |       15               3 -16995.346     1                    1  -9781.6373       0               1\n",
      " |       16               3  26052.495     0                    3 -61284.6900       0               2\n",
      " |       16               3 -22905.288     1                    3 -61284.6900       0               3\n",
      " |       13               3 -12776.884     1                    4  28080.1607       0               4\n",
      " |       13               3 -12776.884     1                    5 -18421.6171       0               5\n",
      " |      \n",
      " |       If the following commands are issued:\n",
      " |       rankedF1 = h2o.rank_within_group_by(train, [\"Group_by_column\"], [\"Column_to_arrange_by\"], [TRUE], sort_cols_sorted=True)\n",
      " |       h2o.summary(rankedF1)\n",
      " |      \n",
      " |       The returned frame will be sorted according to sort_cols and hence look like this instead:\n",
      " |       ID Group_by_column        num fdata Column_to_arrange_by       num_1 fdata.1 New_Rank_column\n",
      " |       15               3 -16995.346     1                    1  -9781.6373       0               1\n",
      " |       17               2 -13465.496     0                    2  12094.4851       1               1\n",
      " |       17               2  -3329.619     0                    2  12094.4851       1               2\n",
      " |       12               1   2941.552     1                    3  -3177.9077       1               1\n",
      " |       12               2 -22722.174     1                    3  -3177.9077       1               3\n",
      " |       16               1 -10003.593     0                    3 -61284.6900       0               2\n",
      " |       16               3  26052.495     0                    3 -61284.6900       0               2\n",
      " |       16               3 -22905.288     1                    3 -61284.6900       0               3\n",
      " |       17               2 -13465.496     0                    3 -11772.1338       1               4\n",
      " |       17               2 -13465.496     0                    3   -415.1114       0               5\n",
      " |       17               2  -3329.619     0                    3 -11772.1338       1               6\n",
      " |       17               2  -3329.619     0                    3   -415.1114       0               7\n",
      " |       13               3 -12776.884     1                    4  28080.1607       0               4\n",
      " |       13               1  -6049.830     0                    4  28080.1607       0               3\n",
      " |       12               1   2941.552     1                    5 -13311.8247       1               4\n",
      " |       12               2 -22722.174     1                    5 -13311.8247       1               8\n",
      " |       13               3 -12776.884     1                    5 -18421.6171       0               5\n",
      " |       13               1  -6049.830     0                    5 -18421.6171       0               5\n",
      " |  \n",
      " |  rbind(self, data)\n",
      " |      Append data to this frame row-wise.\n",
      " |      \n",
      " |      :param data: an H2OFrame or a list of H2OFrame's to be combined with current frame row-wise.\n",
      " |      :returns: this H2OFrame with all frames in data appended row-wise.\n",
      " |  \n",
      " |  refresh(self)\n",
      " |      Reload frame information from the backend H2O server.\n",
      " |  \n",
      " |  relevel(self, y)\n",
      " |      Reorder levels of an H2O factor for one single column of a H2O frame\n",
      " |      \n",
      " |      The levels of a factor are reordered such that the reference level is at level 0, all remaining levels are\n",
      " |      moved down as needed.\n",
      " |      \n",
      " |      :param str y: The reference level\n",
      " |      :returns: New reordered factor column\n",
      " |  \n",
      " |  rename(self, columns=None)\n",
      " |      Change names of columns in the frame.\n",
      " |      \n",
      " |      Dict key is an index or name of the column whose name is to be set.\n",
      " |      Dict value is the new name of the column.\n",
      " |      \n",
      " |      :param columns: dict-like transformations to apply to the column names\n",
      " |  \n",
      " |  rep_len(self, length_out)\n",
      " |      Create a new frame replicating the current frame.\n",
      " |      \n",
      " |      If the source frame has a single column, then the new frame will be replicating rows and its dimensions\n",
      " |      will be ``length_out x 1``. However if the source frame has more than 1 column, then then new frame\n",
      " |      will be replicating data in columnwise direction, and its dimensions will be ``nrows x length_out``,\n",
      " |      where ``nrows`` is the number of rows in the source frame. Also note that if ``length_out`` is smaller\n",
      " |      than the corresponding dimension of the source frame, then the new frame will actually be a truncated\n",
      " |      version of the original.\n",
      " |      \n",
      " |      :param int length_out: Number of columns (rows) of the resulting H2OFrame\n",
      " |      :returns: new H2OFrame with repeated data from the current frame.\n",
      " |  \n",
      " |  round(self, digits=0)\n",
      " |      Round doubles/floats to the given number of decimal places.\n",
      " |      \n",
      " |      :param int digits: The number of decimal places to retain. Rounding to a negative number of decimal places is\n",
      " |          not supported. For rounding we use the \"round half to even\" mode (IEC 60559 standard), so that\n",
      " |          ``round(2.5) = 2`` and ``round(3.5) = 4``.\n",
      " |      :returns: new H2OFrame with rounded values from the original frame.\n",
      " |  \n",
      " |  rstrip(self, set=' ')\n",
      " |      Return a copy of the column with trailing characters removed.\n",
      " |      \n",
      " |      The set argument is a string specifying the set of characters to be removed.\n",
      " |      If omitted, the set argument defaults to removing whitespace.\n",
      " |      \n",
      " |      :param character set: The set of characters to rstrip from strings in column\n",
      " |      :returns: a new H2OFrame with the same shape as the original frame and having all its values\n",
      " |          trimmed from the right (equivalent of Python's ``str.rstrip()``).\n",
      " |  \n",
      " |  runif(self, seed=None)\n",
      " |      Generate a column of random numbers drawn from a uniform distribution [0,1) and\n",
      " |      having the same data layout as the source frame.\n",
      " |      \n",
      " |      :param int seed: seed for the random number generator.\n",
      " |      \n",
      " |      :returns: Single-column H2OFrame filled with doubles sampled uniformly from [0,1).\n",
      " |  \n",
      " |  scale(self, center=True, scale=True)\n",
      " |      Center and/or scale the columns of the current frame.\n",
      " |      \n",
      " |      :param center: If True, then demean the data. If False, no shifting is done. If ``center`` is a list of\n",
      " |          numbers then shift each column by the corresponding amount.\n",
      " |      :param scale: If True, then scale the data by each column's standard deviation. If False, no scaling\n",
      " |          is done. If ``scale`` is a list of numbers, then scale each column by the requested amount.\n",
      " |      :returns: an H2OFrame with scaled values from the current frame.\n",
      " |  \n",
      " |  sd(self, na_rm=False)\n",
      " |      Compute the standard deviation for each column in the frame.\n",
      " |      \n",
      " |      :param bool na_rm: if True, then NAs will be removed from the computation.\n",
      " |      :returns: A list containing the standard deviation for each column (NaN for non-numeric columns).\n",
      " |  \n",
      " |  second(self)\n",
      " |      Extract the \"second\" part from a date column.\n",
      " |      \n",
      " |      :returns: a single-column H2OFrame containing the \"second\" part from the source frame.\n",
      " |  \n",
      " |  set_level(self, level)\n",
      " |      A method to set all column values to one of the levels.\n",
      " |      \n",
      " |      :param str level: The level at which the column will be set (a string)\n",
      " |      \n",
      " |      :returns: H2OFrame with entries set to the desired level.\n",
      " |  \n",
      " |  set_levels(self, levels)\n",
      " |      Replace the levels of a categorical column.\n",
      " |      \n",
      " |      New levels must be aligned with the old domain. This call has copy-on-write semantics.\n",
      " |      \n",
      " |      :param List[str] levels: A list of strings specifying the new levels. The number of new\n",
      " |          levels must match the number of old levels.\n",
      " |      :returns: A single-column H2OFrame with the desired levels.\n",
      " |  \n",
      " |  set_name(self, col=None, name=None)\n",
      " |      Set a new name for a column.\n",
      " |      \n",
      " |      :param col: index or name of the column whose name is to be set; may be skipped for 1-column frames\n",
      " |      :param name: the new name of the column\n",
      " |  \n",
      " |  set_names(self, names)\n",
      " |      Change names of all columns in the frame.\n",
      " |      \n",
      " |      :param List[str] names: The list of new names for every column in the frame.\n",
      " |  \n",
      " |  show(self, use_pandas=False, rows=10, cols=200)\n",
      " |      Used by the H2OFrame.__repr__ method to print or display a snippet of the data frame.\n",
      " |      \n",
      " |      If called from IPython, displays an html'ized result. Else prints a tabulate'd result.\n",
      " |  \n",
      " |  sign(self)\n",
      " |      Return new H2OFrame equal to signs of the values in the frame: -1 , +1, or 0.\n",
      " |  \n",
      " |  signif(self, digits=6)\n",
      " |      Round doubles/floats to the given number of significant digits.\n",
      " |      \n",
      " |      :param int digits: Number of significant digits to retain.\n",
      " |      :returns: new H2OFrame with rounded values from the original frame.\n",
      " |  \n",
      " |  sin(self)\n",
      " |      Return new H2OFrame equal to elementwise sine of the current frame.\n",
      " |  \n",
      " |  sinh(self)\n",
      " |      Return new H2OFrame equal to elementwise hyperbolic sine of the current frame.\n",
      " |  \n",
      " |  sinpi(self)\n",
      " |      Return new H2OFrame equal to elementwise sine of the current frame multiplied by Pi.\n",
      " |  \n",
      " |  skewness(self, na_rm=False)\n",
      " |      Compute the skewness of each column in the frame.\n",
      " |      \n",
      " |      :param bool na_rm: If True, then ignore NAs during the computation.\n",
      " |      :returns: A list containing the skewness for each column (NaN for non-numeric columns).\n",
      " |  \n",
      " |  sort(self, by, ascending=[])\n",
      " |      Return a new Frame that is sorted by column(s) in ascending order. A fully distributed and parallel sort.\n",
      " |      However, the original frame can contain String columns but sorting cannot be done on String columns.\n",
      " |      Default sorting direction is ascending.\n",
      " |      \n",
      " |      :param by: The column to sort by (either a single column name, or a list of column names, or\n",
      " |          a list of column indices)\n",
      " |      :param ascending: Boolean array to denote sorting direction for each sorting column.  True for ascending\n",
      " |          sort and False for descending sort.\n",
      " |      \n",
      " |      :return:  a new sorted Frame\n",
      " |  \n",
      " |  split_frame(self, ratios=None, destination_frames=None, seed=None)\n",
      " |      Split a frame into distinct subsets of size determined by the given ratios.\n",
      " |      \n",
      " |      The number of subsets is always 1 more than the number of ratios given. Note that\n",
      " |      this does not give an exact split. H2O is designed to be efficient on big data\n",
      " |      using a probabilistic splitting method rather than an exact split. For example\n",
      " |      when specifying a split of 0.75/0.25, H2O will produce a test/train split with\n",
      " |      an expected value of 0.75/0.25 rather than exactly 0.75/0.25. On small datasets,\n",
      " |      the sizes of the resulting splits will deviate from the expected value more than\n",
      " |      on big data, where they will be very close to exact.\n",
      " |      \n",
      " |      :param List[float] ratios: The fractions of rows for each split.\n",
      " |      :param List[str] destination_frames: The names of the split frames.\n",
      " |      :param int seed: seed for the random number generator\n",
      " |      \n",
      " |      :returns: A list of H2OFrames\n",
      " |  \n",
      " |  sqrt(self)\n",
      " |      Return new H2OFrame equal to elementwise square root of the current frame.\n",
      " |  \n",
      " |  stratified_kfold_column(self, n_folds=3, seed=-1)\n",
      " |      Build a fold assignment column with the constraint that each fold has the same class\n",
      " |      distribution as the fold column.\n",
      " |      \n",
      " |      :param int n_folds: The number of folds to build.\n",
      " |      :param int seed: A seed for the random number generator.\n",
      " |      \n",
      " |      :returns: A single column H2OFrame with the fold assignments.\n",
      " |  \n",
      " |  stratified_split(self, test_frac=0.2, seed=-1)\n",
      " |      Construct a column that can be used to perform a random stratified split.\n",
      " |      \n",
      " |      :param float test_frac: The fraction of rows that will belong to the \"test\".\n",
      " |      :param int seed: The seed for the random number generator.\n",
      " |      \n",
      " |      :returns: an H2OFrame having single categorical column with two levels: ``\"train\"`` and ``\"test\"``.\n",
      " |      \n",
      " |      :examples:\n",
      " |        >>> stratsplit = df[\"y\"].stratified_split(test_frac=0.3, seed=12349453)\n",
      " |        >>> train = df[stratsplit==\"train\"]\n",
      " |        >>> test = df[stratsplit==\"test\"]\n",
      " |        >>>\n",
      " |        >>> # check that the distributions among the initial frame, and the\n",
      " |        >>> # train/test frames match\n",
      " |        >>> df[\"y\"].table()[\"Count\"] / df[\"y\"].table()[\"Count\"].sum()\n",
      " |        >>> train[\"y\"].table()[\"Count\"] / train[\"y\"].table()[\"Count\"].sum()\n",
      " |        >>> test[\"y\"].table()[\"Count\"] / test[\"y\"].table()[\"Count\"].sum()\n",
      " |  \n",
      " |  strdistance(self, y, measure=None, compare_empty=True)\n",
      " |      Compute element-wise string distances between two H2OFrames. Both frames need to have the same\n",
      " |      shape and only contain string/factor columns.\n",
      " |      \n",
      " |      :param H2OFrame y: A comparison frame.\n",
      " |      :param str measure: A string identifier indicating what string distance measure to use. Must be one of:\n",
      " |      \n",
      " |          - ``\"lv\"``:        Levenshtein distance\n",
      " |          - ``\"lcs\"``:       Longest common substring distance\n",
      " |          - ``\"qgram\"``:     q-gram distance\n",
      " |          - ``\"jaccard\"``:   Jaccard distance between q-gram profiles\n",
      " |          - ``\"jw\"``:        Jaro, or Jaro-Winker distance\n",
      " |          - ``\"soundex\"``:   Distance based on soundex encoding\n",
      " |      \n",
      " |      :param compare_empty if set to FALSE, empty strings will be handled as NaNs\n",
      " |      \n",
      " |      :examples:\n",
      " |        >>>\n",
      " |        >>> x = h2o.H2OFrame.from_python(['Martha', 'Dwayne', 'Dixon'], column_types=['factor'])\n",
      " |        >>> y = h2o.H2OFrame.from_python(['Marhta', 'Duane', 'Dicksonx'], column_types=['string'])\n",
      " |        >>> x.strdistance(y, measure=\"jw\")\n",
      " |      \n",
      " |      :returns: An H2OFrame of the matrix containing element-wise distance between the\n",
      " |          strings of this frame and ``y``. The returned frame has the same shape as the input frames.\n",
      " |  \n",
      " |  strsplit(self, pattern)\n",
      " |      Split the strings in the target column on the given regular expression pattern.\n",
      " |      \n",
      " |      :param str pattern: The split pattern.\n",
      " |      :returns: H2OFrame containing columns of the split strings.\n",
      " |  \n",
      " |  structure(self)\n",
      " |      Compactly display the internal structure of an H2OFrame.\n",
      " |  \n",
      " |  sub(self, pattern, replacement, ignore_case=False)\n",
      " |      Substitute the first occurrence of pattern in a string with replacement.\n",
      " |      \n",
      " |      :param str pattern: A regular expression.\n",
      " |      :param str replacement: A replacement string.\n",
      " |      :param bool ignore_case: If True then pattern will match case-insensitively.\n",
      " |      :returns: an H2OFrame with all values matching ``pattern`` replaced with ``replacement``.\n",
      " |  \n",
      " |  substring(self, start_index, end_index=None)\n",
      " |      For each string, return a new string that is a substring of the original string.\n",
      " |      \n",
      " |      If end_index is not specified, then the substring extends to the end of the original string. If the start_index\n",
      " |      is longer than the length of the string, or is greater than or equal to the end_index, an empty string is\n",
      " |      returned. Negative start_index is coerced to 0.\n",
      " |      \n",
      " |      :param int start_index: The index of the original string at which to start the substring, inclusive.\n",
      " |      :param int end_index: The index of the original string at which to end the substring, exclusive.\n",
      " |      :returns: An H2OFrame containing the specified substrings.\n",
      " |  \n",
      " |  sum(self, skipna=True, axis=0, **kwargs)\n",
      " |      Compute the frame's sum by-column (or by-row).\n",
      " |      \n",
      " |      :param bool skipna: If True (default), then NAs are ignored during the computation. Otherwise presence\n",
      " |          of NAs renders the entire result NA.\n",
      " |      :param int axis: Direction of sum computation. If 0 (default), then sum is computed columnwise, and the result\n",
      " |          is a frame with 1 row and number of columns as in the original frame. If 1, then sum is computed rowwise\n",
      " |          and the result is a frame with 1 column (called \"sum\"), and number of rows equal to the number of rows\n",
      " |          in the original frame.\n",
      " |      :returns: either an aggregated value with sum of values per-column (old semantic); or an H2OFrame containing sum of values\n",
      " |          per-column/per-row in the original frame (new semantic). The new semantic is triggered by either\n",
      " |          providing the ``return_frame=True`` parameter, or having the ``general.allow_breaking_changed`` config\n",
      " |          option turned on.\n",
      " |  \n",
      " |  summary(self, return_data=False)\n",
      " |      Display summary information about the frame.\n",
      " |      \n",
      " |      Summary includes min/mean/max/sigma and other rollup data.\n",
      " |      \n",
      " |      :param bool return_data: Return a dictionary of the summary output\n",
      " |  \n",
      " |  table(self, data2=None, dense=True)\n",
      " |      Compute the counts of values appearing in a column, or co-occurence counts between two columns.\n",
      " |      \n",
      " |      :param H2OFrame data2: An optional single column to aggregate counts by.\n",
      " |      :param bool dense: If True (default) then use dense representation, which lists only non-zero counts,\n",
      " |          1 combination per row. Set to False to expand counts across all combinations.\n",
      " |      \n",
      " |      :returns: H2OFrame of the counts at each combination of factor levels\n",
      " |  \n",
      " |  tail(self, rows=10, cols=200)\n",
      " |      Return the last ``rows`` and ``cols`` of the frame as a new H2OFrame.\n",
      " |      \n",
      " |      :param int rows: maximum number of rows to return\n",
      " |      :param int cols: maximum number of columns to return\n",
      " |      :returns: a new H2OFrame cut from the bottom left corner of the current frame, and having dimensions at\n",
      " |          most ``rows`` x ``cols``.\n",
      " |  \n",
      " |  tan(self)\n",
      " |      Return new H2OFrame equal to elementwise tangent of the current frame.\n",
      " |  \n",
      " |  tanh(self)\n",
      " |      Return new H2OFrame equal to elementwise hyperbolic tangent of the current frame.\n",
      " |  \n",
      " |  tanpi(self)\n",
      " |      Return new H2OFrame equal to elementwise tangent of the current frame multiplied by Pi.\n",
      " |  \n",
      " |  tokenize(self, split)\n",
      " |      Tokenize String\n",
      " |      \n",
      " |      tokenize() is similar to strsplit(), the difference between them is that tokenize() will store the tokenized\n",
      " |      text into a single column making it easier for additional processing (filtering stop words, word2vec algo, ...).\n",
      " |      \n",
      " |      :param str split The regular expression to split on.\n",
      " |      @return An H2OFrame with a single column representing the tokenized Strings. Original rows of the input DF are separated by NA.\n",
      " |  \n",
      " |  tolower(self)\n",
      " |      Translate characters from upper to lower case for a particular column.\n",
      " |      \n",
      " |      :returns: new H2OFrame with all strings in the current frame converted to the lowercase.\n",
      " |  \n",
      " |  topN(self, column=0, nPercent=10)\n",
      " |      Given a column name or one column index, a percent N, this function will return the top N% of the values\n",
      " |      of the column of a frame.  The column must be a numerical column.\n",
      " |      \n",
      " |      :param column: a string for column name or an integer index\n",
      " |      :param nPercent: a top percentage of the column values to return\n",
      " |      :returns: a H2OFrame containing two columns.  The first column contains the original row indices where\n",
      " |          the top values are extracted from.  The second column contains the top nPercent values.\n",
      " |  \n",
      " |  topNBottomN(self, column=0, nPercent=10, grabTopN=-1)\n",
      " |      Given a column name or one column index, a percent N, this function will return the top or bottom N% of the\n",
      " |       values of the column of a frame.  The column must be a numerical column.\n",
      " |      \n",
      " |      :param column: a string for column name or an integer index\n",
      " |      :param nPercent: a top or bottom percentage of the column values to return\n",
      " |      :param grabTopN: -1 to grab bottom N percent and 1 to grab top N percent\n",
      " |      :returns: a H2OFrame containing two columns.  The first column contains the original row indices where\n",
      " |          the top/bottom values are extracted from.  The second column contains the values.\n",
      " |  \n",
      " |  toupper(self)\n",
      " |      Translate characters from lower to upper case for a particular column.\n",
      " |      \n",
      " |      :returns: new H2OFrame with all strings in the current frame converted to the uppercase.\n",
      " |  \n",
      " |  transpose(self)\n",
      " |      Transpose rows and columns of this frame.\n",
      " |      \n",
      " |      :returns: new H2OFrame where with rows/columns from the original frame transposed.\n",
      " |  \n",
      " |  trigamma(self)\n",
      " |      Return new H2OFrame equals to elementwise trigamma function of the current frame.\n",
      " |  \n",
      " |  trim(self)\n",
      " |      Trim white space on the left and right of strings in a single-column H2OFrame.\n",
      " |      \n",
      " |      :returns: H2OFrame with trimmed strings.\n",
      " |  \n",
      " |  trunc(self)\n",
      " |      Apply the numeric truncation function.\n",
      " |      \n",
      " |      ``trunc(x)`` is the integer obtained from ``x`` by dropping its decimal tail. This is equal to ``floor(x)``\n",
      " |      if ``x`` is positive, and ``ceil(x)`` if ``x`` is negative. Truncation is also called \"rounding towards zero\".\n",
      " |      \n",
      " |      :returns: new H2OFrame of truncated values of the original frame.\n",
      " |  \n",
      " |  type(self, col)\n",
      " |      The type for the given column.\n",
      " |      \n",
      " |      :param col: either a name, or an index of the column to look up\n",
      " |      :returns: type of the column, one of: ``str``, ``int``, ``real``, ``enum``, ``time``, ``bool``.\n",
      " |      :raises H2OValueError: if such column does not exist in the frame.\n",
      " |  \n",
      " |  unique(self)\n",
      " |      Extract the unique values in the column.\n",
      " |      \n",
      " |      :returns: H2OFrame of just the unique values in the column.\n",
      " |  \n",
      " |  var(self, y=None, na_rm=False, use=None)\n",
      " |      Compute the variance-covariance matrix of one or two H2OFrames.\n",
      " |      \n",
      " |      :param H2OFrame y: If this parameter is given, then a covariance  matrix between the columns of the target\n",
      " |          frame and the columns of ``y`` is computed. If this parameter is not provided then the covariance matrix\n",
      " |          of the target frame is returned. If target frame has just a single column, then return the scalar variance\n",
      " |          instead of the matrix. Single rows are treated as single columns.\n",
      " |      :param str use: A string indicating how to handle missing values. This could be one of the following:\n",
      " |      \n",
      " |          - ``\"everything\"``: outputs NaNs whenever one of its contributing observations is missing\n",
      " |          - ``\"all.obs\"``: presence of missing observations will throw an error\n",
      " |          - ``\"complete.obs\"``: discards missing values along with all observations in their rows so that only\n",
      " |            complete observations are used\n",
      " |      :param bool na_rm: an alternative to ``use``: when this is True then default value for ``use`` is\n",
      " |          ``\"everything\"``; and if False then default ``use`` is ``\"complete.obs\"``. This parameter has no effect\n",
      " |          if ``use`` is given explicitly.\n",
      " |      \n",
      " |      :returns: An H2OFrame of the covariance matrix of the columns of this frame (if ``y`` is not given),\n",
      " |          or with the columns of ``y`` (if ``y`` is given). However when this frame and ``y`` are both single rows\n",
      " |          or single columns, then the variance is returned as a scalar.\n",
      " |  \n",
      " |  week(self)\n",
      " |      Extract the \"week\" part from a date column.\n",
      " |      \n",
      " |      :returns: a single-column H2OFrame containing the \"week\" part from the source frame.\n",
      " |  \n",
      " |  which(self)\n",
      " |      Compose the list of row indices for which the frame contains non-zero values.\n",
      " |      \n",
      " |      Only applicable to integer single-column frames.\n",
      " |      Equivalent to comprehension ``[index for index, value in enumerate(self) if value]``.\n",
      " |      \n",
      " |      :returns: a new single-column H2OFrame containing indices of those rows in the original frame\n",
      " |          that contained non-zero values.\n",
      " |  \n",
      " |  year(self)\n",
      " |      Extract the \"year\" part from a date column.\n",
      " |      \n",
      " |      :returns: a single-column H2OFrame containing the \"year\" part from the source frame.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods defined here:\n",
      " |  \n",
      " |  from_python(python_obj, destination_frame=None, header=0, separator=',', column_names=None, column_types=None, na_strings=None)\n",
      " |      [DEPRECATED] Use constructor ``H2OFrame()`` instead.\n",
      " |  \n",
      " |  get_frame(frame_id, rows=10, rows_offset=0, cols=-1, full_cols=-1, cols_offset=0, light=False)\n",
      " |      Retrieve an existing H2OFrame from the H2O cluster using the frame's id.\n",
      " |      \n",
      " |      :param str frame_id: id of the frame to retrieve\n",
      " |      :param int rows: number of rows to fetch for preview (10 by default)\n",
      " |      :param int rows_offset: offset to fetch rows from (0 by default)\n",
      " |      :param int cols: number of columns to fetch (all by default)\n",
      " |      :param full_cols: number of columns to fetch together with backed data\n",
      " |      :param int cols_offset: offset to fetch rows from (0 by default)\n",
      " |      :param bool light: wether to use light frame endpoint or not\n",
      " |      :returns: an existing H2OFrame with the id provided; or None if such frame doesn't exist.\n",
      " |  \n",
      " |  mktime(year=1970, month=0, day=0, hour=0, minute=0, second=0, msec=0)\n",
      " |      Deprecated, use :func:`moment` instead.\n",
      " |      \n",
      " |      This function was left for backward-compatibility purposes only. It is\n",
      " |      not very stable, and counterintuitively uses 0-based months and days,\n",
      " |      so \"January 4th, 2001\" should be entered as ``mktime(2001, 0, 3)``.\n",
      " |  \n",
      " |  moment(year=None, month=None, day=None, hour=None, minute=None, second=None, msec=None, date=None, time=None)\n",
      " |      Create a time column from individual components.\n",
      " |      \n",
      " |      Each parameter should be either an integer, or a single-column H2OFrame\n",
      " |      containing the corresponding time parts for each row.\n",
      " |      \n",
      " |      The \"date\" part of the timestamp can be specified using either the tuple ``(year, month, day)``, or an\n",
      " |      explicit ``date`` parameter. The \"time\" part of the timestamp is optional, but can be specified either via\n",
      " |      the ``time`` parameter, or via the ``(hour, minute, second, msec)`` tuple.\n",
      " |      \n",
      " |      :param year: the year part of the constructed date\n",
      " |      :param month: the month part of the constructed date\n",
      " |      :param day: the day-of-the-month part of the constructed date\n",
      " |      :param hour: the hours part of the constructed date\n",
      " |      :param minute: the minutes part of the constructed date\n",
      " |      :param second: the seconds part of the constructed date\n",
      " |      :param msec: the milliseconds part of the constructed date\n",
      " |      :param date date: construct the timestamp from the Python's native ``datetime.date`` (or ``datetime.datetime``)\n",
      " |          object. If the object passed is of type ``date``, then you can specify the time part using either the\n",
      " |          ``time`` argument, or ``hour`` ... ``msec`` arguments (but not both). If the object passed is of type\n",
      " |          ``datetime``, then no other arguments can be provided.\n",
      " |      :param time time: construct the timestamp from this Python's native ``datetime.time`` object. This argument\n",
      " |          cannot be used alone, it should be supplemented with either ``date`` argument, or ``year`` ... ``day``\n",
      " |          tuple.\n",
      " |      \n",
      " |      :returns: H2OFrame with one column containing the date constructed from the provided arguments.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables (if defined)\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object (if defined)\n",
      " |  \n",
      " |  col_names\n",
      " |      Same as ``self.names``.\n",
      " |  \n",
      " |  columns\n",
      " |      Same as ``self.names``.\n",
      " |  \n",
      " |  dim\n",
      " |      Same as ``list(self.shape)``.\n",
      " |  \n",
      " |  frame_id\n",
      " |      Internal id of the frame (str).\n",
      " |  \n",
      " |  names\n",
      " |      The list of column names (List[str]).\n",
      " |  \n",
      " |  ncol\n",
      " |      Same as ``self.ncols``.\n",
      " |  \n",
      " |  ncols\n",
      " |      Number of columns in the dataframe (int).\n",
      " |  \n",
      " |  nrow\n",
      " |      Same as ``self.nrows``.\n",
      " |  \n",
      " |  nrows\n",
      " |      Number of rows in the dataframe (int).\n",
      " |  \n",
      " |  shape\n",
      " |      Number of rows and columns in the dataframe as a tuple ``(nrows, ncols)``.\n",
      " |  \n",
      " |  types\n",
      " |      The dictionary of column name/type pairs.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |  \n",
      " |  __LOCAL_EXPANSION_ON_SINGLE_IMPORT__ = True\n",
      " |  \n",
      " |  __hash__ = None\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "help(h2o.H2OFrame)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['loan_amnt',\n",
       " 'term',\n",
       " 'int_rate',\n",
       " 'emp_length',\n",
       " 'home_ownership',\n",
       " 'annual_inc',\n",
       " 'purpose',\n",
       " 'addr_state',\n",
       " 'dti',\n",
       " 'delinq_2yrs',\n",
       " 'revol_util',\n",
       " 'total_acc',\n",
       " 'bad_loan',\n",
       " 'longest_credit_length',\n",
       " 'verification_status']"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train.col_names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'loan_amnt': 'int',\n",
       " 'term': 'enum',\n",
       " 'int_rate': 'real',\n",
       " 'emp_length': 'int',\n",
       " 'home_ownership': 'enum',\n",
       " 'annual_inc': 'real',\n",
       " 'purpose': 'enum',\n",
       " 'addr_state': 'enum',\n",
       " 'dti': 'real',\n",
       " 'delinq_2yrs': 'int',\n",
       " 'revol_util': 'real',\n",
       " 'total_acc': 'int',\n",
       " 'bad_loan': 'int',\n",
       " 'longest_credit_length': 'int',\n",
       " 'verification_status': 'enum'}"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train.types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loan_train\n"
     ]
    }
   ],
   "source": [
    "print(train.frame_id)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "train[\"bad_loan\"] = train[\"bad_loan\"].asfactor()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "py_1_sid_b77f\n"
     ]
    }
   ],
   "source": [
    "print(train.frame_id)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exploratory Data Analysis in H2O"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### A Quick Look at the Target Variable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will begin our exploration with a quick look at the frequency of bad loan status in the data using H2OFrame's [`table`](http://docs.h2o.ai/h2o/latest-stable/h2o-py/docs/frame.html?highlight=table#h2o.frame.H2OFrame.table) method. Since the `table` method returns an H2OFrame, it is converted to a pandas DataFrame using the [`as_data_frame`](http://docs.h2o.ai/h2o/latest-stable/h2o-py/docs/frame.html?highlight=as_data_frame#h2o.frame.H2OFrame.as_data_frame) method. The bad loan rate for customers in this data set is roughly 18%."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   bad_loan   Count\n",
      "0         0  133971\n",
      "1         1   30016\n",
      "\n",
      "Fraction of bad_loan = 0.1830\n"
     ]
    }
   ],
   "source": [
    "tbl = train[\"bad_loan\"].table()\n",
    "tbl = tbl.as_data_frame()\n",
    "\n",
    "print(tbl)\n",
    "print(\"\\nFraction of bad_loan = {:0.4f}\".format(tbl[tbl[\"bad_loan\"] == 1][\"Count\"].values[0] / tbl[\"Count\"].sum()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### A Quick Look at the Predictor Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In preparation for our modeling bad loans, we can turn to H2OFrame's [`describe`](http://docs.h2o.ai/h2o/latest-stable/h2o-py/docs/frame.html?highlight=describe#h2o.frame.H2OFrame.describe) method to provide summary statistics for each of the columns in the data set, which includes minimums, maximums, means, and standard deviations.\n",
    "\n",
    "Given the nature of this data, it will also be useful to explore the skewness and shape of the numeric data, [`columns_by_type(\"numeric\")`](http://docs.h2o.ai/h2o/latest-stable/h2o-py/docs/frame.html?highlight=columns_by_type#h2o.frame.H2OFrame.columns_by_type), using H2OFrame's [`skewness`](http://docs.h2o.ai/h2o/latest-stable/h2o-py/docs/frame.html?highlight=skewness#h2o.frame.H2OFrame.skewness) and [`kurtosis`](http://docs.h2o.ai/h2o/latest-stable/h2o-py/docs/frame.html?highlight=kurtosis#h2o.frame.H2OFrame.kurtosis) methods. These aspects of the data are shown graphically using H2OFrame's [`hist`](http://docs.h2o.ai/h2o/latest-stable/h2o-py/docs/frame.html?highlight=hist#h2o.frame.H2OFrame.hist) method to produce histograms for numeric columns.\n",
    "\n",
    "As the summaries below show, most of the numeric columns contain skewed data that we will address during feature engineering."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rows:163987\n",
      "Cols:15\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "<thead>\n",
       "<tr><th>       </th><th>loan_amnt         </th><th>term     </th><th>int_rate          </th><th>emp_length        </th><th>home_ownership  </th><th>annual_inc        </th><th>purpose           </th><th>addr_state  </th><th>dti               </th><th>delinq_2yrs       </th><th>revol_util        </th><th>total_acc         </th><th>bad_loan  </th><th>longest_credit_length  </th><th>verification_status  </th></tr>\n",
       "</thead>\n",
       "<tbody>\n",
       "<tr><td>type   </td><td>int               </td><td>enum     </td><td>real              </td><td>int               </td><td>enum            </td><td>real              </td><td>enum              </td><td>enum        </td><td>real              </td><td>int               </td><td>real              </td><td>int               </td><td>enum      </td><td>int                    </td><td>enum                 </td></tr>\n",
       "<tr><td>mins   </td><td>500.0             </td><td>         </td><td>5.42              </td><td>0.0               </td><td>                </td><td>1896.0            </td><td>                  </td><td>            </td><td>0.0               </td><td>0.0               </td><td>0.0               </td><td>1.0               </td><td>          </td><td>0.0                    </td><td>                     </td></tr>\n",
       "<tr><td>mean   </td><td>13074.169141456336</td><td>         </td><td>13.715904065566173</td><td>5.68435293299533  </td><td>                </td><td>71915.67051974901 </td><td>                  </td><td>            </td><td>15.881530121290117</td><td>0.2273570060625282</td><td>54.07917280242258 </td><td>24.579733834274638</td><td>          </td><td>14.854273655448353     </td><td>                     </td></tr>\n",
       "<tr><td>maxs   </td><td>35000.0           </td><td>         </td><td>26.06             </td><td>10.0              </td><td>                </td><td>7141778.0         </td><td>                  </td><td>            </td><td>39.99             </td><td>29.0              </td><td>150.70000000000002</td><td>118.0             </td><td>          </td><td>65.0                   </td><td>                     </td></tr>\n",
       "<tr><td>sigma  </td><td>7993.556188734649 </td><td>         </td><td>4.391939870545795 </td><td>3.6106637311002365</td><td>                </td><td>59070.915654918244</td><td>                  </td><td>            </td><td>7.587668224192549 </td><td>0.6941679229284182</td><td>25.285366766770505</td><td>11.685190365910659</td><td>          </td><td>6.947732922546696      </td><td>                     </td></tr>\n",
       "<tr><td>zeros  </td><td>0                 </td><td>         </td><td>0                 </td><td>14248             </td><td>                </td><td>0                 </td><td>                  </td><td>            </td><td>270               </td><td>139459            </td><td>1562              </td><td>0                 </td><td>          </td><td>11                     </td><td>                     </td></tr>\n",
       "<tr><td>missing</td><td>0                 </td><td>0        </td><td>0                 </td><td>5804              </td><td>0               </td><td>4                 </td><td>0                 </td><td>0           </td><td>0                 </td><td>29                </td><td>193               </td><td>29                </td><td>0         </td><td>29                     </td><td>0                    </td></tr>\n",
       "<tr><td>0      </td><td>5000.0            </td><td>36 months</td><td>10.65             </td><td>10.0              </td><td>RENT            </td><td>24000.0           </td><td>credit_card       </td><td>AZ          </td><td>27.65             </td><td>0.0               </td><td>83.7              </td><td>9.0               </td><td>0         </td><td>26.0                   </td><td>verified             </td></tr>\n",
       "<tr><td>1      </td><td>2500.0            </td><td>60 months</td><td>15.27             </td><td>0.0               </td><td>RENT            </td><td>30000.0           </td><td>car               </td><td>GA          </td><td>1.0               </td><td>0.0               </td><td>9.4               </td><td>4.0               </td><td>1         </td><td>12.0                   </td><td>verified             </td></tr>\n",
       "<tr><td>2      </td><td>2400.0            </td><td>36 months</td><td>15.96             </td><td>10.0              </td><td>RENT            </td><td>12252.0           </td><td>small_business    </td><td>IL          </td><td>8.72              </td><td>0.0               </td><td>98.5              </td><td>10.0              </td><td>0         </td><td>10.0                   </td><td>not verified         </td></tr>\n",
       "<tr><td>3      </td><td>10000.0           </td><td>36 months</td><td>13.49             </td><td>10.0              </td><td>RENT            </td><td>49200.0           </td><td>other             </td><td>CA          </td><td>20.0              </td><td>0.0               </td><td>21.0              </td><td>37.0              </td><td>0         </td><td>15.0                   </td><td>verified             </td></tr>\n",
       "<tr><td>4      </td><td>5000.0            </td><td>36 months</td><td>7.9               </td><td>3.0               </td><td>RENT            </td><td>36000.0           </td><td>wedding           </td><td>AZ          </td><td>11.2              </td><td>0.0               </td><td>28.3              </td><td>12.0              </td><td>0         </td><td>7.0                    </td><td>verified             </td></tr>\n",
       "<tr><td>5      </td><td>3000.0            </td><td>36 months</td><td>18.64             </td><td>9.0               </td><td>RENT            </td><td>48000.0           </td><td>car               </td><td>CA          </td><td>5.3500000000000005</td><td>0.0               </td><td>87.5              </td><td>4.0               </td><td>0         </td><td>4.0                    </td><td>verified             </td></tr>\n",
       "<tr><td>6      </td><td>5600.0            </td><td>60 months</td><td>21.28             </td><td>4.0               </td><td>OWN             </td><td>40000.0           </td><td>small_business    </td><td>CA          </td><td>5.55              </td><td>0.0               </td><td>32.6              </td><td>13.0              </td><td>1         </td><td>7.0                    </td><td>verified             </td></tr>\n",
       "<tr><td>7      </td><td>5375.0            </td><td>60 months</td><td>12.69             </td><td>0.0               </td><td>RENT            </td><td>15000.0           </td><td>other             </td><td>TX          </td><td>18.08             </td><td>0.0               </td><td>36.5              </td><td>3.0               </td><td>1         </td><td>7.0                    </td><td>verified             </td></tr>\n",
       "<tr><td>8      </td><td>6500.0            </td><td>60 months</td><td>14.65             </td><td>5.0               </td><td>OWN             </td><td>72000.0           </td><td>debt_consolidation</td><td>AZ          </td><td>16.12             </td><td>0.0               </td><td>20.6              </td><td>23.0              </td><td>0         </td><td>13.0                   </td><td>not verified         </td></tr>\n",
       "<tr><td>9      </td><td>12000.0           </td><td>36 months</td><td>12.69             </td><td>10.0              </td><td>OWN             </td><td>75000.0           </td><td>debt_consolidation</td><td>CA          </td><td>10.78             </td><td>0.0               </td><td>67.10000000000001 </td><td>34.0              </td><td>0         </td><td>22.0                   </td><td>verified             </td></tr>\n",
       "</tbody>\n",
       "</table>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "train.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'loan_amnt': 0.8753344731629872,\n",
       " 'int_rate': 0.3278618866458746,\n",
       " 'emp_length': -0.1054415215350723,\n",
       " 'annual_inc': 35.490175276568756,\n",
       " 'dti': 0.18215840060680447,\n",
       " 'delinq_2yrs': 5.961064174114161,\n",
       " 'revol_util': -0.24909373161407267,\n",
       " 'total_acc': 0.7672568687389832,\n",
       " 'longest_credit_length': 1.1320402013276156}"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{ train.col_names[int(j)] : train[int(j)].skewness(na_rm = True)[0] for j in train.columns_by_type(\"numeric\") }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'loan_amnt': 3.2288978583663726,\n",
       " 'int_rate': 2.6791986218866417,\n",
       " 'emp_length': 1.597127424673438,\n",
       " 'annual_inc': 3270.723574206677,\n",
       " 'dti': 2.47660889447404,\n",
       " 'delinq_2yrs': 75.67871449257943,\n",
       " 'revol_util': 2.1979478719219996,\n",
       " 'total_acc': 3.6270448687190786,\n",
       " 'longest_credit_length': 4.962164722357427}"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{ train.col_names[int(j)] : train[int(j)].kurtosis(na_rm = True)[0] for j in train.columns_by_type(\"numeric\") }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "import warnings\n",
    "import matplotlib.cbook\n",
    "warnings.filterwarnings(\"ignore\", category = matplotlib.cbook.mplDeprecation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "for j in train.columns_by_type(\"numeric\"):\n",
    "    train[int(j)].hist()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Feature Engineering in H2O"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since the goal of this analysis is to predict credit card default, we will create a string, `y`, for the response variable, \"bad_loan\", and a list of column names for the original set of predictors, `x_orig`. The original set of predictors should not include interest rate since they were set based upon a risk assessment that the loan would be bad.\n",
    "\n",
    "The goal of this section is to improve upon these predictors through a number of feature engineering steps. In particular, we will perform three feature engineering tasks:\n",
    "\n",
    "1. **Separating Typical from Extreme Loan Amount**\n",
    "1. **Converting Term to a 0/1 Indicator**\n",
    "1. **Creating Missing Value Indicator for Employment Length**\n",
    "1. **Combining Categories in Home Ownership**\n",
    "1. **Separating Typical from Extreme Annual Income**\n",
    "1. **Creating Target Encoding for Loan Purpose**\n",
    "1. **Creating Target Encoding for State of Residence**\n",
    "1. **Separating Typical from Extreme Debt to Income Ratio**\n",
    "1. **Separating Typical from Extreme Number of Delinquencies in the Past 2 Years**\n",
    "1. **Separating Typical from Extreme Revolving Credit Line Utilized**\n",
    "1. **Separating Typical from Extreme Number of Credit Lines**\n",
    "1. **Separating Typical from Extreme Longest Credit Length**\n",
    "1. **Converting Income Verification Status to a 0/1 Indicator**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = \"bad_loan\"\n",
    "x_orig = train.col_names\n",
    "x_orig.remove(y)\n",
    "x_orig.remove(\"int_rate\")\n",
    "\n",
    "x_trans = x_orig.copy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Cross Validation and Target Encoding"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This analysis will use [cross-validated mean target encoding](https://github.com/h2oai/h2o-tutorials/blob/master/best-practices/categorical-predictors/target_encoding.md) of the categorical predictors as one hot encodings can lead to overfitting of infrequent categories.\n",
    "\n",
    "To achieve this goal, we will first create soft partitions using H2OFrame's [`kfold_column`](http://docs.h2o.ai/h2o/latest-stable/h2o-py/docs/frame.html?highlight=kfold_column#h2o.frame.H2OFrame.kfold_column) function, then calculate summary statistics using H2O's [`group_by`](http://docs.h2o.ai/h2o/latest-stable/h2o-py/docs/frame.html#groupby) function, and finally join these engineered features using H2OFrame's [`merge`](http://docs.h2o.ai/h2o/latest-stable/h2o-py/docs/frame.html?highlight=merge#h2o.frame.H2OFrame.merge)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "cv_nfolds = 5\n",
    "cv_seed = 987"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "train[\"cv_fold\"] = train.kfold_column(n_folds = cv_nfolds, seed = cv_seed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table>\n",
       "<thead>\n",
       "<tr><th style=\"text-align: right;\">  cv_fold</th><th style=\"text-align: right;\">  Count</th></tr>\n",
       "</thead>\n",
       "<tbody>\n",
       "<tr><td style=\"text-align: right;\">        0</td><td style=\"text-align: right;\">  32818</td></tr>\n",
       "<tr><td style=\"text-align: right;\">        1</td><td style=\"text-align: right;\">  32810</td></tr>\n",
       "<tr><td style=\"text-align: right;\">        2</td><td style=\"text-align: right;\">  33045</td></tr>\n",
       "<tr><td style=\"text-align: right;\">        3</td><td style=\"text-align: right;\">  32570</td></tr>\n",
       "<tr><td style=\"text-align: right;\">        4</td><td style=\"text-align: right;\">  32744</td></tr>\n",
       "</tbody>\n",
       "</table>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": []
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train[\"cv_fold\"].table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def logit(p):\n",
    "    return np.log(p) - np.log(1 - p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mean_target(data, x, y = \"bad_loan\"):\n",
    "    grouped_data = data[[x, y]].group_by([x])\n",
    "    stats = grouped_data.count(na = \"ignore\").mean(na = \"ignore\")\n",
    "    return stats.get_frame().as_data_frame()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mean_target_encoding(data, x, y = \"bad_loan\", fold_column = \"cv_fold\", prior_mean = 0.183, prior_count = 1):\n",
    "    \"\"\"\n",
    "    Creates target encoding for binary target\n",
    "    data (H2OFrame) : data set\n",
    "    x (string) : categorical predictor column name\n",
    "    y (string) : binary target column name\n",
    "    fold_column (string) : cross-validation fold column name\n",
    "    prior_mean (float) : proportion of 1s in the target column\n",
    "    prior_count (positive number) : weight to give to prior_mean\n",
    "    \"\"\" \n",
    "    grouped_data = data[[x, fold_column, y]].group_by([x, fold_column])\n",
    "    grouped_data.sum(na = \"ignore\").count(na = \"ignore\")\n",
    "    df = grouped_data.get_frame().as_data_frame()\n",
    "    df_list = []\n",
    "    nfold = int(data[fold_column].max()) + 1\n",
    "    for j in range(0, nfold):\n",
    "        te_x = \"te_{}\".format(x)\n",
    "        sum_y = \"sum_{}\".format(y)\n",
    "        oof = df.loc[df[fold_column] != j, [x, sum_y, \"nrow\"]]\n",
    "        stats = oof.groupby([x]).sum()\n",
    "        stats[x] = stats.index\n",
    "        stats[fold_column] = j\n",
    "        p = (stats[sum_y] + (prior_count * prior_mean)) / (stats[\"nrow\"] + prior_count)\n",
    "        stats[te_x] = logit(p)\n",
    "        df_list.append(stats[[x, fold_column, te_x]])\n",
    "    return h2o.H2OFrame(pd.concat(df_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Separating Typical from Extreme Loan Amount"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After binning `loan_amt` using H2OFrame's [`cut`](http://docs.h2o.ai/h2o/latest-stable/h2o-py/docs/frame.html?highlight=cut#h2o.frame.H2OFrame.cut) function and looking at the fraction of bad loans on a logit scale, we see that the chance of a bad loan roughly increases linearly in loan amount from \\$5,000 to \\$30,000 and is relatively flat below \\$5,000 and above \\$30,000. To reflect this finding in the modeling, we will replace the original `loan_amnt` measure with two derived measures:\n",
    "\n",
    "\\begin{eqnarray}\n",
    "loan\\_amnt\\_core & = & \\max(5000, \\min(loan\\_amnt, 30000)) \\\\\n",
    "loan\\_amnt\\_diff & = & loan\\_amnt - loan\\_amnt\\_core\n",
    "\\end{eqnarray}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table>\n",
       "<thead>\n",
       "<tr><th style=\"text-align: right;\">  Probs</th><th style=\"text-align: right;\">  loan_amntQuantiles</th></tr>\n",
       "</thead>\n",
       "<tbody>\n",
       "<tr><td style=\"text-align: right;\">   0   </td><td style=\"text-align: right;\">                 500</td></tr>\n",
       "<tr><td style=\"text-align: right;\">   0.05</td><td style=\"text-align: right;\">                3000</td></tr>\n",
       "<tr><td style=\"text-align: right;\">   0.25</td><td style=\"text-align: right;\">                7000</td></tr>\n",
       "<tr><td style=\"text-align: right;\">   0.5 </td><td style=\"text-align: right;\">               11325</td></tr>\n",
       "<tr><td style=\"text-align: right;\">   0.75</td><td style=\"text-align: right;\">               18000</td></tr>\n",
       "<tr><td style=\"text-align: right;\">   0.95</td><td style=\"text-align: right;\">               30000</td></tr>\n",
       "<tr><td style=\"text-align: right;\">   1   </td><td style=\"text-align: right;\">               35000</td></tr>\n",
       "</tbody>\n",
       "</table>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": []
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train[\"loan_amnt\"].quantile([0, 0.05, 0.25, 0.5, 0.75, 0.95, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "breaks = np.linspace(0, 35000, 8).tolist()\n",
    "train[\"loan_amnt_cat\"] = train[\"loan_amnt\"].cut(breaks = breaks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = mean_target(train, \"loan_amnt_cat\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.xticks(rotation = 90)\n",
    "plt.yscale(\"logit\")\n",
    "plt.plot(df[\"loan_amnt_cat\"], df[\"mean_bad_loan\"])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>loan_amnt_cat</th>\n",
       "      <th>nrow</th>\n",
       "      <th>mean_bad_loan</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>(0.0,5000.0]</td>\n",
       "      <td>25785</td>\n",
       "      <td>0.163234</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>(5000.0,10000.0]</td>\n",
       "      <td>50384</td>\n",
       "      <td>0.164278</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>(10000.0,15000.0]</td>\n",
       "      <td>35552</td>\n",
       "      <td>0.173436</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>(15000.0,20000.0]</td>\n",
       "      <td>24659</td>\n",
       "      <td>0.208281</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>(20000.0,25000.0]</td>\n",
       "      <td>14447</td>\n",
       "      <td>0.214508</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>(25000.0,30000.0]</td>\n",
       "      <td>6913</td>\n",
       "      <td>0.238825</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>(30000.0,35000.0]</td>\n",
       "      <td>6247</td>\n",
       "      <td>0.236594</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       loan_amnt_cat   nrow  mean_bad_loan\n",
       "0       (0.0,5000.0]  25785       0.163234\n",
       "1   (5000.0,10000.0]  50384       0.164278\n",
       "2  (10000.0,15000.0]  35552       0.173436\n",
       "3  (15000.0,20000.0]  24659       0.208281\n",
       "4  (20000.0,25000.0]  14447       0.214508\n",
       "5  (25000.0,30000.0]   6913       0.238825\n",
       "6  (30000.0,35000.0]   6247       0.236594"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_trans.remove(\"loan_amnt\")\n",
    "x_trans.append(\"loan_amnt_core\")\n",
    "x_trans.append(\"loan_amnt_delta\")\n",
    "\n",
    "train[\"loan_amnt_core\"] = h2o.H2OFrame.ifelse(train[\"loan_amnt\"] <= 5000, 5000, train[\"loan_amnt\"])\n",
    "train[\"loan_amnt_core\"] = h2o.H2OFrame.ifelse(train[\"loan_amnt_core\"] <= 30000, train[\"loan_amnt_core\"], 30000)\n",
    "\n",
    "train[\"loan_amnt_delta\"] = train[\"loan_amnt\"] - train[\"loan_amnt_core\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Converting Term to a 0/1 Indicator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Given that term of the loans are either 3 or 5 years, we will create a simplifed `term_36month` binary indicator that is 1 when the terms of the loan is for 5 years and 0 for loans with a term of 3 years."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table>\n",
       "<thead>\n",
       "<tr><th>term     </th><th style=\"text-align: right;\">  Count</th></tr>\n",
       "</thead>\n",
       "<tbody>\n",
       "<tr><td>36 months</td><td style=\"text-align: right;\"> 129950</td></tr>\n",
       "<tr><td>60 months</td><td style=\"text-align: right;\">  34037</td></tr>\n",
       "</tbody>\n",
       "</table>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": []
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train[\"term\"].table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_trans.remove(\"term\")\n",
    "x_trans.append(\"term_60months\")\n",
    "\n",
    "train[\"term_60months\"] = train[\"term\"] == \"60 months\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table>\n",
       "<thead>\n",
       "<tr><th style=\"text-align: right;\">  term_60months</th><th style=\"text-align: right;\">  Count</th></tr>\n",
       "</thead>\n",
       "<tbody>\n",
       "<tr><td style=\"text-align: right;\">              0</td><td style=\"text-align: right;\"> 129950</td></tr>\n",
       "<tr><td style=\"text-align: right;\">              1</td><td style=\"text-align: right;\">  34037</td></tr>\n",
       "</tbody>\n",
       "</table>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": []
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train[\"term_60months\"].table()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Creating Missing Value Indicator for Employment Length"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The most interesting characteristic about employment length is whether or not it is missing. The divide between those with missing values for employment length to those who have a recorded employment length is 26.3% bad loans to 18.0% bad loans respectively. Interestingly, there doesn't appear to be any differences in bad loans across employment lengths."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table>\n",
       "<thead>\n",
       "<tr><th>       </th><th>emp_length        </th></tr>\n",
       "</thead>\n",
       "<tbody>\n",
       "<tr><td>type   </td><td>int               </td></tr>\n",
       "<tr><td>mins   </td><td>0.0               </td></tr>\n",
       "<tr><td>mean   </td><td>5.68435293299533  </td></tr>\n",
       "<tr><td>maxs   </td><td>10.0              </td></tr>\n",
       "<tr><td>sigma  </td><td>3.6106637311002365</td></tr>\n",
       "<tr><td>zeros  </td><td>14248             </td></tr>\n",
       "<tr><td>missing</td><td>5804              </td></tr>\n",
       "<tr><td>0      </td><td>10.0              </td></tr>\n",
       "<tr><td>1      </td><td>0.0               </td></tr>\n",
       "<tr><td>2      </td><td>10.0              </td></tr>\n",
       "<tr><td>3      </td><td>10.0              </td></tr>\n",
       "<tr><td>4      </td><td>3.0               </td></tr>\n",
       "<tr><td>5      </td><td>9.0               </td></tr>\n",
       "<tr><td>6      </td><td>4.0               </td></tr>\n",
       "<tr><td>7      </td><td>0.0               </td></tr>\n",
       "<tr><td>8      </td><td>5.0               </td></tr>\n",
       "<tr><td>9      </td><td>10.0              </td></tr>\n",
       "</tbody>\n",
       "</table>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "train[\"emp_length\"].summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_trans.append(\"emp_length_missing\")\n",
    "\n",
    "train[\"emp_length_missing\"] = train[\"emp_length\"] == None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.6/site-packages/h2o/utils/shared_utils.py:177: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  data = _handle_python_lists(python_obj.as_matrix().tolist(), -1)[1]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parse progress: |█████████████████████████████████████████████████████████| 100%\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "<thead>\n",
       "<tr><th style=\"text-align: right;\">  emp_length_missing</th><th style=\"text-align: right;\">  cv_fold</th><th style=\"text-align: right;\">  te_emp_length_missing</th></tr>\n",
       "</thead>\n",
       "<tbody>\n",
       "<tr><td style=\"text-align: right;\">                   0</td><td style=\"text-align: right;\">        0</td><td style=\"text-align: right;\">               -1.51627</td></tr>\n",
       "<tr><td style=\"text-align: right;\">                   1</td><td style=\"text-align: right;\">        0</td><td style=\"text-align: right;\">               -1.04832</td></tr>\n",
       "<tr><td style=\"text-align: right;\">                   0</td><td style=\"text-align: right;\">        1</td><td style=\"text-align: right;\">               -1.5119 </td></tr>\n",
       "<tr><td style=\"text-align: right;\">                   1</td><td style=\"text-align: right;\">        1</td><td style=\"text-align: right;\">               -1.00873</td></tr>\n",
       "<tr><td style=\"text-align: right;\">                   0</td><td style=\"text-align: right;\">        2</td><td style=\"text-align: right;\">               -1.52094</td></tr>\n",
       "<tr><td style=\"text-align: right;\">                   1</td><td style=\"text-align: right;\">        2</td><td style=\"text-align: right;\">               -1.03431</td></tr>\n",
       "<tr><td style=\"text-align: right;\">                   0</td><td style=\"text-align: right;\">        3</td><td style=\"text-align: right;\">               -1.51924</td></tr>\n",
       "<tr><td style=\"text-align: right;\">                   1</td><td style=\"text-align: right;\">        3</td><td style=\"text-align: right;\">               -1.02358</td></tr>\n",
       "<tr><td style=\"text-align: right;\">                   0</td><td style=\"text-align: right;\">        4</td><td style=\"text-align: right;\">               -1.50977</td></tr>\n",
       "<tr><td style=\"text-align: right;\">                   1</td><td style=\"text-align: right;\">        4</td><td style=\"text-align: right;\">               -1.04019</td></tr>\n",
       "</tbody>\n",
       "</table>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": []
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mean_target_encoding(train, \"emp_length_missing\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = mean_target(train, \"emp_length\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.yscale(\"logit\")\n",
    "plt.plot(df[\"emp_length\"], df[\"mean_bad_loan\"])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>emp_length</th>\n",
       "      <th>nrow</th>\n",
       "      <th>mean_bad_loan</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>NaN</td>\n",
       "      <td>0</td>\n",
       "      <td>0.262922</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.0</td>\n",
       "      <td>14248</td>\n",
       "      <td>0.184307</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1.0</td>\n",
       "      <td>11414</td>\n",
       "      <td>0.177238</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2.0</td>\n",
       "      <td>15766</td>\n",
       "      <td>0.173728</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>3.0</td>\n",
       "      <td>13611</td>\n",
       "      <td>0.178679</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>4.0</td>\n",
       "      <td>11024</td>\n",
       "      <td>0.173258</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>5.0</td>\n",
       "      <td>12347</td>\n",
       "      <td>0.181664</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>6.0</td>\n",
       "      <td>10000</td>\n",
       "      <td>0.188500</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>7.0</td>\n",
       "      <td>9079</td>\n",
       "      <td>0.190770</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>8.0</td>\n",
       "      <td>7424</td>\n",
       "      <td>0.185614</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>9.0</td>\n",
       "      <td>6087</td>\n",
       "      <td>0.187120</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>10.0</td>\n",
       "      <td>47183</td>\n",
       "      <td>0.177670</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    emp_length   nrow  mean_bad_loan\n",
       "0          NaN      0       0.262922\n",
       "1          0.0  14248       0.184307\n",
       "2          1.0  11414       0.177238\n",
       "3          2.0  15766       0.173728\n",
       "4          3.0  13611       0.178679\n",
       "5          4.0  11024       0.173258\n",
       "6          5.0  12347       0.181664\n",
       "7          6.0  10000       0.188500\n",
       "8          7.0   9079       0.190770\n",
       "9          8.0   7424       0.185614\n",
       "10         9.0   6087       0.187120\n",
       "11        10.0  47183       0.177670"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Combining Categories in Home Ownership"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Although there are 6 recorded categories within home ownership, only three had over 200 observations: OWN, MORTGAGE, and RENT. The remaining three are so infrequent we will combine them {ANY, NONE, OTHER} with RENT to form an enlarged OTHER category. This new `home_ownership_3cat` variable will have values in {MORTGAGE, OTHER, OWN}."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>home_ownership</th>\n",
       "      <th>nrow</th>\n",
       "      <th>mean_bad_loan</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>ANY</td>\n",
       "      <td>1</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>MORTGAGE</td>\n",
       "      <td>79714</td>\n",
       "      <td>0.164137</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>NONE</td>\n",
       "      <td>30</td>\n",
       "      <td>0.233333</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>OTHER</td>\n",
       "      <td>156</td>\n",
       "      <td>0.224359</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>OWN</td>\n",
       "      <td>13560</td>\n",
       "      <td>0.188348</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>RENT</td>\n",
       "      <td>70526</td>\n",
       "      <td>0.203273</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  home_ownership   nrow  mean_bad_loan\n",
       "0            ANY      1       0.000000\n",
       "1       MORTGAGE  79714       0.164137\n",
       "2           NONE     30       0.233333\n",
       "3          OTHER    156       0.224359\n",
       "4            OWN  13560       0.188348\n",
       "5           RENT  70526       0.203273"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mean_target(train, \"home_ownership\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "lvls = [\"OTHER\", \"MORTGAGE\", \"OTHER\", \"OTHER\", \"OWN\", \"OTHER\"]\n",
    "train[\"home_ownership_3cat\"] = train[\"home_ownership\"].set_levels(lvls).ascharacter().asfactor()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table>\n",
       "<thead>\n",
       "<tr><th>home_ownership  </th><th>home_ownership_3cat  </th><th style=\"text-align: right;\">  Counts</th></tr>\n",
       "</thead>\n",
       "<tbody>\n",
       "<tr><td>ANY             </td><td>OTHER                </td><td style=\"text-align: right;\">       1</td></tr>\n",
       "<tr><td>MORTGAGE        </td><td>MORTGAGE             </td><td style=\"text-align: right;\">   79714</td></tr>\n",
       "<tr><td>NONE            </td><td>OTHER                </td><td style=\"text-align: right;\">      30</td></tr>\n",
       "<tr><td>OTHER           </td><td>OTHER                </td><td style=\"text-align: right;\">     156</td></tr>\n",
       "<tr><td>OWN             </td><td>OWN                  </td><td style=\"text-align: right;\">   13560</td></tr>\n",
       "<tr><td>RENT            </td><td>OTHER                </td><td style=\"text-align: right;\">   70526</td></tr>\n",
       "</tbody>\n",
       "</table>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": []
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train[[\"home_ownership\", \"home_ownership_3cat\"]].table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>home_ownership_3cat</th>\n",
       "      <th>nrow</th>\n",
       "      <th>mean_bad_loan</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>MORTGAGE</td>\n",
       "      <td>79714</td>\n",
       "      <td>0.164137</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>OTHER</td>\n",
       "      <td>70713</td>\n",
       "      <td>0.203329</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>OWN</td>\n",
       "      <td>13560</td>\n",
       "      <td>0.188348</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  home_ownership_3cat   nrow  mean_bad_loan\n",
       "0            MORTGAGE  79714       0.164137\n",
       "1               OTHER  70713       0.203329\n",
       "2                 OWN  13560       0.188348"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mean_target(train, \"home_ownership_3cat\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_trans.remove(\"home_ownership\")\n",
    "x_trans.append(\"home_ownership_3cat\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Separating Typical from Extreme Annual Income"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Looking at the occurance of bad loans on a logit scale reveal that the chance of a bad loan roughly decreases linearly in annual income from \\$10,000 to \\$105,000 and is relatively flat above \\$105,000. To reflect this finding in the modeling, we will replace the original `annual_inc` measure with two derived measures:\n",
    "\n",
    "\\begin{eqnarray}\n",
    "annual\\_inc\\_core & = & \\max(10000, \\min(annual\\_inc, 105000)) \\\\\n",
    "annual\\_inc\\_diff & = & annual\\_inc - annual\\_inc\\_core\n",
    "\\end{eqnarray}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table>\n",
       "<thead>\n",
       "<tr><th style=\"text-align: right;\">  Probs</th><th style=\"text-align: right;\">  annual_incQuantiles</th></tr>\n",
       "</thead>\n",
       "<tbody>\n",
       "<tr><td style=\"text-align: right;\">   0   </td><td style=\"text-align: right;\">       1896          </td></tr>\n",
       "<tr><td style=\"text-align: right;\">   0.05</td><td style=\"text-align: right;\">      27000          </td></tr>\n",
       "<tr><td style=\"text-align: right;\">   0.25</td><td style=\"text-align: right;\">      45000          </td></tr>\n",
       "<tr><td style=\"text-align: right;\">   0.5 </td><td style=\"text-align: right;\">      61000          </td></tr>\n",
       "<tr><td style=\"text-align: right;\">   0.75</td><td style=\"text-align: right;\">      85000          </td></tr>\n",
       "<tr><td style=\"text-align: right;\">   0.95</td><td style=\"text-align: right;\">     145000          </td></tr>\n",
       "<tr><td style=\"text-align: right;\">   1   </td><td style=\"text-align: right;\">          7.14178e+06</td></tr>\n",
       "</tbody>\n",
       "</table>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": []
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train[\"annual_inc\"].quantile([0, 0.05, 0.25, 0.5, 0.75, 0.95, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "breaks = np.linspace(0, 150000, 31).tolist()\n",
    "train[\"annual_inc_cat\"] = train[\"annual_inc\"].cut(breaks = breaks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = mean_target(train, \"annual_inc_cat\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.yscale(\"logit\")\n",
    "plt.plot(df[\"annual_inc_cat\"].index, df[\"mean_bad_loan\"])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>annual_inc_cat</th>\n",
       "      <th>nrow</th>\n",
       "      <th>mean_bad_loan</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>NaN</td>\n",
       "      <td>0</td>\n",
       "      <td>0.126695</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>(0.0,5000.0]</td>\n",
       "      <td>25</td>\n",
       "      <td>0.240000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>(5000.0,10000.0]</td>\n",
       "      <td>192</td>\n",
       "      <td>0.213542</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>(10000.0,15000.0]</td>\n",
       "      <td>868</td>\n",
       "      <td>0.288018</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>(15000.0,20000.0]</td>\n",
       "      <td>1847</td>\n",
       "      <td>0.251760</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>(20000.0,25000.0]</td>\n",
       "      <td>3975</td>\n",
       "      <td>0.241509</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      annual_inc_cat  nrow  mean_bad_loan\n",
       "0                NaN     0       0.126695\n",
       "1       (0.0,5000.0]    25       0.240000\n",
       "2   (5000.0,10000.0]   192       0.213542\n",
       "3  (10000.0,15000.0]   868       0.288018\n",
       "4  (15000.0,20000.0]  1847       0.251760\n",
       "5  (20000.0,25000.0]  3975       0.241509"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[0:6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>annual_inc_cat</th>\n",
       "      <th>nrow</th>\n",
       "      <th>mean_bad_loan</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>20</th>\n",
       "      <td>(95000.0,100000.0]</td>\n",
       "      <td>5473</td>\n",
       "      <td>0.138315</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>21</th>\n",
       "      <td>(100000.0,105000.0]</td>\n",
       "      <td>2860</td>\n",
       "      <td>0.129021</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>22</th>\n",
       "      <td>(105000.0,110000.0]</td>\n",
       "      <td>3275</td>\n",
       "      <td>0.133740</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>23</th>\n",
       "      <td>(110000.0,115000.0]</td>\n",
       "      <td>1908</td>\n",
       "      <td>0.108491</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>24</th>\n",
       "      <td>(115000.0,120000.0]</td>\n",
       "      <td>3009</td>\n",
       "      <td>0.147557</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25</th>\n",
       "      <td>(120000.0,125000.0]</td>\n",
       "      <td>1741</td>\n",
       "      <td>0.125790</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>26</th>\n",
       "      <td>(125000.0,130000.0]</td>\n",
       "      <td>1642</td>\n",
       "      <td>0.107186</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>27</th>\n",
       "      <td>(130000.0,135000.0]</td>\n",
       "      <td>974</td>\n",
       "      <td>0.120123</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>28</th>\n",
       "      <td>(135000.0,140000.0]</td>\n",
       "      <td>1235</td>\n",
       "      <td>0.132794</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>29</th>\n",
       "      <td>(140000.0,145000.0]</td>\n",
       "      <td>746</td>\n",
       "      <td>0.107239</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>30</th>\n",
       "      <td>(145000.0,150000.0]</td>\n",
       "      <td>1492</td>\n",
       "      <td>0.136729</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         annual_inc_cat  nrow  mean_bad_loan\n",
       "20   (95000.0,100000.0]  5473       0.138315\n",
       "21  (100000.0,105000.0]  2860       0.129021\n",
       "22  (105000.0,110000.0]  3275       0.133740\n",
       "23  (110000.0,115000.0]  1908       0.108491\n",
       "24  (115000.0,120000.0]  3009       0.147557\n",
       "25  (120000.0,125000.0]  1741       0.125790\n",
       "26  (125000.0,130000.0]  1642       0.107186\n",
       "27  (130000.0,135000.0]   974       0.120123\n",
       "28  (135000.0,140000.0]  1235       0.132794\n",
       "29  (140000.0,145000.0]   746       0.107239\n",
       "30  (145000.0,150000.0]  1492       0.136729"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[20:31]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_trans.remove(\"annual_inc\")\n",
    "x_trans.append(\"annual_inc_core\")\n",
    "x_trans.append(\"annual_inc_delta\")\n",
    "\n",
    "train[\"annual_inc_core\"] = h2o.H2OFrame.ifelse(train[\"annual_inc\"] <= 10000, 10000, train[\"annual_inc\"])\n",
    "train[\"annual_inc_core\"] = h2o.H2OFrame.ifelse(train[\"annual_inc_core\"] <= 105000,\n",
    "                                               train[\"annual_inc_core\"], 105000)\n",
    "\n",
    "train[\"annual_inc_delta\"] = train[\"annual_inc\"] - train[\"annual_inc_core\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Creating Target Encoding for Loan Purpose"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Given that there is a high concentration of loans for debt consolidation (56.87%), a sizable number for credit card (18.78%), and the remaining 24.35% loans are spread amongst 12 other purposes, we will use mean target encoding to avoid overfitting of the later group."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "               purpose  Count  Percent\n",
      "0   debt_consolidation  93261    56.87\n",
      "1          credit_card  30792    18.78\n",
      "2                other  10492     6.40\n",
      "3     home_improvement   9872     6.02\n",
      "4       major_purchase   4686     2.86\n",
      "5       small_business   3841     2.34\n",
      "6                  car   2842     1.73\n",
      "7              medical   2029     1.24\n",
      "8              wedding   1751     1.07\n",
      "9               moving   1464     0.89\n",
      "10               house   1245     0.76\n",
      "11            vacation   1096     0.67\n",
      "12         educational    418     0.25\n",
      "13    renewable_energy    198     0.12\n"
     ]
    }
   ],
   "source": [
    "tbl = train[\"purpose\"].table().as_data_frame()\n",
    "tbl[\"Percent\"] = np.round((100 * tbl[\"Count\"]/train.nrows), 2)\n",
    "tbl = tbl.sort_values(by = \"Count\", ascending = 0)\n",
    "tbl = tbl.reset_index(drop = True)\n",
    "print(tbl)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>purpose</th>\n",
       "      <th>nrow</th>\n",
       "      <th>mean_bad_loan</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>car</td>\n",
       "      <td>2842</td>\n",
       "      <td>0.125968</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>credit_card</td>\n",
       "      <td>30792</td>\n",
       "      <td>0.157281</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>debt_consolidation</td>\n",
       "      <td>93261</td>\n",
       "      <td>0.189479</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>educational</td>\n",
       "      <td>418</td>\n",
       "      <td>0.210526</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>home_improvement</td>\n",
       "      <td>9872</td>\n",
       "      <td>0.155895</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>house</td>\n",
       "      <td>1245</td>\n",
       "      <td>0.182329</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>major_purchase</td>\n",
       "      <td>4686</td>\n",
       "      <td>0.137217</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>medical</td>\n",
       "      <td>2029</td>\n",
       "      <td>0.203056</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>moving</td>\n",
       "      <td>1464</td>\n",
       "      <td>0.207650</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>other</td>\n",
       "      <td>10492</td>\n",
       "      <td>0.214354</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>renewable_energy</td>\n",
       "      <td>198</td>\n",
       "      <td>0.227273</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>small_business</td>\n",
       "      <td>3841</td>\n",
       "      <td>0.309034</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>vacation</td>\n",
       "      <td>1096</td>\n",
       "      <td>0.178832</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>wedding</td>\n",
       "      <td>1751</td>\n",
       "      <td>0.145060</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "               purpose   nrow  mean_bad_loan\n",
       "0                  car   2842       0.125968\n",
       "1          credit_card  30792       0.157281\n",
       "2   debt_consolidation  93261       0.189479\n",
       "3          educational    418       0.210526\n",
       "4     home_improvement   9872       0.155895\n",
       "5                house   1245       0.182329\n",
       "6       major_purchase   4686       0.137217\n",
       "7              medical   2029       0.203056\n",
       "8               moving   1464       0.207650\n",
       "9                other  10492       0.214354\n",
       "10    renewable_energy    198       0.227273\n",
       "11      small_business   3841       0.309034\n",
       "12            vacation   1096       0.178832\n",
       "13             wedding   1751       0.145060"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mean_target(train, \"purpose\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.6/site-packages/h2o/utils/shared_utils.py:177: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  data = _handle_python_lists(python_obj.as_matrix().tolist(), -1)[1]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parse progress: |█████████████████████████████████████████████████████████| 100%\n"
     ]
    }
   ],
   "source": [
    "te_purpose = mean_target_encoding(train, \"purpose\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "train = train.merge(te_purpose, all_x = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_trans.remove(\"purpose\")\n",
    "x_trans.append(\"te_purpose\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "train[\"te_purpose\"].hist()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Creating Target Encoding for State of Residence"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will also use a mean target encoding for state of residence for a reason similar to that for purpose."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  addr_state  Count  Percent\n",
      "0         CA  28702    17.50\n",
      "1         NY  14285     8.71\n",
      "2         TX  12128     7.40\n",
      "3         FL  11396     6.95\n",
      "4         NJ   6457     3.94\n"
     ]
    }
   ],
   "source": [
    "tbl = train[\"addr_state\"].table().as_data_frame()\n",
    "tbl[\"Percent\"] = np.round((100 * tbl[\"Count\"]/train.nrows), 2)\n",
    "tbl = tbl.sort_values(by = \"Count\", ascending = 0)\n",
    "tbl = tbl.reset_index(drop = True)\n",
    "print(tbl[0:5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = mean_target(train, \"addr_state\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX0AAAD8CAYAAACb4nSYAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJztnXl8lNW9/99nJpmsECALkLCHfRFUFMUNcN9Qa62it1fb3trF3m63i7a9bX+2tr1tre2t9rba2t2ita2ipe4boMgia0BICEsWCFkg2ySZzMz5/XGeJ5lMJskMZJ7J8n2/XnnBnGc7z/Z5vud7vud7lNYaQRAEYXjgSnQFBEEQBOcQ0RcEQRhGiOgLgiAMI0T0BUEQhhEi+oIgCMMIEX1BEIRhhIi+IAjCMEJEXxAEYRghoi8IgjCMSEp0BcLJycnRU6ZMSXQ1BEEQBhVbt26t0Vrn9rXegBP9KVOmsGXLlkRXQxAEYVChlDoczXri3hEEQRhGiOgLgiAMI0T0BUEQhhEi+oIgCMMIEX1BEIRhhIi+IAjCMEJEXxAEYRghoi8ICaQ9EOSpzWUEgzJtqeAMIvqCkEDWF9fwlb/tZEf5yURXRRgmiOgLQgJpbPMD0NwWSHBNhOGCiL4gJBCvJfot7SL6gjOI6AtCAvH6jNiL6AtOIaIvCAnE6zOWfqtPRF9wBhF9QUggtqVvi78gxBsRfUFIIJ3unWCCayIMF0T0BSGB2Ba++PQFpxDRF4QEYlv6rSL6gkOI6AtCAulw70hHruAQUYm+UuoqpdQ+pVSJUureCMvvUkpVK6W2W3//EbLsTqVUsfV3Z39WXhAGO7Z7xyuiLzhEn3PkKqXcwCPA5UA5sFkptUZrvSds1Se11p8J23YM8C1gMaCBrda2J/ql9oIwyGkR947gMNFY+ucCJVrrUq21D1gN3BDl/q8EXtZa11lC/zJw1alVVRCGHs0yOEtwmGhEvwAoC/ldbpWFc7NSaqdS6mml1MQYtxWEYUmL+PQFh4lG9FWEsvA8sM8BU7TWZwCvAL+PYVuUUncrpbYopbZUV1dHUSVBGBpIyKbgNNGIfjkwMeT3BKAydAWtda3Wus36+RhwdrTbWts/qrVerLVenJubG23dBWHQ0yyWvuAw0Yj+ZmCGUmqqUsoD3AasCV1BKTU+5OdKYK/1/xeBK5RSo5VSo4ErrDJBGPb4A0F8fjMSVyx9wSn6jN7RWvuVUp/BiLUbeFxrXaSUuh/YorVeA3xWKbUS8AN1wF3WtnVKqe9gPhwA92ut6+JwHoIw6PCGCL2IvuAUfYo+gNZ6LbA2rOybIf+/D7ivh20fBx4/jToKwpDEdumkJLkky6bgGDIiVxAShD0gKyczBW97AK1lnlwh/ojoC0KCaLZmzcrO9BAIatoDIvpC/BHRF4QEYfvxszM8XX4LQjwR0ReEBGG7d8ZkpACSikFwBhF9QUgQ3hD3DkisvuAMIvqCkCBsS99270imTcEJRPQFIUHYKRiyM417R3z6ghOI6AtCggi39MWnLziBiL4gJAhb9EdniE9fcA4RfUFIEF6fn9RkF5kpbkDcO4IziOgLQoLw+gJkeJJITbZEXyx9wQFE9AUhQbT4AqR53KR7TAossfQFJxDRF4QE0ezzk+5xk5Ys7h3BOUT0BSFBeH0B0j1JpCSZ11DcO4ITiOgLQoIwou/G5VKkJrvE0hccQURfEBKEbekDpCW7xdIXHEFEXxASRIvl0wdI9ySJpS84goi+ICSIZsu9A4h7R3AMEX1BSBAtoe4dj1umTBQcQURfEBKA1rojZBOMT1+ybApOIKIvCAmgzR9Ea2PhA6Qmu8W9IziCiL4gJADbqs/o6Mh1S5ZNwRFE9AUhAdiToncJ2RTRFxxARF8QEoAt8OlWhs00j8TpC84goi8ICcB276SH+vRF9AUHENEXhARgT4qelizuHcFZRPQFIQF0dOSmdHbk+oOa9kAwkdUShgExib5S6iql1D6lVIlS6t5e1vugUkorpRaHlN1nbbdPKXXl6VRaEAY7zT67I7fTvQOSXlmIP1GLvlLKDTwCXA3MBVYppeZGWG8E8Fng3ZCyucBtwDzgKuAX1v4EYVjS0uHT7xyRG1ouCPEiFkv/XKBEa12qtfYBq4EbIqz3HeCHQGtI2Q3Aaq11m9b6IFBi7U8QhiXhHblpMmWi4BCxiH4BUBbyu9wq60ApdSYwUWv9/Clse71S6tH6+voYqiQIgxOv5d5JCxd9ce8IcSYW0VcRynTHQqVcwEPAf8W6LYDW+jmt9d1ZWVkxVEkQBideX4Akl8LjNq9gh3tHRF+IM0kxrFsOTAz5PQGoDPk9ApgPvKGUAhgHrFFKrYxiW0EYVnitSdGtd6XD0pdMm0K8icXS3wzMUEpNVUp5MB2za+yFWut6rXWO1nqK1noKsBFYqbXeYq13m1IqRSk1FZgBbOq3sxCEQYY3JMMmdFr6kmlTiDdRW/paa79S6jPAi4AbeFxrXaSUuh/YorVe08u2RUqpp4A9gB+4R2stT7cwbPH6AmR4Ol8/8ekLThGLewet9VpgbVjZN3tYd1nY7weAB2KsnyAMSWz3jo3E6QtOISNyBSEBeH3+Lpa+7eqR9MpCvBHRF4QE0BJm6cvgLMEpRPQFIQGETooOkJokHbmCM4joC0ICCJ0UHcDlUqQkucS9I8QdEX1BSADhIZtgTaQioi/EGRF9QUgAzb5Ax6xZNukykYrgACL6guAw/kAQnz9IenLXiOlUsfQFBxDRFwSH8bZ3zbBpkyaWvuAAIvqC4DAdufRTIoi+WPpCnBHRFwSHCc+lbyMduYITiOgLgsM0h02KbiPuHcEJRPQFwWFsaz4j3L0jlr7gACL6guAwtqUvHblCIhDRFwSHCZ8U3SZVOnIFBxDRFwSH6akjN93jljQMQtwR0RcEhwmfFN0mLdlNe0DTHggmolrCMEFEXxAcxrb0M8LcOzI5uuAEIvqC4DC26NtTJNqkyuToggOI6AuCw3h9ftKS3bhcqku5zJMrOIGIviA4jDdsAhWbdHHvCA4goi8IDhM+KbpNqkyZKDiAiL4gOEz4pOg2He4dEX0hjojoC4LD9GTpi09fcAIRfUFwmJ58+hKyKTiBiL4gOIw3bFJ0G3HvCE4goi8IDtMSYVJ0EEtfcAYRfUFwmGZfoFtaZRBLX3AGEX1BcJgWX6DbBCrQOSJXLH0hnojoC4KDaK1p7sG943YpPEkuEX0hrsQk+kqpq5RS+5RSJUqpeyMs/6RSapdSartSar1Sam7Isvus7fYppa7sj8oLwmCjzR9E6+6Totuke9ySe0eIK1GLvlLKDTwCXA3MBVaFirrFE1rrBVrrRcAPgZ9Y284FbgPmAVcBv7D2JwjDio5c+smRH/+0ZHfHOoIQD2Kx9M8FSrTWpVprH7AauCF0Ba11Q8jPDEBb/78BWK21btNaHwRKrP0JwrCiY6rElO4+fbCmTBT3jhBHIj95kSkAykJ+lwNLwldSSt0DfBHwACtCtt0Ytm1BTDUVhCGALeiRfPpgOnNl9iwhnsRi6asIZbpbgdaPaK0Lga8C34h2W6XU9UqpR+vr62OokiAMLnqaKtEmzSOWvhBfYhH9cmBiyO8JQGUv668Gbox2W631c1rru7OysmKokiAMLry2eyfCiFxT7pY4fSGuxCL6m4EZSqmpSikPpmN2TegKSqkZIT+vBYqt/68BblNKpSilpgIzgE2nXm1BGJz0ZemnSkeuEGei9ulrrf1Kqc8ALwJu4HGtdZFS6n5gi9Z6DfAZpdRlQDtwArjT2rZIKfUUsAfwA/doreXJFoYdzT7b0u85ekd8+kI8iaUjF631WmBtWNk3Q/7/uV62fQB4INYKCsJQoqXD0pfoHSExyIhcQXCQqDpyxb0jxBERfUFwEK+v945cid4R4o2IviA4iNcXIMnKsROJtGQ37QFNeyDocM2E4YKIviA4SE9TJdrY6ZWlM1eIFyL6guAgPU2KbpMqE6kIcUZEXxAcpKf5cW06LH2fuHeE+CCiLwgO0pd7x/4geNv9TlVJGGaI6AuCg/Tl3pEpE4V4I6IvCA7S0oelL1MmCvFGRF8QHKSnSdFt7A+CRO8I8UJEXxAcpKdJ0W1sn36LdOQKcUJEXxAcpKdJ0W1sn749clcQ+hsRfUFwEK8v0OOk6NDp0xf3jhAvRPQFwSH8gSA+f5D0Xtw7aTI4S4gzIvqC4BBeS8h77chNFp++EF9E9AXBIezY+95CNt1WMjax9IV4IaIvCA7RVy59m7RkNy3SkSvECRF9QXCI5j4mRbeR2bOEeCKiLwgOYQt5n5a+x01Lu/j0hfggoi8IDtFp6fcu+qnJMmWiED9E9AXBIfqaFN0m3eOmRbJsCnFCRF8QHCK2jlyx9KOlrtnHtiMnEl2NQYOIviA4RF+TotukJotPPxb+99Vibnt0I36ZVzgqRPQFwSGitvQ9bknDEAM7yk/S5g9ytL410VUZFIjoC4JDNNuDs5L7cu+4xL0TJf5AkL1HGwA4VNuc4NoMDkT0BcEhWnx+0pLduFyq1/XSPUmSZTNKDlQ302q5wg7VehNcm8GBiL4gOERfk6LbpCa7O4RM6J1dFfUd/z9cI5Z+NIjoC8Ip8Oz2CvYda4xpm77SKtukJbvxBYL91jG5dtdRLvyf12hqG3qth90V9aR73EzPyxRLP0pE9AUhRipOtvCFJ7fz2LrSmLbz+vy9plW2SfOY17LV3z+iv3pzGeUnWlhfXNMv+xtI7K6oZ+74kUzLyeCw+PSjQkRfEGLkyU1HCGooPxGbZentY1J0m870yqffmdvQ2s47B4zYv/7+8dPe30AiENQUVTYwvyCLKTkZHKnzEgzqRFdrwCOiLwgx4A8EeXJLGWAs/ljw9jEpuk2aFcffH6L/+vvHaQ9oJmen8/q+42g9dETxYE0TLe0B5hdkMTk7nTZ/kKpGCdvsCxF9QYiBV98/TlVDG7PGjuDoyVYCMViW3j4mRbfpsPT7IVb/pT1V5GSmcM/y6RxvbKOosuG09zlQsDtxFxRkMXlMBgCHasSv3xci+sIpo7XmwZf2xdyhOZh54t0jjBuZyu1LJuEPao7HYFl6+5gU3cb26Z+u6Le2B3jj/eNcPncsK2bnoRS8NoRcPLsrGkhNdlGYm8Hk7HQA8etHgYi+cMrsq2rk56+V8Pj6g4muiiOU1Xl5q7iaD50zkUmWyFSciN7FE617J7WffPrvHKil2RfgynljyclM4YwJo4aU6O+qqGfO+JEkuV3kj0oj2a0kgicKRPQHESe9vkRXoQt2NMj6kpoh5SvuidWbj6CA286ZyIRRaUBsfv2WmN07pxdi+WLRMTJTkji/MBuA5bNy2VF+ktqmttPa70AgGNTsqWxgfn4WYKaZnDgmnSN1Yun3hYj+IGF9cQ1nfedldpXX972yQ6yzRL/iZAsHh/jAmPZAkKe2lLN8Vh75o9IoGG1EvzxKS19rTbPPH5Wln97RkXvqIZuBoOblPVUsn51HSpI55orZeWgNb+6vPuX9DhQO1TbT1OZnQUFWR9mU7Azx6UfBsBD9TQfrBpyVHCuv7K0iqOHprWWJrgoAbf4Amw7WsWxWLmCs/aHMq3urqG5s4/YlkwAjzGMyPFFb+m3+IFr3Pim6TX905L535AS1zT6umDu2o2x+fhY5mSlDwsWz2+qQnlcwsqNs0ph0Dtc2D4tW5+kw5EW/xRfg9sc28qk/vTeoY3g3WKL63M6jtA+AFLLvHT5JS3uA28+dxITRaR1W/1Dlz+8eIT8rlWWz8jrKCkalRe3T78iw2UeyNYDUfujIfXH3MTxuV8dHGcDlUiyflctb+6sHfRri3RX1eJJczBw7oqNsSnY6zb4ANU2D28CLN0Ne9EuON+EPat4preWJTUcSXZ1T4nhDK8XHmzh36hjqmn28NQCa5+tLqnG7FOcVZnPRjFw2HqgdEB+jeHCk1su64hpuPWcS7pBkaQWj0qK29DumSkyJ3qffeooduVprXtpTxdLp2YxITe6ybMXsPBpa/Ww9PLgnHdlVXs+ccSNIdndK2OQcE7YpETy9E7XoK6WuUkrtU0qVKKXujbD8i0qpPUqpnUqpV5VSk0OW3amUKrb+7uyvykfD/ioTTjgjL5Pvr91LWd3g8/ltsEZU3nv1bEanJ/OPbRUJrhGsL6ll0cRRjExN5qIZOTS2+dlRdjLR1YoLf9l8BLdLces5E7uUF4w2ln407oRoJ0WHTtH3nqLov3+skSN1Xq6cN67bsgtn5JDsVry2b/C6eLTW7K6sZ16IPx+MTx/gsETw9EpUoq+UcgOPAFcDc4FVSqm5YattAxZrrc8AngZ+aG07BvgWsAQ4F/iWUmp0/1S/b/Yfb8TjdvHrOxcDcO/fdw46n9+GklpGpSezcMIorl+Yz8t7qmhobU9Yfeq97ewqP8mF03MAWFqYjVIMSRePzx/kr1vKWDE7j3FZqV2WFYxKo6U9QF1z3+4E29LP6GPWLIAktwuP23XK7p2XiqpQCi6bM7bbshGpyZwzZcygTslwpM5LY2vXTlww98PtUmLp90G0lv65QInWulRr7QNWAzeErqC1fl1rbX9iNwITrP9fCbysta7TWp8AXgauOv2qR0dxVRPTcjOYnJ3B166dw4aSWv6yaWB0hkaD1pq3S2o4f1o2bpfipjMLaPMHeWH3sYTV6e0DNQS1sRoBRqV7OKMga8B35tZ722NOOvbynipqmnwdHbih2BE80bh47Jj7aDpyAVKTXT3OnnW4trnXQWEvFh3j7EmjyR2REnH5itl57K9qijl3UGt7gAf+uYentiT2/dldYTpx7XBNG0+Si/xRqRKr3wfRin4BEHqny62ynvgY8K9YtlVKXa+UerS+vn9DEvdXNTLD6uy5/dxJLC3M5ntr98acNyVRHKr1UlnfylLLql40cRRTstN5JoEunvUlNWSmJLFo4qiOsgtn5LC97GRCWyB98b21e7n7j1uob4m+jk9sOkzBqDQunpHbbVmBHasfRWdutFMl2qR5Ik+OHghqbvnlO1zx0Fu8HeEjW1bnZc/RBq6Y193Kt1k+23RGx2Lt1zS1ccev3+WxdQf52SvFCW0t76qoJ9mtmDkus9uyKdmSbbMvohX9SFP9RLzrSql/AxYDP4plW631c1rru7OysiKsfmo0t/kpP9HCzLxMu278z81nENSae/82ONw8dtTOBdYAG6UUN55ZwDultRyt71ls7BQJLxX1f4tgfUkN500b06UT7cLpuQSCmo0Hanvd9umt5Xz6z1spqnR+vMGHz5+M1xfgyc3RdeiXHG9iQ0ktq86d2KUD12ZCDJZ+c5STotukJbsjune2l53keGMbwaDmw49v4ncbDnZ5jl/aUwXAFXO7+/NtpuVkWAnYogsI2F/VyI2PbGB3RT3XLBhHxckWSo43RbVtPCiqrGfm2BEd4w9CmZydLpZ+H0Qr+uVAaC/WBKAyfCWl1GXA14GVWuu2WLaNB/aDOSMkrGvimHTuu3o264prEt5MjYa3D9QwPiuVqVZkAsBNZxagNTy7vefL+NSWMn7+Wgk/fmlfv9anrM7L4VovF1gtD5uzJo8iLdndq4unvqWd+58rYu2uY1z38/V88cntMbsYTof5BVksmTqG3799OKqQxV++eYC0ZDe3L5kccXlWWjIZHndUA7RaYrT0U5PdETtyX9lbRZJL8cLnL2b5rFy+/dwe7vv7LnxW7v0Xi44xa+wIpoQ8L+EopVg+K4+3D9T0OQH7m/urufkXb9PmD/LUJ87nG9earrw3ovxg9ITWmoM1scfUa63ZVVHfzZ9vMyU7g/qW9kE/LieeRCv6m4EZSqmpSikPcBuwJnQFpdSZwK8wgh/abnwRuEIpNdrqwL3CKos7HZE7Y7s2A+9YMpnzpo3hu8/v7dVaTjTBoOadA7UsLcxBqU5Lc3J2BmdNGsU/3quI+NIcrGnm22v2MCI1if1VTbx/rP8yK9qiftGMrqKfkuRmybQxvfrMf7P+IA2tfv7y8fO4++JpPL/rKCsefJPvrd1LvdcZt9BHL5xKxcmWDou4J8pPeHlmWwWrzp3EmAxPxHWUUiaCJwpLP1b3TrrHHVGQX91bxblTx5A/Ko1HP7yYzyyfzurNZdz+2Eb2HWtky6E6ruzFtWOzfHYere1B3umlZfaHdw7xkd9uYsKYdJ695wIWThxF/qg0Zo7N5PXTiP4JBjXfeX4vy3/8RsyRaOUnWjjpbWd+D6I/WSJ4+iQq0dda+4HPYMR6L/CU1rpIKXW/UmqltdqPgEzgr0qp7UqpNda2dcB3MB+OzcD9VlncKTnehMftYvKY9C7lLpfihzcvxB/U/Pczu52oyimx52gDJ7ztXDA9u9uym86awL6qRvYe7Zrhsj0Q5POrt+FJcvGXj5+H26VY00uLIFbWF9cwbmQqhbnd/akXzciltKY5ogieaPbx+PqDXD1/HOcXZnPf1XN4/UvLuP6MfB5bV8pFP3yNx9cfjLvL7bI5Y5k0Jr3PJHGPvVWKUvDxi6f2ul60A7Tsic6j7chN83R37xyp9bK/qolLragcl0vxpStn8fDtZ7K7sp7rH15PUMMVEUI1w1kydQxpye5uo3MDQc17R07wlad38M1ni1gxO4+nP3k++Vb/BcCyWXlsPlR3StMvtvkDfO7J7Ty+4SAet4unt5bHtL3tFuxZ9M27fkj8+j0SdZy+1nqt1nqm1rpQa/2AVfZNrbUt7pdprcdqrRdZfytDtn1caz3d+vtt/59GZPZXNTItN4Mkd/fTnJSdzhcun8Ere48P2PC1Dn9+mCsF4LoF40lyKZ7Z3tVS+tkrxewor+f7H1jA/IIsLpiew5odlf0ipsGgZsOBGi6Y3rXlYWNb/+uLuzf9H11XSrPPzxcun9lRVjAqjQc/tJC1n72IhRNHcf/ze3i5Dwv8dHG7FHctncKWwyd6HFdQ3djG6s1lfODMCYzPSou4js2E0elRWfqHar3kZHoi+qEjkZbcvSP3lb3m2lw2J69L+XVn5PO3Ty0lNzOFaTkZzMsfSV+kJru5YHoOr71/nOONrTy9tZzPPPEeZ33nZT7wi7d5ems5d188jV99eDEZYQPKls3KpT2gI3Yk90Zjazsf/d1mnttRyVevms0nlxXyTmktVQ3Rp6feVVGP26WYPW5ExOWTxtgplsXS74khPSJ3f1VTl2Ha4dy1dCrTcjP4f88V0eY//Qkr+psNB2qZnpfJ2JGp3ZaNzvCwbFYez26v6JjIY9PBOn7xRgm3nD2BaxaMB2DlwnzKT7Tw3pHTHzhVVNnASW97N9eOzYy8TMaOTOGtMBdPdWMbv9twiOvPyI94P+aMH8lv7zqHwtwMfvCv9+M+sveWxRPITEnitxsiW/uPbzhIeyDIJ5cV9rmvgtFp1Le092n1FlU2MDc/+iCF1Agdua++X8WMvMwOF0Yo8/KzeOWLl/C3Ty2N+EGOxIrZeVScbOHcB17lS3/dwbsH67h87lh+vupM3vvvy/naNXMidmAvnjyGDI+bN2IYGV7d2MZtj25kY2kdP75lIZ9aVsiNi/LRGp7bEX1LdHdFAzPyMjvST4eTmuxmfFaqWPq9MGRFv7nNT8XJFmaO7e6GsPEkufj29fM4VOvlNwMsJ7zPH2TzwbqOqJ1IfOCsAqoa2njnQC31Le184cntTByTzrdWzutY58p5Y/EkuWJ6sXpiXYl5ySO1PMD4uC+YnsPbJTVd8hz98s0Dpll/2Ywe953kdvG1a+ZQWtPMnzcePu269saI1GQ+tHgiz+882s3KrG9p54/vHOaaBeO7dJ73RDRhm23+AMVVjVFZ4DbpYSGbDa3tvFta1+HaiUSax83oHvofInHtgvHcdGYBX75yFv/87IW8e9+l/PiWhVy/MJ9R6T3vx5Pk4oLpOby5rzqqFuShmmZu/r+3Ka1u5td3LuaDZ5shPNNyMzljQla31mpPaK3Z3Usnrs3k7HSx9HthyIp+cYTInUhcPDOXK+aO5eHXSjhWP3Dm19x25AQt7YGO+PxIrJidx4jUJP6+rZxvPrubYw2tPHTrIjJDmuMjUpO5dHYez+88etpJtjaU1DB73IgeB/2AcfGc8LZ3TMtX1dDKnzYe5qYzJ0TsBwg/nwumZ/PTV4vj3rF719IpBLTmD+8c6lL+x3cO0dTm59PLpke1n84BWj2LTHGVyf8Ui+iHh2y+ua8af1Bz+dy8XraKjaz0ZB66dRH3LJ/OvPwsXBGs+p5YNsu0Eor7CN08UN3Ezf/3No2t7Tzx8SUsn9W1/isX5rO7oiGqENBjDa3UNvt69OfbmFh9Ef2eGLKib0fu9Obesfnv6+biD2q+t3ZvvKsVNRsO1OJScN60ni391GQ31y4Yz7PbK3l2eyWfu3QGZ03qnuFi5cJ8apra2Fh66v3nre0BNh860ZF6oSfsVoDdKnjk9RICQc3nLu3ZyrdRSvH1a+ZS39LOw68X97n+U1vKqDzFQXaTstO5fM5Ynnj3SIdF7fX5eXzDIVbMzmNulAI9IQpL3+58nBeLeyesI/fVvVWMyfCwaKJjGUx6xc7e+UYfUTw/emEfvkCQpz+1lDN7eDZdCtZEYe3bc0n0JfqTstOpaWo7pY7m4cCQFf3iqkZSklwdHTu9MXFMOp+8eBprdlTybmnvg4uc4u2SGhYUZJGVltzrejeeWUAgqDl78mg+3YMPevnsPDJTkliz49RH8W46WIfPH+xIvdATeSNSmT1uBOuLa6g42cLqTWXcsrhzesG+mJs/kg+eNYHfv32415GVj71Vylee3slj60pjOo9QPnrhVE542zvcC6s3lVHX7OvxOkYiJzMFj9vVa6x+UWUDmSlJ3aLIeiMt2Y3PHyQQ1PgDQV7fV83yWXkRfeyJIH9UGrPGjug1Xv/9Yw28UHSMj1wwtcdWXt7IVJYW5vDM9r6DDXZXNuBSMHd87x/kzsRr/ePXP+n18ek/b+XM+19i8XdfYen3X+XiH77Oigff4MqH3uJDv3qH/321mJ3lJwdF+vYhK/r7q5oozM2M+iX51LLpFIxK41trihKea7ypzc/2spO9unZslkwdw/03zOOR28+KGKUEpkVwxbyx/Gv3sVMH9hC6AAAgAElEQVTusN5QUoPH7eLcqWP6XPfC6TlsOXSCH79oBob954roXCU2X7pyFm6X4n9eeD/i8kdeL+GBtXu59ozxfO2aOTHtO5QlU8cwL38kj68/SJs/wGPrSjl36hgWT+n7HG1cLkX+qFTKe2lx7K6oZ+74kTG5T0InUtly+AT1Le3donYSzbJZub2Gbv781RIyU5L46AVTet3PykX5HKnzsq2XLK1am9He0/My+wx77Zwk/fRdPDvKTnLt/67n5T1VXDZnLJfPHcsF03M4e/Jo5o4fyZScdFrbAzz0yn5WPryBc7/3Cl98ajtrdlQO2AFiQ1b0i6sauw3K6o00j5uvXzuH94818pcIefd3V9TzrWd3c9uj78Q9v8ymg7X4g7pPVwoYl8i/nz+lWwbIcG5YVEBjq/+UR1KuK67hrMmjokojcOGMHHyBIP/YVsGqcyd2ifGOhrEjU/nEJdNYu+sYWw51uqS01jz08n5+9OI+bjqzgJ/duqhLKohYUUrx0QumUny8iS//dSdH61u5Z3lsHyjoTLEciUBQs/doY9TuIht7EFeLL8Cre6vwuF1cNLN7/p9EckkvoZv7qxpZu/sody2d0munMMBV88fhSXL1Op7kb+9VsOlQHbee0z3xXTh2dNPpRPBoq7/nll++A8BTnzifH92ykO9/YAE/umUhD926iIdvP4tffXgxaz5zIZu/fhk/+dBClhaaMNjP/mUb5z7wakLTVfTEkBT9xtZ2Kutbo/Lnh3L1/HEsLczmxy/tp67Zx4lmH7/bcJBrfraO636+nj+9e4SNpXWs2x/fbJIbSmrxJLk4e3L/+W8vKMwmO8PDmlOI4qlpamPP0QYuipB0LBJLpmbjcbtISXKdkogC3H3xNMaOTOE7/9xLMKjRWvOjF/fxs1eLueXsCfz4loU9tmxi4bqF48nJTGHNjkrmF4zk4j7cV5HobTKVgzXNtLQHYurEBTpCElvbA7y69zjnFWZ36aAfCCyePIbMlKSIOXwefq2EtGQ3H7uw98FtACNTk7lsTh7P76yM2Mo+Wt/C/3uuiHOmjOaupVP63F9mShI5mSkcOUVLv6nNz2dXb+ebzxZxwfRsnv/PCyP2R4SSk5nCB86awP+uOpOt37ic337kHHyBIJsOOjIONSYG1lPUT3RE7uRFb+mDsfy+vXIeV/9sHR/8v7cpP9GCLxBkQUEW37lhHtcsGM+yH7/BW/urufaM8fGoOmBcKYsnj+4xFvlUSHK7uGbBeP66tYzmNn+3ATe9YXegnROl2yPN4+Y/LppK7ogU8iKMMYiGdE8SX7piFl9+eifP7axkd0U9j607yO1LJvHdG+bH5CrpjZQkNx8+bzIPvbKfe5ZNjzrGPZSCUelUN7bR2h7ods9OpRMXOkfuFlXWU1rTzF19uEgSgQndzObNfcfRWndcu5LjTTy3s5JPXFwYdQjpDYsKWLvrGOtLarpMSam15qt/24U/oPnxLQujdteaxGs9W/onmn3UeX1orQkEIag1gaCmvqWd/352N4dqmvnylbP41CWFMT9rbpdi2cxcstKS2VXhfGLBvhiSol9SZUQ/Vkvf3uaTl0zjyc1l3HHeJG45e2KXpvmF03NYV1zd5SHvT2qa2nj/WCNfvnJWv+975aJ8/rjxMC/vqeLGM3vLjN2VI9ZsY1Nyou+I/MpVs2OuXzg3nzWB3244xJef3onPH+SupVP41vVz+/26f+KSacwYmxlxpqlosMM2j9a3dovt31PZgMftisnVCJ0+/ed2HgXoNT4/kSyblceLRVUUH+8cCPmL10tITTIf/uj3k8vI1CTWbK/sIvqrN5fx1v5q7r9hXsRBaT0xOTu9x7xC246c4LZHN9Lmj9x3lzsihSc+fl6vkXN9oZRifsFIdovoO8N+K3JnYgzREqF8+crZfPnKyKJ10Yxc/rX7GAeqm5keY0siGuwHdWkvg7JOlbMnjSY/K5U1OypjFv3UZBe5mT3H58cDl0vx39fN5d9+8y4fv2gqX7tmTlw+tKnJ7o4RzKdCR4rlEy3dRL+osoGZ4zJj7nuwRf/VvVXMGT+yYxDYQCM0dHPm2BEcqmnmme0VfOzCqeTE8LykJJl78NyOSlp8AdI8bspPePnu83s4f1o2/9ZDptOemJKdwd/fq+jW+mptD/Bff91BdoaHr149G5dSuF0Kl6Lj/2dNGh3TILeemJ+fxW83HMLnD+JJGjie9KEp+sebmJ4XfeROLNgpCNYVV0cl+s9sq2Be/sg+B4nZbDtykrRkd5+jDk8Fl0tx/aJ8frPuICeafVE/2EfqvEwakx4Xwe2L8wuz2fbNyxmZ2nvoaiLpGJUbNkBLa01RZX2vue17wnbvtLYHB1zUTijjs9KYPc6Ebt59cSGPvF5CstvF3RdHH/Zqc8OiAlZvLuPlvVVct2A8X3l6JwA//OAZMbtY7AieI3XeLi3+H724j9LqZv70sSV9hh+fLvMLsvAFguyvauxzbIGTDJzPTz9SXNV4Sq6daJg4Jp2pORm8FUXekaP1LXzhqe386q3oY8kPVDf1mCSuP1i5MB9/ULN299GotymzRD9RDGTBBxiXlYpLdR+gdbS+lRPeduYVxNaJC12zcUaa63YgcYkVurmnsoG/b6vgjiWTex213RNLpo5h3MhUnt1WwZ/ePczbB2r5xnVzT6nFHmmS9I2ltTy+4SAfPm9y3AUf6DDcBpqLZ8iJfkNrO0frW2P2ocbCxTNy2Fha12fM+5rtlWhthDxaSmuamNZHuoLTYe74kRTmZvD8juhEX2vNkTrvKbvKhgPJbhfjRnaP1bdTUcQauQOd7p3cESlxafX1J8tm5tEe0Hzqz1txuxSfuGTaKe3H5VKsXJTPm/ur+f7a97l4Zi63nTOx7w0jED5Aq6nNz5ef3sGkMence/Xp9zdFw6Qx6YxISWJ3AmaJ640hJ/rFdiduXnwsfTB+/Zb2AFsPn+h1PXuCiAPHm6JKTNXaHqD8RAvTokj0daoopVhamMPuyvqo6lTb7MPrCyTU0h8MRIrV311Rj1Iwe9ypi/6ls/P6LVIpXiyeMprMlCQO13pZdc7EiFlho+WGRaYlmuRW/M/NC07ZpZiVnkxWWnJHBM/31u6l/EQLP75lYUyRa6eDy6WYVzCSXRX9N4lRfzAERT/ybFn9yXmF2SS5FOt6mSXq/WMNvH+skcLcDBpa/dQ09T0673CtF61hWm78RB/M/htb/dQ2910nO3JHRL93IsXqF1U2MC0n45REJiczhX8/fzIfjSLOPdEku11cOD0Hj9sVVTrq3pg7fiQfPm8yD96ysM+5DPpiipVt88391Tzx7hE+ftG0qMOO+4v5+VnsPdoQ93ThsTDkRH9/VROpyS4mjo6fSGWmJHHW5NG9+vWf2VaJ26X4zxUm0Vg0Lp5Sa52+slGeLnaESWl13yMWy0T0o6JgdBpH61u7DC7aU1kfc3y+jculuP+G+XHrm+pv/vv6ufzpP5actlArpfjOjfOjmv2rLyZnZ7DvWCNffXon0/My+WLIBD5OsWBCFj5/cECNzB1yol98vJHpeZlxbxJfMjOXosoGapraui0LBjXPbq/g4hk5nGPlqolG9O11osnjfjrYH5XSKOpki/6EOH5EhwIFo9IJBDVVjeZ5ONHso7K+9ZT8+YORglFpUeVlcpIp2ekcb2yjuqmNn3xoYb8OdowWO2pnIA3SGnKiv7+qMa7+fBs7dHNDhLwj7x6s42h9KzeeWcD4kamkJbs5cLxvq7q0uplxI1Pj7nPMH5WGJ8nFwZq+63SkzkveiJSo53YdrhSM7ppiubMTd2B3wg5lpljG0z3Lp3PGhFEJqcPU7AwyPG6KRPTjQ31LO1UNbVHHxJ8O8/KzGJ2ezFsR8vA8s62CDI+bK+aOw+VSTMvNiM7Sr2mmMC++Vj6YYeJTstM5EIV750iCwzUHC+Gx+p3pF4aHpT8QuXLeOL7/gQUxZ3ntT1wuxbz8LLH040XJcXvilPj6xMEI5wUhKRlsWtsDrN19lCvnjeuwjgtzM/sUfa01pdVNTMuJf93BuJAO1kTj3mkR0Y+C8GkTiyobyM9K7ZeRncKpkZGSxKpzJ51WJtb+YH5BFnuONnTMZZ1ohpTo7z+NnDunwsUzczne2MY+K2II4PX3j9PY6u+S5qAwN5OKky1d5jwNp6bJR2OrP+6ROzbTcjM5Uuftde4Anz9IZX2LxOhHQZrHTXaGpyOCp6iyPqaJ0IWhy/yCkbS2B2MarxNPhpjoN5KW7HYsT0lHSoYQF88/tlWQOyKlS+6cwrwMtKZXH7rdqRrPgVmhTMvJoD2gKetlxqeKky1oLZE70TJhdBrlJ1rw+vyU1jSLa0cAOkfm2tlqE82QEv3iqiZmjI1/5I7N+Kw0ZuRl8laxCd086fXxxr5qVi7M75JGwY6W6e1LX2p9EOI5MCsUu0XRm4unI0Y/yqkOhzsFo02s/t6jjWgt/nzBMC03k7Rk94AZmTukRH9/VWNcMl/2xkUzctl0sM748ncdwxcIcuOirhksp+ZkoFTvon/geBMpSS7HWil230FvsfoyMCs2CkalUXmypSPXyrwBnj5BcAa3SzE3f+CkWR4yol/vbed4Y5vjg1kunplDm9/MkPPMtgoKczOYH5ZgKzXZzYTRab1Gy5TWNDM1J8OxVsroDA+j0pM7WhiRKKvzkpLkfErlwUrBqDRa24OsK65hdHoy+X1MYSkMHxYUZFFUOTA6c4eM6O93MHInFHtqwNWbj7DpUB03nVkQMV9IYW4mB3oZlVda3RT3kbjhTMvJ6HWA1pFak2htoOd+GSgUWAPY1hVXMy8/KyGpqIWBybz8kXh9gajGxsSbISP6CyeM4oXPX+R4bo00j5tzpo5m7a5jgMkJHonC3ExKa5oIRvjS+/xByk60OBa5YzMtN7PXh1Bi9GPDds21+YPizxe6sGDCwEmzPGRE35PkYva4kYxIQO51e8LwxZNH9xjeWJibSWu7CYEM50hdM4Ggdlz0p+ZkUNXQRlObv9syrXXC8+gPNuxRuUCXKTYFYXpuJilJLhH9ocJya07Pm8+e0OM6hZagR/Lr22VODcwKr9PBCHU66W2nsc0vMfoxkJWWzAgrhYakXxBCSXK7mDN+5IAYmSui3w/MGjeCl75wMbcu7nnCh0IrqiiSX9+OoHHe0rcieCKEbUrkzqlRMDqNtGR33JPmCYMPuzM3kovXSUT0+4mZY0f02uGZneEhKy05YtjmgeomckekOO6ampydjlKRwzZF9E+NRRNHccH07LjMzywMbuYXjKSpzc/hOm/fK8eRITkx+kBEKUVhD4nXTM4d5y3DVGv0cqTOXFv0J45xZtzAUOEHN58R1YxkwvAjNM1yIluCYuk7iEm81l1gS2uaHUu/EM40K6oonLI6LzmZKaR7xC6IFQnVFCIxc+wIPG5XwtMsi+g7SGFeJtWNbdS3tHeU1TX7OOlt7+hUdZppORkcrG7uZp2acE2x8gWhv0h2u5g9fkTCO3NF9B0k0oxVTk2R2BPTcjNo9gU43th1BjCJ0ReE/md+QRa7K+oT6gIU0XcQOy9QqIsnUZE7NnaYaGhfQ3sgSOVJyaMvCP3NgoIsGlr9lNX1nN023ojoO8jE0Wkku1WXSZIP1DThcbsSNgft1I5sm50fosqTLQQ1TBDRF4R+ZX5+4ufMFdF3kCS3iynZXSN4DhxvZnJ2esJC/MaPTCU12dUlbFPCNQUhPswaN4IMj5v1JdUJq4OIvsOET51YWtOUMNcOmDk8p2R3Tbwmoi8I8cGT5OLSOWN5saiq11nr4omIvsMU5mVwpNZLeyBIeyDIkVpvwsI1O+oUlnitrK4Fj9vF2JGSGlgQ+ptrFoynrtnHxtK6hBxfRN9hCnMz8Qc1h2u9lNV58Qd1wiJ3bKblZlB2ogWf31geZXVeJoxOk1GlghAHls3KJd3jZu3uowk5voi+w4ROnZjoyB2bqTkZBIK6w61zpM4ridYEIU6kJrtZMTuPF3cfS4iLR0TfYaZ1ZNts6hgJW+hwds1wpoWNH5AYfUGIL9cuGE9ts49NB5138YjoO8yI1GTGjkzhwPFmSqubTSK2dOfnAAjFzgNysKaZem879S3tIvqCEEeWzcojLTkxLh4R/QRgR/AcqE5s5I5NVloyOZkeSqubKTthJ1oT0ReEeJHmMS6eF3ZXOT5vroh+ArBFv7S62fGJU3piWo5JvCbhmoLgDNcsGE9NU5vjLh4R/QRQmJtBY6uf2mbfgLD0wbh4DtY0S0plQXCI5bNzSU12sXaXsy4eEf0EYM+iBSQ8Rt9mWm4GNU0+dlfUMybDk5C5hgVhOJHuSWL5rDxeKDrmqItHRD8BhMblJyqlcjh2Z+664hrx5wuCQ1yzYDzVjW1sOeSci0dEPwGMG5lKusdNkksNGIG1WxwSuSMIzrFidh4pSc66eET0E4DLpZiWm8Gk7HSS3QPjFkwa05n0TSZPEQRnyEhJYtmsXP61+5hjE6YPDMUZhnz+0pl8+YpZia5GB54kFxNHG7EXS18QnOOaBeM53tjG1iMnHDmeiH6CuGzuWK5eMD7R1eiC7eIZKC4nQRgOXDpnLJ4kF//c6YyLR0Rf6MDuzBVLXxCcIzMliUtm5vKv3UcdcfGI6AsdXLNgPDedWcD4LPHpC4KTXLtgPFUNbWwri7+LJynuRxAGDWdPHs3Zk0cnuhqCMOy4dE4eHreLf+48xtmTx8T1WGLpC4IgJJgRqcncvmQSE0bHv5Utlr4gCMIA4Nsr5zlyHLH0BUEQhhEi+oIgCMMIEX1BEIRhRFSir5S6Sim1TylVopS6N8Lyi5VS7yml/EqpD4Ytu1MpVWz93dlfFRcEQRBip0/RV0q5gUeAq4G5wCql1Nyw1Y4AdwFPhG07BvgWsAQ4F/iWUkpiAgVBEBJENJb+uUCJ1rpUa+0DVgM3hK6gtT6ktd4JhE/tfiXwsta6Tmt9AngZuKof6i0IgiCcAtGIfgFQFvK73CqLhqi2VUrdrZTaopTaUl1dHeWuBUEQhFiJRvRVhLJoE0REta3W+lGt9WKt9eLc3Nwody0IgiDESjSDs8qBiSG/JwCVUe6/HFgWtu0bvW2wdevWGqXU4Sj3H4kcoCYB5UP92E4cQ449NI8hx+6fbfpiclRraa17/cN8GEqBqYAH2AHM62Hd3wEfDPk9BjgIjLb+DgJj+jrm6fwBWxJRPtSPPdTPb7gee6if31A5dn/+9ene0Vr7gc8ALwJ7gae01kVKqfuVUisBlFLnKKXKgVuAXymliqxt64DvAJutv/utMkEQBCEBRJV7R2u9FlgbVvbNkP9vxrhuIm37OPD4adRREARB6CeG4ojcRxNUPtSP7cQx5NhD8xhy7P7Zpl9Qlh9JEARBGAYMRUtfEARB6Il49xTH8w+4CRP3P9v6PQXYHbasCBM5NAU4HGH9FkxUkQaeAZKBe4DtwG7gBNBmLX8TmAmMA97DjEB+H9PfMROYB6wHGgAfcBx43dq2BfBb+6oAXgEC1nFKgSZr/feBX2NGM9vb2X93WOdVYW2zFXgHuCnkmvis5S7r913Aw9b+vw18ySr/AtAKNIVdi22YDvtNQGv4dbV+h26jgf8MKXsY+AlQDEwCmjFhutsx6TrqgX+3zt1uabqt5Rr4IyZC7C+YPqdquzzk+GuAduB5a9kGa71t1nF9VlnoMnv/QeANaz8ftc7ZPu5d1vIzrW3s/f8duBHYad0fPyYwQQN/tdbbAeyh81l5wTrmdmv9qpA6/AvzbBVZ5Rp40Lo/FdbfMWv9HwBfstex6m2f17et3y8BL4Us08B06/eXrLro0H1Yy76CeS4+DdRZ1+4A8L/W+Xzdqodd/jPgD1ZdQ8s3WXW43DqG17oO+4D0CO/rXuv8nwNGWcfZj3ket2PStiRj3rc2q7wZ+JpV31br/rdb92mXtd/j1vbHMM/ZMat+ZcBeqw52FGFZyPH2YJ6DCky4ZBHwS2t5FvAQ5h3fY63fDjRa/38F8x4+E/JeBax1P2+VPYh5buqsfX3eKtPAOuDXIddoK+Z5WRB2n37pWPTOAGcVRmRvi7DsXszD909tUkCAecDC1z+AeYHXAwuBD2mtH8G8+I3AfZgb9Gfgc8BY4B+Yh2cD5qX8mlW+BhOm+hXrWLYot2it04A/AZ/CPPQbMA/alRjR+xBGVJ7EvKTpQEBrnWb/YXIbfReo1VpP01qfbZ3LBACllAsjlGXAxVFcu8107cw/oLU+U2s9x9pvslLqI33s57h1XWwmAP8GXKW1PgKkYB70/8K8LLdprf+AEdePWdv8p1WXZuBs63pcDFyHeREDwHylVJpSahRwvlWWZm0zAXhaa30m8FnMx+VszP23ly3CvMStVjmYj3STvX+M0JQDP7WOi1XPMzDPwA2Yl3o/Jg9VC7Ac8xFZaJ3jQWubWcBl1nEbgN9b/28HVgC3aq3nWdcmCHwAc88fsv5+GVJnMOL3AaVUjvV7rrV+OAHrGB8NKZuLESGAD4XsYwbm/t2FEfD/wRgv51rL/w04prWeYZVnAmcBt4aU/9a6xkXWcQNa63TM8z8O837YrLLO9Umt9XyMCP4Ac5+vA0qAyzDP72+AOUCO1joVWAzUAluAC4EHgG9gPkJ11vVptrb/JfCWdQ0LMe/dWKsOP8D4zbcDO61rfA2dH4ebMB+9mzHP5E3A25gP0Ses868HKrXWi7TWl1nXJTPkHL0YfVhqlS3FCHyqta+l1t8LQCHmObTf3/nW8X+hDAXWce+jnxi0oq+UygQuwAjHbWHLPoy5OZcDK63idOsvfH1XyH5G0pkmYjnmId6DEeRPa623Y4TBjXnhvwGssspnYh6cGq31L7XWXkyo64fpmpOoAbjbWgamVfF7bSKk7PK/YVoY4ayw6nTELtBaH9Za/zykzkHg/zAPX0SUUoWYh/Qb9BDBpbUuxVjMn+1pPxbVwKtAklLqIqsOD2mtD9iHwww4eQy4Vmv9L6vcB9ynlJpnnfNXrfI6jMX+EvBFjMUPxjq+FvMy1mFe6nxr2U5MqwPrvB/DXKPksGVJwEYgz/p9Hkbs7P0vxFjtZ2DyRNn4gRe01get/f8eI1DJVl1sQVmFEUGNEZYvRLheboxQ3R6y74C1/nkR1g+tg71PjRG/SOsHMdbjXdbvMRhBrLb2sTukXosw1nArpiVzHzAbyMWMy/FjPoJorQPWdjOtY5Qrpf4Lk4jxbEzrreMjpLVuwXwcZ0GX97WVzvfvHcyAohrM84DWugY4iRHbrVrrRqt8r9b6V2HnGsAYWJOsOvV0zX8DpCulPo/5YDyIea/nKqVSrHWSMc/Tesy1HQ38P8w9PYyx+NdjBPok0KKUGm1tPw6Ybb1X2RiDLgW4wFo+D2PpB6zrvxTzQXvMumaNViLKSzHPx73AUeuaPoRp0fXbjOmDVvQxD+kLWuv9QJ1S6iyrfDLGxfC01vrtkGVXAI0R1h+B+eIewYiCPRp4PuYG/Ra4U2vdEFLejhGjdcAspVQe5sY2Yqx7ACzhsy0AQspLMddeWfvbGlZui5JbKdVi/Z3EWL/F4fsLYZW1/X8BH1FKbQfu72E9u/4uq/6RCGBEoC9+gHnIn8U0g4+GLNOYh7sSuNqy1O3yn2Je/O/qzvEbEzAvztMYEX7XKl+NEYs7rHP8A50f6HeBGUqpVIxgv4uxxlzW/1copXZg7u90oMBadyLGvWLvfwnmnjQAC0LOwQ3MDNv/SWv/PwE+p5R6E2NklFjbPALcoZTKCrtWLoyYhC97xNr3FzHC9Uml1OvWsi9gWjWrgC9bddwEnBFh/wCvAVlKqfMwLdbdVnkAI2x3KKVyMfe2GSOuR+m8H9+xrkENcJFSarv1LL1lXYsGjIB/Erja2vaIdW0BsFoTM6y6gPW+Yu57nVJqMUbkfoW5D68B45VSl1j7KbV+71dK/cIq74b1MdphXddHMM9HSthqfszH7SGMy8WHMdqO0JkAMgvTAtGYD5n97s4Crreu00SMYFdj7vP5mBbIDusYn7Su9bNWfTwYQ+UY5kPSgvmYujGur1xMq+Cgta9PAwet+n0e05rJ1Vr/MdK5nyqDWfRXYV5UrH9ty9b2AZ8MW7YSIwTh6+cDl2Caju9jbqLNCuBPWusNYceeBazWWgcx/t5bMC9iLKFQkfIShZeHundGWXXsXFGpR5RSO5RSm5VSHkwz1au1PgNjsX4d+CbduS2k/n6r/qeMZQEHMB/M8LTbPkxLoAWTkmNjiHX1CODWWv/O+u3CuFXyMNazwvpoapPFdTpGGP+KsUC1tU05ppW2is7xJPZ1LMfc959iPtb/TqeA7gg5h52YFskMjBttrrWefQ75kfavtf4lxrWxFyOSj1nlDZgPU6SWUmP4Mmv9HZiWie3eWW4tfgjjIjyDTndJm7V+pP23YVouP8AYFe9b5UGMZflP63ocwdx/+7kNvx8aWGe5MRaFuJs0RvQUxpiyr4fGMlQwbqN9Vt2h831Nw1jm6zGtkOcwLYWvYZ6hJzHPSdAqvxvzTj+plLorwrnaxw695kvClmvMc3TUuh422+hsdWTR2aq8DdNquBXzfn8EY73bbhn73Ozfb1vLb7PO4W3MR6wd47Zrw/QBeq31j2I+BEut/Y/CfEQvxdw3tNaV1j7+r4dzPmUGpegrpbIxgvxrpdQhjPVzK+bmt2G+9P+hlKq2lq3CXOCCsPVHW9vYzfSzgLuUUgpjReZjrJ5QvJiH9WVrX7dZ+y/CCM/ZIfWchvEZh9d/GubhsDuazw4rP97DqRdhRAkArfU9mAclF2OxZGGasYcwzdhILp7x1j7s+if1sB4Yi2RvD8vCacNYNnkY/6xNEOMLz8BYyH6sF8/66IR+KJMw1mchRjxdmA+yTQXm2t9Jp4DY7qmDwI/pfHFH0ulWs5f5rd9V1m+7FWGzDfPyPQE8Raflut/6C0h3cicAAAUqSURBVN1/Vsj+/4H5cN6OEQP7g/NTjNsw9ENui5m9LCNk2UaMPz20LJyfWv9mWOt/DPP8hvNZzDPQiLk3NqutshsxLo5qLEPHvh9KqZGY69cl+6FVnmydexXGyHhIKXUtxgo+gGWoYO7jVIwLpeN9pfPjUI15Xu6xrPWNmOf+MxjLehKmE/gNrfW3rPKbw0/Smu9jAZ334qeY99gTslq+VefzgC8opcZjnqM3Me/PPEzgw3tKqTMw78dnMW7dD1vr/hOjIQswBmUxxjpfihH8Q5h361qMpX8+RszPx3xo92EMn/Mxz7XL2tfPMPf8Gmt5qFsxSPd09afNoBR94IPAH7TWk7XWU7TWEzEv9gTMw/oHjO/RC/yH9e+LwP6w9W8HTlr7mYi5yR6MG+UOTBOzoyNTKXWOVV4OPGDtKx/zcDdgRCJXKfVxpVQapkNmNV2v80hMR9PD1u+HgTuVUleGlN+BedDCec2q3+SQMtuPuso+V631FKtOV9D14Qfjx/22Vfcp1rUpICzltVJqirXtz4kO+wMWAM5XStmdtG6MxXMdRqwn0NlJGno8uxP6DMzL8EXMy78iZLVxwM+01gWYj+06OkV/DybNxy6MW2iSddyOZXS+QGXW7/KwaqwDNlv7eAFj+SvMB2gR8LC1bBzmXrcrpVZgPhL3Y158u5/BTkPyFMaFaOMDfoi5tk9hRNt+Plow1vvH6IEQN9gd1vpPYUQufL1KTKskfNKiv9ApnudhnvF0pdS/h6zzoHXOHqznwhLXBzEfPzdQYLlKP2jV4Z90dpBjLfs+pq+m433FPJ8TreP+FrhXKTUn5NiLMAL5d+B3VgsWzAcs3G3jso5RhnVvretThNUZbRlwP8G87zOAH2Hey6swLdA3rDLbC7AK835MxvStVWA+mqWYZ7gO86w30Snq72CeiQZMy2iK1no85tmcgnnOgph3YxTmHVgA1GmtizEfwFmYjt53iDODVfRXYayrUP6GaSKOAv5huRxWYlJApGFexllKqXIrT9BCjA+uIWQfz2Bu5lcxllQS8EOlVJvVZP0Zpul5B3C5UuqAlWeoDWMt3YDpgH3Q2u+5GDdBiuUTvQHjbnkJ49dNw3yMAlb9F2E+PBdhfIhu259qbX8zpvN1jjU1pQ/zEv4BEwX0T/tEtNbNmCb0orDrtCjCtfsHRmALlVLblFJ7MS9yu9b6t9Y6odcuXSkVySX0gHWdHwS+oZS6ASMQuzGhqwGM6C2x9lEe8u/nTbV1hda6XGv9M4wPeQp0fITGYT4GNna45TTMC/kRpdR+6/5spbMVcR3m452GsTbTrP2HcwLjXgHTKjiIEf09mH6SDyil3ge+h2kB2Vb7GoxQv4O5B6Gtlwfp+p4FMG6UVzDPZ3j6ktlW2Setez6K7mg6jYIHMR9+f4T1Po6xcDs31HoPRpxfwvSdgOk0vUUpVWztqxXzLn0DyLfK7ZDK9zCGjF3+BMY6XUbIB8/ilxgD6iNEfl/PwbiJ1lj7mI55X76NuU/nAU1KqVaMW+4xa9s/Y6LgvoR5T7tM6oRxr9itpY9j3Fg3WufzMYw1/qTV5/YXTKeq7Q6+LaSuf8HoxDPWvzmYFonNLqDe6nxegflIhi4vxjw/68K2qcXcP3vdv2A+aMetfcUVGZErCIMcpdQ/gMesCDBB6JXBaukLggAopXZhWhwvJbouwuBALH1BEIRhhFj6giAIwwgRfUEQhGGEiL4gCMIwQkRfEARhGCGiLwiCMIwQ0RcEQRhG/H85z6vTOE2O5QAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.yscale(\"logit\")\n",
    "plt.plot(df[\"addr_state\"], df[\"mean_bad_loan\"])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.6/site-packages/h2o/utils/shared_utils.py:177: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
      "  data = _handle_python_lists(python_obj.as_matrix().tolist(), -1)[1]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parse progress: |█████████████████████████████████████████████████████████| 100%\n"
     ]
    }
   ],
   "source": [
    "te_addr_state = mean_target_encoding(train, \"addr_state\", prior_count = 30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "train = train.merge(te_addr_state, all_x = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_trans.remove(\"addr_state\")\n",
    "x_trans.append(\"te_addr_state\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "train[\"te_addr_state\"].hist()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Separating Typical from Extreme Debt to Income Ratio"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Looking at the occurance of bad loans on a logit scale reveal that the chance of a bad loan roughly increases linearly in debt-to-income from 5% to 30% and is highly volatile outside of that range due to small numbers of observations. To reflect this finding in the modeling, we will replace the original `dti` measure with two derived measures:\n",
    "\n",
    "\\begin{eqnarray}\n",
    "dti\\_core & = & \\max(5, \\min(dti, 30)) \\\\\n",
    "dti\\_diff & = & dti - dti\\_core\n",
    "\\end{eqnarray}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table>\n",
       "<thead>\n",
       "<tr><th style=\"text-align: right;\">  Probs</th><th style=\"text-align: right;\">  dtiQuantiles</th></tr>\n",
       "</thead>\n",
       "<tbody>\n",
       "<tr><td style=\"text-align: right;\">   0   </td><td style=\"text-align: right;\">          0   </td></tr>\n",
       "<tr><td style=\"text-align: right;\">   0.05</td><td style=\"text-align: right;\">          3.79</td></tr>\n",
       "<tr><td style=\"text-align: right;\">   0.25</td><td style=\"text-align: right;\">         10.23</td></tr>\n",
       "<tr><td style=\"text-align: right;\">   0.5 </td><td style=\"text-align: right;\">         15.62</td></tr>\n",
       "<tr><td style=\"text-align: right;\">   0.75</td><td style=\"text-align: right;\">         21.26</td></tr>\n",
       "<tr><td style=\"text-align: right;\">   0.95</td><td style=\"text-align: right;\">         29.02</td></tr>\n",
       "<tr><td style=\"text-align: right;\">   1   </td><td style=\"text-align: right;\">         39.99</td></tr>\n",
       "</tbody>\n",
       "</table>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": []
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train[\"dti\"].quantile([0, 0.05, 0.25, 0.5, 0.75, 0.95, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "breaks = np.linspace(0, 40, 41).tolist()\n",
    "train[\"dti_cat\"] = train[\"dti\"].cut(breaks = breaks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = mean_target(train, \"dti_cat\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.yscale(\"logit\")\n",
    "plt.plot(df[\"dti_cat\"].index, df[\"mean_bad_loan\"])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>dti_cat</th>\n",
       "      <th>nrow</th>\n",
       "      <th>mean_bad_loan</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>30</th>\n",
       "      <td>(29.0,30.0]</td>\n",
       "      <td>2329</td>\n",
       "      <td>0.280378</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>31</th>\n",
       "      <td>(30.0,31.0]</td>\n",
       "      <td>1496</td>\n",
       "      <td>0.293449</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>32</th>\n",
       "      <td>(31.0,32.0]</td>\n",
       "      <td>1282</td>\n",
       "      <td>0.287051</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>33</th>\n",
       "      <td>(32.0,33.0]</td>\n",
       "      <td>1051</td>\n",
       "      <td>0.308278</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>34</th>\n",
       "      <td>(33.0,34.0]</td>\n",
       "      <td>1025</td>\n",
       "      <td>0.290732</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>35</th>\n",
       "      <td>(34.0,35.0]</td>\n",
       "      <td>750</td>\n",
       "      <td>0.318667</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>36</th>\n",
       "      <td>(35.0,36.0]</td>\n",
       "      <td>75</td>\n",
       "      <td>0.160000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>37</th>\n",
       "      <td>(36.0,37.0]</td>\n",
       "      <td>66</td>\n",
       "      <td>0.227273</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>38</th>\n",
       "      <td>(37.0,38.0]</td>\n",
       "      <td>65</td>\n",
       "      <td>0.123077</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>39</th>\n",
       "      <td>(38.0,39.0]</td>\n",
       "      <td>59</td>\n",
       "      <td>0.322034</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>40</th>\n",
       "      <td>(39.0,40.0]</td>\n",
       "      <td>47</td>\n",
       "      <td>0.063830</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        dti_cat  nrow  mean_bad_loan\n",
       "30  (29.0,30.0]  2329       0.280378\n",
       "31  (30.0,31.0]  1496       0.293449\n",
       "32  (31.0,32.0]  1282       0.287051\n",
       "33  (32.0,33.0]  1051       0.308278\n",
       "34  (33.0,34.0]  1025       0.290732\n",
       "35  (34.0,35.0]   750       0.318667\n",
       "36  (35.0,36.0]    75       0.160000\n",
       "37  (36.0,37.0]    66       0.227273\n",
       "38  (37.0,38.0]    65       0.123077\n",
       "39  (38.0,39.0]    59       0.322034\n",
       "40  (39.0,40.0]    47       0.063830"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[30:41]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_trans.remove(\"dti\")\n",
    "x_trans.append(\"dti_core\")\n",
    "x_trans.append(\"dti_delta\")\n",
    "\n",
    "train[\"dti_core\"] = h2o.H2OFrame.ifelse(train[\"dti\"] <= 5, 5, train[\"dti\"])\n",
    "train[\"dti_core\"] = h2o.H2OFrame.ifelse(train[\"dti_core\"] <= 30, train[\"dti_core\"], 30)\n",
    "\n",
    "train[\"dti_delta\"] = train[\"dti\"] - train[\"dti_core\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Separating Typical from Extreme Number of Delinquencies in the Past 2 Years"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The chance of a bad loan seems to max out at 3 delinquent payments in the past two years. To reflect this finding in the modeling, we will replace the original `delinq_2yrs` measure with two derived measures:\n",
    "\n",
    "\\begin{eqnarray}\n",
    "delinq\\_2yrs\\_core & = & \\min(delinq\\_2yrs, 3) \\\\\n",
    "delinq\\_2yrs\\_diff & = & delinq\\_2yrs - delinq\\_2yrs\\_core\n",
    "\\end{eqnarray}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table>\n",
       "<thead>\n",
       "<tr><th style=\"text-align: right;\">  Probs</th><th style=\"text-align: right;\">  delinq_2yrsQuantiles</th></tr>\n",
       "</thead>\n",
       "<tbody>\n",
       "<tr><td style=\"text-align: right;\">   0   </td><td style=\"text-align: right;\">                     0</td></tr>\n",
       "<tr><td style=\"text-align: right;\">   0.05</td><td style=\"text-align: right;\">                     0</td></tr>\n",
       "<tr><td style=\"text-align: right;\">   0.25</td><td style=\"text-align: right;\">                     0</td></tr>\n",
       "<tr><td style=\"text-align: right;\">   0.5 </td><td style=\"text-align: right;\">                     0</td></tr>\n",
       "<tr><td style=\"text-align: right;\">   0.75</td><td style=\"text-align: right;\">                     0</td></tr>\n",
       "<tr><td style=\"text-align: right;\">   0.95</td><td style=\"text-align: right;\">                     1</td></tr>\n",
       "<tr><td style=\"text-align: right;\">   1   </td><td style=\"text-align: right;\">                    29</td></tr>\n",
       "</tbody>\n",
       "</table>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": []
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train[\"delinq_2yrs\"].quantile([0, 0.05, 0.25, 0.5, 0.75, 0.95, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "breaks = np.linspace(0, 5, 6).tolist()\n",
    "train[\"delinq_2yrs_cat\"] = train[\"delinq_2yrs\"].cut(breaks = breaks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>delinq_2yrs_cat</th>\n",
       "      <th>nrow</th>\n",
       "      <th>mean_bad_loan</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>NaN</td>\n",
       "      <td>0</td>\n",
       "      <td>0.181037</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>(0.0,1.0]</td>\n",
       "      <td>17158</td>\n",
       "      <td>0.189299</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>(1.0,2.0]</td>\n",
       "      <td>4635</td>\n",
       "      <td>0.201510</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>(2.0,3.0]</td>\n",
       "      <td>1488</td>\n",
       "      <td>0.221774</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>(3.0,4.0]</td>\n",
       "      <td>579</td>\n",
       "      <td>0.215889</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>(4.0,5.0]</td>\n",
       "      <td>310</td>\n",
       "      <td>0.216129</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  delinq_2yrs_cat   nrow  mean_bad_loan\n",
       "0             NaN      0       0.181037\n",
       "1       (0.0,1.0]  17158       0.189299\n",
       "2       (1.0,2.0]   4635       0.201510\n",
       "3       (2.0,3.0]   1488       0.221774\n",
       "4       (3.0,4.0]    579       0.215889\n",
       "5       (4.0,5.0]    310       0.216129"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mean_target(train, \"delinq_2yrs_cat\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_trans.remove(\"delinq_2yrs\")\n",
    "x_trans.append(\"delinq_2yrs_core\")\n",
    "x_trans.append(\"delinq_2yrs_delta\")\n",
    "\n",
    "train[\"delinq_2yrs_core\"] = h2o.H2OFrame.ifelse(train[\"delinq_2yrs\"] <= 3, train[\"delinq_2yrs\"], 3)\n",
    "\n",
    "train[\"delinq_2yrs_delta\"] = train[\"delinq_2yrs\"] - train[\"delinq_2yrs_core\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Separating Typical from Extreme Revolving Credit Line Utilized"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The relationship between credit line utilized is somewhat interesting. There appears to be a higher rate for a bad loan when 0% of the credit lines are utilized, then it drops down slightly and roughly increases linearly in credit line utilized up to 100%. To reflect this finding in the modeling, we will replace the original `revol_util` measure with three derived measures:\n",
    "\n",
    "\\begin{eqnarray}\n",
    "revol\\_util\\_0 & = & I(revol\\_util == 0) \\\\\n",
    "revol\\_util\\_core & = & \\max(5, \\min(revol\\_util, 30)) \\\\\n",
    "revol\\_util\\_diff & = & revol\\_util - revol\\_util\\_core\n",
    "\\end{eqnarray}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table>\n",
       "<thead>\n",
       "<tr><th style=\"text-align: right;\">  Probs</th><th style=\"text-align: right;\">  revol_utilQuantiles</th></tr>\n",
       "</thead>\n",
       "<tbody>\n",
       "<tr><td style=\"text-align: right;\">   0   </td><td style=\"text-align: right;\">                  0  </td></tr>\n",
       "<tr><td style=\"text-align: right;\">   0.05</td><td style=\"text-align: right;\">                  8.7</td></tr>\n",
       "<tr><td style=\"text-align: right;\">   0.25</td><td style=\"text-align: right;\">                 35.6</td></tr>\n",
       "<tr><td style=\"text-align: right;\">   0.5 </td><td style=\"text-align: right;\">                 55.8</td></tr>\n",
       "<tr><td style=\"text-align: right;\">   0.75</td><td style=\"text-align: right;\">                 74.2</td></tr>\n",
       "<tr><td style=\"text-align: right;\">   0.95</td><td style=\"text-align: right;\">                 92.5</td></tr>\n",
       "<tr><td style=\"text-align: right;\">   1   </td><td style=\"text-align: right;\">                150.7</td></tr>\n",
       "</tbody>\n",
       "</table>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": []
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train[\"revol_util\"].quantile([0, 0.05, 0.25, 0.5, 0.75, 0.95, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "breaks = np.linspace(0, 120, 25).tolist()\n",
    "train[\"revol_util_cat\"] = train[\"revol_util\"].cut(breaks = breaks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = mean_target(train, \"revol_util_cat\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.yscale(\"logit\")\n",
    "plt.plot(df[\"revol_util_cat\"].index, df[\"mean_bad_loan\"])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>revol_util_cat</th>\n",
       "      <th>nrow</th>\n",
       "      <th>mean_bad_loan</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>20</th>\n",
       "      <td>(95.0,100.0]</td>\n",
       "      <td>4316</td>\n",
       "      <td>0.255097</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>21</th>\n",
       "      <td>(100.0,105.0]</td>\n",
       "      <td>238</td>\n",
       "      <td>0.260504</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>22</th>\n",
       "      <td>(105.0,110.0]</td>\n",
       "      <td>35</td>\n",
       "      <td>0.200000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>23</th>\n",
       "      <td>(110.0,115.0]</td>\n",
       "      <td>9</td>\n",
       "      <td>0.333333</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>24</th>\n",
       "      <td>(115.0,120.0]</td>\n",
       "      <td>3</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   revol_util_cat  nrow  mean_bad_loan\n",
       "20   (95.0,100.0]  4316       0.255097\n",
       "21  (100.0,105.0]   238       0.260504\n",
       "22  (105.0,110.0]    35       0.200000\n",
       "23  (110.0,115.0]     9       0.333333\n",
       "24  (115.0,120.0]     3       0.000000"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[20:25]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_trans.remove(\"revol_util\")\n",
    "x_trans.append(\"revol_util_0\")\n",
    "x_trans.append(\"revol_util_core\")\n",
    "x_trans.append(\"revol_util_delta\")\n",
    "\n",
    "train[\"revol_util_0\"] = train[\"revol_util\"] == 0\n",
    "\n",
    "train[\"revol_util_core\"] = h2o.H2OFrame.ifelse(train[\"revol_util\"] <= 100, train[\"revol_util\"], 100)\n",
    "\n",
    "train[\"revol_util_delta\"] = train[\"revol_util\"] - train[\"revol_util_core\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Separating Typical from Extreme Number of Credit Lines"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Looking at the occurance of bad loans on a logit scale reveal that the chance of a bad loan roughly decreases linearly in number of lines of credit up to about 50. To reflect this finding in the modeling, we will replace the original `total_acc` measure with two derived measures:\n",
    "\n",
    "\\begin{eqnarray}\n",
    "total\\_acc\\_core & = & \\min(total\\_acc, 50) \\\\\n",
    "total\\_acc\\_diff & = & total\\_acc - total\\_acc\\_core\n",
    "\\end{eqnarray}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table>\n",
       "<thead>\n",
       "<tr><th style=\"text-align: right;\">  Probs</th><th style=\"text-align: right;\">  total_accQuantiles</th></tr>\n",
       "</thead>\n",
       "<tbody>\n",
       "<tr><td style=\"text-align: right;\">   0   </td><td style=\"text-align: right;\">                   1</td></tr>\n",
       "<tr><td style=\"text-align: right;\">   0.05</td><td style=\"text-align: right;\">                   8</td></tr>\n",
       "<tr><td style=\"text-align: right;\">   0.25</td><td style=\"text-align: right;\">                  16</td></tr>\n",
       "<tr><td style=\"text-align: right;\">   0.5 </td><td style=\"text-align: right;\">                  23</td></tr>\n",
       "<tr><td style=\"text-align: right;\">   0.75</td><td style=\"text-align: right;\">                  31</td></tr>\n",
       "<tr><td style=\"text-align: right;\">   0.95</td><td style=\"text-align: right;\">                  46</td></tr>\n",
       "<tr><td style=\"text-align: right;\">   1   </td><td style=\"text-align: right;\">                 118</td></tr>\n",
       "</tbody>\n",
       "</table>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": []
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train[\"total_acc\"].quantile([0, 0.05, 0.25, 0.5, 0.75, 0.95, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "breaks = np.linspace(0, 60, 13).tolist()\n",
    "train[\"total_acc_cat\"] = train[\"total_acc\"].cut(breaks = breaks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = mean_target(train, \"total_acc_cat\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXwAAAD8CAYAAAB0IB+mAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzt3Xd8leX9//HXlb1DQgYkAULCCrLCHooDFzjBiruKfutotf1ql6O/2tZvrdbR1mrVOnAPqqhUcYuLJRuRmRNGEkYOYWaRdf/+SIKUHiAJybnPue/38/HgQXJyxueG5H3uXNd1fy5jWRYiIuJ8IXYXICIi/qHAFxFxCQW+iIhLKPBFRFxCgS8i4hIKfBERl1Dgi4i4hAJfRMQlFPgiIi4RZncBh0pJSbGys7PtLkNEJKgsWbJkp2VZqce6X0AFfnZ2NosXL7a7DBGRoGKM2dyS+2lIR0TEJRT4IiIuocAXEXEJBb6IiEso8EVEXEKBLyLiEgp8ERGXUOC3UOn+av61uAhtCSkiwUqB30KvLizil2+s5PEvPHaXIiLSJgr8FirwlgPw4Ifr+HK91+ZqRERaT4HfQp7Sckb1TKZ3Wjw/fW0ZRbsq7S5JRKRVFPgt0NBgUbiznIGZiTx51TAaGixueHEJVTX1dpcmItJiCvwW2Lq3iuraBnLT4shOieVvl+azZvs+7nzrW03iikjQUOC3QEFp4/h9bmocAKf2S+PW0/vw1rISnpu3ycbKRERaToHfAh5vBQC5qbEHb7v51F6cnpfO/723hoWFZXaVJiLSYgr8FvB4y0mKCadzXOTB20JCDA9fMpgeyTH85JWlbNtbZWOFIiLHpsBvAU9p+cHhnEMlRIXz5FXDqKqp56aXlnKgTpO4IhK4FPgt4PH6DnyA3unxPHjxYJYX7eF3s1b7uTIRkZZT4B/DnsoadpbXkJsWe8T7TBzYlZtOyeXVb7bw2jdb/FidiEjLKfCP4fsJW99n+M1+cWZfTuqdwm/f+Y5lW3b7ozQRkVZR4B+Dp6mlQq+0owd+aIjhkUvzSUuI5KaXluLdf8Af5YmItJgC/xg83nIiQkPISoo55n2TYiN48qph7Kmq4SevLKW2vsEPFYqItIwC/xg8peX0TIklNMS06P4nZCRy35RBfLNxF/fOXtPB1YmItJwC/xg83oqjTtj6cmF+JtPGZTN97ibeWlbcQZWJiLSOAv8oDtTVs2VXJb2OMWHry52T8hjZM5k7Zn7Ld1v3dkB1IiKto8A/ii1lldQ3WOQeY8LWl/DQEB67fCidoiO48aUl7Kms6YAKRURaToF/FIc3TWut1PhIHr9yKDv2HuCWV5dR36DOmiJiHwX+UTQvyeyZ0rox/EPld0/i9xecwFcbdvLQR+vaqzQRkVZT4B+Fx1tBRmIUsZFhx/U8l43szmUju/GPzz18sGpbO1UnItI6Cvyj8HjL2zR+78vvzj+BId068fMZK9iwY3+7PKeISGso8I/Asqwjdslsi8iwUB6/cijREaHc8OIS9lXXtsvzioi0lAL/CLbvq6aipr7dzvABuiZG89jlQ9m8q5Kfz1hBgyZxRcSPFPhH4Cn9712u2sOonM7cNSmPj1fv4LE5Be363CIiR6PAP4KWNk1ri2njsrlwSAYPf7KeOetK2/35RUR8UeAfgcdbTnxUGKmHbGvYXowx/GnKIPK6JPCzV5exaWdFu7+GiMjhFPhHUNA0YWtMy5qmtVZ0RChPXjWMkBDDjS8tobKmrkNeR0SkmQL/CI62rWF76ZYcwyOX5rN+x35+9cZKLEuTuCLScRT4PuyvrmXHvgMdMn5/uPF9UvnFWX15d+U2nv5qY4e/noi4lwLfh0Jvx6zQOZKbTs5l4oAu/On9Ncwr2OmX1xQR91Hg+3CwaZofzvChcRL3gYsHk5Max82vLmNzmSZxRaT9KfB98HjLCQsxdE8+9raG7SUuMownrxpGfYPF+Y/OZc5aLdcUkfalwPfB4y2nR+cYwkP9+8+TmxrHrJvHkdkpmmnPLeLhj9appbKItBsFvg8eb4VfJmx96dE5lpk/HsvFw7J45LMCrpn+DbsqtHmKiBw/Bf5hausb2FxW0eFLMo8mKjyUBy4ezP0XDWThxl2c+8hXLNuy27Z6RMQZFPiH2bKrktp6y9bAb3bJiO68eeNYQkIMU5+cz4vzN2mtvoi0mQL/MB4/r9A5loFZibx7y4mc2CuF//fOd9z6+nJdlSsibaLAP4zHz2vwW6JTTATPXD2Cn5/Rh3dWbGXyY/MobGruJiLSUgr8w3i85aQnRBIfFW53Kf8hJMRwy4TevHDtSEr3V3P+o3O1XaKItIoC/zAF7bjLVUc4qXcq7/70JHLT4rjxpaXcO3sNdfUNdpclIkFAgX8Iy7L80jTteGV2imbGDaO5anQP/vllIZc/vZDSfdV2lyUiAU6Bfwhv+QH2V9cF1Pj9kUSGhXLPhQP4yyWDWVm8h3P+/jULC8vsLktEApgC/xDN2xr2Sou3uZKWm5yfxds/GUdcZBiXP72Qp74s1NJNEfFJgX+I5m0Nc9MC/wz/UP26JDDr5nGckZfOH2ev4ccvL2V/da3dZYlIgFHgH6KgtJyYiFC6JETZXUqrxUeF8/iVQ7lrUh4frd7BBY/OZd32/XaXJSIBRIF/iOYJ247a1rCjGWP40fgcXvmfUew/UMeFj83l7WUldpclIgFCgX+IQhubprWnUTmdee+WExmYmcj/vr6c376zigN19XaXJSI2U+A3qaypo2RPVVCs0GmJtIQoXv7RKK4fn8ML8zdzyZML2Lqnyu6yRMRGCvwm329rGPxn+M3CQ0O4c1Iej18xlILScs79+9d8vUFbKIq4VYsC3xhztjFmnTGmwBhzu4+v32aMWW2MWWmM+dQY0+OQr11tjNnQ9Ofq9iy+PX2/Qsc5gd9s4sCuzLp5HKlxkVz17EIe/WwDDdpYRcR1jhn4xphQ4DFgItAfuMwY0/+wuy0DhluWNQh4A/hz02OTgbuBUcBI4G5jTFL7ld9+PKXlhBjo0dl/2xr6U05qHG/9ZCznD87gwY/Wc/2LS9R1U8RlWnKGPxIosCyr0LKsGuA14IJD72BZ1hzLsiqbPl0AZDV9fBbwsWVZuyzL2g18DJzdPqW3L4+3gh6dY4kMC7W7lA4TExHGXy8Zwu/O689na3dw2VML2Vl+wO6yRMRPWhL4mUDRIZ8XN912JNcB77fmscaY84wx/9y7d28LyukYjUsynTFhezTGGK4Z15MnrhzGuu37uOjxeWzaWWF3WSLiBy0JfF+L0n0OABtjrgSGAw+05rGWZf3bsqzrExMTW1BO+6tvsCjcae+2hv525gldeOVHo9lXVcuUx+dpC0URF2hJ4BcD3Q75PAvYevidjDGnA3cB51uWdaA1j7Vb8e5KauoaXBX4AEO7J/HmTWOJjQzlsqcW8MnqHXaXJCIdqCWBvwjobYzpaYyJAC4FZh16B2NMPvAkjWFfesiXPgTONMYkNU3Wntl0W0Bx8gqdY8lJjWPmTePokx7P9S8u5uWFm+0uSUQ6yDED37KsOuBmGoN6DTDDsqzvjDF/MMac33S3B4A44F/GmOXGmFlNj90F3EPjm8Yi4A9NtwWU5i6ZbhjD9yU1PpLXrh/NyX1SueutVTz44Tp13BRxoLCW3MmyrNnA7MNu++0hH59+lMc+Czzb1gL9oaC0nJS4CDrFRNhdim1iIsJ46ofD+c3bq3h0TgFb91Zx35RBRITp2jwRp2hR4Dudx1tOjsvG730JCw3hT1MGktEpmoc/Xo93/wH+ccXQgNvfV0TaRqdvEBTbGvqLMYafTujNn38wiHmeMi55cgE7tH2iiCO4PvB3VdSwu7LWEV0y29PU4d149poRbCqrYMo/5rFhh3rriwQ71wf+wRU6Lp2wPZqT+6Qy44YxHKhr4KLH5/HNxoCbbxeRVnB94BeUNge+zvB9GZCZyFs/HktKfCRXPrOQ91Zus7skEWkj1we+p7ScqPAQMjtF211KwOqWHMObN45lYGYiN7+6lGe+3mh3SSLSBgp8bzk5KXGEhATntob+khQbwcv/M4qz+nfhnndXc8+7q9ViWSTIKPC9Fa68wrYtosJDeeyKoVwzNptnvt7ILa8to7pWWyeKBAtXB351bT1Fuys1YdsKoSGGu8/rz52T+vHeym388Nlv2FtZa3dZItICrg78jTsrsCxN2LaWMYbrx+fyt0uHsGzLbi56Yh4l2i9XJOC5OvC/X5KpwG+LC4Zk8vy1I9mxr5rJj83lu6327WcgIsfm7sAvrcAYyNGQTpuNzU3hjRvHEhpiuOTJBXy1wWt3SSJyBO4OfG85WUnRRIU7d1tDf+jbJZ6ZPx5LVlI006YvYubSYrtLEhEfXB34BaXqodNeuiZGM+PGMYzITua2GSt4bE6BWiyLBBjXBn5Dg0XhTgV+e0qICuf5a0dywZAMHvhwHXe+tYq9VVrBIxIoXNseeeveKqprG9Q0rZ1FhIXwl6lD6JoYzRNfeHhneQkXD8vimnE96ZmiuRIRO7k28D3e5l2uFPjtLSTEcPvEfpw7qCvT527ilW+28MKCzZzWN43rTuzJmNzOGKMrm0X8zbVDOt83TdNZZ0cZkJnIQ1MHM/f207jltN4sL9rD5U8vZOLfvmLG4iJdpSviZ64NfI+3nE4x4STHundbQ39Ji4/itjP6MPf20/jzRYMA+NUbKxl332c8/PF6SvdrgxURf3DvkE7TCh0NLfhPVHgoU0d04+LhWcz3lPHM1xt55NMNPPG5h/MGZ3DtidmckJFod5kijuXewPdWMKFfmt1luJIxhrG9UhjbK4VCbznPzdvEvxYX8+bSYkbnJHPtuJ5MyEsnVB1MRdqVK4d09lbWsrP8ALlpGr+3W05qHH+4YAAL7pjAnZP6UbSriutfXMJpD33O9LkbKT9QZ3eJIo7hysAvUA+dgJMYE87143P54pen8NjlQ0mJi+T3/17NmHs/5f/eXU3Rrkq7SxQJeq4c0lHTtMAVFhrCOYO6cs6griwv2sOzX2/kuXmbeHbuRs46oQvXntiT4T2SNPci0gauDfyI0BC6JcfYXYocxZBunXjksnzumNSPF+Zv5pWFW3h/1XYGZiZy7YnZnDMwg4gwV/6SKtImrvxp8ZRW0DMlVpOCQaJrYjS/PrsfC+6YwB8nD6Cypo5bX1/Bifd/xqOfbWB/tdo3iLSEOwPfW64J2yAUHRHKFaN68PGtJ/PctBH07RLPgx+t55rpi3QRl0gLuC7wD9TVs2VXpcbvg1hIiOGUvmm8eN0oHr08nyWbd/PzGSu0qbrIMbhuDH9LWSX1DZYC3yHOHZTB1j1V3Dt7LZlJ0dw5Kc/ukkQClusCv3mFjrpkOsePTsqheHcV//yykKykaH44JtvukkQCkusCv7lpmlr1OocxhrvPO4Gte6r43azv6JoYzRn90+0uSyTguG4M3+OtICMxithI173XOVpoiOGRy/IZkJnILa8uZUXRHrtLEgk4Lgz8cnI1nONIMRFhPHP1CFLiIrnu+UW6OlfkMK4KfMuyDnbJFGdKjY/kuWkjqK23uHr6N+yprLG7JJGA4arA37HvABU19TrDd7heafH886phFO+q4voXlmiNvkgTVwW+drlyj1E5nXlw6mC+2bSLX76xUmv0RXDZKp2DSzI1pOMK5w/OoGR3Ffd/sJbMTtHcPrGf3SWJ2Mp1gR8fFUZqfKTdpYif3HhyDkW7K3niCw9ZSdFcObqH3SWJ2MZ1ga9tDd3FGMMfzj+BbXuq+O07q8joFMVp/bRGX9zJdWP4WqHjPmGhITx6+VD6ZyRw8yvL+LZ4r90lidjCNYG/v7qWHfu0raFbxUaG8ezVI0iKieDa5xdRvFtr9MV9XBP4hd4KQLtcuVlaQhTPTRtBdW0910xfxN5K9dEXd3FN4KtpmgD0To/nyauGsbmsghteWsyBOq3RF/dwVeCHhRi6a1tD1xubm8IDPxjMgsJd/PqNlViW1uiLO7hmlU5BaTk9OscQHuqa9zg5igvzMynZU8UDH64jKymGX5zV1+6SRDqcawLf463Q+L38hx+fkkvRrkoenVNAZlI0l43sbndJIh3KFae7tfUNbC6r0Pi9/AdjDPdcOICT+6Tym7dX8fm6UrtLEulQrgj8ol2V1NZrW0P5b+GhITx2xVD6psfzk5eX8t1WrdEX53JF4B9smqYzfPEhLjKM6dNGkBgdzrTpiyjZU2V3SSIdwhWB72lag5+jLplyBOkJUUyfNpKqmnqunb6IfdVaoy/O45LALyctPpKEqHC7S5EA1rdLPE9cNQyPt5ybXlpCTV2D3SWJtCvXBL4mbKUlxvVK4f6LBjG3oIzbZ2qNvjiL4wNf2xpKa100LItbT+/DzKUl/PWTDXaXI9JuHL8O31t+gH3VddrlSlrlpxN6Uby7kr99uoHMpGimDu9md0kix83xge8pbWqapiEdaQVjDPdOGcj2fdXcOfNbUuMiObVfmt1liRwXxw/pqGmatFV4aAj/uGIovdLimPbcIs77+9dMn7uRneUH7C5NpE1cEfgxEaF0SYiyuxQJQvFR4bx+wxjuPq8/AL//92pG3/sp//P8It5buY3qWnXblODh+CGd5l2utK2htFVidDjTxvVk2rierN+xn5lLS3h7WQmfrFlKfFQY5w7K4KKhmQzrkaTvMwlojg/8Qm8FI7KT7C5DHKJPejy3T+zHL8/qy3xPGTOXFvP2shJe/WYLPTrHMDk/kyn5WXTvrDbcEngcHfiVNXWU7Kni0lStsJD2FRpiOLF3Cif2TuGeC+v4YNV2Zi4r5m+fbuCvn2xgRHYSU4ZmMWlgVxKjdcGfBAZHB37ztoaasJWOFBsZxkXDsrhoWBbb9lbx9rKtvLm0mDtmfsvds77jjLx0pgzNZHyfVO3HILZydOA3r9DRkkzxl66J0dx0Si43npzDqpJ9vLm0mFkrtvLet9voHBvB+UMyuGhoFidkJGi8X/zO2YFfWk6IgR4aTxU/M8YwMCuRgVmJ3HVOHl+s8zJzWTEvL9jC9Lmb6JMex5ShWVw4JJMuiVpBJv7h7MD3VtA9OYbIsFC7SxEXCw8N4fT+6ZzeP529lbW8++1WZi4t4b7313L/B2s5sVcKU4ZmctYJXYiJcPSPpNjM0d9dapomgSYxJpwrRvXgilE92LSzgpnLSpi5tJhbX19BbMQqrhzdgx+NzyElLtLuUsWBHDuDVN9gUbhT+9hK4MpOieW2M/rw5S9PZcYNY5iQl85TXxVy0v1z+ON7q/Hu1xW90r4ce4ZfvLuSmroGBb4EvJAQw8ieyYzsmczPTu/No58V8MzXG3lxwWauGNWDG07OIS1e4/xy/Bx7hv/9Ch11yZTgkZsax18uGcInt53MpIFdeW7eJk66fw6///d37NhXbXd5EuScG/jNXTJ1hi9BKCc1joenDuHT207m/MEZvDB/Myf9eQ53v7OK7XsV/NI2zg18bzkpcRF0iomwuxSRNstOieWBiwcz5+enMHlIJi8v3ML4P8/h/729iq3abF1aybGBX1BaTo7O7sUhuneO4f4fDGLOL07homFZvLZoCyc/MIe73vqW4t2VdpcnQcKxge/xaltDcZ5uyTH8acpA5vziFKYO78aMxUWc+uDn3DFzJUW7FPzByJ/7Jjsy8HdV1LC7slbbGopjZSXF8MfJA/nil6dy6YjuvLmkhFMf/Jxfv7GSLWUK/mDywartTPnHXL/MzTgy8LXLlbhFRqdo7rlwAF/86hSuHN2Dt5aXcOpDn/PLf61g084Ku8uTFnh9cRFb91STGt/xF9s5M/BLm5ZkakhHXKJrYjS/O/8EvvrVqfxwTA9mrdjKhIe/4LYZy9mo4A9Y2/ZW8eV6LxcNyyQ0pOOb6Tky8AtKy4kMCyGzU7TdpYj4VXpCFHef1xj808ZmM/vbbUx46HNufX35wd98JXDMXFpCgwUXD/PPnh2OvNLW421coRPih3dMkUCUlhDFb87tzw0n5/LUV4W8OH8z7ywv4bzBGVw2sjv53TupqaDNGhosZiwuYlTPZLJT/DPf6NDAr2BQVqLdZYjYLjU+kjsn5XH9+JxDgn8rkWEhDM9OYkxOZ8bkdmZQVidtzuJn32zaxeaySn42obffXtNxgV9dW0/R7kqmDM20uxSRgJESF8kdE/P4yam9WFi4i/meMuZ5dvLgR+sBiIkIZXh28sE3gAEZCYTpDaBDzVhURHxkGBMHdPXbazou8DfurMCyNGEr4ktCVDhn9E/njP7pQOMS5oWFZcwvLGO+p4z7P1gLQHxkGCN7JjMmtzOjczrTv2uChkjb0b7qWmav2saUoVlER/hvaM1xgX+waZoCX+SYkmMjmDiwKxMHNp5levcfYEFhGfM8ZSwoLOPTtaUAJEaHM6rpDWBMbmf6pMXrDeA4/HvFVqprG5g63D+Ttc2cF/ilFRgDObroSqTVUuMjOW9wBucNzgBg+95q5hfuZL6n8beAj1bvABrfKMbkdGZ0bmfG5HQmNzVWe/S2wozFxfRNj2ewn+canRf43nKykqKJCtcKBJHj1SUxisn5WUzOzwKgaFcl8wvLWND0BvDet9sASIuPZHTT+P+YnM706ByjN4AjWLd9PyuK9vCbc/L8/m/kyMDXcI5Ix+iWHEO35BimDu+GZVlsLqs8OP4/v7CMWSu2AtA9OYYLhmQwOT9TTQwPM2NxEeGhhsn5/l9Y4qjAb2iw8HjLGZ3T2e5SRBzPGEN2SizZKbFcNrI7ltX48zff0zj089icAv7+WQGDu3ViSn4m5w3OIDnW3e3Ka+oaeGtZCafnpdPZhn2LHRX4W/dWUV2rbQ1F7GCMoVdaPL3S4rlqTDY79lUza/lWZi4r4e5Z33HPu6s5pW8qk/OzmJCX5sph10/X7GBXRY3fJ2ubOSrwPd7mXa40YStit/SEKH40Pocfjc9hzbZ9vLWshHeWl/DJmlLio8I4d1BXJudnMbxHkmtW/MxYXESXhCjG90m15fWdFfil6pIpEojyuiaQ1zWBX5/dj3menby1tIR3lm/l1W+KyEqKZnJ+puPH+7fvreaL9V5uOiXXL43SfHFU4Bd4y+kUE+76cUKRQBUaYjipdyon9U7l/2rq+PC77cxcWuKK8f43lxb7tVGaL44KfE9p4wodLQcTCXwxEWEHl3w6fbzfjkZpvjgr8L0VnNbPnrExEWk7p4/329EozRfHBP7eylp2lh/Q+L1IkHPieP+MxUXE+blRmi+OCXzPTvXQEXGSY43353fvxCOX5tMtOcbuUo9qX3Uts7/dxuR8/zZK88Ux/U8LtK2hiGM1j/e/eN0o5t8xgbsm5bF++37+8O5qu0s7pndXbKO6toFLRtg3WdvMMYHv8ZYTERpCVpK2NRRxsubx/h+f2ouPV+9gYWGZ3SUd1euLi+iTHuf3Rmm+OCfwSyvITonRpg0iLnHtuJ50TYzi3tlraGiw7C7Hp+ZGaVOHdwuI1YOOScdCb7kmbEVcJDoilJ+f2ZcVxXt5t6lrZ6Cxs1GaL44I/Jq6BjbvqtT4vYjLTM7PpH/XBO5/fy3VtfV2l/Mf7G6U5osjAn9zWQX1DZYCX8RlQkMMd07Ko2RPFS/M32R3Of/B7kZpvjgi8LWtoYh7ndg7hVP6pvLoZwXsrqixu5yDZiwuIj0hkpN6p9hdykEOCfzGLpna1lDEne6YmEf5gTr+/lmB3aUA3zdK+8GwrIBaSBI4lRwHT2k5GYlRxEY65joyEWmFvl3imTq8Gy8u2MTmsgq7ywmIRmm+OCLwC7zl5GqFjoir3XZGH8JCQvjzB+tsrcOyAqNRmi+OCPwbT87lmrHZdpchIjZKS4ji+vE5vPftNpZs3m1bHQs3NjZKC6TJ2maOCPxJA7syIS/d7jJExGbXj88hNT6Se2evwbLsuRiruVHapIH2NkrzxRGBLyICEBsZxm1n9GHJ5t18+N12v79+c6O08wZn2N4ozRcFvog4ysXDsuiTHsd976+lpq7Br68dSI3SfFHgi4ijhIWGcMfEPDaVVfLyws1+fe1AapTmiwJfRBznlL6pjOvVmUc+3cDeqlq/vGagNUrzRYEvIo5jjOGOiXnsqarlH5/752Ksfy0uIiwkcBql+aLAFxFHGpCZyOT8TKbP3UTx7soOfa2augZmBlijNF8U+CLiWL84sy8GePDDjr0Y67O1jY3SAnWytpkCX0QcK6NTNNed2JO3l2/l2+K9HfY6ry8KvEZpvijwRcTRbjoll86xEfxx9uoOuRgrUBul+RLY1YmIHKf4qHB+dnpvFhTu4rO1pe3+/IHaKM0XBb6ION5lI7uTkxLLvbPXUFfffhdjNTdKGxmAjdJ8UeCLiOOFh4bw64n98HgreH1xUbs97zdNjdIuCcBGab4o8EXEFc7sn87I7GT+8vF6yg/Utctzvt7UKG3iwC7t8nwdTYEvIq5gjOHOc/LYWV7Dk194jvv59h/SKC0mIjg2X1Lgi4hrDOnWifMGZ/DUV4Vs31t9XM/176ZGaVOHZ7VTdR1PgS8irvKrs/rS0AAPfXR8F2PNaGqUNqRbp3aqrOMp8EXEVbolx3D12B68sbSYNdv2tek51u/Yz/IAb5TmiwJfRFzn5lN7kxAVzr2z17Tp8TMWBX6jNF8U+CLiOokx4dxyWi++2rCTL9Z7W/XYYGmU5osCX0Rc6aoxPeieHMOfZq+hvqHlLReaG6VNHRE8k7XNFPgi4kqRYaH86uy+rN2+nzeXFrf4cTMWF5OeEMn43qkdWF3HUOCLiGudM7ArQ7p14qGP1lFZc+yLsbbvrebzdaVcNDTwG6X5EnwVi4i0E2MMvzknjx37DvD0VxuPef/mRmlTg6SVwuEU+CLiasOzkzn7hC488YWH0v1HvhjLsiz+FUSN0nxR4IuI6/16Yj9q6hr46ycbjnifbzbuYlMQNUrzRYEvIq7XMyWWK0f34PVFRWzYsd/nfYKtUZovCnwREeCnE3oTEx7Kfe+v/a+vBWOjNF8U+CIiQHJsBD8+tRefri1lnmfnf3wtGBul+aLAFxFpMm1cNpmdorl39hoaDrkYa8biInqnBVejNF8U+CIiTaLCQ/nFWX3HBcflAAAEyElEQVRYVbKPWSu2At83SrtkRHA1SvNFgS8icogLBmcyIDOBBz5cR3Vt/cFGaRcGWaM0XxT4IiKHCAkx3Dkpj5I9VTz1ZSFvNTVKSwmyRmm+BO90s4hIBxmbm8KEfmk8/Ml6LIugbJTmi87wRUR8uH1iPwwEbaM0X3SGLyLiQ+/0eP44eSBJMRFB2SjNFwW+iMgRXDayu90ltCtnvG2JiMgxKfBFRFxCgS8i4hIKfBERl1Dgi4i4hAJfRMQlFPgiIi6hwBcRcQljWdax7+UnxhgvsLmND08Bdh7zXsHBKcfilOMAHUugcsqxHO9x9LAs65j9HwIq8I+HMWaxZVnD7a6jPTjlWJxyHKBjCVROORZ/HYeGdEREXEKBLyLiEk4K/H/aXUA7csqxOOU4QMcSqJxyLH45DseM4YuIyNE56QxfRESOIugD3xhztjFmnTGmwBhzu931tJUxppsxZo4xZo0x5jtjzM/srul4GWNCjTHLjDHv2l3L8TDGdDLGvGGMWdv0/zPG7prawhhza9P31ipjzKvGmCi7a2opY8yzxphSY8yqQ25LNsZ8bIzZ0PR3kp01ttQRjuWBpu+vlcaYt4wxnTritYM68I0xocBjwESgP3CZMaa/vVW1WR3wc8uy8oDRwE+C+Fia/QxYY3cR7eBvwAeWZfUDBhOEx2SMyQR+Cgy3LGsAEApcam9VrfIccPZht90OfGpZVm/g06bPg8Fz/PexfAwMsCxrELAeuKMjXjioAx8YCRRYllVoWVYN8Bpwgc01tYllWdssy1ra9PF+GkMl096q2s4YkwWcAzxtdy3HwxiTAIwHngGwLKvGsqw99lbVZmFAtDEmDIgBttpcT4tZlvUlsOuwmy8Anm/6+HngQr8W1Ua+jsWyrI8sy6pr+nQB0CG7pgd74GcCRYd8XkwQh2QzY0w2kA8stLeS4/JX4FdAg92FHKccwAtMbxqeetoYE2t3Ua1lWVYJ8CCwBdgG7LUs6yN7qzpu6ZZlbYPGEyYgzeZ62su1wPsd8cTBHvjGx21BvezIGBMHvAn8r2VZ++yupy2MMecCpZZlLbG7lnYQBgwFHrcsKx+oIHiGDg5qGt++AOgJZACxxpgr7a1KDmeMuYvG4d2XO+L5gz3wi4Fuh3yeRRD9mno4Y0w4jWH/smVZM+2u5ziMA843xmyicZjtNGPMS/aW1GbFQLFlWc2/bb1B4xtAsDkd2GhZlteyrFpgJjDW5pqO1w5jTFeApr9Lba7nuBhjrgbOBa6wOmi9fLAH/iKgtzGmpzEmgsZJqFk219QmxhhD4zjxGsuyHra7nuNhWdYdlmVlWZaVTeP/yWeWZQXl2aRlWduBImNM36abJgCrbSyprbYAo40xMU3faxMIwsnnw8wCrm76+GrgHRtrOS7GmLOBXwPnW5ZV2VGvE9SB3zTJcTPwIY3fvDMsy/rO3qrabBxwFY1nw8ub/kyyuygB4BbgZWPMSmAIcK/N9bRa028obwBLgW9p/NkPmqtUjTGvAvOBvsaYYmPMdcB9wBnGmA3AGU2fB7wjHMujQDzwcdPP/hMd8tq60lZExB2C+gxfRERaToEvIuISCnwREZdQ4IuIuIQCX0TEJRT4IiIuocAXEXEJBb6IiEv8f4O8FD+IvCWQAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.yscale(\"logit\")\n",
    "plt.plot(df[\"total_acc_cat\"].index, df[\"mean_bad_loan\"])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table>\n",
       "<thead>\n",
       "<tr><th style=\"text-align: right;\">  C1</th><th style=\"text-align: right;\">  Count</th></tr>\n",
       "</thead>\n",
       "<tbody>\n",
       "<tr><td style=\"text-align: right;\">   0</td><td style=\"text-align: right;\"> 163958</td></tr>\n",
       "<tr><td style=\"text-align: right;\">   1</td><td style=\"text-align: right;\">     29</td></tr>\n",
       "</tbody>\n",
       "</table>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": []
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(train[\"total_acc\"] == None).table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>total_acc_cat</th>\n",
       "      <th>nrow</th>\n",
       "      <th>mean_bad_loan</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>NaN</td>\n",
       "      <td>0</td>\n",
       "      <td>0.153788</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>(0.0,5.0]</td>\n",
       "      <td>2309</td>\n",
       "      <td>0.226072</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>(5.0,10.0]</td>\n",
       "      <td>12717</td>\n",
       "      <td>0.210034</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  total_acc_cat   nrow  mean_bad_loan\n",
       "0           NaN      0       0.153788\n",
       "1     (0.0,5.0]   2309       0.226072\n",
       "2    (5.0,10.0]  12717       0.210034"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[0:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>total_acc_cat</th>\n",
       "      <th>nrow</th>\n",
       "      <th>mean_bad_loan</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>(35.0,40.0]</td>\n",
       "      <td>11251</td>\n",
       "      <td>0.163719</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>(40.0,45.0]</td>\n",
       "      <td>7174</td>\n",
       "      <td>0.161137</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>(45.0,50.0]</td>\n",
       "      <td>4203</td>\n",
       "      <td>0.157507</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>(50.0,55.0]</td>\n",
       "      <td>2350</td>\n",
       "      <td>0.140426</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>(55.0,60.0]</td>\n",
       "      <td>1287</td>\n",
       "      <td>0.165501</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   total_acc_cat   nrow  mean_bad_loan\n",
       "8    (35.0,40.0]  11251       0.163719\n",
       "9    (40.0,45.0]   7174       0.161137\n",
       "10   (45.0,50.0]   4203       0.157507\n",
       "11   (50.0,55.0]   2350       0.140426\n",
       "12   (55.0,60.0]   1287       0.165501"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[8:13]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_trans.remove(\"total_acc\")\n",
    "x_trans.append(\"total_acc_core\")\n",
    "x_trans.append(\"total_acc_delta\")\n",
    "\n",
    "train[\"total_acc_core\"] = h2o.H2OFrame.ifelse(train[\"total_acc\"] <= 50, train[\"total_acc\"], 50)\n",
    "\n",
    "train[\"total_acc_delta\"] = train[\"total_acc\"] - train[\"total_acc_core\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Separating Typical from Extreme Longest Credit Length"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Looking at the occurance of bad loans on a logit scale reveal that the chance of a bad loan roughly decreases linearly in longest credit length from 3 to 20 years and is highly volatile outside of that range due to small numbers of observations. To reflect this finding in the modeling, we will replace the original `longest_credit_length` measure with two derived measures:\n",
    "\n",
    "\\begin{eqnarray}\n",
    "longest\\_credit\\_length\\_core & = & \\max(3, \\min(longest\\_credit\\_length, 20)) \\\\\n",
    "longest\\_credit\\_length\\_diff & = & longest\\_credit\\_length - longest\\_credit\\_length\\_core\n",
    "\\end{eqnarray}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table>\n",
       "<thead>\n",
       "<tr><th style=\"text-align: right;\">  Probs</th><th style=\"text-align: right;\">  longest_credit_lengthQuantiles</th></tr>\n",
       "</thead>\n",
       "<tbody>\n",
       "<tr><td style=\"text-align: right;\">   0   </td><td style=\"text-align: right;\">                               0</td></tr>\n",
       "<tr><td style=\"text-align: right;\">   0.05</td><td style=\"text-align: right;\">                               6</td></tr>\n",
       "<tr><td style=\"text-align: right;\">   0.25</td><td style=\"text-align: right;\">                              10</td></tr>\n",
       "<tr><td style=\"text-align: right;\">   0.5 </td><td style=\"text-align: right;\">                              14</td></tr>\n",
       "<tr><td style=\"text-align: right;\">   0.75</td><td style=\"text-align: right;\">                              18</td></tr>\n",
       "<tr><td style=\"text-align: right;\">   0.95</td><td style=\"text-align: right;\">                              28</td></tr>\n",
       "<tr><td style=\"text-align: right;\">   1   </td><td style=\"text-align: right;\">                              65</td></tr>\n",
       "</tbody>\n",
       "</table>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": []
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train[\"longest_credit_length\"].quantile([0, 0.05, 0.25, 0.5, 0.75, 0.95, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "breaks = np.linspace(0, 25, 26).tolist()\n",
    "train[\"longest_credit_length_cat\"] = train[\"longest_credit_length\"].cut(breaks = breaks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = mean_target(train, \"longest_credit_length_cat\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.yscale(\"logit\")\n",
    "plt.plot(df[\"longest_credit_length_cat\"].index, df[\"mean_bad_loan\"])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>longest_credit_length_cat</th>\n",
       "      <th>nrow</th>\n",
       "      <th>mean_bad_loan</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>NaN</td>\n",
       "      <td>0</td>\n",
       "      <td>0.171094</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>(0.0,1.0]</td>\n",
       "      <td>67</td>\n",
       "      <td>0.253731</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>(1.0,2.0]</td>\n",
       "      <td>100</td>\n",
       "      <td>0.300000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>(2.0,3.0]</td>\n",
       "      <td>914</td>\n",
       "      <td>0.205689</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  longest_credit_length_cat  nrow  mean_bad_loan\n",
       "0                       NaN     0       0.171094\n",
       "1                 (0.0,1.0]    67       0.253731\n",
       "2                 (1.0,2.0]   100       0.300000\n",
       "3                 (2.0,3.0]   914       0.205689"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[0:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>longest_credit_length_cat</th>\n",
       "      <th>nrow</th>\n",
       "      <th>mean_bad_loan</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>20</th>\n",
       "      <td>(19.0,20.0]</td>\n",
       "      <td>4682</td>\n",
       "      <td>0.163392</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>21</th>\n",
       "      <td>(20.0,21.0]</td>\n",
       "      <td>3892</td>\n",
       "      <td>0.157760</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>22</th>\n",
       "      <td>(21.0,22.0]</td>\n",
       "      <td>3350</td>\n",
       "      <td>0.160000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>23</th>\n",
       "      <td>(22.0,23.0]</td>\n",
       "      <td>3092</td>\n",
       "      <td>0.167206</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>24</th>\n",
       "      <td>(23.0,24.0]</td>\n",
       "      <td>2856</td>\n",
       "      <td>0.176821</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25</th>\n",
       "      <td>(24.0,25.0]</td>\n",
       "      <td>2471</td>\n",
       "      <td>0.164711</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   longest_credit_length_cat  nrow  mean_bad_loan\n",
       "20               (19.0,20.0]  4682       0.163392\n",
       "21               (20.0,21.0]  3892       0.157760\n",
       "22               (21.0,22.0]  3350       0.160000\n",
       "23               (22.0,23.0]  3092       0.167206\n",
       "24               (23.0,24.0]  2856       0.176821\n",
       "25               (24.0,25.0]  2471       0.164711"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[20:26]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_trans.remove(\"longest_credit_length\")\n",
    "x_trans.append(\"longest_credit_length_core\")\n",
    "x_trans.append(\"longest_credit_length_delta\")\n",
    "\n",
    "train[\"longest_credit_length_core\"] = h2o.H2OFrame.ifelse(train[\"longest_credit_length\"] <= 3,\n",
    "                                                          3, train[\"longest_credit_length\"])\n",
    "train[\"longest_credit_length_core\"] = h2o.H2OFrame.ifelse(train[\"longest_credit_length_core\"] <= 20,\n",
    "                                                          train[\"longest_credit_length_core\"], 20)\n",
    "\n",
    "train[\"longest_credit_length_delta\"] = train[\"longest_credit_length\"] - train[\"longest_credit_length_core\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Converting Income Verification Status to a 0/1 Indicator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Given that incomes are either verified or not verified, we will create a simplifed `verified` binary indicator that is 1 when income has been verified."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table>\n",
       "<thead>\n",
       "<tr><th>verification_status  </th><th style=\"text-align: right;\">  Count</th></tr>\n",
       "</thead>\n",
       "<tbody>\n",
       "<tr><td>not verified         </td><td style=\"text-align: right;\">  59155</td></tr>\n",
       "<tr><td>verified             </td><td style=\"text-align: right;\"> 104832</td></tr>\n",
       "</tbody>\n",
       "</table>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": []
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train[\"verification_status\"].table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_trans.remove(\"verification_status\")\n",
    "x_trans.append(\"verified\")\n",
    "\n",
    "train[\"verified\"] = train[\"verification_status\"] == \"verified\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table>\n",
       "<thead>\n",
       "<tr><th style=\"text-align: right;\">  verified</th><th style=\"text-align: right;\">  Count</th></tr>\n",
       "</thead>\n",
       "<tbody>\n",
       "<tr><td style=\"text-align: right;\">         0</td><td style=\"text-align: right;\">  59155</td></tr>\n",
       "<tr><td style=\"text-align: right;\">         1</td><td style=\"text-align: right;\"> 104832</td></tr>\n",
       "</tbody>\n",
       "</table>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": []
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train[\"verified\"].table()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Saving the Transformed Data to a Known Key"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To make it easier to find the data in the cluster, we will [`assign`](http://docs.h2o.ai/h2o/latest-stable/h2o-py/docs/h2o.html?highlight=assign#h2o.assign) the transformed data set to a known key and then retrieving that frame using the [`get_frame`](http://docs.h2o.ai/h2o/latest-stable/h2o-py/docs/h2o.html?highlight=get_frame#h2o.get_frame) function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "py_204_sid_b77f\n"
     ]
    }
   ],
   "source": [
    "print(train.frame_id)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loan_transformed\n"
     ]
    }
   ],
   "source": [
    "h2o.assign(train, \"loan_transformed\")\n",
    "train = h2o.get_frame(\"loan_transformed\")\n",
    "print(train.frame_id)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Supervised Learning in H2O"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This exploration will employ six different supervised learning techniques:\n",
    "\n",
    "1. [Generalized Linear Model](http://docs.h2o.ai/h2o/latest-stable/h2o-py/docs/modeling.html#h2ogeneralizedlinearestimator)\n",
    "1. [Random Forest](http://docs.h2o.ai/h2o/latest-stable/h2o-py/docs/modeling.html#h2orandomforestestimator)\n",
    "1. [Gradient Boosting Machine](http://docs.h2o.ai/h2o/latest-stable/h2o-py/docs/modeling.html#h2ogradientboostingestimator)\n",
    "1. [Multilayer Perceptron (Deep Learning)](http://docs.h2o.ai/h2o/latest-stable/h2o-py/docs/modeling.html#h2odeeplearningestimator)\n",
    "1. [Stacked Ensembles](http://docs.h2o.ai/h2o/latest-stable/h2o-py/docs/modeling.html#h2ostackedensembleestimator)\n",
    "1. [Automatic Machine Learning (AutoML)](http://docs.h2o.ai/h2o/latest-stable/h2o-py/docs/modeling.html#h2oautoml)\n",
    "\n",
    "H2O has two other superviesed learning techiques, [Naive Bayes Classifier](http://docs.h2o.ai/h2o/latest-stable/h2o-py/docs/modeling.html#h2onaivebayesestimator) and [eXtreme Gradient Boosting (XGBoost)](http://docs.h2o.ai/h2o/latest-stable/h2o-py/docs/modeling.html#h2oxgboostestimator), that are left for the reader to explore outside of this script.\n",
    "\n",
    "Given we only have 163987 rows of data, we will use cross-validation to detect overfitting rather than creating a separate validation split."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Response = bad_loan\n",
      "Predictors (Orig) = ['loan_amnt', 'term', 'emp_length', 'home_ownership', 'annual_inc', 'purpose', 'addr_state', 'dti', 'delinq_2yrs', 'revol_util', 'total_acc', 'longest_credit_length', 'verification_status']\n",
      "Predictors (Trans) = ['emp_length', 'loan_amnt_core', 'loan_amnt_delta', 'term_60months', 'emp_length_missing', 'home_ownership_3cat', 'annual_inc_core', 'annual_inc_delta', 'te_purpose', 'te_addr_state', 'dti_core', 'dti_delta', 'delinq_2yrs_core', 'delinq_2yrs_delta', 'revol_util_0', 'revol_util_core', 'revol_util_delta', 'total_acc_core', 'total_acc_delta', 'longest_credit_length_core', 'longest_credit_length_delta', 'verified']\n"
     ]
    }
   ],
   "source": [
    "print(\"Response = \" + y)\n",
    "print(\"Predictors (Orig) = \" + str(x_orig))\n",
    "print(\"Predictors (Trans) = \" + str(x_trans))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generalized Linear Model : Logistic Regression"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Initial Models"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Following standard convention for binary classification exercises, we will start with logistic regression. From Python, H2O uses a scikit-learn like [`H2OGeneralizedLinearEstimator`](http://docs.h2o.ai/h2o/latest-stable/h2o-py/docs/modeling.html?highlight=h2ogeneralizedlinearestimator#h2o.estimators.glm.H2OGeneralizedLinearEstimator) to fit a couple of models. The first model we will fit uses the original set of predictors and the second model uses the engineered features. As is expected, the logistic regression model containing the engineered features have a lower cross-validated logloss and a higher cross-validated AUC than the model with the original features."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "from h2o.estimators.glm import H2OGeneralizedLinearEstimator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class H2OGeneralizedLinearEstimator in module h2o.estimators.glm:\n",
      "\n",
      "class H2OGeneralizedLinearEstimator(h2o.estimators.estimator_base.H2OEstimator)\n",
      " |  Generalized Linear Modeling\n",
      " |  \n",
      " |  Fits a generalized linear model, specified by a response variable, a set of predictors, and a\n",
      " |  description of the error distribution.\n",
      " |  \n",
      " |  A subclass of :class:`ModelBase` is returned. The specific subclass depends on the machine learning task\n",
      " |  at hand (if it's binomial classification, then an H2OBinomialModel is returned, if it's regression then a\n",
      " |  H2ORegressionModel is returned). The default print-out of the models is shown, but further GLM-specific\n",
      " |  information can be queried out of the object. Upon completion of the GLM, the resulting object has\n",
      " |  coefficients, normalized coefficients, residual/null deviance, aic, and a host of model metrics including\n",
      " |  MSE, AUC (for logistic regression), degrees of freedom, and confusion matrices.\n",
      " |  \n",
      " |  Method resolution order:\n",
      " |      H2OGeneralizedLinearEstimator\n",
      " |      h2o.estimators.estimator_base.H2OEstimator\n",
      " |      h2o.model.model_base.ModelBase\n",
      " |      h2o.utils.backward_compatibility.BackwardsCompatibleBase\n",
      " |      builtins.object\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __init__(self, **kwargs)\n",
      " |      Construct a new model instance.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods defined here:\n",
      " |  \n",
      " |  getGLMRegularizationPath(model)\n",
      " |      Extract full regularization path explored during lambda search from glm model.\n",
      " |      \n",
      " |      :param model: source lambda search model\n",
      " |  \n",
      " |  makeGLMModel(model, coefs, threshold=0.5)\n",
      " |      Create a custom GLM model using the given coefficients.\n",
      " |      \n",
      " |      Needs to be passed source model trained on the dataset to extract the dataset information from.\n",
      " |      \n",
      " |      :param model: source model, used for extracting dataset information\n",
      " |      :param coefs: dictionary containing model coefficients\n",
      " |      :param threshold: (optional, only for binomial) decision threshold used for classification\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  Lambda\n",
      " |      DEPRECATED. Use ``self.lambda_`` instead\n",
      " |  \n",
      " |  alpha\n",
      " |      Distribution of regularization between the L1 (Lasso) and L2 (Ridge) penalties. A value of 1 for alpha\n",
      " |      represents Lasso regression, a value of 0 produces Ridge regression, and anything in between specifies the\n",
      " |      amount of mixing between the two. Default value of alpha is 0 when SOLVER = 'L-BFGS'; 0.5 otherwise.\n",
      " |      \n",
      " |      Type: ``List[float]``.\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",
      " |  beta_constraints\n",
      " |      Beta constraints\n",
      " |      \n",
      " |      Type: ``H2OFrame``.\n",
      " |  \n",
      " |  beta_epsilon\n",
      " |      Converge if  beta changes less (using L-infinity norm) than beta esilon, ONLY applies to IRLSM solver\n",
      " |      \n",
      " |      Type: ``float``  (default: ``0.0001``).\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",
      " |  compute_p_values\n",
      " |      Request p-values computation, p-values work only with IRLSM solver and no regularization\n",
      " |      \n",
      " |      Type: ``bool``  (default: ``False``).\n",
      " |  \n",
      " |  custom_metric_func\n",
      " |      Reference to custom evaluation function, format: `language:keyName=funcName`\n",
      " |      \n",
      " |      Type: ``str``.\n",
      " |  \n",
      " |  early_stopping\n",
      " |      Stop early when there is no more relative improvement on train or validation (if provided)\n",
      " |      \n",
      " |      Type: ``bool``  (default: ``True``).\n",
      " |  \n",
      " |  family\n",
      " |      Family. Use binomial for classification with logistic regression, others are for regression problems.\n",
      " |      \n",
      " |      One of: ``\"gaussian\"``, ``\"binomial\"``, ``\"quasibinomial\"``, ``\"ordinal\"``, ``\"multinomial\"``, ``\"poisson\"``,\n",
      " |      ``\"gamma\"``, ``\"tweedie\"``  (default: ``\"gaussian\"``).\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",
      " |  fold_column\n",
      " |      Column with cross-validation fold index assignment per observation.\n",
      " |      \n",
      " |      Type: ``str``.\n",
      " |  \n",
      " |  gradient_epsilon\n",
      " |      Converge if  objective changes less (using L-infinity norm) than this, ONLY applies to L-BFGS solver. Default\n",
      " |      indicates: If lambda_search is set to False and lambda is equal to zero, the default value of gradient_epsilon\n",
      " |      is equal to .000001, otherwise the default value is .0001. If lambda_search is set to True, the conditional\n",
      " |      values above are 1E-8 and 1E-6 respectively.\n",
      " |      \n",
      " |      Type: ``float``  (default: ``-1``).\n",
      " |  \n",
      " |  ignore_const_cols\n",
      " |      Ignore constant columns.\n",
      " |      \n",
      " |      Type: ``bool``  (default: ``True``).\n",
      " |  \n",
      " |  ignored_columns\n",
      " |      Names of columns to ignore for training.\n",
      " |      \n",
      " |      Type: ``List[str]``.\n",
      " |  \n",
      " |  interaction_pairs\n",
      " |      A list of pairwise (first order) column interactions.\n",
      " |      \n",
      " |      Type: ``List[tuple]``.\n",
      " |  \n",
      " |  interactions\n",
      " |      A list of predictor column indices to interact. All pairwise combinations will be computed for the list.\n",
      " |      \n",
      " |      Type: ``List[str]``.\n",
      " |  \n",
      " |  intercept\n",
      " |      Include constant term in the model\n",
      " |      \n",
      " |      Type: ``bool``  (default: ``True``).\n",
      " |  \n",
      " |  keep_cross_validation_fold_assignment\n",
      " |      Whether to keep the cross-validation fold assignment.\n",
      " |      \n",
      " |      Type: ``bool``  (default: ``False``).\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",
      " |  lambda_\n",
      " |      Regularization strength\n",
      " |      \n",
      " |      Type: ``List[float]``.\n",
      " |  \n",
      " |  lambda_min_ratio\n",
      " |      Minimum lambda used in lambda search, specified as a ratio of lambda_max (the smallest lambda that drives all\n",
      " |      coefficients to zero). Default indicates: if the number of observations is greater than the number of variables,\n",
      " |      then lambda_min_ratio is set to 0.0001; if the number of observations is less than the number of variables, then\n",
      " |      lambda_min_ratio is set to 0.01.\n",
      " |      \n",
      " |      Type: ``float``  (default: ``-1``).\n",
      " |  \n",
      " |  lambda_search\n",
      " |      Use lambda search starting at lambda max, given lambda is then interpreted as lambda min\n",
      " |      \n",
      " |      Type: ``bool``  (default: ``False``).\n",
      " |  \n",
      " |  link\n",
      " |      One of: ``\"family_default\"``, ``\"identity\"``, ``\"logit\"``, ``\"log\"``, ``\"inverse\"``, ``\"tweedie\"``,\n",
      " |      ``\"ologit\"``, ``\"oprobit\"``, ``\"ologlog\"``  (default: ``\"family_default\"``).\n",
      " |  \n",
      " |  max_active_predictors\n",
      " |      Maximum number of active predictors during computation. Use as a stopping criterion to prevent expensive model\n",
      " |      building with many predictors. Default indicates: If the IRLSM solver is used, the value of\n",
      " |      max_active_predictors is set to 5000 otherwise it is set to 100000000.\n",
      " |      \n",
      " |      Type: ``int``  (default: ``-1``).\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",
      " |  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_hit_ratio_k\n",
      " |      Maximum 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",
      " |  max_iterations\n",
      " |      Maximum number of iterations\n",
      " |      \n",
      " |      Type: ``int``  (default: ``-1``).\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",
      " |  missing_values_handling\n",
      " |      Handling of missing values. Either MeanImputation or Skip.\n",
      " |      \n",
      " |      One of: ``\"mean_imputation\"``, ``\"skip\"``  (default: ``\"mean_imputation\"``).\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",
      " |  nlambdas\n",
      " |      Number of lambdas to be used in a search. Default indicates: If alpha is zero, with lambda search set to True,\n",
      " |      the value of nlamdas is set to 30 (fewer lambdas are needed for ridge regression) otherwise it is set to 100.\n",
      " |      \n",
      " |      Type: ``int``  (default: ``-1``).\n",
      " |  \n",
      " |  non_negative\n",
      " |      Restrict coefficients (not intercept) to be non-negative\n",
      " |      \n",
      " |      Type: ``bool``  (default: ``False``).\n",
      " |  \n",
      " |  obj_reg\n",
      " |      Likelihood divider in objective value computation, default is 1/nobs\n",
      " |      \n",
      " |      Type: ``float``  (default: ``-1``).\n",
      " |  \n",
      " |  objective_epsilon\n",
      " |      Converge if  objective value changes less than this. Default indicates: If lambda_search is set to True the\n",
      " |      value of objective_epsilon is set to .0001. If the lambda_search is set to False and lambda is equal to zero,\n",
      " |      the value of objective_epsilon is set to .000001, for any other value of lambda the default value of\n",
      " |      objective_epsilon is set to .0001.\n",
      " |      \n",
      " |      Type: ``float``  (default: ``-1``).\n",
      " |  \n",
      " |  offset_column\n",
      " |      Offset column. This will be added to the combination of columns before applying the link function.\n",
      " |      \n",
      " |      Type: ``str``.\n",
      " |  \n",
      " |  prior\n",
      " |      Prior probability for y==1. To be used only for logistic regression iff the data has been sampled and the mean\n",
      " |      of response does not reflect reality.\n",
      " |      \n",
      " |      Type: ``float``  (default: ``-1``).\n",
      " |  \n",
      " |  remove_collinear_columns\n",
      " |      In case of linearly dependent columns, remove some of the dependent columns\n",
      " |      \n",
      " |      Type: ``bool``  (default: ``False``).\n",
      " |  \n",
      " |  response_column\n",
      " |      Response variable column.\n",
      " |      \n",
      " |      Type: ``str``.\n",
      " |  \n",
      " |  score_each_iteration\n",
      " |      Whether to score during each iteration of model training.\n",
      " |      \n",
      " |      Type: ``bool``  (default: ``False``).\n",
      " |  \n",
      " |  seed\n",
      " |      Seed for pseudo random number generator (if applicable)\n",
      " |      \n",
      " |      Type: ``int``  (default: ``-1``).\n",
      " |  \n",
      " |  solver\n",
      " |      AUTO will set the solver based on given data and the other parameters. IRLSM is fast on on problems with small\n",
      " |      number of predictors and for lambda-search with L1 penalty, L_BFGS scales better for datasets with many columns.\n",
      " |      Coordinate descent is experimental (beta).\n",
      " |      \n",
      " |      One of: ``\"auto\"``, ``\"irlsm\"``, ``\"l_bfgs\"``, ``\"coordinate_descent_naive\"``, ``\"coordinate_descent\"``,\n",
      " |      ``\"gradient_descent_lh\"``, ``\"gradient_descent_sqerr\"``  (default: ``\"auto\"``).\n",
      " |  \n",
      " |  standardize\n",
      " |      Standardize numeric columns to have zero mean and unit variance\n",
      " |      \n",
      " |      Type: ``bool``  (default: ``True``).\n",
      " |  \n",
      " |  training_frame\n",
      " |      Id of the training data frame.\n",
      " |      \n",
      " |      Type: ``H2OFrame``.\n",
      " |  \n",
      " |  tweedie_link_power\n",
      " |      Tweedie link power\n",
      " |      \n",
      " |      Type: ``float``  (default: ``1``).\n",
      " |  \n",
      " |  tweedie_variance_power\n",
      " |      Tweedie variance power\n",
      " |      \n",
      " |      Type: ``float``  (default: ``0``).\n",
      " |  \n",
      " |  validation_frame\n",
      " |      Id of the validation data frame.\n",
      " |      \n",
      " |      Type: ``H2OFrame``.\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",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |  \n",
      " |  algo = 'glm'\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from h2o.estimators.estimator_base.H2OEstimator:\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",
      " |  __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",
      " |  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",
      " |  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",
      " |  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",
      " |  levelone_frame_id(self)\n",
      " |      Fetch the levelone_frame_id for the model, if any.  Currently only used by H2OStackedEnsembleEstimator.\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",
      " |  metalearner(self)\n",
      " |      Print the metalearner for the model, if any.  Currently only used by H2OStackedEnsembleEstimator.\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",
      " |  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, destination_key=None, nbins=20, plot=True, plot_stddev=True, figsize=(7, 10), server=False)\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.\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: ?\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",
      " |  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 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_leaf_node_assignment(self, test_data)\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",
      " |      \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",
      " |  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",
      " |  varimp(self, use_pandas=False)\n",
      " |      Pretty print the variable importances, or return them in a list.\n",
      " |      \n",
      " |      :param 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",
      " |  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",
      " |  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",
      " |  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",
      " |  Methods inherited from h2o.utils.backward_compatibility.BackwardsCompatibleBase:\n",
      " |  \n",
      " |  __getattr__(self, item)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors inherited from h2o.utils.backward_compatibility.BackwardsCompatibleBase:\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": [
    "help(H2OGeneralizedLinearEstimator)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [],
   "source": [
    "glm_orig_0 = H2OGeneralizedLinearEstimator(family = \"binomial\", lambda_search = True,\n",
    "                                           nfolds = cv_nfolds, fold_column = \"cv_fold\")\n",
    "glm_trans_0 = H2OGeneralizedLinearEstimator(family = \"binomial\", lambda_search = True,\n",
    "                                            nfolds = cv_nfolds, fold_column = \"cv_fold\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "glm Model Build progress: |███████████████████████████████████████████████| 100%\n",
      "glm Model Build progress: |███████████████████████████████████████████████| 100%\n"
     ]
    }
   ],
   "source": [
    "glm_orig_0.train(x = x_orig, y = y, training_frame = train, model_id = \"bad_loan_glm_orig_0\")\n",
    "glm_trans_0.train(x = x_trans, y = y, training_frame = train, model_id = \"bad_loan_glm_trans_0\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Log Loss_GLM(orig)  = 0.4477\n",
      "Log Loss_GLM(trans) = 0.4457\n"
     ]
    }
   ],
   "source": [
    "print(\"Log Loss_GLM(orig)  = {:0.4f}\".format(glm_orig_0.logloss(xval = True)))\n",
    "print(\"Log Loss_GLM(trans) = {:0.4f}\".format(glm_trans_0.logloss(xval = True)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AUC_GLM(orig)  = 0.6738\n",
      "AUC_GLM(trans) = 0.6772\n"
     ]
    }
   ],
   "source": [
    "print(\"AUC_GLM(orig)  = {:0.4f}\".format(glm_orig_0.auc(xval = True)))\n",
    "print(\"AUC_GLM(trans) = {:0.4f}\".format(glm_trans_0.auc(xval = True)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Regularization Path"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The [`H2OGeneralizedLinearEstimator.getGLMRegularizationPath`](http://docs.h2o.ai/h2o/latest-stable/h2o-py/docs/modeling.html?highlight=getglmregularizationpath#h2o.estimators.glm.H2OGeneralizedLinearEstimator.getGLMRegularizationPath) method extracts the regularization path from the lambda search."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [],
   "source": [
    "reg_path = H2OGeneralizedLinearEstimator.getGLMRegularizationPath(glm_trans_0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['lambdas', 'explained_deviance_train', 'explained_deviance_valid', 'coefficients', 'coefficients_std'])\n"
     ]
    }
   ],
   "source": [
    "print(reg_path.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>lambdas</th>\n",
       "      <th>explained_deviance_train</th>\n",
       "      <th>Intercept</th>\n",
       "      <th>annual_inc_core</th>\n",
       "      <th>annual_inc_delta</th>\n",
       "      <th>delinq_2yrs_core</th>\n",
       "      <th>delinq_2yrs_delta</th>\n",
       "      <th>dti_core</th>\n",
       "      <th>dti_delta</th>\n",
       "      <th>emp_length</th>\n",
       "      <th>...</th>\n",
       "      <th>longest_credit_length_delta</th>\n",
       "      <th>revol_util_0</th>\n",
       "      <th>revol_util_core</th>\n",
       "      <th>revol_util_delta</th>\n",
       "      <th>te_addr_state</th>\n",
       "      <th>te_purpose</th>\n",
       "      <th>term_60months</th>\n",
       "      <th>total_acc_core</th>\n",
       "      <th>total_acc_delta</th>\n",
       "      <th>verified</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.114482</td>\n",
       "      <td>-1.554312e-13</td>\n",
       "      <td>-1.495893</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>...</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.104312</td>\n",
       "      <td>2.907636e-03</td>\n",
       "      <td>-1.496091</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>...</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.025000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.095045</td>\n",
       "      <td>5.458983e-03</td>\n",
       "      <td>-1.496641</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>...</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.048511</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.086601</td>\n",
       "      <td>7.687483e-03</td>\n",
       "      <td>-1.497478</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>...</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.070564</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.078908</td>\n",
       "      <td>9.966709e-03</td>\n",
       "      <td>-1.498416</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.002666</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>...</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.001528</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.091097</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>0.071898</td>\n",
       "      <td>1.527707e-02</td>\n",
       "      <td>-1.500107</td>\n",
       "      <td>-0.016700</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.015053</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>...</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.017942</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.110452</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>0.065511</td>\n",
       "      <td>2.018967e-02</td>\n",
       "      <td>-1.502328</td>\n",
       "      <td>-0.036021</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.026017</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>...</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.033752</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.129076</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>0.059691</td>\n",
       "      <td>2.447512e-02</td>\n",
       "      <td>-1.505095</td>\n",
       "      <td>-0.054450</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.036161</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>...</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.048754</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.146518</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>0.054388</td>\n",
       "      <td>2.820458e-02</td>\n",
       "      <td>-1.508291</td>\n",
       "      <td>-0.071992</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.045541</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>...</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.062966</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.162835</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>0.049556</td>\n",
       "      <td>3.179152e-02</td>\n",
       "      <td>-1.511836</td>\n",
       "      <td>-0.088584</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.054138</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>...</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.076372</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.006896</td>\n",
       "      <td>0.177920</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>0.045154</td>\n",
       "      <td>3.519768e-02</td>\n",
       "      <td>-1.515714</td>\n",
       "      <td>-0.104250</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.062030</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>...</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.089019</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.019485</td>\n",
       "      <td>0.191857</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>0.041143</td>\n",
       "      <td>3.814529e-02</td>\n",
       "      <td>-1.519842</td>\n",
       "      <td>-0.119080</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.069343</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>...</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.100965</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.031298</td>\n",
       "      <td>0.204852</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>0.037488</td>\n",
       "      <td>4.069010e-02</td>\n",
       "      <td>-1.524133</td>\n",
       "      <td>-0.133083</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.076108</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>...</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.112231</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.042368</td>\n",
       "      <td>0.216958</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>0.034157</td>\n",
       "      <td>4.288202e-02</td>\n",
       "      <td>-1.528515</td>\n",
       "      <td>-0.146282</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.082359</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>...</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.122837</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.052726</td>\n",
       "      <td>0.228216</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>0.031123</td>\n",
       "      <td>4.476019e-02</td>\n",
       "      <td>-1.532759</td>\n",
       "      <td>-0.158630</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.088134</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>...</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.132763</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.062375</td>\n",
       "      <td>0.238656</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>0.028358</td>\n",
       "      <td>4.657201e-02</td>\n",
       "      <td>-1.537192</td>\n",
       "      <td>-0.172718</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.092895</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>...</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.141932</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000920</td>\n",
       "      <td>0.071267</td>\n",
       "      <td>0.246516</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>0.025839</td>\n",
       "      <td>4.854483e-02</td>\n",
       "      <td>-1.541627</td>\n",
       "      <td>-0.187616</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.096663</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>...</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.150508</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.008379</td>\n",
       "      <td>0.079511</td>\n",
       "      <td>0.251976</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17</th>\n",
       "      <td>0.023543</td>\n",
       "      <td>5.046411e-02</td>\n",
       "      <td>-1.546114</td>\n",
       "      <td>-0.198855</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.102151</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>...</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.157442</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.015326</td>\n",
       "      <td>0.087111</td>\n",
       "      <td>0.257118</td>\n",
       "      <td>-0.007081</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>18</th>\n",
       "      <td>0.021452</td>\n",
       "      <td>5.210090e-02</td>\n",
       "      <td>-1.550578</td>\n",
       "      <td>-0.209149</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.107383</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>...</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.163842</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.021759</td>\n",
       "      <td>0.094172</td>\n",
       "      <td>0.261820</td>\n",
       "      <td>-0.014037</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>19</th>\n",
       "      <td>0.019546</td>\n",
       "      <td>5.349673e-02</td>\n",
       "      <td>-1.554974</td>\n",
       "      <td>-0.218852</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.112204</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>...</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.169800</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.027720</td>\n",
       "      <td>0.100711</td>\n",
       "      <td>0.266148</td>\n",
       "      <td>-0.020490</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>20</th>\n",
       "      <td>0.017810</td>\n",
       "      <td>5.469696e-02</td>\n",
       "      <td>-1.559258</td>\n",
       "      <td>-0.228034</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.116494</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>...</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.175322</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.033235</td>\n",
       "      <td>0.106747</td>\n",
       "      <td>0.269715</td>\n",
       "      <td>-0.026477</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.002005</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>21</th>\n",
       "      <td>0.016228</td>\n",
       "      <td>5.585172e-02</td>\n",
       "      <td>-1.563415</td>\n",
       "      <td>-0.236992</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.006053</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.120555</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>...</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.180502</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.038311</td>\n",
       "      <td>0.112240</td>\n",
       "      <td>0.272887</td>\n",
       "      <td>-0.032762</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.004091</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>22</th>\n",
       "      <td>0.014786</td>\n",
       "      <td>5.687064e-02</td>\n",
       "      <td>-1.567477</td>\n",
       "      <td>-0.245687</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.012334</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.124300</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>...</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.185318</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.042992</td>\n",
       "      <td>0.117327</td>\n",
       "      <td>0.275792</td>\n",
       "      <td>-0.038698</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.005919</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>23</th>\n",
       "      <td>0.013472</td>\n",
       "      <td>5.777029e-02</td>\n",
       "      <td>-1.571383</td>\n",
       "      <td>-0.253381</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.018277</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.127853</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>...</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.189813</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.047313</td>\n",
       "      <td>0.122032</td>\n",
       "      <td>0.278590</td>\n",
       "      <td>-0.043574</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.007636</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>24</th>\n",
       "      <td>0.012276</td>\n",
       "      <td>5.859384e-02</td>\n",
       "      <td>-1.576705</td>\n",
       "      <td>-0.260149</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.023855</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.131038</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>...</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.193963</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.051327</td>\n",
       "      <td>0.126312</td>\n",
       "      <td>0.281168</td>\n",
       "      <td>-0.047180</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.009215</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25</th>\n",
       "      <td>0.011185</td>\n",
       "      <td>5.939829e-02</td>\n",
       "      <td>-1.581160</td>\n",
       "      <td>-0.265582</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.029008</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.133933</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>...</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.197783</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.055162</td>\n",
       "      <td>0.130081</td>\n",
       "      <td>0.283846</td>\n",
       "      <td>-0.049840</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.010711</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>26</th>\n",
       "      <td>0.010191</td>\n",
       "      <td>6.007765e-02</td>\n",
       "      <td>-1.585219</td>\n",
       "      <td>-0.270634</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.033739</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.136586</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>...</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.201295</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.058699</td>\n",
       "      <td>0.133534</td>\n",
       "      <td>0.286306</td>\n",
       "      <td>-0.052302</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.012078</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>27</th>\n",
       "      <td>0.009286</td>\n",
       "      <td>6.065077e-02</td>\n",
       "      <td>-1.589024</td>\n",
       "      <td>-0.275325</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.038086</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.139018</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>...</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.204544</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.061960</td>\n",
       "      <td>0.136740</td>\n",
       "      <td>0.288562</td>\n",
       "      <td>-0.054528</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.013328</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>28</th>\n",
       "      <td>0.008461</td>\n",
       "      <td>6.117526e-02</td>\n",
       "      <td>-1.592597</td>\n",
       "      <td>-0.279743</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.042057</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.141296</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>...</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.003827</td>\n",
       "      <td>0.208158</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.064978</td>\n",
       "      <td>0.139655</td>\n",
       "      <td>0.290607</td>\n",
       "      <td>-0.056359</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.014453</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>29</th>\n",
       "      <td>0.007709</td>\n",
       "      <td>6.162677e-02</td>\n",
       "      <td>-1.595897</td>\n",
       "      <td>-0.283915</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.045697</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.143399</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>...</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.008168</td>\n",
       "      <td>0.211673</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.067764</td>\n",
       "      <td>0.142320</td>\n",
       "      <td>0.292436</td>\n",
       "      <td>-0.057983</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.015424</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>30</th>\n",
       "      <td>0.007025</td>\n",
       "      <td>6.200584e-02</td>\n",
       "      <td>-1.598949</td>\n",
       "      <td>-0.287830</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.049037</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.145295</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>...</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.012077</td>\n",
       "      <td>0.214922</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.070328</td>\n",
       "      <td>0.144772</td>\n",
       "      <td>0.294069</td>\n",
       "      <td>-0.059512</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.016359</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>31</th>\n",
       "      <td>0.006400</td>\n",
       "      <td>6.232372e-02</td>\n",
       "      <td>-1.601898</td>\n",
       "      <td>-0.291339</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.052101</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.147061</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>...</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.015615</td>\n",
       "      <td>0.217916</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.072685</td>\n",
       "      <td>0.147025</td>\n",
       "      <td>0.295652</td>\n",
       "      <td>-0.060857</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.017207</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>32</th>\n",
       "      <td>0.005832</td>\n",
       "      <td>6.259017e-02</td>\n",
       "      <td>-1.604725</td>\n",
       "      <td>-0.294582</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.054908</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.148677</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>...</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.018825</td>\n",
       "      <td>0.220683</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.074852</td>\n",
       "      <td>0.149096</td>\n",
       "      <td>0.297107</td>\n",
       "      <td>-0.062082</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.017990</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>33</th>\n",
       "      <td>0.005314</td>\n",
       "      <td>6.281378e-02</td>\n",
       "      <td>-1.607422</td>\n",
       "      <td>-0.297574</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.057480</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.150156</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>...</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.021737</td>\n",
       "      <td>0.223232</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.076843</td>\n",
       "      <td>0.150998</td>\n",
       "      <td>0.298441</td>\n",
       "      <td>-0.063199</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.018702</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>34</th>\n",
       "      <td>0.004842</td>\n",
       "      <td>6.300120e-02</td>\n",
       "      <td>-1.609982</td>\n",
       "      <td>-0.300336</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.059837</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.151510</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>...</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.024380</td>\n",
       "      <td>0.225579</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.078671</td>\n",
       "      <td>0.152744</td>\n",
       "      <td>0.299664</td>\n",
       "      <td>-0.064218</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.019352</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>35</th>\n",
       "      <td>0.004412</td>\n",
       "      <td>6.315816e-02</td>\n",
       "      <td>-1.612403</td>\n",
       "      <td>-0.302882</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.061995</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.152748</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>...</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.026782</td>\n",
       "      <td>0.227738</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.080348</td>\n",
       "      <td>0.154346</td>\n",
       "      <td>0.300785</td>\n",
       "      <td>-0.065146</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.019944</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>36</th>\n",
       "      <td>0.004020</td>\n",
       "      <td>6.328954e-02</td>\n",
       "      <td>-1.614686</td>\n",
       "      <td>-0.305228</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.063970</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.153880</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>...</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.028964</td>\n",
       "      <td>0.229722</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.081886</td>\n",
       "      <td>0.155814</td>\n",
       "      <td>0.301812</td>\n",
       "      <td>-0.065992</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.020484</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>37</th>\n",
       "      <td>0.003663</td>\n",
       "      <td>6.339944e-02</td>\n",
       "      <td>-1.616833</td>\n",
       "      <td>-0.307387</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.065777</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.154915</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>...</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.030948</td>\n",
       "      <td>0.231544</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.083296</td>\n",
       "      <td>0.157161</td>\n",
       "      <td>0.302752</td>\n",
       "      <td>-0.066764</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.020977</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>38</th>\n",
       "      <td>0.003337</td>\n",
       "      <td>6.349132e-02</td>\n",
       "      <td>-1.618847</td>\n",
       "      <td>-0.309372</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.067430</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.155861</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>...</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.032753</td>\n",
       "      <td>0.233217</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.084588</td>\n",
       "      <td>0.158394</td>\n",
       "      <td>0.303613</td>\n",
       "      <td>-0.067467</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.021426</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>39</th>\n",
       "      <td>0.003041</td>\n",
       "      <td>6.356809e-02</td>\n",
       "      <td>-1.620735</td>\n",
       "      <td>-0.311197</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.068942</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.156726</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>...</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.034395</td>\n",
       "      <td>0.234751</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.085771</td>\n",
       "      <td>0.159523</td>\n",
       "      <td>0.304401</td>\n",
       "      <td>-0.068107</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.021836</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>40</th>\n",
       "      <td>0.002771</td>\n",
       "      <td>6.363540e-02</td>\n",
       "      <td>-1.622504</td>\n",
       "      <td>-0.312938</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.070332</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.157486</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000721</td>\n",
       "      <td>...</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.035898</td>\n",
       "      <td>0.236134</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.086839</td>\n",
       "      <td>0.160560</td>\n",
       "      <td>0.305090</td>\n",
       "      <td>-0.068685</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.022207</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>41</th>\n",
       "      <td>0.002524</td>\n",
       "      <td>6.369878e-02</td>\n",
       "      <td>-1.624165</td>\n",
       "      <td>-0.314582</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.071603</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.158494</td>\n",
       "      <td>-0.000892</td>\n",
       "      <td>0.002243</td>\n",
       "      <td>...</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.037207</td>\n",
       "      <td>0.237465</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.087798</td>\n",
       "      <td>0.161500</td>\n",
       "      <td>0.305703</td>\n",
       "      <td>-0.069161</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.022571</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>42</th>\n",
       "      <td>0.002300</td>\n",
       "      <td>6.375470e-02</td>\n",
       "      <td>-1.625696</td>\n",
       "      <td>-0.316149</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.072766</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.159684</td>\n",
       "      <td>-0.002476</td>\n",
       "      <td>0.003640</td>\n",
       "      <td>...</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.038343</td>\n",
       "      <td>0.238755</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.088676</td>\n",
       "      <td>0.162339</td>\n",
       "      <td>0.306257</td>\n",
       "      <td>-0.069521</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.022936</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>43</th>\n",
       "      <td>0.002096</td>\n",
       "      <td>6.380127e-02</td>\n",
       "      <td>-1.627128</td>\n",
       "      <td>-0.317539</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.073810</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.160819</td>\n",
       "      <td>-0.003927</td>\n",
       "      <td>0.004916</td>\n",
       "      <td>...</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.039373</td>\n",
       "      <td>0.239915</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.089479</td>\n",
       "      <td>0.163120</td>\n",
       "      <td>0.306774</td>\n",
       "      <td>-0.069867</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.023266</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>44</th>\n",
       "      <td>0.001910</td>\n",
       "      <td>6.384236e-02</td>\n",
       "      <td>-1.628483</td>\n",
       "      <td>-0.318828</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.074797</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.161862</td>\n",
       "      <td>-0.005256</td>\n",
       "      <td>0.006090</td>\n",
       "      <td>...</td>\n",
       "      <td>0.000761</td>\n",
       "      <td>0.040309</td>\n",
       "      <td>0.240997</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.090212</td>\n",
       "      <td>0.163835</td>\n",
       "      <td>0.307243</td>\n",
       "      <td>-0.070228</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.023570</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>45</th>\n",
       "      <td>0.001740</td>\n",
       "      <td>6.387754e-02</td>\n",
       "      <td>-1.629759</td>\n",
       "      <td>-0.319985</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.075679</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.162819</td>\n",
       "      <td>-0.006471</td>\n",
       "      <td>0.007173</td>\n",
       "      <td>...</td>\n",
       "      <td>0.001832</td>\n",
       "      <td>0.041161</td>\n",
       "      <td>0.242000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.090882</td>\n",
       "      <td>0.164488</td>\n",
       "      <td>0.307685</td>\n",
       "      <td>-0.070516</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.023845</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>46</th>\n",
       "      <td>0.001585</td>\n",
       "      <td>6.390790e-02</td>\n",
       "      <td>-1.630957</td>\n",
       "      <td>-0.321054</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.076488</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.163682</td>\n",
       "      <td>-0.007582</td>\n",
       "      <td>0.008181</td>\n",
       "      <td>...</td>\n",
       "      <td>0.002807</td>\n",
       "      <td>0.041940</td>\n",
       "      <td>0.242948</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.091493</td>\n",
       "      <td>0.165087</td>\n",
       "      <td>0.308088</td>\n",
       "      <td>-0.070832</td>\n",
       "      <td>0.000464</td>\n",
       "      <td>0.024093</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>47 rows × 27 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "     lambdas  explained_deviance_train  Intercept  annual_inc_core  \\\n",
       "0   0.114482             -1.554312e-13  -1.495893         0.000000   \n",
       "1   0.104312              2.907636e-03  -1.496091         0.000000   \n",
       "2   0.095045              5.458983e-03  -1.496641         0.000000   \n",
       "3   0.086601              7.687483e-03  -1.497478         0.000000   \n",
       "4   0.078908              9.966709e-03  -1.498416         0.000000   \n",
       "5   0.071898              1.527707e-02  -1.500107        -0.016700   \n",
       "6   0.065511              2.018967e-02  -1.502328        -0.036021   \n",
       "7   0.059691              2.447512e-02  -1.505095        -0.054450   \n",
       "8   0.054388              2.820458e-02  -1.508291        -0.071992   \n",
       "9   0.049556              3.179152e-02  -1.511836        -0.088584   \n",
       "10  0.045154              3.519768e-02  -1.515714        -0.104250   \n",
       "11  0.041143              3.814529e-02  -1.519842        -0.119080   \n",
       "12  0.037488              4.069010e-02  -1.524133        -0.133083   \n",
       "13  0.034157              4.288202e-02  -1.528515        -0.146282   \n",
       "14  0.031123              4.476019e-02  -1.532759        -0.158630   \n",
       "15  0.028358              4.657201e-02  -1.537192        -0.172718   \n",
       "16  0.025839              4.854483e-02  -1.541627        -0.187616   \n",
       "17  0.023543              5.046411e-02  -1.546114        -0.198855   \n",
       "18  0.021452              5.210090e-02  -1.550578        -0.209149   \n",
       "19  0.019546              5.349673e-02  -1.554974        -0.218852   \n",
       "20  0.017810              5.469696e-02  -1.559258        -0.228034   \n",
       "21  0.016228              5.585172e-02  -1.563415        -0.236992   \n",
       "22  0.014786              5.687064e-02  -1.567477        -0.245687   \n",
       "23  0.013472              5.777029e-02  -1.571383        -0.253381   \n",
       "24  0.012276              5.859384e-02  -1.576705        -0.260149   \n",
       "25  0.011185              5.939829e-02  -1.581160        -0.265582   \n",
       "26  0.010191              6.007765e-02  -1.585219        -0.270634   \n",
       "27  0.009286              6.065077e-02  -1.589024        -0.275325   \n",
       "28  0.008461              6.117526e-02  -1.592597        -0.279743   \n",
       "29  0.007709              6.162677e-02  -1.595897        -0.283915   \n",
       "30  0.007025              6.200584e-02  -1.598949        -0.287830   \n",
       "31  0.006400              6.232372e-02  -1.601898        -0.291339   \n",
       "32  0.005832              6.259017e-02  -1.604725        -0.294582   \n",
       "33  0.005314              6.281378e-02  -1.607422        -0.297574   \n",
       "34  0.004842              6.300120e-02  -1.609982        -0.300336   \n",
       "35  0.004412              6.315816e-02  -1.612403        -0.302882   \n",
       "36  0.004020              6.328954e-02  -1.614686        -0.305228   \n",
       "37  0.003663              6.339944e-02  -1.616833        -0.307387   \n",
       "38  0.003337              6.349132e-02  -1.618847        -0.309372   \n",
       "39  0.003041              6.356809e-02  -1.620735        -0.311197   \n",
       "40  0.002771              6.363540e-02  -1.622504        -0.312938   \n",
       "41  0.002524              6.369878e-02  -1.624165        -0.314582   \n",
       "42  0.002300              6.375470e-02  -1.625696        -0.316149   \n",
       "43  0.002096              6.380127e-02  -1.627128        -0.317539   \n",
       "44  0.001910              6.384236e-02  -1.628483        -0.318828   \n",
       "45  0.001740              6.387754e-02  -1.629759        -0.319985   \n",
       "46  0.001585              6.390790e-02  -1.630957        -0.321054   \n",
       "\n",
       "    annual_inc_delta  delinq_2yrs_core  delinq_2yrs_delta  dti_core  \\\n",
       "0                0.0          0.000000                0.0  0.000000   \n",
       "1                0.0          0.000000                0.0  0.000000   \n",
       "2                0.0          0.000000                0.0  0.000000   \n",
       "3                0.0          0.000000                0.0  0.000000   \n",
       "4                0.0          0.000000                0.0  0.002666   \n",
       "5                0.0          0.000000                0.0  0.015053   \n",
       "6                0.0          0.000000                0.0  0.026017   \n",
       "7                0.0          0.000000                0.0  0.036161   \n",
       "8                0.0          0.000000                0.0  0.045541   \n",
       "9                0.0          0.000000                0.0  0.054138   \n",
       "10               0.0          0.000000                0.0  0.062030   \n",
       "11               0.0          0.000000                0.0  0.069343   \n",
       "12               0.0          0.000000                0.0  0.076108   \n",
       "13               0.0          0.000000                0.0  0.082359   \n",
       "14               0.0          0.000000                0.0  0.088134   \n",
       "15               0.0          0.000000                0.0  0.092895   \n",
       "16               0.0          0.000000                0.0  0.096663   \n",
       "17               0.0          0.000000                0.0  0.102151   \n",
       "18               0.0          0.000000                0.0  0.107383   \n",
       "19               0.0          0.000000                0.0  0.112204   \n",
       "20               0.0          0.000000                0.0  0.116494   \n",
       "21               0.0          0.006053                0.0  0.120555   \n",
       "22               0.0          0.012334                0.0  0.124300   \n",
       "23               0.0          0.018277                0.0  0.127853   \n",
       "24               0.0          0.023855                0.0  0.131038   \n",
       "25               0.0          0.029008                0.0  0.133933   \n",
       "26               0.0          0.033739                0.0  0.136586   \n",
       "27               0.0          0.038086                0.0  0.139018   \n",
       "28               0.0          0.042057                0.0  0.141296   \n",
       "29               0.0          0.045697                0.0  0.143399   \n",
       "30               0.0          0.049037                0.0  0.145295   \n",
       "31               0.0          0.052101                0.0  0.147061   \n",
       "32               0.0          0.054908                0.0  0.148677   \n",
       "33               0.0          0.057480                0.0  0.150156   \n",
       "34               0.0          0.059837                0.0  0.151510   \n",
       "35               0.0          0.061995                0.0  0.152748   \n",
       "36               0.0          0.063970                0.0  0.153880   \n",
       "37               0.0          0.065777                0.0  0.154915   \n",
       "38               0.0          0.067430                0.0  0.155861   \n",
       "39               0.0          0.068942                0.0  0.156726   \n",
       "40               0.0          0.070332                0.0  0.157486   \n",
       "41               0.0          0.071603                0.0  0.158494   \n",
       "42               0.0          0.072766                0.0  0.159684   \n",
       "43               0.0          0.073810                0.0  0.160819   \n",
       "44               0.0          0.074797                0.0  0.161862   \n",
       "45               0.0          0.075679                0.0  0.162819   \n",
       "46               0.0          0.076488                0.0  0.163682   \n",
       "\n",
       "    dti_delta  emp_length    ...     longest_credit_length_delta  \\\n",
       "0    0.000000    0.000000    ...                        0.000000   \n",
       "1    0.000000    0.000000    ...                        0.000000   \n",
       "2    0.000000    0.000000    ...                        0.000000   \n",
       "3    0.000000    0.000000    ...                        0.000000   \n",
       "4    0.000000    0.000000    ...                        0.000000   \n",
       "5    0.000000    0.000000    ...                        0.000000   \n",
       "6    0.000000    0.000000    ...                        0.000000   \n",
       "7    0.000000    0.000000    ...                        0.000000   \n",
       "8    0.000000    0.000000    ...                        0.000000   \n",
       "9    0.000000    0.000000    ...                        0.000000   \n",
       "10   0.000000    0.000000    ...                        0.000000   \n",
       "11   0.000000    0.000000    ...                        0.000000   \n",
       "12   0.000000    0.000000    ...                        0.000000   \n",
       "13   0.000000    0.000000    ...                        0.000000   \n",
       "14   0.000000    0.000000    ...                        0.000000   \n",
       "15   0.000000    0.000000    ...                        0.000000   \n",
       "16   0.000000    0.000000    ...                        0.000000   \n",
       "17   0.000000    0.000000    ...                        0.000000   \n",
       "18   0.000000    0.000000    ...                        0.000000   \n",
       "19   0.000000    0.000000    ...                        0.000000   \n",
       "20   0.000000    0.000000    ...                        0.000000   \n",
       "21   0.000000    0.000000    ...                        0.000000   \n",
       "22   0.000000    0.000000    ...                        0.000000   \n",
       "23   0.000000    0.000000    ...                        0.000000   \n",
       "24   0.000000    0.000000    ...                        0.000000   \n",
       "25   0.000000    0.000000    ...                        0.000000   \n",
       "26   0.000000    0.000000    ...                        0.000000   \n",
       "27   0.000000    0.000000    ...                        0.000000   \n",
       "28   0.000000    0.000000    ...                        0.000000   \n",
       "29   0.000000    0.000000    ...                        0.000000   \n",
       "30   0.000000    0.000000    ...                        0.000000   \n",
       "31   0.000000    0.000000    ...                        0.000000   \n",
       "32   0.000000    0.000000    ...                        0.000000   \n",
       "33   0.000000    0.000000    ...                        0.000000   \n",
       "34   0.000000    0.000000    ...                        0.000000   \n",
       "35   0.000000    0.000000    ...                        0.000000   \n",
       "36   0.000000    0.000000    ...                        0.000000   \n",
       "37   0.000000    0.000000    ...                        0.000000   \n",
       "38   0.000000    0.000000    ...                        0.000000   \n",
       "39   0.000000    0.000000    ...                        0.000000   \n",
       "40   0.000000    0.000721    ...                        0.000000   \n",
       "41  -0.000892    0.002243    ...                        0.000000   \n",
       "42  -0.002476    0.003640    ...                        0.000000   \n",
       "43  -0.003927    0.004916    ...                        0.000000   \n",
       "44  -0.005256    0.006090    ...                        0.000761   \n",
       "45  -0.006471    0.007173    ...                        0.001832   \n",
       "46  -0.007582    0.008181    ...                        0.002807   \n",
       "\n",
       "    revol_util_0  revol_util_core  revol_util_delta  te_addr_state  \\\n",
       "0       0.000000         0.000000               0.0       0.000000   \n",
       "1       0.000000         0.000000               0.0       0.000000   \n",
       "2       0.000000         0.000000               0.0       0.000000   \n",
       "3       0.000000         0.000000               0.0       0.000000   \n",
       "4       0.000000         0.001528               0.0       0.000000   \n",
       "5       0.000000         0.017942               0.0       0.000000   \n",
       "6       0.000000         0.033752               0.0       0.000000   \n",
       "7       0.000000         0.048754               0.0       0.000000   \n",
       "8       0.000000         0.062966               0.0       0.000000   \n",
       "9       0.000000         0.076372               0.0       0.000000   \n",
       "10      0.000000         0.089019               0.0       0.000000   \n",
       "11      0.000000         0.100965               0.0       0.000000   \n",
       "12      0.000000         0.112231               0.0       0.000000   \n",
       "13      0.000000         0.122837               0.0       0.000000   \n",
       "14      0.000000         0.132763               0.0       0.000000   \n",
       "15      0.000000         0.141932               0.0       0.000920   \n",
       "16      0.000000         0.150508               0.0       0.008379   \n",
       "17      0.000000         0.157442               0.0       0.015326   \n",
       "18      0.000000         0.163842               0.0       0.021759   \n",
       "19      0.000000         0.169800               0.0       0.027720   \n",
       "20      0.000000         0.175322               0.0       0.033235   \n",
       "21      0.000000         0.180502               0.0       0.038311   \n",
       "22      0.000000         0.185318               0.0       0.042992   \n",
       "23      0.000000         0.189813               0.0       0.047313   \n",
       "24      0.000000         0.193963               0.0       0.051327   \n",
       "25      0.000000         0.197783               0.0       0.055162   \n",
       "26      0.000000         0.201295               0.0       0.058699   \n",
       "27      0.000000         0.204544               0.0       0.061960   \n",
       "28      0.003827         0.208158               0.0       0.064978   \n",
       "29      0.008168         0.211673               0.0       0.067764   \n",
       "30      0.012077         0.214922               0.0       0.070328   \n",
       "31      0.015615         0.217916               0.0       0.072685   \n",
       "32      0.018825         0.220683               0.0       0.074852   \n",
       "33      0.021737         0.223232               0.0       0.076843   \n",
       "34      0.024380         0.225579               0.0       0.078671   \n",
       "35      0.026782         0.227738               0.0       0.080348   \n",
       "36      0.028964         0.229722               0.0       0.081886   \n",
       "37      0.030948         0.231544               0.0       0.083296   \n",
       "38      0.032753         0.233217               0.0       0.084588   \n",
       "39      0.034395         0.234751               0.0       0.085771   \n",
       "40      0.035898         0.236134               0.0       0.086839   \n",
       "41      0.037207         0.237465               0.0       0.087798   \n",
       "42      0.038343         0.238755               0.0       0.088676   \n",
       "43      0.039373         0.239915               0.0       0.089479   \n",
       "44      0.040309         0.240997               0.0       0.090212   \n",
       "45      0.041161         0.242000               0.0       0.090882   \n",
       "46      0.041940         0.242948               0.0       0.091493   \n",
       "\n",
       "    te_purpose  term_60months  total_acc_core  total_acc_delta  verified  \n",
       "0     0.000000       0.000000        0.000000         0.000000  0.000000  \n",
       "1     0.000000       0.025000        0.000000         0.000000  0.000000  \n",
       "2     0.000000       0.048511        0.000000         0.000000  0.000000  \n",
       "3     0.000000       0.070564        0.000000         0.000000  0.000000  \n",
       "4     0.000000       0.091097        0.000000         0.000000  0.000000  \n",
       "5     0.000000       0.110452        0.000000         0.000000  0.000000  \n",
       "6     0.000000       0.129076        0.000000         0.000000  0.000000  \n",
       "7     0.000000       0.146518        0.000000         0.000000  0.000000  \n",
       "8     0.000000       0.162835        0.000000         0.000000  0.000000  \n",
       "9     0.006896       0.177920        0.000000         0.000000  0.000000  \n",
       "10    0.019485       0.191857        0.000000         0.000000  0.000000  \n",
       "11    0.031298       0.204852        0.000000         0.000000  0.000000  \n",
       "12    0.042368       0.216958        0.000000         0.000000  0.000000  \n",
       "13    0.052726       0.228216        0.000000         0.000000  0.000000  \n",
       "14    0.062375       0.238656        0.000000         0.000000  0.000000  \n",
       "15    0.071267       0.246516        0.000000         0.000000  0.000000  \n",
       "16    0.079511       0.251976        0.000000         0.000000  0.000000  \n",
       "17    0.087111       0.257118       -0.007081         0.000000  0.000000  \n",
       "18    0.094172       0.261820       -0.014037         0.000000  0.000000  \n",
       "19    0.100711       0.266148       -0.020490         0.000000  0.000000  \n",
       "20    0.106747       0.269715       -0.026477         0.000000  0.002005  \n",
       "21    0.112240       0.272887       -0.032762         0.000000  0.004091  \n",
       "22    0.117327       0.275792       -0.038698         0.000000  0.005919  \n",
       "23    0.122032       0.278590       -0.043574         0.000000  0.007636  \n",
       "24    0.126312       0.281168       -0.047180         0.000000  0.009215  \n",
       "25    0.130081       0.283846       -0.049840         0.000000  0.010711  \n",
       "26    0.133534       0.286306       -0.052302         0.000000  0.012078  \n",
       "27    0.136740       0.288562       -0.054528         0.000000  0.013328  \n",
       "28    0.139655       0.290607       -0.056359         0.000000  0.014453  \n",
       "29    0.142320       0.292436       -0.057983         0.000000  0.015424  \n",
       "30    0.144772       0.294069       -0.059512         0.000000  0.016359  \n",
       "31    0.147025       0.295652       -0.060857         0.000000  0.017207  \n",
       "32    0.149096       0.297107       -0.062082         0.000000  0.017990  \n",
       "33    0.150998       0.298441       -0.063199         0.000000  0.018702  \n",
       "34    0.152744       0.299664       -0.064218         0.000000  0.019352  \n",
       "35    0.154346       0.300785       -0.065146         0.000000  0.019944  \n",
       "36    0.155814       0.301812       -0.065992         0.000000  0.020484  \n",
       "37    0.157161       0.302752       -0.066764         0.000000  0.020977  \n",
       "38    0.158394       0.303613       -0.067467         0.000000  0.021426  \n",
       "39    0.159523       0.304401       -0.068107         0.000000  0.021836  \n",
       "40    0.160560       0.305090       -0.068685         0.000000  0.022207  \n",
       "41    0.161500       0.305703       -0.069161         0.000000  0.022571  \n",
       "42    0.162339       0.306257       -0.069521         0.000000  0.022936  \n",
       "43    0.163120       0.306774       -0.069867         0.000000  0.023266  \n",
       "44    0.163835       0.307243       -0.070228         0.000000  0.023570  \n",
       "45    0.164488       0.307685       -0.070516         0.000000  0.023845  \n",
       "46    0.165087       0.308088       -0.070832         0.000464  0.024093  \n",
       "\n",
       "[47 rows x 27 columns]"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reg_path_df = \\\n",
    "    pd.concat([pd.DataFrame({'lambdas': reg_path['lambdas'],\n",
    "                             'explained_deviance_train': reg_path['explained_deviance_train']}),\n",
    "               pd.DataFrame(reg_path['coefficients_std'])], axis = 1)\n",
    "reg_path_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(reg_path_df.iloc[:, 3:27])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Grid Search Over Hyper-Parameters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In general, machine learning models require hyper-parameter tuning to capture the signal in the data without overfitting the noise. To aid in this effort, H2O provides and [`H2OGridSearch`](http://docs.h2o.ai/h2o/latest-stable/h2o-py/docs/modeling.html?highlight=h2ogridsearch#h2o.grid.grid_search.H2OGridSearch) framework to automate hyper-parameter exploration.\n",
    "\n",
    "In the context of logistic regression, the most important hyper-parameter is `alpha`, which balances the importance given to L1 and L2 regularization on the coefficient estimates. When `alpha = 0` only L2 regularization is used (ridge regression), when `alpha = 1` only L1 regularization is used (Least Absolute Shrinkage and Selection Operator (LASSO)), and when `alpha` is somewhere in-between a combination of the two are used (elastic-net)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "source": [
    "from h2o.grid.grid_search import H2OGridSearch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class H2OGridSearch in module h2o.grid.grid_search:\n",
      "\n",
      "class H2OGridSearch(h2o.utils.backward_compatibility.BackwardsCompatibleBase)\n",
      " |  Grid Search of a Hyper-Parameter Space for a Model\n",
      " |  \n",
      " |  :param model: The type of model to be explored initialized with optional parameters that will be\n",
      " |      unchanged across explored models.\n",
      " |  :param hyper_params: A dictionary of string parameters (keys) and a list of values to be explored by grid\n",
      " |      search (values).\n",
      " |  :param str grid_id: The unique id assigned to the resulting grid object. If none is given, an id will\n",
      " |      automatically be generated.\n",
      " |  :param search_criteria:  A dictionary of directives which control the search of the hyperparameter space.\n",
      " |      The default strategy \"Cartesian\" covers the entire space of hyperparameter combinations. Specify the\n",
      " |      \"RandomDiscrete\" strategy to get random search of all the combinations of your hyperparameters.\n",
      " |      RandomDiscrete should usually be combined with at least one early stopping criterion: max_models\n",
      " |      and/or max_runtime_secs, e.g::\n",
      " |  \n",
      " |          >>> criteria = {\"strategy\": \"RandomDiscrete\", \"max_models\": 42,\n",
      " |          ...             \"max_runtime_secs\": 28800, \"seed\": 1234}\n",
      " |          >>> criteria = {\"strategy\": \"RandomDiscrete\", \"stopping_metric\": \"AUTO\",\n",
      " |          ...             \"stopping_tolerance\": 0.001, \"stopping_rounds\": 10}\n",
      " |          >>> criteria = {\"strategy\": \"RandomDiscrete\", \"stopping_rounds\": 5,\n",
      " |          ...             \"stopping_metric\": \"misclassification\",\n",
      " |          ...             \"stopping_tolerance\": 0.00001}\n",
      " |  :returns: a new H2OGridSearch instance\n",
      " |  \n",
      " |  Examples\n",
      " |  --------\n",
      " |      >>> from h2o.grid.grid_search import H2OGridSearch\n",
      " |      >>> from h2o.estimators.glm import H2OGeneralizedLinearEstimator\n",
      " |      >>> hyper_parameters = {'alpha': [0.01,0.5], 'lambda': [1e-5,1e-6]}\n",
      " |      >>> gs = H2OGridSearch(H2OGeneralizedLinearEstimator(family='binomial'), hyper_parameters)\n",
      " |      >>> training_data = h2o.import_file(\"smalldata/logreg/benign.csv\")\n",
      " |      >>> gs.train(x=range(3) + range(4,11),y=3, training_frame=training_data)\n",
      " |      >>> gs.show()\n",
      " |  \n",
      " |  Method resolution order:\n",
      " |      H2OGridSearch\n",
      " |      h2o.utils.backward_compatibility.BackwardsCompatibleBase\n",
      " |      builtins.object\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __getitem__(self, item)\n",
      " |  \n",
      " |  __init__(self, model, hyper_params, grid_id=None, search_criteria=None)\n",
      " |      Initialize self.  See help(type(self)) for accurate signature.\n",
      " |  \n",
      " |  __iter__(self)\n",
      " |  \n",
      " |  __len__(self)\n",
      " |  \n",
      " |  __repr__(self)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  aic(self, train=False, valid=False, xval=False)\n",
      " |      Get the AIC(s).\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(s).\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",
      " |  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",
      " |      :returns: an H2OFrame which represents the bias vector identified by vector_id\n",
      " |  \n",
      " |  build_model(self, algo_params)\n",
      " |      (internal)\n",
      " |  \n",
      " |  catoffsets(self)\n",
      " |      Categorical offsets for one-hot encoding\n",
      " |  \n",
      " |  coef(self)\n",
      " |      Return the coefficients that can be applied to the non-standardized data.\n",
      " |      \n",
      " |      Note: standardize = True by default. If set to False, then coef() returns the coefficients that are fit directly.\n",
      " |  \n",
      " |  coef_norm(self)\n",
      " |      Return coefficients fitted on the standardized data (requires standardize = True, which is on by default). These coefficients can be used to evaluate variable importance.\n",
      " |  \n",
      " |  deepfeatures(self, test_data, layer)\n",
      " |      Obtain a hidden layer's details on a dataset.\n",
      " |      \n",
      " |      :param test_data: Data to create a feature space on.\n",
      " |      :param int layer: Index of the hidden layer.\n",
      " |      :returns: A dictionary of hidden layer details for each model.\n",
      " |  \n",
      " |  get_grid(self, sort_by=None, decreasing=None)\n",
      " |      Retrieve an H2OGridSearch instance.\n",
      " |      \n",
      " |      Optionally specify a metric by which to sort models and a sort order.\n",
      " |      Note that if neither cross-validation nor a validation frame is used in the grid search, then the\n",
      " |      training metrics will display in the \"get grid\" output. If a validation frame is passed to the grid, and\n",
      " |      ``nfolds = 0``, then the validation metrics will display. However, if ``nfolds`` > 1, then cross-validation\n",
      " |      metrics will display even if a validation frame is provided.\n",
      " |      \n",
      " |      :param str sort_by: A metric by which to sort the models in the grid space. Choices are: ``\"logloss\"``,\n",
      " |          ``\"residual_deviance\"``, ``\"mse\"``, ``\"auc\"``, ``\"r2\"``, ``\"accuracy\"``, ``\"precision\"``, ``\"recall\"``,\n",
      " |          ``\"f1\"``, etc.\n",
      " |      :param bool decreasing: Sort the models in decreasing order of metric if true, otherwise sort in increasing\n",
      " |          order (default).\n",
      " |      \n",
      " |      :returns: A new H2OGridSearch instance optionally sorted on the specified metric.\n",
      " |  \n",
      " |  get_hyperparams(self, id, display=True)\n",
      " |      Get the hyperparameters of a model explored by grid search.\n",
      " |      \n",
      " |      :param str id: The model id of the model with hyperparameters of interest.\n",
      " |      :param bool display: Flag to indicate whether to display the hyperparameter names.\n",
      " |      \n",
      " |      :returns: A list of the hyperparameters for the specified model.\n",
      " |  \n",
      " |  get_hyperparams_dict(self, id, display=True)\n",
      " |      Derived and returned the model parameters used to train the particular grid search model.\n",
      " |      \n",
      " |      :param str id: The model id of the model with hyperparameters of interest.\n",
      " |      :param bool display: Flag to indicate whether to display the hyperparameter names.\n",
      " |      \n",
      " |      :returns: A dict of model pararmeters derived from the hyper-parameters used to train this particular model.\n",
      " |  \n",
      " |  get_xval_models(self, key=None)\n",
      " |      Return a Model object.\n",
      " |      \n",
      " |      :param str key: If None, return all cross-validated models; otherwise return the model\n",
      " |          specified by the key.\n",
      " |      :returns: A model or a list of models.\n",
      " |  \n",
      " |  gini(self, train=False, valid=False, xval=False)\n",
      " |      Get the Gini Coefficient(s).\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",
      " |  join(self)\n",
      " |      Wait until grid finishes computing.\n",
      " |  \n",
      " |  logloss(self, train=False, valid=False, xval=False)\n",
      " |      Get the Log Loss(s).\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 binomial model.\n",
      " |  \n",
      " |  mean_residual_deviance(self, train=False, valid=False, xval=False)\n",
      " |      Get the Mean Residual Deviances(s).\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",
      " |      :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 test_data: Data set for which model metrics shall be computed against. All three of train, valid\n",
      " |          and xval arguments are ignored if test_data is not None.\n",
      " |      :param train: Report the training metrics for the model.\n",
      " |      :param valid: Report the validation metrics for the model.\n",
      " |      :param xval: Report the validation metrics for the model.\n",
      " |      :return: An object of class H2OModelMetrics.\n",
      " |  \n",
      " |  mse(self, train=False, valid=False, xval=False)\n",
      " |      Get the MSE(s).\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",
      " |      :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",
      " |  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",
      " |      :param bool xval: Get the null dof for the cross-validated models.\n",
      " |      \n",
      " |      :returns: 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\n",
      " |          train is selected by default.\n",
      " |      :param bool valid: Get the null deviance for the validation set. If both train and valid are True, then\n",
      " |          train is selected by default.\n",
      " |      :param bool xval: Get the null deviance for the cross-validated models.\n",
      " |      \n",
      " |      :returns: the null deviance, or None if it is not present.\n",
      " |  \n",
      " |  pprint_coef(self)\n",
      " |      Pretty print the coefficents table (includes normalized coefficients).\n",
      " |  \n",
      " |  predict(self, test_data)\n",
      " |      Predict on a dataset.\n",
      " |      \n",
      " |      :param H2OFrame test_data: Data to be predicted on.\n",
      " |      :returns: H2OFrame filled with predictions.\n",
      " |  \n",
      " |  r2(self, train=False, valid=False, xval=False)\n",
      " |      Return the R^2 for this regression model.\n",
      " |      \n",
      " |      The R^2 value is defined to be ``1 - MSE/var``, where ``var`` is computed as ``sigma^2``.\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^2 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\n",
      " |          train is selected by default.\n",
      " |      :param bool valid: Get the residual dof for the validation set. If both train and valid are True, then\n",
      " |          train is selected by default.\n",
      " |      :param bool xval: Get the residual dof for the cross-validated models.\n",
      " |      \n",
      " |      :returns: the residual degrees of freedom, or None if they are not present.\n",
      " |  \n",
      " |  residual_deviance(self, train=False, valid=False, xval=False)\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,\n",
      " |          then train is selected by default.\n",
      " |      :param bool valid: Get the residual deviance for the validation set. If both train and valid are True,\n",
      " |          then train is selected by default.\n",
      " |      :param bool xval: Get the residual deviance for the cross-validated models.\n",
      " |      \n",
      " |      :returns: 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",
      " |  scoring_history(self)\n",
      " |      Retrieve model scoring history.\n",
      " |      \n",
      " |      :returns: Score history (H2OTwoDimTable)\n",
      " |  \n",
      " |  show(self)\n",
      " |      Print models sorted by metric.\n",
      " |  \n",
      " |  sort_by(*args, **kwargs)\n",
      " |      grid.sort_by() is deprecated; use grid.get_grid() instead\n",
      " |  \n",
      " |  sorted_metric_table(self)\n",
      " |      Retrieve summary table of an H2O Grid Search.\n",
      " |      \n",
      " |      :returns: The summary table as an H2OTwoDimTable or a Pandas DataFrame.\n",
      " |  \n",
      " |  start(self, x, y=None, training_frame=None, offset_column=None, fold_column=None, weights_column=None, validation_frame=None, **params)\n",
      " |      Asynchronous model build by specifying the predictor columns, response column, and any\n",
      " |      additional frame-specific values.\n",
      " |      \n",
      " |      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 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",
      " |  summary(self, header=True)\n",
      " |      Print a detailed summary of the explored models.\n",
      " |  \n",
      " |  train(self, x=None, y=None, training_frame=None, offset_column=None, fold_column=None, weights_column=None, validation_frame=None, **params)\n",
      " |      Train the model synchronously (i.e. do not return until the model finishes training).\n",
      " |      \n",
      " |      To train asynchronously call :meth:`start`.\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 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",
      " |  varimp(self, use_pandas=False)\n",
      " |      Pretty print the variable importances, or return them in a list/pandas DataFrame.\n",
      " |      \n",
      " |      :param bool use_pandas: If True, then the variable importances will be returned as a pandas data frame.\n",
      " |      \n",
      " |      :returns: A dictionary of lists or Pandas DataFrame instances.\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",
      " |      :returns: an H2OFrame which represents the weight matrix identified by matrix_id\n",
      " |  \n",
      " |  xval_keys(self)\n",
      " |      Model keys for the cross-validated model.\n",
      " |  \n",
      " |  xvals(self)\n",
      " |      Return the list of cross-validated models.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  failed_params\n",
      " |  \n",
      " |  failed_raw_params\n",
      " |  \n",
      " |  failure_details\n",
      " |  \n",
      " |  failure_stack_traces\n",
      " |  \n",
      " |  grid_id\n",
      " |      A key that identifies this grid search object in H2O.\n",
      " |  \n",
      " |  hyper_names\n",
      " |  \n",
      " |  model_ids\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from h2o.utils.backward_compatibility.BackwardsCompatibleBase:\n",
      " |  \n",
      " |  __getattr__(self, item)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors inherited from h2o.utils.backward_compatibility.BackwardsCompatibleBase:\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": [
    "help(H2OGridSearch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "glm Grid Build progress: |████████████████████████████████████████████████| 100%\n",
      "glm Grid Build progress: |████████████████████████████████████████████████| 100%\n",
      "glm Grid Build progress: |████████████████████████████████████████████████| 100%\n",
      "glm Grid Build progress: |████████████████████████████████████████████████| 100%\n",
      "glm Grid Build progress: |████████████████████████████████████████████████| 100%\n",
      "glm Grid Build progress: |████████████████████████████████████████████████| 100%\n",
      "glm Grid Build progress: |████████████████████████████████████████████████| 100%\n",
      "glm Grid Build progress: |████████████████████████████████████████████████| 100%\n",
      "glm Grid Build progress: |████████████████████████████████████████████████| 100%\n",
      "glm Grid Build progress: |████████████████████████████████████████████████| 100%\n",
      "glm Grid Build progress: |████████████████████████████████████████████████| 100%\n",
      "glm Grid Build progress: |████████████████████████████████████████████████| 100%\n",
      "glm Grid Build progress: |████████████████████████████████████████████████| 100%\n",
      "glm Grid Build progress: |████████████████████████████████████████████████| 100%\n",
      "glm Grid Build progress: |████████████████████████████████████████████████| 100%\n",
      "glm Grid Build progress: |████████████████████████████████████████████████| 100%\n",
      "glm Grid Build progress: |████████████████████████████████████████████████| 100%\n",
      "glm Grid Build progress: |████████████████████████████████████████████████| 100%\n",
      "glm Grid Build progress: |████████████████████████████████████████████████| 100%\n",
      "glm Grid Build progress: |████████████████████████████████████████████████| 100%\n",
      "glm Grid Build progress: |████████████████████████████████████████████████| 100%\n",
      "glm Grid Build progress: |████████████████████████████████████████████████| 100%\n"
     ]
    }
   ],
   "source": [
    "glm_hyper_parameters = {\"alpha\": [0.05, 0.5, 0.95]}\n",
    "\n",
    "j = 0\n",
    "while j < len(x_trans):\n",
    "    j = j + 1\n",
    "    glm_grid = H2OGridSearch(H2OGeneralizedLinearEstimator(family = \"binomial\", lambda_search = True,\n",
    "                                                           fold_column = \"cv_fold\",\n",
    "                                                           keep_cross_validation_predictions = True,\n",
    "                                                           max_active_predictors = j),\n",
    "                             glm_hyper_parameters)\n",
    "    glm_grid.train(x = x_trans, y = y, training_frame = train, grid_id = \"bad_loan_glm_grid\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "        alpha                   model_ids              logloss\n",
      "0      [0.05]  bad_loan_glm_grid_model_60  0.44575379665894127\n",
      "1      [0.05]  bad_loan_glm_grid_model_63   0.4457543478932118\n",
      "2      [0.05]  bad_loan_glm_grid_model_57   0.4457581913003404\n",
      "3      [0.95]  bad_loan_glm_grid_model_53  0.44577010351867563\n",
      "4      [0.95]  bad_loan_glm_grid_model_56   0.4457705343610416\n",
      "5      [0.95]  bad_loan_glm_grid_model_62   0.4457705343610416\n",
      "6      [0.95]  bad_loan_glm_grid_model_59   0.4457705343610416\n",
      "7      [0.95]  bad_loan_glm_grid_model_65   0.4457705343610416\n",
      "8       [0.5]  bad_loan_glm_grid_model_61  0.44577054890084056\n",
      "9       [0.5]  bad_loan_glm_grid_model_55  0.44577054890084056\n",
      "10      [0.5]  bad_loan_glm_grid_model_58  0.44577054890084056\n",
      "11      [0.5]  bad_loan_glm_grid_model_64  0.44577054890084056\n",
      "12     [0.95]  bad_loan_glm_grid_model_47   0.4457708230897978\n",
      "13      [0.5]  bad_loan_glm_grid_model_46   0.4457713492545339\n",
      "14     [0.95]  bad_loan_glm_grid_model_50   0.4457714294809969\n",
      "15      [0.5]  bad_loan_glm_grid_model_49  0.44577213888648637\n",
      "16      [0.5]  bad_loan_glm_grid_model_52   0.4457727670425298\n",
      "17     [0.05]  bad_loan_glm_grid_model_51  0.44578604676815975\n",
      "18     [0.05]  bad_loan_glm_grid_model_54  0.44578705065698077\n",
      "19     [0.05]  bad_loan_glm_grid_model_48  0.44586126759240374\n",
      "20     [0.05]  bad_loan_glm_grid_model_45    0.445900308003022\n",
      "21     [0.95]  bad_loan_glm_grid_model_44    0.445917749804053\n",
      "22      [0.5]  bad_loan_glm_grid_model_43    0.445918992771017\n",
      "23     [0.95]  bad_loan_glm_grid_model_41   0.4459712124096708\n",
      "24      [0.5]  bad_loan_glm_grid_model_40  0.44598198841457803\n",
      "25     [0.95]  bad_loan_glm_grid_model_38  0.44634411985482225\n",
      "26      [0.5]  bad_loan_glm_grid_model_37  0.44635048273150557\n",
      "27     [0.05]  bad_loan_glm_grid_model_42  0.44635507182760475\n",
      "28     [0.05]  bad_loan_glm_grid_model_39  0.44644508930526916\n",
      "29     [0.95]  bad_loan_glm_grid_model_35  0.44646773143763296\n",
      ".. ..     ...                         ...                  ...\n",
      "36     [0.05]  bad_loan_glm_grid_model_30  0.44703257821128917\n",
      "37     [0.95]  bad_loan_glm_grid_model_29  0.44703705031072943\n",
      "38     [0.05]  bad_loan_glm_grid_model_27  0.44704073944248074\n",
      "39     [0.95]  bad_loan_glm_grid_model_26  0.44712950757511827\n",
      "40      [0.5]  bad_loan_glm_grid_model_25  0.44722852494599746\n",
      "41     [0.95]  bad_loan_glm_grid_model_23  0.44748336314091924\n",
      "42     [0.05]  bad_loan_glm_grid_model_24   0.4475576304832919\n",
      "43      [0.5]  bad_loan_glm_grid_model_22  0.44763037925053506\n",
      "44     [0.95]  bad_loan_glm_grid_model_20  0.44801550761604686\n",
      "45     [0.05]  bad_loan_glm_grid_model_21   0.4480741414857037\n",
      "46      [0.5]  bad_loan_glm_grid_model_19   0.4481447377496844\n",
      "47     [0.05]  bad_loan_glm_grid_model_18    0.448486289920663\n",
      "48      [0.5]  bad_loan_glm_grid_model_16  0.44872573729054027\n",
      "49     [0.95]  bad_loan_glm_grid_model_17  0.44891482640245634\n",
      "50     [0.05]  bad_loan_glm_grid_model_15   0.4494720909021964\n",
      "51     [0.95]  bad_loan_glm_grid_model_14   0.4497055493509229\n",
      "52      [0.5]  bad_loan_glm_grid_model_13   0.4497101191165593\n",
      "53     [0.05]  bad_loan_glm_grid_model_12   0.4497214668522089\n",
      "54     [0.95]  bad_loan_glm_grid_model_11   0.4519035205312204\n",
      "55      [0.5]  bad_loan_glm_grid_model_10  0.45191137987410945\n",
      "56     [0.05]   bad_loan_glm_grid_model_9  0.45193366358482423\n",
      "57     [0.95]   bad_loan_glm_grid_model_8   0.4581993112325942\n",
      "58      [0.5]   bad_loan_glm_grid_model_7    0.458200420638772\n",
      "59     [0.05]   bad_loan_glm_grid_model_6  0.45821788261748536\n",
      "60     [0.95]   bad_loan_glm_grid_model_5  0.46160055664033084\n",
      "61      [0.5]   bad_loan_glm_grid_model_4   0.4616073258502808\n",
      "62     [0.05]   bad_loan_glm_grid_model_3  0.46162282840051594\n",
      "63     [0.95]   bad_loan_glm_grid_model_2  0.46608531288212496\n",
      "64      [0.5]   bad_loan_glm_grid_model_1   0.4661000073584618\n",
      "65     [0.05]   bad_loan_glm_grid_model_0  0.46611408199163773\n",
      "\n",
      "[66 rows x 4 columns]\n"
     ]
    }
   ],
   "source": [
    "glm_grid.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(146235.23993205334, 'bad_loan_glm_grid_model_47'),\n",
       " (146235.4125004065, 'bad_loan_glm_grid_model_46'),\n",
       " (146237.43881260048, 'bad_loan_glm_grid_model_50'),\n",
       " (146237.67147915644, 'bad_loan_glm_grid_model_49'),\n",
       " (146239.00393143413, 'bad_loan_glm_grid_model_53'),\n",
       " (146239.09703353784, 'bad_loan_glm_grid_model_57'),\n",
       " (146239.65570541957, 'bad_loan_glm_grid_model_60'),\n",
       " (146239.83649592823, 'bad_loan_glm_grid_model_63'),\n",
       " (146239.87749800668, 'bad_loan_glm_grid_model_52'),\n",
       " (146241.14523652825, 'bad_loan_glm_grid_model_56'),\n",
       " (146241.14523652825, 'bad_loan_glm_grid_model_59'),\n",
       " (146241.14523652825, 'bad_loan_glm_grid_model_62'),\n",
       " (146241.14523652825, 'bad_loan_glm_grid_model_65'),\n",
       " (146241.15000520425, 'bad_loan_glm_grid_model_55'),\n",
       " (146243.15000520425, 'bad_loan_glm_grid_model_58'),\n",
       " (146243.15000520425, 'bad_loan_glm_grid_model_61'),\n",
       " (146243.15000520425, 'bad_loan_glm_grid_model_64'),\n",
       " (146244.23290274042, 'bad_loan_glm_grid_model_51'),\n",
       " (146246.5621521726, 'bad_loan_glm_grid_model_54'),\n",
       " (146266.90337735103, 'bad_loan_glm_grid_model_48'),\n",
       " (146277.70761698313, 'bad_loan_glm_grid_model_45'),\n",
       " (146281.42807423449, 'bad_loan_glm_grid_model_44'),\n",
       " (146281.83573508152, 'bad_loan_glm_grid_model_43'),\n",
       " (146296.96241884935, 'bad_loan_glm_grid_model_41'),\n",
       " (146300.49666828284, 'bad_loan_glm_grid_model_40'),\n",
       " (146417.26636526547, 'bad_loan_glm_grid_model_38'),\n",
       " (146419.35322338282, 'bad_loan_glm_grid_model_37'),\n",
       " (146424.85832758684, 'bad_loan_glm_grid_model_42'),\n",
       " (146452.38171980635, 'bad_loan_glm_grid_model_39'),\n",
       " (146455.80775052626, 'bad_loan_glm_grid_model_35'),\n",
       " (146462.73167004765, 'bad_loan_glm_grid_model_34'),\n",
       " (146532.96514710854, 'bad_loan_glm_grid_model_31'),\n",
       " (146536.35577763477, 'bad_loan_glm_grid_model_32'),\n",
       " (146576.80622183107, 'bad_loan_glm_grid_model_36'),\n",
       " (146608.89326525043, 'bad_loan_glm_grid_model_33'),\n",
       " (146635.249633903, 'bad_loan_glm_grid_model_28'),\n",
       " (146638.52953861118, 'bad_loan_glm_grid_model_29'),\n",
       " (146639.06280626936, 'bad_loan_glm_grid_model_30'),\n",
       " (146639.73947790818, 'bad_loan_glm_grid_model_27'),\n",
       " (146666.85311744185, 'bad_loan_glm_grid_model_26'),\n",
       " (146699.32824063857, 'bad_loan_glm_grid_model_25'),\n",
       " (146780.90854277986, 'bad_loan_glm_grid_model_23'),\n",
       " (146807.2663001272, 'bad_loan_glm_grid_model_24'),\n",
       " (146829.12600431498, 'bad_loan_glm_grid_model_22'),\n",
       " (146953.43809486536, 'bad_loan_glm_grid_model_20'),\n",
       " (146974.66847963218, 'bad_loan_glm_grid_model_21'),\n",
       " (146995.82221871498, 'bad_loan_glm_grid_model_19'),\n",
       " (147107.84245043952, 'bad_loan_glm_grid_model_18'),\n",
       " (147184.37496212765, 'bad_loan_glm_grid_model_16'),\n",
       " (147246.3912745192, 'bad_loan_glm_grid_model_17'),\n",
       " (147429.15954155696, 'bad_loan_glm_grid_model_15'),\n",
       " (147503.7278428196, 'bad_loan_glm_grid_model_14'),\n",
       " (147505.22660713445, 'bad_loan_glm_grid_model_13'),\n",
       " (147508.94836938634, 'bad_loan_glm_grid_model_12'),\n",
       " (148222.6052427065, 'bad_loan_glm_grid_model_11'),\n",
       " (148225.18290283118, 'bad_loan_glm_grid_model_10'),\n",
       " (148232.49138056915, 'bad_loan_glm_grid_model_9'),\n",
       " (150285.4609021989, 'bad_loan_glm_grid_model_8'),\n",
       " (150285.8247585806, 'bad_loan_glm_grid_model_7'),\n",
       " (150291.55183358715, 'bad_loan_glm_grid_model_6'),\n",
       " (151398.9809635559, 'bad_loan_glm_grid_model_5'),\n",
       " (151401.20108842, 'bad_loan_glm_grid_model_4'),\n",
       " (151406.2855218308, 'bad_loan_glm_grid_model_3'),\n",
       " (152867.86440720205, 'bad_loan_glm_grid_model_2'),\n",
       " (152872.68381338415, 'bad_loan_glm_grid_model_1'),\n",
       " (152877.2999271254, 'bad_loan_glm_grid_model_0')]"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted((v, k) for (k,v) in glm_grid.aic(xval = True).items())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Number of non-zero coefs = 22'"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "glm_best = glm_grid.models[0]\n",
    "\"Number of non-zero coefs = {}\".format(sum(x != 0 for x in glm_best.coef().values()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "glm_best.std_coef_plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "glm_best.model_performance(xval = True).plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "glm prediction progress: |████████████████████████████████████████████████| 100%\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "<thead>\n",
       "<tr><th style=\"text-align: right;\">  predict</th><th style=\"text-align: right;\">      p0</th><th style=\"text-align: right;\">       p1</th></tr>\n",
       "</thead>\n",
       "<tbody>\n",
       "<tr><td style=\"text-align: right;\">        0</td><td style=\"text-align: right;\">0.96999 </td><td style=\"text-align: right;\">0.03001  </td></tr>\n",
       "<tr><td style=\"text-align: right;\">        0</td><td style=\"text-align: right;\">0.807572</td><td style=\"text-align: right;\">0.192428 </td></tr>\n",
       "<tr><td style=\"text-align: right;\">        0</td><td style=\"text-align: right;\">0.866912</td><td style=\"text-align: right;\">0.133088 </td></tr>\n",
       "<tr><td style=\"text-align: right;\">        0</td><td style=\"text-align: right;\">0.952953</td><td style=\"text-align: right;\">0.0470467</td></tr>\n",
       "<tr><td style=\"text-align: right;\">        0</td><td style=\"text-align: right;\">0.901452</td><td style=\"text-align: right;\">0.0985483</td></tr>\n",
       "<tr><td style=\"text-align: right;\">        1</td><td style=\"text-align: right;\">0.787788</td><td style=\"text-align: right;\">0.212212 </td></tr>\n",
       "<tr><td style=\"text-align: right;\">        1</td><td style=\"text-align: right;\">0.650202</td><td style=\"text-align: right;\">0.349798 </td></tr>\n",
       "<tr><td style=\"text-align: right;\">        1</td><td style=\"text-align: right;\">0.685619</td><td style=\"text-align: right;\">0.314381 </td></tr>\n",
       "<tr><td style=\"text-align: right;\">        1</td><td style=\"text-align: right;\">0.768092</td><td style=\"text-align: right;\">0.231908 </td></tr>\n",
       "<tr><td style=\"text-align: right;\">        0</td><td style=\"text-align: right;\">0.828937</td><td style=\"text-align: right;\">0.171063 </td></tr>\n",
       "</tbody>\n",
       "</table>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": []
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "glm_best.predict(train)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}