API deep learning fully connected with categorical data: h2o > R mxnet > py keras >>>>> tensorflow

API_DL_FC_catdata--tools.R

#### h2o

library(h2o)
h2o.init(max_mem_size = "50g", nthreads = -1)

dx_train <- h2o.importFile("train-1m.csv")
dx_test <- h2o.importFile("test.csv")

Xnames <- names(dx_train)[which(names(dx_train)!="dep_delayed_15min")]

md <- h2o.deeplearning(x = Xnames, y = "dep_delayed_15min", training_frame = dx_train,
            activation = "Rectifier", hidden = c(200,200), 
            adaptive_rate = FALSE, rate = 0.01, rate_annealing = 0,
            momentum_start = 0.9, momentum_stable = 0.9, nesterov_accelerated_gradient = FALSE,
            epochs = 1) 

h2o.performance(md, dx_test)@metrics$AUC



#### mxnet (from R)

library(readr)
library(ROCR)
library(mxnet)
library(Matrix)
library(magrittr)

d_train <- read_csv("train-1m.csv")
d_test <- read_csv("test.csv")

## normalization BOILERPLATE
d_train$DepTime <- d_train$DepTime/2500
d_test$DepTime <- d_test$DepTime/2500
d_train$Distance <- log10(d_train$Distance)/4
d_test$Distance <- log10(d_test$Distance)/4

X_train_test <- model.matrix(dep_delayed_15min ~ ., data = rbind(d_train, d_test))

## categ.levels BOILERPLATE
X_train <- X_train_test[1:nrow(d_train),]
X_test <- X_train_test[(nrow(d_train)+1):(nrow(d_train)+nrow(d_test)),]

md_spec <- mx.symbol.Variable('data') %>%
  mx.symbol.FullyConnected(num_hidden = 200) %>% mx.symbol.Activation(act_type = "relu") %>%
  mx.symbol.FullyConnected(num_hidden = 200) %>% mx.symbol.Activation(act_type = "relu") %>%
  mx.symbol.FullyConnected(num_hidden = 2) %>% mx.symbol.SoftmaxOutput()

md <- mx.model.FeedForward.create(md_spec, 
               X = X_train, y = as.numeric(d_train$dep_delayed_15min=="Y"), array.layout = "rowmajor",
               initializer = mx.init.normal(0.1),
               eval.metric = mx.metric.accuracy,
               learning.rate = 0.01, momentum = 0.9,  
               ctx = mx.gpu(), 
               num.round = 1, array.batch.size = 128,
               epoch.end.callback = mx.callback.log.train.metric(100))

phat <- t(predict(md, X_test, array.layout = "rowmajor"))[,2]
rocr_pred <- prediction(phat, as.numeric(d_test$dep_delayed_15min=="Y"))
performance(rocr_pred, "auc")



#### keras (python)

from __future__ import print_function
from keras.models import Sequential
from keras.layers import Dense
from keras.optimizers import SGD
from keras.utils import np_utils
from keras import backend as K
import numpy as np
import time
import pandas as pd
from sklearn import metrics

d_train = pd.read_csv("train-1m.csv")
d_test = pd.read_csv("test.csv")
d_train_test = d_train.append(d_test)

## normalization BOILERPLATE
d_train_test["DepTime"] = d_train_test["DepTime"]/2500
d_train_test["Distance"] = np.log10(d_train_test["Distance"])/4

## 1-hot encoding BOILERPLATE
vars_categ = ["Month","DayofMonth","DayOfWeek","UniqueCarrier", "Origin", "Dest"]
vars_num = ["DepTime","Distance"]
def get_dummies(d, col):
    dd = pd.get_dummies(d.ix[:, col])
    dd.columns = [col + "_%s" % c for c in dd.columns]
    return(dd)
       
X_train_test_categ = pd.concat([get_dummies(d_train_test, col) for col in vars_categ], axis = 1)

## categ level BOILERPLATE
X_train_test = pd.concat([X_train_test_categ, d_train_test.ix[:,vars_num]], axis = 1)
y_train_test = np.where(d_train_test["dep_delayed_15min"]=="Y", 1, 0)

X_train = X_train_test[0:d_train.shape[0]]
y_train = y_train_test[0:d_train.shape[0]]
X_test = X_train_test[d_train.shape[0]:]
y_test = y_train_test[d_train.shape[0]:]

## more BOILERPLATE
X_train = X_train.as_matrix()
X_test = X_test.as_matrix()
y_train = np_utils.to_categorical(y_train, 2)

model = Sequential()
model.add(Dense(200, activation = 'relu', input_dim = 690))
model.add(Dense(200, activation = 'relu'))
model.add(Dense(2, activation = 'softmax'))
sgd = SGD(lr = 0.01, momentum = 0.9)
model.compile(loss = 'categorical_crossentropy', optimizer = sgd, metrics = ['accuracy'])

model.fit(X_train, y_train, batch_size = 128, nb_epoch = 1)

phat = model.predict_proba(X_test)[:,1]
metrics.roc_auc_score(y_test, phat)