H2O4GPU: Machine Learning with GPUs in R

Virtual environments

Using a Python virtual environment is a good solution if you don't want to upgrade your main Python installation to 3.6. If you installed the h2o4gpu Python module into a virtual environment, you will have to add a line of code to tell R which Python envivonment you want to use:

library(reticulate)
use_virtualenv("/home/username/venv/h2o4gpu")  # set this to the path of your venv

If you have installed h2o4gpu Python module using Anaconda, then you can use the use_condaenv() function instead. More information about Python environment configuration is available in the reticulate user guide.

Binary Classification

In this example, we will train and test three different models on a subset of the HIGGS dataset. The goal in this dataset is to distinguish between signal "1" and background "0", so this is a binary classification problem. The features are all numeric.

H2O4GPU requires all feature and response columns to be numeric, so in this case, we don't have to do any pre-processing of the data. If your response column is a factor, then you can simply convert the levels to integer values using as.integer(). If you have categorical/factor columns among your features, you must apply an encoding method to convert the columns into numeric data. Some options are label encoding (simply convert the levels to integers) or one hot encoding (binary indicator columns, one for each categorical level). For simplicity, in this tutorial, we will always use label encoding, however you can read more about different types of encodings here.

# Load a sample dataset for binary classification
# Source: https://archive.ics.uci.edu/ml/datasets/HIGGS
train <- read.csv("https://s3.amazonaws.com/erin-data/higgs/higgs_train_10k.csv")
test <- read.csv("https://s3.amazonaws.com/erin-data/higgs/higgs_test_5k.csv")

# Create train & test sets (column 1 is the response)
x_train <- train[, -1]
y_train <- train[, 1]
x_test <- test[, -1]
y_test <- test[, 1]

Below we see that the h2o4gpu modeling functions follow a two-phased functional apporach. The two phased approach to modeling (first initialize model, then train) is more common in Python, and we borrow that paradigm here. We blend this with the the functional pipe syntax in R.

First you define the model with it's hyperparameters, for example, h2o4gpu.gradient_boosting_classifier(n_estimators = 500, subsample = 0.8). Then we pipe the initialized model object to the fit(x, y) function to train the model, and save the resulting object.

# Train three different binary classification models
model_gbc <- h2o4gpu.gradient_boosting_classifier() %>% fit(x_train, y_train)
model_rfc <- h2o4gpu.random_forest_classifier() %>% fit(x_train, y_train)
model_enc <- h2o4gpu.elastic_net_classifier() %>% fit(x_train, y_train) 

We pipe our trained models to the familiar predict() method. In binary classification, we are often more interested in the numeric predicted values, rather than the predicted class labels. We follow the same design as the predict() function in the popular caret package, which allows the user to specify which type of predictions they want to return using the type argument. This defaults to "raw" which in classification, yields predicted class labels. When we set it to "prob", it returns the (uncalibrated) class probabilities. This is not mentioned often in modeling software documentation, but you should note that despite using the term "probabilities", these predicted values do not represent actual probabilities unless some method like Platt scaling is used for calibration. This is true for all machine learning packages, including caret, h2o, and h2o4gpu (though we do offer the option to perform Platt scaling inside the h2o R package).

# Generate predictions (type "prob" gives predicted values instead of predicted label)
pred_gbc <- model_gbc %>% predict(x_test, type = "prob")
pred_rfc <- model_rfc %>% predict(x_test, type = "prob")
pred_enc <- model_enc %>% predict(x_test, type = "prob")

Let's take a look at what the output of the predict() function looks like in binary classification. It will be a two-column matrix with the column names set to the names of the classes.

head(pred_rfc)

To compute AUC of a binary classification model, we use the predicted values of the second column (the "positive" class) and pass that to the Metrics::auc() function.

# Compare test set performance using AUC
auc(actual = y_test, predicted = pred_gbc[, 2])
auc(actual = y_test, predicted = pred_rfc[, 2])
auc(actual = y_test, predicted = pred_enc[, 2])

Multiclass Classification

