## Stacked Ensembles and Word2Vec now available in H2O!

Prepared by: Erin LeDell and Navdeep Gill

## Stacked Ensembles

H2O’s new Stacked Ensemble method is a supervised ensemble machine learning algorithm that finds the optimal combination of a collection of prediction algorithms using a process called stacking or “Super Learning.” This method currently supports regression and binary classification, and multiclass support is planned for a future release. A full list of the planned features for Stacked Ensemble can be viewed here.

H2O previously has supported the creation of ensembles of H2O models through a separate implementation, the h2oEnsemble R package, which is still available and will continue to be maintained, however for new projects we’d recommend using the native H2O version. Native support for stacking in the H2O backend brings support for ensembles to all the H2O APIs.

Creating ensembles of H2O models is now dead simple. You simply pass a list of existing H2O model ids to the stacked ensemble function and you are ready to go. This list of models can be a set of manually created H2O models, a random grid of models (of GBMs, for example), or set of grids of different algorithms. Typically, the more diverse the collection of base models, the better the ensemble performance. Thus, using H2O’s Random Grid Search to generate a collection of random models is a handy way of quickly generating a set of base models for the ensemble.

R:

ensemble <- h2o.stackedEnsemble(x = x, y = y, training_frame = train, base_models = my_models)

Python:

ensemble = H2OStackedEnsembleEstimator(base_models=my_models)
ensemble.train(x=x, y=y, training_frame=train)

Full R and Python code examples are available on the Stacked Ensembles docs page. Kagglers rejoice!

## Word2Vec



H2O now has a full implementation of Word2Vec. Word2Vec is a group of related models that are used to produce word embeddings (a language modeling/feature engineering technique in natural language processing where words or phrases are mapped to vectors of real numbers). The word embeddings can subsequently be used in a machine learning model, for example, GBM. This allows user to utilize text based data with current H2O algorithms in a very efficient manner. An R example is available here.

### Technical Details

H2O’s Word2Vec is based on the skip-gram model. The training objective of skip-gram is to learn word vector representations that are good at predicting its context in the same sentence. Mathematically, given a sequence of training words $w_1, w_2, \dots, w_T$, the objective of the skip-gram model is to maximize the average log-likelihood

$$\frac{1}{T} \sum_{t = 1}^{T}\sum_{j=-k}^{j=k} \log p(w_{t+j} | w_t)$$

where $k$ is the size of the training window.
In the skip-gram model, every word w is associated with two vectors $u_w$ and $v_w$ which are vector representations of $w$ as word and context respectively. The probability of correctly predicting word $w_i$ given word $w_j$ is determined by the softmax model, which is

$$p(w_i | w_j ) = \frac{\exp(u_{w_i}^{\top}v_{w_j})}{\sum_{l=1}^{V} \exp(u_l^{\top}v_{w_j})}$$

where $V$ is the vocabulary size.
The skip-gram model with softmax is expensive because the cost of computing $\log p(w_i | w_j)$ is proportional to $V$, which can be easily in order of millions. To speed up training of Word2Vec, we used hierarchical softmax, which reduced the complexity of computing of $\log p(w_i | w_j)$ to $O(\log(V))$

## Tverberg Release (H2O 3.10.3.4)

Below is a detailed list of all the items that are part of the Tverberg release.

List of New Features:

PUBDEV-2058- Implement word2vec in h2o (To use this feature in R, please visit this demo)
PUBDEV-3635- Ability to Select Columns for PDP computation in Flow (With this enhancement, users will be able to select which features/columns to render Partial Dependence Plots from Flow. (R/Python supported already). Known issue PUBDEV-3782: when nbins < categorical levels, PDP won't compute. Please visit also this post.)
PUBDEV-3881- Add PCA Estimator documentation to Python API Docs
PUBDEV-3902- Documentation: Add information about Azure support to H2O User Guide (Beta)
PUBDEV-3739- StackedEnsemble: put ensemble creation into the back end.

List of Improvements:

PUBDEV-3989- Decrease size of h2o.jar
PUBDEV-3257- Documentation: As a K-Means user, I want to be able to better understand the parameters
PUBDEV-3741- StackedEnsemble: add tests in R and Python to ensure that a StackedEnsemble performs at least as well as the base_models
PUBDEV-3857- Clean up the generated Python docs
PUBDEV-3895- Filter H2OFrame on pandas dates and time (python)
PUBDEV-3912- Provide way to specify context_path via Python/R h2o.init methods
PUBDEV-3933- Modify gen_R.py for Stacked Ensemble
PUBDEV-3972- Add Stacked Ensemble code examples to Python docstrings

List of Bugs:

PUBDEV-2464- Using asfactor() in Python client cannot allocate to a variable
PUBDEV-3111- R API's h2o.interaction() does not use destination_frame argument
PUBDEV-3694- Errors with PCA on wide data for pca_method = GramSVD which is the default
PUBDEV-3742- StackedEnsemble should work for regression
PUBDEV-3865- h2o gbm : for an unseen categorical level, discrepancy in predictions when score using h2o vs pojo/mojo
PUBDEV-3883- Negative indexing for H2OFrame is buggy in R API
PUBDEV-3894- Relational operators don't work properly with time columns.
PUBDEV-3966- java.lang.AssertionError when using h2o.makeGLMModel
PUBDEV-3835- Standard Errors in GLM: calculating and showing specifically when called
PUBDEV-3965- Importing data in python returns error - TypeError: expected string or bytes-like object
Hotfix: Remove StackedEnsemble from Flow UI. Training is only supported from Python and R interfaces. Viewing is supported in the Flow UI.

PUBDEV-3336- h2o.create_frame(): if randomize=True, value param cannot be used
PUBDEV-3740- REST: implement simple ensemble generation API
PUBDEV-3843- Modify R REST API to always return binary data
PUBDEV-3844- Safe GET calls for POJO/MOJO/genmodel
PUBDEV-3864- Import files by pattern
PUBDEV-3884- StackedEnsemble: Add to online documentation
PUBDEV-3940- Add Stacked Ensemble code examples to R docs

## Behind the scenes of CRAN

(Just from my point of view as a package maintainer.)

New users of R might not appreciate the full benefit of CRAN and new package maintainers may not appreciate the importance of keeping their packages updated and free of warnings and errors. This is something I only came to realize myself in the last few years so I thought I would write about it, by way of today’s example.

Since data.table was updated on CRAN on 3rd December, it has been passing all-OK. But today I noticed a new warning (converted to error by data.table) on one CRAN machine. This is displayed under the CRAN checks link.

Sometimes errors happen for mundane reasons. For example, one of the Windows machines was in error recently because somehow the install became locked. That either fixed itself or someone spent time fixing it (if so, thank you). Today’s issue appears to be different.

I can either look lower down on that page or click the link to see the message.

Calling 'structure(NULL, *)' is deprecated, as NULL cannot have attributes.

I’ve never seen this message before. But given it mentions something about something being deprecated and the flavor name is r-devel it looks likely that it has just been added to R itself in development. On a daily basis all CRAN packages are retested with the very latest commits to R that day. I did a quick scan of the latest commit messages to R but I couldn’t see anything relating to this apparently new warning. Some of the commit messages are long with detail right there in the message. Others are short and use reference numbers that require you to hop to that reference such as “port r71828 from trunk” which prevent fast scanning at times like this. There is more hunting I could do, but for now, let’s see if I get lucky.

The last line of data.table’s test suite output has been refined over the years for my future self, and on the same CRAN page without me needing to go anywhere else, it is showing me today:

5 errors out of 5940 (lastID=1748.4, endian==little, sizeof(long double)==16, sizeof(pointer)==8) in inst/tests/tests.Rraw on Tue Dec 27 18:09:48 2016. Search tests.Rraw for test numbers: 167, 167.1, 167.2, 168, 168.1.

The date and time is included to double check to myself that it really did run on CRAN’s machine recently and I’m not seeing an old stale result that would disappear when simply rerun with latest commits/fixes.

Next I do what I told myself and open tests.Rraw file in my editor and search for "test(167". Immediately, I see this test is within a block of code starting with :

if ("package:ggplot2" %in% search()) {
test(167, ...
}

In data.table we test compatibility of data.table with a bunch of popular packages. These packages are listed in the Suggests suggestion of DESCRIPTION.

Suggests: bit64, knitr, chron, ggplot2 (≥ 0.9.0), plyr, reshape, reshape2, testthat (≥ 0.4), hexbin, fastmatch, nlme, xts, gdata, GenomicRanges, caret, curl, zoo, plm, rmarkdown, parallel

We do not necessarily suggest these packages in the English sense of the verb; i.e., ‘to recommend’. Rather, perhaps a better name for that field would be Optional in the sense that you need those packages installed if you wish to run all tests, documentation and in data.table’s case, compatibility.

Anyway, now that I know that the failing tests are testing compatibility with ggplot2, I’ll click over to ggplot2 and look at its status. I’m hoping I’ll get lucky and ggplot2 is in error too.

Indeed it is. And I can see the same message on ggplot2’s CRAN checks page.

Calling 'structure(NULL, *)' is deprecated, as NULL cannot have attributes.

It’s my lucky day. ggplot2 is in error too with the same message. This time, thankfully, the new warning is therefore nothing to do with data.table per se. I got to this point in under 30 seconds! No typing was required to run anything at all. It was all done just by clicking within CRAN’s pages and searching a file. My task is done and I can move on. Thanks to CRAN and the people that run it.

What if data.table or ggplot2 were already in error or warning before R-core made their change? R-core members wouldn’t have seen any status change. If they see no status change for any of the 9,787 CRAN packages then they don’t know for sure it’s ok. All they know is their change didn’t affect any of the passing packages but they can’t be sure about the packages which are already in error or warning for an unrelated reason. I get more requests from R-core and CRAN maintainers to update data.table than from users of data.table. I’m sorry that I could not find time earlier in 2016 to update data.table than I did (data.table was showing an error for many months).

Regarding today’s warning, it has been caught before it gets to users. You will never be aware it ever happened. Either R-core will revert this change, or ggplot2 will be asked to send an update to CRAN before this change in R is released.

This is one reason why packages need to be on CRAN not just on GitHub. Not just so they are available to users most easily but so they are under the watchful eye of CRAN daily tests on all platforms.

Now that data.table is used by 320 CRAN and Bioconductor packages, I’m experiencing the same (minor in comparison) frustration that R-core maintainers must have been having for many years: package maintainers not keeping their packages clean of errors and warnings, myself included. No matter how insignificant those errors or warnings might appear. Sometimes, as in my case in 2016, I simply haven’t been able to assign time to start the process of releasing to CRAN. I have worked hard to reduce the time it takes to run the checks not covered by R CMD check and this is happening faster now. One aspect of that script is reverse dependency checks; checking packages which use data.table in some way.

The current status() of data.table reverse dependency checks is as follows, using data.table in development on my laptop. These 320 packages themselves often depend or suggest other packages so my local revdep library has 2,108 packages.

> status()
CRAN:
ERROR : 6 : AFM mlr mtconnectR partools quanteda stremr
WARNING : 2 : ie2miscdata PGRdup
NOTE : 69
OK : 155
TOTAL : 232 / 237
RUNNING : 0
NOT STARTED (first 5 of 5) : finch flippant gasfluxes propr rlas

BIOC:
ERROR : 1 : RTCGA
WARNING : 4 : genomation methylPipe RiboProfiling S4Vectors
NOTE : 68
OK : 9
TOTAL : 82 / 83
RUNNING : 0
NOT STARTED (first 5 of 1) : diffloop

Now that Jan Gorecki has joined H2O he has been able to spend some time to automate and improve this. Currently, the result he gets with a docker script is as follows.

> status()
CRAN:
ERROR : 18 : AFM blscrapeR brainGraph checkmate ie2misc lava mlr mtconnectR OptiQuantR panelaggregation partools pcrsim psidR quanteda simcausal stremr strvalidator xgboost
WARNING : 4 : data.table ie2miscdata msmtools PGRdup
NOTE : 72
OK : 141
TOTAL : 235 / 235
RUNNING : 0

BIOC:
ERROR : 20 : CAGEr dada2 facopy flowWorkspace GenomicTuples ggcyto GOTHiC IONiseR LowMACA methylPipe minfi openCyto pepStat PGA phyloseq pwOmics QUALIFIER RTCGA SNPhood TCGAbiolinks
WARNING : 15 : biobroom bsseq Chicago genomation GenomicInteractions iGC ImmuneSpaceR metaX MSnID MSstats paxtoolsr Pviz r3Cseq RiboProfiling scater
NOTE : 27
OK : 3
TOTAL : 65 / 65
RUNNING : 0

So, our next task is to make Jan’s result on docker match mine. I can’t quite remember how I got all these packages to pass locally for me. In some cases I needed to find and install Ubuntu libraries and I tried my best to keep a note of them at the time here here. Another case is that lava suggests mets but mets depends on lava. We currently solve chicken-or-egg situations manually, one-by-one. A third example is that permissions of /tmp seem to be different on docker which at least one package appears to test and depend on. We have tried changing TEMPDIR from /tmp to ~/tmp to solve that and will wait for the rerun to see if that worked. I won’t be surprised if it takes a week of elapsed time to get our results to match. That’s two man weeks of on-and-off time as we fix, automate-the-fix and wait to see if the rerun works. And this is work after data.table has already made it to CRAN; to make next time easier and less of a barrier-to-entry to start.

The point is, all this takes time behind the scenes. I’m sure other package maintainers have similar issues and have come up with various solutions. I’m aware of devtools::revdep_check, used it gratefully for some years and thanked Hadley for it in this tweet. But recently I’ve found it more reliable and simpler to run R CMD check at the command line directly using the unix parallel command. Thank you to R-core and CRAN maintainers for keeping CRAN going in 2016. There must be much that nobody knows about. Thank you to the package maintainers that use data.table and have received my emails and fixed their warnings or errors (users will never know that happened). Sorry I myself didn’t keep data.table cleaner, faster. We’re working to improve that going forward.

## sparklyr: R interface for Apache Spark

This post is reposted from Rstudio’s announcement on sparklyr – Rstudio’s extension for Spark

• Connect to Spark from R. The sparklyr package provides a complete dplyr backend.
• Filter and aggregate Spark datasets then bring them into R for analysis and visualization.
• Use Spark’s distributed machine learning library from R.
• Create extensions that call the full Spark API and provide interfaces to Spark packages.

## Installation

You can install the sparklyr package from CRAN as follows:

install.packages("sparklyr")

You should also install a local version of Spark for development purposes:

library(sparklyr)
spark_install(version = "1.6.2")

To upgrade to the latest version of sparklyr, run the following command and restart your r session:

devtools::install_github("rstudio/sparklyr")

If you use the RStudio IDE, you should also download the latest preview release of the IDE which includes several enhancements for interacting with Spark (see the RStudio IDE section below for more details).

## Connecting to Spark

You can connect to both local instances of Spark as well as remote Spark clusters. Here we’ll connect to a local instance of Spark via the spark_connect function:

library(sparklyr)
sc <- spark_connect(master = "local")

The returned Spark connection (sc) provides a remote dplyr data source to the Spark cluster.

For more information on connecting to remote Spark clusters see the Deployment section of the sparklyr website.

## Using dplyr

We can new use all of the available dplyr verbs against the tables within the cluster.

We’ll start by copying some datasets from R into the Spark cluster (note that you may need to install the nycflights13 and Lahman packages in order to execute this code):

install.packages(c("nycflights13", "Lahman"))
library(dplyr)
iris_tbl <- copy_to(sc, iris)
flights_tbl <- copy_to(sc, nycflights13::flights, "flights")
batting_tbl <- copy_to(sc, Lahman::Batting, "batting")
src_tbls(sc)
## [1] "batting" "flights" "iris"

To start with here’s a simple filtering example:

# filter by departure delay and print the first few records
flights_tbl %>% filter(dep_delay == 2)
## Source:   query [?? x 19]
## Database: spark connection master=local[8] app=sparklyr local=TRUE
##
##     year month   day dep_time sched_dep_time dep_delay arr_time
##    <int> <int> <int>    <int>          <int>     <dbl>    <int>
## 1   2013     1     1      517            515         2      830
## 2   2013     1     1      542            540         2      923
## 3   2013     1     1      702            700         2     1058
## 4   2013     1     1      715            713         2      911
## 5   2013     1     1      752            750         2     1025
## 6   2013     1     1      917            915         2     1206
## 7   2013     1     1      932            930         2     1219
## 8   2013     1     1     1028           1026         2     1350
## 9   2013     1     1     1042           1040         2     1325
## 10  2013     1     1     1231           1229         2     1523
## # ... with more rows, and 12 more variables: sched_arr_time <int>,
## #   arr_delay <dbl>, carrier <chr>, flight <int>, tailnum <chr>,
## #   origin <chr>, dest <chr>, air_time <dbl>, distance <dbl>, hour <dbl>,
## #   minute <dbl>, time_hour <dbl>

Introduction to dplyr provides additional dplyr examples you can try. For example, consider the last example from the tutorial which plots data on flight delays:

delay <- flights_tbl %>%
group_by(tailnum) %>%
summarise(count = n(), dist = mean(distance), delay = mean(arr_delay)) %>%
filter(count > 20, dist < 2000, !is.na(delay)) %>%
collect

# plot delays
library(ggplot2)
ggplot(delay, aes(dist, delay)) +
geom_point(aes(size = count), alpha = 1/2) +
geom_smooth() +
scale_size_area(max_size = 2)

### Window Functions

dplyr window functions are also supported, for example:

batting_tbl %>%
select(playerID, yearID, teamID, G, AB:H) %>%
arrange(playerID, yearID, teamID) %>%
group_by(playerID) %>%
filter(min_rank(desc(H)) <= 2 & H > 0)
## Source:   query [?? x 7]
## Database: spark connection master=local[8] app=sparklyr local=TRUE
## Groups: playerID
##
##     playerID yearID teamID     G    AB     R     H
##        <chr>  <int>  <chr> <int> <int> <int> <int>
## 1  abbotpa01   2000    SEA    35     5     1     2
## 2  abbotpa01   2004    PHI    10    11     1     2
## 3  abnersh01   1992    CHA    97   208    21    58
## 4  abnersh01   1990    SDN    91   184    17    45
## 5  abreujo02   2014    CHA   145   556    80   176
## 6  acevejo01   2001    CIN    18    34     1     4
## 7  acevejo01   2004    CIN    39    43     0     2
## 8  adamsbe01   1919    PHI    78   232    14    54
## 9  adamsbe01   1918    PHI    84   227    10    40
## 10 adamsbu01   1945    SLN   140   578    98   169
## # ... with more rows

For additional documentation on using dplyr with Spark see the dplyr section of the sparklyr website.

## Using SQL

It’s also possible to execute SQL queries directly against tables within a Spark cluster. The spark_connection object implements a DBI interface for Spark, so you can use dbGetQuery to execute SQL and return the result as an R data frame:

library(DBI)
iris_preview <- dbGetQuery(sc, "SELECT * FROM iris LIMIT 10")
iris_preview
##    Sepal_Length Sepal_Width Petal_Length Petal_Width Species
## 1           5.1         3.5          1.4         0.2  setosa
## 2           4.9         3.0          1.4         0.2  setosa
## 3           4.7         3.2          1.3         0.2  setosa
## 4           4.6         3.1          1.5         0.2  setosa
## 5           5.0         3.6          1.4         0.2  setosa
## 6           5.4         3.9          1.7         0.4  setosa
## 7           4.6         3.4          1.4         0.3  setosa
## 8           5.0         3.4          1.5         0.2  setosa
## 9           4.4         2.9          1.4         0.2  setosa
## 10          4.9         3.1          1.5         0.1  setosa

## Machine Learning

You can orchestrate machine learning algorithms in a Spark cluster via the machine learning functions within sparklyr. These functions connect to a set of high-level APIs built on top of DataFrames that help you create and tune machine learning workflows.

Here’s an example where we use ml_linear_regression to fit a linear regression model. We’ll use the built-in mtcars dataset, and see if we can predict a car’s fuel consumption (mpg) based on its weight (wt), and the number of cylinders the engine contains (cyl). We’ll assume in each case that the relationship between mpg and each of our features is linear.

# copy mtcars into spark
mtcars_tbl <- copy_to(sc, mtcars)

# transform our data set, and then partition into 'training', 'test'
partitions <- mtcars_tbl %>%
filter(hp >= 100) %>%
mutate(cyl8 = cyl == 8) %>%
sdf_partition(training = 0.5, test = 0.5, seed = 1099)

# fit a linear model to the training dataset
fit <- partitions$training %>% ml_linear_regression(response = "mpg", features = c("wt", "cyl")) fit ## Call: ml_linear_regression(., response = "mpg", features = c("wt", "cyl")) ## ## Coefficients: ## (Intercept) wt cyl ## 37.066699 -2.309504 -1.639546 For linear regression models produced by Spark, we can use summary() to learn a bit more about the quality of our fit, and the statistical significance of each of our predictors. summary(fit) ## Call: ml_linear_regression(., response = "mpg", features = c("wt", "cyl")) ## ## Deviance Residuals:: ## Min 1Q Median 3Q Max ## -2.6881 -1.0507 -0.4420 0.4757 3.3858 ## ## Coefficients: ## Estimate Std. Error t value Pr(>|t|) ## (Intercept) 37.06670 2.76494 13.4059 2.981e-07 *** ## wt -2.30950 0.84748 -2.7252 0.02341 * ## cyl -1.63955 0.58635 -2.7962 0.02084 * ## --- ## Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1 ## ## R-Squared: 0.8665 ## Root Mean Squared Error: 1.799 Spark machine learning supports a wide array of algorithms and feature transformations and as illustrated above it’s easy to chain these functions together with dplyr pipelines. To learn more see the machine learning section. ## Reading and Writing Data You can read and write data in CSV, JSON, and Parquet formats. Data can be stored in HDFS, S3, or on the lcoal filesystem of cluster nodes. temp_csv <- tempfile(fileext = ".csv") temp_parquet <- tempfile(fileext = ".parquet") temp_json <- tempfile(fileext = ".json") spark_write_csv(iris_tbl, temp_csv) iris_csv_tbl <- spark_read_csv(sc, "iris_csv", temp_csv) spark_write_parquet(iris_tbl, temp_parquet) iris_parquet_tbl <- spark_read_parquet(sc, "iris_parquet", temp_parquet) spark_write_csv(iris_tbl, temp_json) iris_json_tbl <- spark_read_csv(sc, "iris_json", temp_json) src_tbls(sc) ## [1] "batting" "flights" "iris" "iris_csv" ## [5] "iris_json" "iris_parquet" "mtcars" ## Extensions The facilities used internally by sparklyr for its dplyr and machine learning interfaces are available to extension packages. Since Spark is a general purpose cluster computing system there are many potential applications for extensions (e.g. interfaces to custom machine learning pipelines, interfaces to 3rd party Spark packages, etc.). Here’s a simple example that wraps a Spark text file line counting function with an R function: # write a CSV tempfile <- tempfile(fileext = ".csv") write.csv(nycflights13::flights, tempfile, row.names = FALSE, na = "") # define an R interface to Spark line counting count_lines <- function(sc, path) { spark_context(sc) %>% invoke("textFile", path, 1L) %>% invoke("count") } # call spark to count the lines of the CSV count_lines(sc, tempfile) ## [1] 336777 To learn more about creating extensions see the Extensions section of the sparklyr website. ## dplyr Utilities You can cache a table into memory with: tbl_cache(sc, "batting") and unload from memory using: tbl_uncache(sc, "batting") ## Connection Utilities You can view the Spark web console using the spark_web function: spark_web(sc) You can show the log using the spark_log function: spark_log(sc, n = 10) ## 16/09/24 07:50:59 INFO ContextCleaner: Cleaned accumulator 224 ## 16/09/24 07:50:59 INFO ContextCleaner: Cleaned accumulator 223 ## 16/09/24 07:50:59 INFO ContextCleaner: Cleaned accumulator 222 ## 16/09/24 07:50:59 INFO BlockManagerInfo: Removed broadcast_64_piece0 on localhost:56324 in memory (size: 20.6 KB, free: 483.0 MB) ## 16/09/24 07:50:59 INFO ContextCleaner: Cleaned accumulator 220 ## 16/09/24 07:50:59 INFO Executor: Finished task 0.0 in stage 67.0 (TID 117). 2082 bytes result sent to driver ## 16/09/24 07:50:59 INFO TaskSetManager: Finished task 0.0 in stage 67.0 (TID 117) in 122 ms on localhost (1/1) ## 16/09/24 07:50:59 INFO DAGScheduler: ResultStage 67 (count at NativeMethodAccessorImpl.java:-2) finished in 0.122 s ## 16/09/24 07:50:59 INFO TaskSchedulerImpl: Removed TaskSet 67.0, whose tasks have all completed, from pool ## 16/09/24 07:50:59 INFO DAGScheduler: Job 47 finished: count at NativeMethodAccessorImpl.java:-2, took 0.125238 s Finally, we disconnect from Spark: spark_disconnect(sc) ## RStudio IDE The latest RStudio Preview Release of the RStudio IDE includes integrated support for Spark and the sparklyr package, including tools for: • Creating and managing Spark connections • Browsing the tables and columns of Spark DataFrames • Previewing the first 1,000 rows of Spark DataFrames Once you’ve installed the sparklyr package, you should find a new Spark pane within the IDE. This pane includes a New Connection dialog which can be used to make connections to local or remote Spark instances: Once you’ve connected to Spark you’ll be able to browse the tables contained within the Spark cluster: The Spark DataFrame preview uses the standard RStudio data viewer: The RStudio IDE features for sparklyr are available now as part of the RStudio Preview Release. ## H2O GBM Tuning Tutorial for R In this tutorial, we show how to build a well-tuned H2O GBM model for a supervised classification task. We specifically don’t focus on feature engineering and use a small dataset to allow you to reproduce these results in a few minutes on a laptop. This script can be directly transferred to datasets that are hundreds of GBs large and H2O clusters with dozens of compute nodes. This tutorial is written in R Markdown. You can download the source from H2O’s github repository. A port to a Python Jupyter Notebook version is available as well. ## Installation of the H2O R Package Either download H2O from H2O.ai’s website or install the latest version of H2O into R with the following R code: # The following two commands remove any previously installed H2O packages for R. if ("package:h2o" %in% search()) { detach("package:h2o", unload=TRUE) } if ("h2o" %in% rownames(installed.packages())) { remove.packages("h2o") } # Next, we download packages that H2O depends on. pkgs <- c("methods","statmod","stats","graphics","RCurl","jsonlite","tools","utils") for (pkg in pkgs) { if (! (pkg %in% rownames(installed.packages()))) { install.packages(pkg) } } # Now we download, install and initialize the H2O package for R. install.packages("h2o", type="source", repos=(c("http://h2o-release.s3.amazonaws.com/h2o/rel-turchin/8/R"))) ## Launch an H2O cluster on localhost library(h2o) h2o.init(nthreads=-1) ## optional: connect to a running H2O cluster #h2o.init(ip="mycluster", port=55555) Starting H2O JVM and connecting: . Connection successful! R is connected to the H2O cluster: H2O cluster uptime: 1 seconds 248 milliseconds H2O cluster version: 3.8.2.8 H2O cluster name: H2O_started_from_R_arno_wyu958 H2O cluster total nodes: 1 H2O cluster total memory: 3.56 GB H2O cluster total cores: 8 H2O cluster allowed cores: 8 H2O cluster healthy: TRUE H2O Connection ip: localhost H2O Connection port: 54321 H2O Connection proxy: NA R Version: R version 3.2.2 (2015-08-14) ## Import the data into H2O Everything is scalable and distributed from now on. All processing is done on the fully multi-threaded and distributed H2O Java-based backend and can be scaled to large datasets on large compute clusters. Here, we use a small public dataset (Titanic), but you can use datasets that are hundreds of GBs large. ## 'path' can point to a local file, hdfs, s3, nfs, Hive, directories, etc. df <- h2o.importFile(path = "http://s3.amazonaws.com/h2o-public-test-data/smalldata/gbm_test/titanic.csv") dim(df) head(df) tail(df) summary(df,exact_quantiles=TRUE) ## pick a response for the supervised problem response <- "survived" ## the response variable is an integer, we will turn it into a categorical/factor for binary classification df[[response]] <- as.factor(df[[response]]) ## use all other columns (except for the name) as predictors predictors <- setdiff(names(df), c(response, "name")) > summary(df,exact_quantiles=TRUE) pclass survived name sex age sibsp parch ticket fare cabin embarked Min. :1.000 Min. :0.000 male :843 Min. : 0.1667 Min. :0.0000 Min. :0.000 Min. : 680 Min. : 0.000 C23 C25 C27 : 6 S :914 1st Qu.:2.000 1st Qu.:0.000 female:466 1st Qu.:21.0000 1st Qu.:0.0000 1st Qu.:0.000 1st Qu.: 19950 1st Qu.: 7.896 B57 B59 B63 B66: 5 C :270 Median :3.000 Median :0.000 Median :28.0000 Median :0.0000 Median :0.000 Median : 234604 Median : 14.454 G6 : 5 Q :123 Mean :2.295 Mean :0.382 Mean :29.8811 Mean :0.4989 Mean :0.385 Mean : 249039 Mean : 33.295 B96 B98 : 4 NA: 2 3rd Qu.:3.000 3rd Qu.:1.000 3rd Qu.:39.0000 3rd Qu.:1.0000 3rd Qu.:0.000 3rd Qu.: 347468 3rd Qu.: 31.275 C22 C26 : 4 Max. :3.000 Max. :1.000 Max. :80.0000 Max. :8.0000 Max. :9.000 Max. :3101298 Max. :512.329 C78 : 4 NA's :263 NA's :352 NA's :1 NA :1014 boat body home.dest Min. : 1.000 Min. : 1.0 New York NY : 64 1st Qu.: 5.000 1st Qu.: 72.0 London : 14 Median :10.000 Median :155.0 Montreal PQ : 10 Mean : 9.405 Mean :160.8 Cornwall / Akron OH: 9 3rd Qu.:13.000 3rd Qu.:256.0 Paris France : 9 Max. :16.000 Max. :328.0 Philadelphia PA : 8 NA's :911 NA's :1188 NA :564 From now on, everything is generic and directly applies to most datasets. We assume that all feature engineering is done at this stage and focus on model tuning. For multi-class problems, you can use h2o.logloss() or h2o.confusionMatrix() instead of h2o.auc() and for regression problems, you can use h2o.deviance() or h2o.mse(). ## Split the data for Machine Learning We split the data into three pieces: 60% for training, 20% for validation, 20% for final testing. Here, we use random splitting, but this assumes i.i.d. data. If this is not the case (e.g., when events span across multiple rows or data has a time structure), you’ll have to sample your data non-randomly. splits <- h2o.splitFrame( data = df, ratios = c(0.6,0.2), ## only need to specify 2 fractions, the 3rd is implied destination_frames = c("train.hex", "valid.hex", "test.hex"), seed = 1234 ) train <- splits[[1]] valid <- splits[[2]] test <- splits[[3]] ## Establish baseline performance As the first step, we’ll build some default models to see what accuracy we can expect. Let’s use the AUC metric for this demo, but you can use h2o.logloss and stopping_metric="logloss" as well. It ranges from 0.5 for random models to 1 for perfect models. The first model is a default GBM, trained on the 60% training split ## We only provide the required parameters, everything else is default gbm <- h2o.gbm(x = predictors, y = response, training_frame = train) ## Show a detailed model summary gbm ## Get the AUC on the validation set h2o.auc(h2o.performance(gbm, newdata = valid)) The AUC is over 94%, so this model is highly predictive! [1] 0.9431953 The second model is another default GBM, but trained on 80% of the data (here, we combine the training and validation splits to get more training data), and cross-validated using 4 folds. Note that cross-validation takes longer and is not usually done for really large datasets. ## h2o.rbind makes a copy here, so it's better to use splitFrame with ratios = c(0.8) instead above gbm <- h2o.gbm(x = predictors, y = response, training_frame = h2o.rbind(train, valid), nfolds = 4, seed = 0xDECAF) ## Show a detailed summary of the cross validation metrics ## This gives you an idea of the variance between the folds gbm@model$cross_validation_metrics_summary

## Get the cross-validated AUC by scoring the combined holdout predictions.
## (Instead of taking the average of the metrics across the folds)
h2o.auc(h2o.performance(gbm, xval = TRUE))

We see that the cross-validated performance is similar to the validation set performance:

[1] 0.9403432

Next, we train a GBM with “I feel lucky” parameters.
We’ll use early stopping to automatically tune the number of trees using the validation AUC.
We’ll use a lower learning rate (lower is always better, just takes more trees to converge).
We’ll also use stochastic sampling of rows and columns to (hopefully) improve generalization.

gbm <- h2o.gbm(
## standard model parameters
x = predictors,
y = response,
training_frame = train,
validation_frame = valid,

## more trees is better if the learning rate is small enough
## here, use "more than enough" trees - we have early stopping
ntrees = 10000,

## smaller learning rate is better (this is a good value for most datasets, but see below for annealing)
learn_rate=0.01,

## early stopping once the validation AUC doesn't improve by at least 0.01% for 5 consecutive scoring events
stopping_rounds = 5, stopping_tolerance = 1e-4, stopping_metric = "AUC",

## sample 80% of rows per tree
sample_rate = 0.8,

## sample 80% of columns per split
col_sample_rate = 0.8,

## fix a random number generator seed for reproducibility
seed = 1234,

## score every 10 trees to make early stopping reproducible (it depends on the scoring interval)
score_tree_interval = 10
)

## Get the AUC on the validation set
h2o.auc(h2o.performance(gbm, valid = TRUE))

This model doesn’t seem to be much better than the previous models:

[1] 0.939335

For this small dataset, dropping 20% of observations per tree seems too aggressive in terms of adding regularization. For larger datasets, this is usually not a bad idea. But we’ll let this parameter tune freshly below, so no worries.

Note: To see what other stopping_metric parameters you can specify, simply pass an invalid option:

gbm <- h2o.gbm(x = predictors, y = response, training_frame = train, stopping_metric = "yada")
Error in .h2o.checkAndUnifyModelParameters(algo = algo, allParams = ALL_PARAMS,  :
"stopping_metric" must be in "AUTO", "deviance", "logloss", "MSE", "AUC",
"lift_top_group", "r2", "misclassification", but got yada

## Hyper-Parameter Search

Next, we’ll do real hyper-parameter optimization to see if we can beat the best AUC so far (around 94%).

The key here is to start tuning some key parameters first (i.e., those that we expect to have the biggest impact on the results). From experience with gradient boosted trees across many datasets, we can state the following “rules”:

1. Build as many trees (ntrees) as it takes until the validation set error starts increasing.
2. A lower learning rate (learn_rate) is generally better, but will require more trees. Using learn_rate=0.02and learn_rate_annealing=0.995 (reduction of learning rate with each additional tree) can help speed up convergence without sacrificing accuracy too much, and is great to hyper-parameter searches. For faster scans, use values of 0.05 and 0.99 instead.
3. The optimum maximum allowed depth for the trees (max_depth) is data dependent, deeper trees take longer to train, especially at depths greater than 10.
4. Row and column sampling (sample_rate and col_sample_rate) can improve generalization and lead to lower validation and test set errors. Good general values for large datasets are around 0.7 to 0.8 (sampling 70-80 percent of the data) for both parameters. Column sampling per tree (col_sample_rate_per_tree) can also be tuned. Note that it is multiplicative with col_sample_rate, so setting both parameters to 0.8 results in 64% of columns being considered at any given node to split.
5. For highly imbalanced classification datasets (e.g., fewer buyers than non-buyers), stratified row sampling based on response class membership can help improve predictive accuracy. It is configured with sample_rate_per_class (array of ratios, one per response class in lexicographic order).
6. Most other options only have a small impact on the model performance, but are worth tuning with a Random hyper-parameter search nonetheless, if highest performance is critical.

First we want to know what value of max_depth to use because it has a big impact on the model training time and optimal values depend strongly on the dataset.
We’ll do a quick Cartesian grid search to get a rough idea of good candidate max_depth values. Each model in the grid search will use early stopping to tune the number of trees using the validation set AUC, as before.
We’ll use learning rate annealing to speed up convergence without sacrificing too much accuracy.

## Depth 10 is usually plenty of depth for most datasets, but you never know
hyper_params = list( max_depth = seq(1,29,2) )
#hyper_params = list( max_depth = c(4,6,8,12,16,20) ) ##faster for larger datasets

grid <- h2o.grid(
## hyper parameters
hyper_params = hyper_params,

## full Cartesian hyper-parameter search
search_criteria = list(strategy = "Cartesian"),

## which algorithm to run
algorithm="gbm",

## identifier for the grid, to later retrieve it
grid_id="depth_grid",

## standard model parameters
x = predictors,
y = response,
training_frame = train,
validation_frame = valid,

## more trees is better if the learning rate is small enough
## here, use "more than enough" trees - we have early stopping
ntrees = 10000,

## smaller learning rate is better
## since we have learning_rate_annealing, we can afford to start with a bigger learning rate
learn_rate = 0.05,

## learning rate annealing: learning_rate shrinks by 1% after every tree
## (use 1.00 to disable, but then lower the learning_rate)
learn_rate_annealing = 0.99,

## sample 80% of rows per tree
sample_rate = 0.8,

## sample 80% of columns per split
col_sample_rate = 0.8,

## fix a random number generator seed for reproducibility
seed = 1234,

## early stopping once the validation AUC doesn't improve by at least 0.01% for 5 consecutive scoring events
stopping_rounds = 5,
stopping_tolerance = 1e-4,
stopping_metric = "AUC",

## score every 10 trees to make early stopping reproducible (it depends on the scoring interval)
score_tree_interval = 10
)

## by default, display the grid search results sorted by increasing logloss (since this is a classification task)
grid

## sort the grid models by decreasing AUC
sortedGrid <- h2o.getGrid("depth_grid", sort_by="auc", decreasing = TRUE)
sortedGrid

## find the range of max_depth for the top 5 models
topDepths = sortedGrid@summary_table$max_depth[1:5] minDepth = min(as.numeric(topDepths)) maxDepth = max(as.numeric(topDepths)) > sortedGrid H2O Grid Details ================ Grid ID: depth_grid Used hyper parameters: - max_depth Number of models: 15 Number of failed models: 0 Hyper-Parameter Search Summary: ordered by decreasing auc max_depth model_ids auc 1 27 depth_grid_model_13 0.95657931811778 2 25 depth_grid_model_12 0.956353902507749 3 29 depth_grid_model_14 0.956241194702733 4 21 depth_grid_model_10 0.954663285432516 5 19 depth_grid_model_9 0.954494223724993 6 13 depth_grid_model_6 0.954381515919978 7 23 depth_grid_model_11 0.954043392504931 8 11 depth_grid_model_5 0.952183713722175 9 15 depth_grid_model_7 0.951789236404621 10 17 depth_grid_model_8 0.951507466892082 11 9 depth_grid_model_4 0.950436742744435 12 7 depth_grid_model_3 0.946942800788955 13 5 depth_grid_model_2 0.939306846999155 14 3 depth_grid_model_1 0.932713440405748 15 1 depth_grid_model_0 0.92902225979149 It appears that max_depth values of 19 to 29 are best suited for this dataset, which is unusally deep! > minDepth [1] 19 > maxDepth [1] 29 Now that we know a good range for max_depth, we can tune all other parameters in more detail. Since we don’t know what combinations of hyper-parameters will result in the best model, we’ll use random hyper-parameter search to “let the machine get luckier than a best guess of any human”. hyper_params = list( ## restrict the search to the range of max_depth established above max_depth = seq(minDepth,maxDepth,1), ## search a large space of row sampling rates per tree sample_rate = seq(0.2,1,0.01), ## search a large space of column sampling rates per split col_sample_rate = seq(0.2,1,0.01), ## search a large space of column sampling rates per tree col_sample_rate_per_tree = seq(0.2,1,0.01), ## search a large space of how column sampling per split should change as a function of the depth of the split col_sample_rate_change_per_level = seq(0.9,1.1,0.01), ## search a large space of the number of min rows in a terminal node min_rows = 2^seq(0,log2(nrow(train))-1,1), ## search a large space of the number of bins for split-finding for continuous and integer columns nbins = 2^seq(4,10,1), ## search a large space of the number of bins for split-finding for categorical columns nbins_cats = 2^seq(4,12,1), ## search a few minimum required relative error improvement thresholds for a split to happen min_split_improvement = c(0,1e-8,1e-6,1e-4), ## try all histogram types (QuantilesGlobal and RoundRobin are good for numeric columns with outliers) histogram_type = c("UniformAdaptive","QuantilesGlobal","RoundRobin") ) search_criteria = list( ## Random grid search strategy = "RandomDiscrete", ## limit the runtime to 60 minutes max_runtime_secs = 3600, ## build no more than 100 models max_models = 100, ## random number generator seed to make sampling of parameter combinations reproducible seed = 1234, ## early stopping once the leaderboard of the top 5 models is converged to 0.1% relative difference stopping_rounds = 5, stopping_metric = "AUC", stopping_tolerance = 1e-3 ) grid <- h2o.grid( ## hyper parameters hyper_params = hyper_params, ## hyper-parameter search configuration (see above) search_criteria = search_criteria, ## which algorithm to run algorithm = "gbm", ## identifier for the grid, to later retrieve it grid_id = "final_grid", ## standard model parameters x = predictors, y = response, training_frame = train, validation_frame = valid, ## more trees is better if the learning rate is small enough ## use "more than enough" trees - we have early stopping ntrees = 10000, ## smaller learning rate is better ## since we have learning_rate_annealing, we can afford to start with a bigger learning rate learn_rate = 0.05, ## learning rate annealing: learning_rate shrinks by 1% after every tree ## (use 1.00 to disable, but then lower the learning_rate) learn_rate_annealing = 0.99, ## early stopping based on timeout (no model should take more than 1 hour - modify as needed) max_runtime_secs = 3600, ## early stopping once the validation AUC doesn't improve by at least 0.01% for 5 consecutive scoring events stopping_rounds = 5, stopping_tolerance = 1e-4, stopping_metric = "AUC", ## score every 10 trees to make early stopping reproducible (it depends on the scoring interval) score_tree_interval = 10, ## base random number generator seed for each model (automatically gets incremented internally for each model) seed = 1234 ) ## Sort the grid models by AUC sortedGrid <- h2o.getGrid("final_grid", sort_by = "auc", decreasing = TRUE) sortedGrid We can see that the best models have even better validation AUCs than our previous best models, so the random grid search was successful! Hyper-Parameter Search Summary: ordered by decreasing auc col_sample_rate col_sample_rate_change_per_level col_sample_rate_per_tree histogram_type max_depth 1 0.49 1.04 0.94 QuantilesGlobal 28 2 0.92 0.93 0.56 QuantilesGlobal 27 3 0.35 1.09 0.83 QuantilesGlobal 29 4 0.42 0.98 0.53 UniformAdaptive 24 5 0.7 1.02 0.56 UniformAdaptive 25 min_rows min_split_improvement nbins nbins_cats sample_rate model_ids auc 1 2 0 32 256 0.86 final_grid_model_68 0.974049027895182 2 4 0 128 128 0.93 final_grid_model_96 0.971400394477318 3 4 1e-08 64 128 0.69 final_grid_model_38 0.968864468864469 4 1 1e-04 64 16 0.69 final_grid_model_55 0.967793744716822 5 2 1e-08 32 256 0.34 final_grid_model_22 0.966553958861651 We can inspect the best 5 models from the grid search explicitly, and query their validation AUC: for (i in 1:5) { gbm <- h2o.getModel(sortedGrid@model_ids[[i]]) print(h2o.auc(h2o.performance(gbm, valid = TRUE))) } [1] 0.974049 [1] 0.9714004 [1] 0.9688645 [1] 0.9677937 [1] 0.966554 You can also see the results of the grid search in Flow: ## Model Inspection and Final Test Set Scoring Let’s see how well the best model of the grid search (as judged by validation set AUC) does on the held out test set: gbm <- h2o.getModel(sortedGrid@model_ids[[1]]) print(h2o.auc(h2o.performance(gbm, newdata = test))) Good news. It does as well on the test set as on the validation set, so it looks like our best GBM model generalizes well to the unseen test set: [1] 0.9712568 We can inspect the winning model’s parameters: gbm@parameters > gbm@parameters$model_id
[1] "final_grid_model_68"

$training_frame [1] "train.hex"$validation_frame
[1] "valid.hex"

$score_tree_interval [1] 10$ntrees
[1] 10000

$max_depth [1] 28$min_rows
[1] 2

$nbins [1] 32$nbins_cats
[1] 256

$stopping_rounds [1] 5$stopping_metric
[1] "AUC"

$stopping_tolerance [1] 1e-04$max_runtime_secs
[1] 3414.017

$seed [1] 1234$learn_rate
[1] 0.05

$learn_rate_annealing [1] 0.99$distribution
[1] "bernoulli"

$sample_rate [1] 0.86$col_sample_rate
[1] 0.49

$col_sample_rate_change_per_level [1] 1.04$col_sample_rate_per_tree
[1] 0.94

$histogram_type [1] "QuantilesGlobal"$x
[1] "pclass"    "sex"       "age"       "sibsp"     "parch"     "ticket"    "fare"      "cabin"
[9] "embarked"  "boat"      "body"      "home.dest"

$y [1] "survived" Now we can confirm that these parameters are generally sound, by building a GBM model on the whole dataset (instead of the 60%) and using internal 5-fold cross-validation (re-using all other parameters including the seed): model <- do.call(h2o.gbm, ## update parameters in place { p <- gbm@parameters p$model_id = NULL          ## do not overwrite the original grid model
p$training_frame = df ## use the full dataset p$validation_frame = NULL  ## no validation frame
p$nfolds = 5 ## cross-validation p } ) model@model$cross_validation_metrics_summary
> model@model$cross_validation_metrics_summary Cross-Validation Metrics Summary: mean sd cv_1_valid cv_2_valid cv_3_valid cv_4_valid cv_5_valid F0point5 0.9082877 0.017469764 0.9448819 0.87398374 0.8935743 0.9034908 0.9255079 F1 0.8978795 0.008511053 0.9099526 0.8820513 0.8989899 0.9119171 0.8864865 F2 0.8886758 0.016845208 0.8775137 0.89026916 0.9044715 0.92050207 0.8506224 accuracy 0.9236877 0.004604631 0.92883897 0.9151291 0.92248064 0.93307084 0.9189189 auc 0.9606385 0.006671454 0.96647465 0.9453869 0.959375 0.97371733 0.95823866 err 0.076312296 0.004604631 0.07116105 0.084870845 0.07751938 0.06692913 0.08108108 err_count 20 1.4142135 19 23 20 17 21 lift_top_group 2.6258688 0.099894695 2.3839285 2.8229167 2.632653 2.6736841 2.6161616 logloss 0.23430987 0.019006629 0.23624699 0.26165685 0.24543843 0.18311584 0.24509121 max_per_class_error 0.11685239 0.025172591 0.14285715 0.104166664 0.091836736 0.07368421 0.17171717 mcc 0.8390522 0.011380583 0.8559271 0.81602895 0.83621955 0.8582395 0.8288459 mean_per_class_accuracy 0.91654545 0.0070778215 0.918894 0.9107738 0.91970664 0.9317114 0.9016414 mean_per_class_error 0.08345456 0.0070778215 0.08110599 0.089226194 0.080293365 0.06828865 0.09835859 mse 0.06535896 0.004872401 0.06470373 0.0717801 0.0669676 0.052562267 0.07078109 precision 0.9159663 0.02743855 0.969697 0.86868685 0.89 0.8979592 0.95348835 r2 0.7223932 0.021921812 0.7342935 0.68621415 0.7157123 0.7754977 0.70024836 recall 0.8831476 0.025172591 0.85714287 0.8958333 0.90816325 0.9263158 0.82828283 specificity 0.94994324 0.016345335 0.9806452 0.9257143 0.93125 0.9371069 0.975 Ouch! So it looks like we overfit quite a bit on the validation set as the mean AUC on the 5 folds is “only” 96.06% +/- 0.67%. So we cannot always expect AUCs of 97% with these parameters on this dataset. So to get a better estimate of model performance, the Random hyper-parameter search could have used nfolds = 5 (or 10, or similar) in combination with 80% of the data for training (i.e., not holding out a validation set, but only the final test set). However, this would take more time, as nfolds+1 models will be built for every set of parameters. Instead, to save time, let’s just scan through the top 5 models and cross-validated their parameters with nfolds=5 on the entire dataset: for (i in 1:5) { gbm <- h2o.getModel(sortedGrid@model_ids[[i]]) cvgbm <- do.call(h2o.gbm, ## update parameters in place { p <- gbm@parameters p$model_id = NULL          ## do not overwrite the original grid model
p$training_frame = df ## use the full dataset p$validation_frame = NULL  ## no validation frame
p$nfolds = 5 ## cross-validation p } ) print(gbm@model_id) print(cvgbm@model$cross_validation_metrics_summary[5,]) ## Pick out the "AUC" row
}
[1] "final_grid_model_68"
Cross-Validation Metrics Summary:
mean          sd cv_1_valid cv_2_valid cv_3_valid cv_4_valid cv_5_valid
auc 0.9606385 0.006671454 0.96647465  0.9453869   0.959375 0.97371733 0.95823866
[1] "final_grid_model_96"
Cross-Validation Metrics Summary:
mean           sd cv_1_valid cv_2_valid cv_3_valid cv_4_valid cv_5_valid
auc 0.96491456 0.0052218214  0.9631913  0.9597024  0.9742985  0.9723933 0.95498735
[1] "final_grid_model_38"
Cross-Validation Metrics Summary:
mean          sd cv_1_valid cv_2_valid cv_3_valid cv_4_valid cv_5_valid
auc 0.9638506 0.004603204 0.96134794  0.9573512   0.971301 0.97192985 0.95732325
[1] "final_grid_model_55"
Cross-Validation Metrics Summary:
mean           sd cv_1_valid cv_2_valid cv_3_valid cv_4_valid cv_5_valid
auc 0.9657447 0.0062724343  0.9562212 0.95428574  0.9686862 0.97490895 0.97462124
[1] "final_grid_model_22"
Cross-Validation Metrics Summary:
mean           sd cv_1_valid cv_2_valid cv_3_valid cv_4_valid cv_5_valid
auc 0.9648925 0.0065437974 0.96633065 0.95285714  0.9557398  0.9736511 0.97588384

The avid reader might have noticed that we just implicitly did further parameter tuning using the “final” test set (which is part of the entire dataset df), which is not good practice – one is not supposed to use the “final” test set more than once. Hence, we’re not going to pick a different “best” model, but we’re just learning about the variance in AUCs. It turns out, for this tiny dataset, that the variance is rather large, which is not surprising.

Keeping the same “best” model, we can make test set predictions as follows:

gbm <- h2o.getModel(sortedGrid@model_ids[[1]])
preds <- h2o.predict(gbm, test)
gbm@model$validation_metrics@metrics$max_criteria_and_metric_scores

Note that the label (survived or not) is predicted as well (in the first predict column), and it uses the threshold with the highest F1 score (here: 0.528098) to make labels from the probabilities for survival (p1). The probability for death (p0) is given for convenience, as it is just 1-p1.

predict         p0         p1
1       0 0.98055935 0.01944065
2       0 0.98051200 0.01948800
3       0 0.81430963 0.18569037
4       1 0.02121241 0.97878759
5       1 0.02528104 0.97471896
6       0 0.92056020 0.07943980
> gbm@model$validation_metrics@metrics$max_criteria_and_metric_scores
Maximum Metrics: Maximum metrics at their respective thresholds
metric threshold    value idx
1                       max f1  0.528098 0.920792  96
2                       max f2  0.170853 0.926966 113
3                 max f0point5  0.767931 0.959488  90
4                 max accuracy  0.767931 0.941606  90
5                max precision  0.979449 1.000000   0
6                   max recall  0.019425 1.000000 206
7              max specificity  0.979449 1.000000   0
8             max absolute_MCC  0.767931 0.878692  90
9   max min_per_class_accuracy  0.204467 0.928994 109
10 max mean_per_class_accuracy  0.252473 0.932319 106

You can also see the “best” model in more detail in Flow:

The model and the predictions can be saved to file as follows:

h2o.saveModel(gbm, "/tmp/bestModel.csv", force=TRUE)
h2o.exportFile(preds, "/tmp/bestPreds.csv", force=TRUE)

The model can also be exported as a plain old Java object (POJO) for H2O-independent (standalone/Storm/Kafka/UDF) scoring in any Java environment.

/*
Licensed under the Apache License, Version 2.0

AUTOGENERATED BY H2O at 2016-06-02T17:06:34.382-07:00
3.9.1.99999

Standalone prediction code with sample test data for GBMModel named final_grid_model_68

mkdir tmpdir
cd tmpdir
curl http://172.16.2.75:54321/3/h2o-genmodel.jar > h2o-genmodel.jar
curl http://172.16.2.75:54321/3/Models.java/final_grid_model_68 > final_grid_model_68.java
javac -cp h2o-genmodel.jar -J-Xmx2g -J-XX:MaxPermSize=128m final_grid_model_68.java

(Note:  Try java argument -XX:+PrintCompilation to show runtime JIT compiler behavior.)
*/
import java.util.Map;
import hex.genmodel.GenModel;
import hex.genmodel.annotations.ModelPojo;

...
class final_grid_model_68_Tree_0_class_0 {
static final double score0(double[] data) {
double pred =      (data[9 /* boat */] <14.003472f ?
(!Double.isNaN(data[9]) && data[9 /* boat */] != 12.0f ?
0.13087687f :
(data[3 /* sibsp */] <7.3529413E-4f ?
0.13087687f :
0.024317414f)) :
(data[5 /* ticket */] <2669.5f ?
(data[5 /* ticket */] <2665.5f ?
(data[10 /* body */] <287.5f ?
-0.08224204f :
(data[2 /* age */] <14.2421875f ?
0.13087687f :
(data[4 /* parch */] <4.892368E-4f ?
(data[6 /* fare */] <39.029896f ?
(data[1 /* sex */] <0.5f ?
(data[5 /* ticket */] <2659.5f ?
0.13087687f :
-0.08224204f) :
-0.08224204f) :
0.08825309f) :
0.13087687f))) :
0.13087687f) :
(data[9 /* boat */] <15.5f ?
0.13087687f :
(!GenModel.bitSetContains(GRPSPLIT0, 42, data[7
...

## Ensembling Techniques

After learning above that the variance of the test set AUC of the top few models was rather large, we might be able to turn this into our advantage by using ensembling techniques. The simplest one is taking the average of the predictions (survival probabilities) of the top k grid search model predictions (here, we use k=10):

prob = NULL
k=10
for (i in 1:k) {
gbm <- h2o.getModel(sortedGrid@model_ids[[i]])
if (is.null(prob)) prob = h2o.predict(gbm, test)$p1 else prob = prob + h2o.predict(gbm, test)$p1
}
prob <- prob/k

We now have a blended probability of survival for each person on the Titanic.

p1
1 0.02258923
2 0.01615957
3 0.15837298
4 0.98565663
5 0.98792208
6 0.17941366

We can bring those ensemble predictions to our R session’s memory space and use other R packages.

probInR  <- as.vector(prob)
labelInR <- as.vector(as.numeric(test[[response]]))
if (! ("cvAUC" %in% rownames(installed.packages()))) { install.packages("cvAUC") }
library(cvAUC)
cvAUC::AUC(probInR, labelInR)
[1] 0.977534

This simple blended ensemble test set prediction has an even higher AUC than the best single model, but we need to do more validation studies, ideally using cross-validation. We leave this as an exercise for the reader – take the parameters of the top 10 models, retrain them with nfolds=5 on the full dataset, set keep_holdout_predictions=TRUE and average the predicted probabilities in h2o.getFrame(cvgbm[i]@model$cross_validation_holdout_predictions_frame_id), then score that with cvAUC as shown above). For more sophisticated ensembling approaches, such as stacking via a superlearner, we refer to the H2O Ensemble github page. ## Summary We learned how to build H2O GBM models for a binary classification task on a small but realistic dataset with numerical and categorical variables, with the goal to maximize the AUC (ranges from 0.5 to 1). We first established a baseline with the default model, then carefully tuned the remaining hyper-parameters without “too much” human guess-work. We used both Cartesian and Random hyper-parameter searches to find good models. We were able to get the AUC on a holdout test set from the low 94% range with the default model to the mid 97% after tuning, and to the high 97% with some simple ensembling technique known as blending. We performed simple cross-validation variance analysis to learn that results were slightly “lucky” due to the specific train/valid/test set splits, and settled to expect mid 96% AUCs instead. Note that this script and the findings therein are directly transferrable to large datasets on distributed clusters including Spark/Hadoop environments. More information can be found here http://www.h2o.ai/docs/. ## Fast csv writing for R R has traditionally been very slow at reading and writing csv files of, say, 1 million rows or more. Getting data into R is often the first task a user needs to do and if they have a poor experience (either hard to use, or very slow) they are less likely to progress. The data.table package in R solved csv import convenience and speed in 2013 by implementing data.table::fread() in C. The examples at that time were 30 seconds down to 3 seconds to read 50MB and over 1 hour down to 8 minute to read 20GB. In 2015 Hadley Wickham implemented readr::read_csv() in C++. But what about writing csv files? It is often the case that the end goal of work in R is a report, a visualization or a summary of some form. Not anything large. So we don’t really need to export large data, right? It turns out that the combination of speed, expressiveness and advanced abilities of R (particularly data.table) mean that it can be faster (so I’m told) to export the data from other environments (e.g. a database), manipulate in R, and export back to the database, than it is keeping the data in the database. However, the data export step out of R being the biggest bottleneck preventing that workflow is being increasingly heard from practitioners in the field. The export step may be needed to send clean data or derived features to other teams or systems in the user’s organization. Yes: feather, I hear you thinking! Indeed feather is a new fast uncompressed binary format which is also cross-language, by Wes McKinney and Hadley Wickham. As Roger Peng pointed out R has had fast XDR binary format for many years but the innovation of feather is that it is compatible with Python and Julia and other systems will adopt the format too. This is a great thing. Note that it is very important to set compress=FALSE in save() and saveRDS() to achieve comparable times to feather using base R. I was thinking about jumping on board with feather when to my surprise 2 weeks ago, the data.table project received a new user contribution from Otto Seiskari: fwrite(). Analogous to fread() it writes a data.frame or data.table to .csv and is implemented in C. I looked at the source and realized a few speed improvements could be made. Over the years I’ve occasionally mulled over different approaches. This contribution gave me the nudge to give those ideas a try. The first change I made was to stop using the fprintf() function in C. This takes a file handle and a format specification string and writes a field to the file. If you have 1 million rows and 6 columns that’s 6 million calls to that function. I’ve never looked at its source code but I guessed that because it was being iteratively called 6 million times, some tasks like interpreting the format specification string and checking the file handle is valid were being performed over and over again wastefully. I knew it maintains its own internal buffer automatically to save writing too many very small chunks of data to disk. But I wondered how much time was spent writing data to the disk versus how much time was spent formatting that data. So I added my own in-memory buffer, writing to it directly and moved from fprintf() to the lower level C functions write(). Note: not the C function fwrite() but write(). This writes a buffer of data to a file; it doesn’t have an internal buffer in the way. I did this so I could wrap the write() call with a timing block and see how much time was being spent writing to file versus formatting. Here is the result : Wow: 99% of the time is being spent formatting! The time is not spent writing to disk at all. Not one ounce. Can we parallelize it then? On first glance, the data has to be written to the file in a serial fashion: row 1, then row 2, then row 3. Perhaps the data could be divided into N subsets, each subset written out in parallel, then joined together afterwards. Before rushing ahead and doing it that way, let’s think what the problems might be. First the N subsets could be writing at the same time (to different files) but that could saturate the internal bus (I don’t know much about that). Once the N files are obtained, they still have to be joined together into one file. I searched online and asked my colleagues and it appears they is no way to create a file by reference to existing files; you have to concatenate the N files into a new single file (a copy). That step would be serial and would also churn through disk space. It’s possible there would not be enough disk space available to complete the task. Having anticipated these problems, is there a better way I could implement from the get go? What did I have one of that I could make N of? Well, I had one buffer: the input to write(). If I make N threads and give each thread its own buffer can it be made to work? This is inherently thread safe since the only memory write would be to a thread’s private buffer. The only tricky aspect is ensuring that each piece is written to the output csv file in the correct order. I’m on good terms with Norman Matloff who has recommended OpenMP to me in the past and kindly gave me a copy of his excellent book Parallel Computing for Data Science. I turned to Google and quickly found that OpenMP has exactly the construct I needed : OpenMP does a lot of work for the programmer. It directs the team of threads to work on each iteration of the for loop. The code after the #pragma omp order gets executed one-at-a-time and in-the-order-of-the-for-loop, automatically. So if iteration 7 finishes quickly for some reason, that thread will wait for iterations 1-6 to finish before it writes its buffer and receives the next piece to work on. I chose the buffer size for each thread to be small (1MB) to fit in each core’s cache. This results in the number of pieces N to be much larger (size of data / 1MB) than the number of threads so that each piece is not too big to get stuck and cause a blockage and not too small either to incur wasteful startup and scheduling overhead. Here is the result on my 4-core MacBook Pro (running bare-metal Ubuntu, of course): This was one of those rare moments where the speedup factor was the best I hoped for. An ideal 4x improvement: 3.6 seconds down to 0.9 seconds. I thought I’d have to add lots of tests for fwrite() but I looked at the test suite and found that Otto had already added 26 tests in his pull request that I’d merged. My changes had broken quite a few of them so I fixed the code to pass his tests. Then I pushed to GitHub for others to test on MacOS and Windows. Within hours feedback came back that the speedup and correctness were confirmed. One outstanding itch was that each field was being written to the buffer by the C function sprintf(). Although this is writing to an in-memory buffer directly, I wondered how big the overhead of interpreting the format string and actually calling the library function was. I knew from fread() that specialized code that is tuned to be iterated can make a big difference. So I created specialized writeNumeric and writeInteger functions in C using base R’s C source code (e.g. format.c:scientific()) as a guide to give me some clues. That’s better. Another 3x speedup: 0.9 seconds down to 0.3. This feels like the lower bound to me. So far we’ve been working with 1 million rows and an output csv file of around 150MB. Quite small by many standards. Let’s scale up 10x to 10 million rows on my laptop with SSD and 100x to 100 million rows on one of our 32 core / 256 GB physical servers. The reproducible code is at the end of this article. On the server we test writing to ram disk (/run/shm) versus writing to hard disk. Ram disk may be appropriate for ephemeral needs; e.g. transferring to a database where there is no requirement to keep the transfer file. To my surprise, writing a csv file using data.table::fwrite() appears to be faster than writing a binary file with feather. Your mileage may of course vary. If you ever need to quickly inspect the data using familiar command line text tools like head, tail, wc, grep and sed then it seems that csv files are still in the running then. Sometimes a csv format can turn out to be quite efficient. Consider the number 1.2 for example. In R that is an 8 byte ‘double’ but in the csv it’s just 3 characters wide, a 62% saving. This may be why the csv size (7.5GB) is slightly smaller than the binary (9.1GB). Here’s a small display of the data being tested: fwrite is available to test now in data.table v1.9.7 in development. Check out our installation notes for how to install the dev version and get OpenMP where necessary. Please try it out and let us know your findings. It works just as well on both data.frame and data.table. Note there are some outstanding items to complete before release to CRAN, collated here. fwrite() is a great improvement over write.csv(): 63 seconds down to 2 seconds for the 10 million row test on my laptop. write.csv() converts the input to character format first in-memory. This creates new string objects for each and every unique integer or numeric which takes compute cycles to create and hits the global character cache (a hash table) and uses more RAM. There is an advantage of doing it that way, though. The character conversion is object oriented so many user or package defined classes with their own print methods in R code will just work automatically with no C programming required. What’s the connection to H2O? Usually you would import data into H2O using h2o.importFile() called from either the R or Python H2O packages. h2o.importFile() has been parallel and distributed for some years. To test big-join I’m using it to load two 200GB files into a 10 node cluster with 2TB of RAM, for example. I’ll write more about this in a future article. Sometimes however, it’s necessary or convenient to transfer data between H2O and the R client. This step currently uses base R’s write.csv and read.csv. We intend to replace these calls with fwrite/fread. We’ll also look at the H2O Python package and see if we can improve that similarly. If you’d like to hear more about big-join in H2O I’ll be presenting at our Open H2O Tour in Chicago on May 3rd, 2016 together with lots of other amazing people including Leland Wilkinson, Jeff Chapman, Erin LeDell, Mark Landry and others. And use the promo code H2OYEAH to get a 50% discount. Also please catch up with me at Data-by-the-Bay where I’ll be presenting on May 16th, 2016. This article was also published on R-Bloggers here: http://www.r-bloggers.com/fast-csv-writing-for-r/ ### Appendix Reproducible code adapted from this Stack Overflow question install.packages(“data.table”, type=”source”, repos=”https://Rdatatable.github.io/data.table”) For Mac and Windows, see https://github.com/Rdatatable/data.table/wiki/Installation require(data.table) # v1.9.7 devtools::install_github(“wesm/feather/R”) require(feather) # v0.0.0.9000 require(readr) # CRAN v0.2.2 DTn = function(N) data.table( # or data.frame. Both work just as well. str1=sample(sprintf(“%010d”,sample(N,1e5,replace=TRUE)), N, replace=TRUE), str2=sample(sprintf(“%09d”,sample(N,1e5,replace=TRUE)), N, replace=TRUE), str3=sample(sapply(sample(2:30, 100, TRUE), function(n) paste0(sample(LETTERS, n, TRUE), collapse=””)), N, TRUE), str4=sprintf(“%05d”,sample(sample(1e5,50),N,TRUE)), num1=sample(round(rnorm(1e6,mean=6.5,sd=15),2), N, replace=TRUE), num2=sample(round(rnorm(1e6,mean=6.5,sd=15),10), N, replace=TRUE), str5=sample(c(“Y”,”N”),N,TRUE), str6=sample(c(“M”,”F”),N,TRUE), int1=sample(ceiling(rexp(1e6)), N, replace=TRUE), int2=sample(N,N,replace=TRUE)-N/2 ) set.seed(21) DT = DTn(1e6) Either ram disk : setwd(“/dev/shm”) or HDD/SDD : setwd(“~”) system.time(fwrite(DT,”fwrite.csv”)) system.time(write_feather(DT, “feather.bin”)) system.time(save(DT,file=”save1.Rdata”,compress=F)) system.time(save(DT,file=”save2.Rdata”,compress=T)) system.time(write.csv(DT,”write.csv.csv”,row.names=F,quote=F)) system.time(readr::write_csv(DT,”write_csv.csv”)) NB: It works just as well on both data.frame and data.table ## Compressing Zip Codes with Generalized Low Rank Models This tutorial introduces the Generalized Low Rank Model (GLRM) [1], a new machine learning approach for reconstructing missing values and identifying important features in heterogeneous data. It demonstrates how to build a GLRM in H2O that condenses categorical information into a numeric representation, which can then be used in other modeling frameworks such as deep learning. ## What is a Low Rank Model? Across business and research, analysts seek to understand large collections of data with numeric and categorical values. Many entries in this table may be noisy or even missing altogether. Low rank models facilitate the understanding of tabular data by producing a condensed vector representation for every row and column in the data set. Specifically, given a data table A with m rows and n columns, a GLRM consists of a decomposition of A into numeric matrices X and Y. The matrix X has the same number of rows as A, but only a small, user-specified number of columns k. The matrix Y has k rows and d columns, where d is equal to the total dimension of the embedded features in A. For example, if A has 4 numeric columns and 1 categorical column with 3 distinct levels (e.g., red, blue and green), then Y will have 7 columns. When A contains only numeric features, the number of columns in A and Y are identical, as shown below. Both X and Y have practical interpretations. Each row of Y is an archetypal feature formed from the columns of A, and each row of X corresponds to a row of A projected into this reduced dimension feature space. We can approximately reconstruct A from the matrix product XY, which has rank k. The number k is chosen to be much less than both m and n: a typical value for 1 million rows and 2,000 columns of numeric data is k = 15. The smaller k is, the more compression we gain from our low rank representation. GLRMs are an extension of well-known matrix factorization methods such as Principal Components Analysis (PCA). While PCA is limited to numeric data, GLRMs can handle mixed numeric, categorical, ordinal and Boolean data with an arbitrary number of missing values. It allows the user to apply regularization to X and Y, imposing restrictions like non-negativity appropriate to a particular data science context. Thus, it is an extremely flexible approach for analyzing and interpreting heterogeneous data sets. ## Data Description For this example, we will be using two data sets. The first is compliance actions carried out by the U.S. Labor Department’s Wage and Hour Division (WHD) from 2014-2015. This includes information on each investigation, including the zip code tabulation area (ZCTA) where the firm is located, number of violations found and civil penalties assessed. We want to predict whether a firm is a repeat and/or willful violator. In order to do this, we need to encode the categorical ZCTA column in a meaningful way. One common approach is to replace ZCTA with indicator variables for every unique level, but due to its high cardinality (there are over 32,000 ZCTAs!), this is slow and leads to overfitting. Instead, we will build a GLRM to condense ZCTAs into a few numeric columns representing the demographics of that area. Our second data set is the 2009-2013 American Community Survey (ACS) 5-year estimates of household characteristics. Each row contains information for a unique ZCTA, such as average household size, number of children and education. By transforming the WHD data with our GLRM, we not only address the speed and overfitting issues, but also transfer knowledge between similar ZCTAs in our model. ## Part 1: Condensing Categorical Data Initialize the H2O server and import the ACS data set. We use all available cores on our computer and allocate a maximum of 2 GB of memory to H2O. r library(h2o) h2o.init(nthreads = -1, max_mem_size = &quot;2G&quot;) We will need to set the path to a scratch directory that will contain the downloaded datasets. Please adjust at your will. r workdir &lt;- &quot;/tmp&quot; Now, let’s import the ACS data into H2O and separate out the zip code tabulation area column. r download.file(&quot;https://s3.amazonaws.com/h2o-public-test-data/bigdata/laptop/census/ACS_13_5YR_DP02_cleaned.zip&quot;, file.path(workdir, &quot;ACS_13_5YR_DP02_cleaned.zip&quot;, &quot;wget&quot;, quiet = TRUE)) acs_orig &lt;- h2o.importFile(path = file.path(workdir, &quot;ACS_13_5YR_DP02_cleaned.zip&quot;), col.types = c(&quot;enum&quot;, rep(&quot;numeric&quot;, 149))) acs_zcta_col &lt;- acs_orig$ZCTA5
acs_full &lt;- acs_orig[,-which(colnames(acs_orig) == &quot;ZCTA5&quot;)]

Get a summary of the ACS data set.
r
dim(acs_full)
summary(acs_full)

Build a GLRM to reduce ZCTA demographics to k = 10 archetypes. We standardize the data before model building to ensure a good fit. For the loss function, we select quadratic again, but this time, apply regularization to X and Y in order to sparsify the condensed features.
r
acs_model &lt;- h2o.glrm(training_frame = acs_full, k = 10, transform = &quot;STANDARDIZE&quot;, loss = &quot;Quadratic&quot;, regularization_x = &quot;Quadratic&quot;, regularization_y = &quot;L1&quot;, max_iterations = 100, gamma_x = 0.25, gamma_y = 0.5)
plot(acs_model)

From the plot of the objective function per iteration, we see that the algorithm has reached convergence.

The rows of the X matrix map each ZCTA into a combination of demographic archetypes.
r
zcta_arch_x &lt;- h2o.getFrame(acs_model@model$representation_name) head(zcta_arch_x) Plot a few interesting ZCTAs on the first two archetypes. We should see cities with similar demographics, such as Sunnyvale and Cupertino, grouped close together, while very different cities, such as the rural town McCune and the upper east side of Manhattan, fall far apart on the graph. r idx &lt;- ((acs_zcta_col == &quot;10065&quot;) | # Manhattan, NY (Upper East Side) (acs_zcta_col == &quot;11219&quot;) | # Manhattan, NY (East Harlem) (acs_zcta_col == &quot;66753&quot;) | # McCune, KS (acs_zcta_col == &quot;84104&quot;) | # Salt Lake City, UT (acs_zcta_col == &quot;94086&quot;) | # Sunnyvale, CA (acs_zcta_col == &quot;95014&quot;)) # Cupertino, CA city_arch &lt;- as.data.frame(zcta_arch_x[idx,1:2]) xeps &lt;- (max(city_arch[,1]) - min(city_arch[,1])) / 10 yeps &lt;- (max(city_arch[,2]) - min(city_arch[,2])) / 10 xlims &lt;- c(min(city_arch[,1]) - xeps, max(city_arch[,1]) + xeps) ylims &lt;- c(min(city_arch[,2]) - yeps, max(city_arch[,2]) + yeps) plot(city_arch[,1], city_arch[,2], xlim = xlims, ylim = ylims, xlab = &quot;First Archetype&quot;, ylab = &quot;Second Archetype&quot;, main = &quot;Archetype Representation of Zip Code Tabulation Areas&quot;) text(city_arch[,1], city_arch[,2], labels = c(&quot;Upper East Side&quot;, &quot;East Harlem&quot;, &quot;McCune&quot;, &quot;Salt Lake City&quot;, &quot;Sunnyvale&quot;, &quot;Cupertino&quot;), pos = 1) Your plot may look different depending on how the GLRM algorithm was initialized. Try plotting other archetypes against each other, or re-run GLRM with rank k = 2 for the best two-dimensional representation of the ZCTAs. ## Part 2: Runtime and Accuracy Comparison We now build a deep learning model on the WHD data set to predict repeat and/or willful violators. For comparison purposes, we train our model using the original data, the data with the ZCTA column replaced by the compressed GLRM representation (the X matrix), and the data with the ZCTA column replaced by all the demographic features in the ACS data set. Import the WHD data set and get a summary. r download.file(&quot;https://s3.amazonaws.com/h2o-public-test-data/bigdata/laptop/census/whd_zcta_cleaned.zip&quot;, file.path(workdir, &quot;whd_zcta_cleaned.zip&quot;, &quot;wget&quot;, quiet = TRUE)) whd_zcta &lt;- h2o.importFile(path = file.path(workdir, &quot;whd_zcta_cleaned.zip&quot;), col.types = c(rep(&quot;enum&quot;, 7), rep(&quot;numeric&quot;, 97))) dim(whd_zcta) summary(whd_zcta) Split the WHD data into test and train with a 20/80 ratio. r split &lt;- h2o.runif(whd_zcta) train &lt;- whd_zcta[split &lt;= 0.8,] test &lt;- whd_zcta[split &gt; 0.8,] Build a deep learning model on the WHD data set to predict repeat/willful violators. Our response is a categorical column with four levels: N/A = neither repeat nor willful, R = repeat, W = willful, and RW = repeat and willful violator. Thus, we specify a multinomial distribution. We skip the first four columns, which consist of the case ID and location information that is already captured by the ZCTA. r myY &lt;- &quot;flsa_repeat_violator&quot; myX &lt;- setdiff(5:ncol(train), which(colnames(train) == myY)) orig_time &lt;- system.time(dl_orig &lt;- h2o.deeplearning(x = myX, y = myY, training_frame = train, validation_frame = test, distribution = &quot;multinomial&quot;, epochs = 0.1, hidden = c(50,50,50))) Replace each ZCTA in the WHD data with the row of the X matrix corresponding to its condensed demographic representation. In the end, our single categorical column will be replaced by k = 10 numeric columns. r zcta_arch_x$zcta5_cd &lt;- acs_zcta_col
whd_arch &lt;- h2o.merge(whd_zcta, zcta_arch_x, all.x = TRUE, all.y = FALSE)
whd_arch$zcta5_cd &lt;- NULL summary(whd_arch) Split the reduced WHD data into test/train and build a deep learning model to predict repeat/willful violators. r train_mod &lt;- whd_arch[split &lt;= 0.8,] test_mod &lt;- whd_arch[split &gt; 0.8,] myX &lt;- setdiff(5:ncol(train_mod), which(colnames(train_mod) == myY)) mod_time &lt;- system.time(dl_mod &lt;- h2o.deeplearning(x = myX, y = myY, training_frame = train_mod, validation_frame = test_mod, distribution = &quot;multinomial&quot;, epochs = 0.1, hidden = c(50,50,50))) Replace each ZCTA in the WHD data with the row of ACS data containing its full demographic information. r colnames(acs_orig)[1] &lt;- &quot;zcta5_cd&quot; whd_acs &lt;- h2o.merge(whd_zcta, acs_orig, all.x = TRUE, all.y = FALSE) whd_acs$zcta5_cd &lt;- NULL
summary(whd_acs)

Split the combined WHD-ACS data into test/train and build a deep learning model to predict repeat/willful violators.
r
train_comb &lt;- whd_acs[split &lt;= 0.8,]
test_comb &lt;- whd_acs[split &gt; 0.8,]
myX &lt;- setdiff(5:ncol(train_comb), which(colnames(train_comb) == myY))
comb_time &lt;- system.time(dl_comb &lt;- h2o.deeplearning(x = myX, y = myY, training_frame = train_comb, validation_frame = test_comb, distribution = &quot;multinomial&quot;, epochs = 0.1, hidden = c(50,50,50)))

Compare the performance between the three models. We see that the model built on the reduced WHD data set finishes almost 10 times faster than the model using the original data set, and it yields a lower log-loss error. The model with the combined WHD-ACS data set does not improve significantly on this error. We can conclude that our GLRM compressed the ZCTA demographics with little informational loss.
r
data.frame(original = c(orig_time[3], h2o.logloss(dl_orig, train = TRUE), h2o.logloss(dl_orig, valid = TRUE)),
reduced = c(mod_time[3], h2o.logloss(dl_mod, train = TRUE), h2o.logloss(dl_mod, valid = TRUE)),
combined = c(comb_time[3], h2o.logloss(dl_comb, train = TRUE), h2o.logloss(dl_comb, valid = TRUE)),
row.names = c(&quot;runtime&quot;, &quot;train_logloss&quot;, &quot;test_logloss&quot;))
# original reduced combined
# runtime 40.3590000 6.5790000 7.5500000
# train_logloss 0.2467982 0.1895277 0.2440147
# test_logloss 0.2429517 0.1980886 0.2277701

## References

[1] M. Udell, C. Horn, R. Zadeh, S. Boyd (2014). Generalized Low Rank Models. Unpublished manuscript, Stanford Electrical Engineering Department.