Now that we are familiar with binary classification, there is not much more to say about multiclass classification. The predict output will have the same format as binary classification, except that if you use type = "prob" number of columns will match the number of classes. Often in multiclass classification, you may be interested in the predicted class label and misclassification error, which we've demonstrated already in the Quickstart section.

Regression

In this next exercise, we will compare a GBM and GLM regression model. Until this issue is respolved, we don't recommend that you use the Random Forest regressor, as there are some bugs that are severely affecting model performance.

We will predicting the age of abalone from physical measurements, using the Abalone dataset.

# Load a sample dataset for regression
# Source: https://archive.ics.uci.edu/ml/datasets/Abalone
df <- read.csv("https://archive.ics.uci.edu/ml/machine-learning-databases/abalone/abalone.data", header = FALSE)
str(df)

There is one categorical/factor column in this dataset, so we will first convert those values to integers (label encoding). Recall that label encoding is just one way of encoding the categorical column and that there may be other ways that produce better results in terms of model performance.

df[, 1] <- as.integer(df[, 1])  #label encode the one factor column

In this case, we started with a single data frame, so we should break the data into train and test splits at random. We can do that easily in R by sampling 80% of the row indices and subsetting the data frame by row.

# Randomly sample 80% of the rows for the training set
set.seed(1)
train_idx <- sample(1:nrow(df), 0.8*nrow(df))

# Create train & test sets (column 9 is the response)
x_train <- df[train_idx, -9]
y_train <- df[train_idx, 9]
x_test <- df[-train_idx, -9]
y_test <- df[-train_idx, 9]

# Train two different regression models
model_gbr <- h2o4gpu.gradient_boosting_regressor() %>% fit(x_train, y_train)
model_enr <- h2o4gpu.elastic_net_regressor() %>% fit(x_train, y_train)

# Generate predictions 
pred_gbr <- model_gbr %>% predict(x_test)
pred_enr <- model_enr %>% predict(x_test)

In regression, the predict() function always returns a vector of predictions (not a data frame).

head(pred_gbr)

In regression problems, Mean Squared Error (MSE), is a common metric for model evaluation. We will use test set MSE to evaluate and compare our two models.

# Compare test set performance using MSE
mse(actual = y_test, predicted = pred_gbr)
mse(actual = y_test, predicted = pred_enr)

In this case, which is not usual, the GBM drastically outperforms the GLM.

K-Means Clustering

First we will train a K-Means model. Let's create a train and test set from the iris dataset.

# Prepare data
iris$Species <- as.integer(iris$Species) # convert to numeric data

# Randomly sample 80% of the rows for the training set
set.seed(1)
train_idx <- sample(1:nrow(iris), 0.8*nrow(iris)) 
train <- iris[train_idx, ]
test <- iris[-train_idx, ]

Train a K-Means model with three clusters.

model_km <- h2o4gpu.kmeans(n_clusters = 3L) %>% fit(train)

Once you have trained a K-Means model, applying the transform() function to a dataset transforms your points into distances from each centroid. So your nxp matrix becomes nxk (n is the number of observations,p the number of features and k the number of clusters).

test_dist <- model_km %>% transform(test)
head(test_dist)

Principal Compoment Analysis (PCA)

Let's use the HIGGS train and test datasets again for demonstration.

# Load a sample dataset for binary classification
# Source: https://archive.ics.uci.edu/ml/datasets/HIGGS
train <- read.csv("https://s3.amazonaws.com/erin-data/higgs/higgs_train_10k.csv")
test <- read.csv("https://s3.amazonaws.com/erin-data/higgs/higgs_test_5k.csv")

Train a PCA model with 4 components and apply the transformation onto a dataset. Once you have created a projection model from a dataset, you can apply that transformation to a new dataset (such as a test set) using the transform() function.

model_pca <- h2o4gpu.pca(n_components = 4) %>% fit(train)
test_transformed <- model_pca %>% transform(test)

Truncated Singular Value Decomposition (SVD)

Train a truncated SVD model with 4 components and apply the transformation on a test set.

model_tsvd <- h2o4gpu.truncated_svd(n_components = 4) %>% fit(train)
test_transformed <- model_tsvd %>% transform(test)