Skip to content

Instantly share code, notes, and snippets.

@ddtxra

ddtxra/test_keras.py

Forked from bacalfa/test_keras.py
Created September 15, 2017 23:52
Show Gist options
  • Save ddtxra/7f035cf31e08aa0606b2bd340f9d9ec8 to your computer and use it in GitHub Desktop.
Save ddtxra/7f035cf31e08aa0606b2bd340f9d9ec8 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
test_keras.py
import numpy as np
from sklearn.neural_network import MLPRegressor
from sklearn.model_selection import RandomizedSearchCV
from keras.models import Sequential
from keras.layers import Dense
from keras.wrappers.scikit_learn import KerasRegressor
import sklearn.metrics
def mean_absolute_percentage_error(y_true, y_pred):
if any(y_true == 0):
return 0.0
else:
return np.mean(np.abs((y_true - y_pred) / y_true)) * 100
import time
## Run on CPU only
import os
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID" # see issue #152
os.environ["CUDA_VISIBLE_DEVICES"] = ""
## Fix random seed for reproducibility
seed = 7
np.random.seed(seed)
## General and CV options
n_iter = 80
n_jobs = -1
cv = 5
max_iter = 1000
batch_size = 32
## Import data
classification = False
X = np.loadtxt("house_dataset_x.txt")
y = np.loadtxt("house_dataset_y.txt")
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=seed)
from sklearn import preprocessing
X_train, X_test = preprocessing.scale(X_train), preprocessing.scale(X_test)
# X_train, X_test = preprocessing.minmax_scale(X_train), preprocessing.minmax_scale(X_test)
## Parameters for MLP
neurons_output = max(1, y_train.shape[1] if len(y_train.shape) > 1 else 1)
sumInOutSize = X_train.shape[1] + neurons_output
minNeuron = neurons_output
maxNeuron = int(X_train.shape[0] / (2.0 * (X_train.shape[1] + neurons_output)))
epochs = np.ceil(np.float(batch_size)/X_train.shape[0]*max_iter).astype(np.int_)
input_dim = X_train.shape[1] if len(X_train.shape) > 1 else 1
output_dim = y_train.shape[1] if len(y_train.shape) > 1 else 1
n_layers = 1
## MLPRegressor
MLPR_mdl = MLPRegressor(random_state=seed, max_iter=max_iter, batch_size=batch_size)
MLPR_param_distributions = \
{
"hidden_layer_sizes": [(x,) for x in range(minNeuron,maxNeuron)],
"solver": ["lbfgs", "sgd", "adam"],
"learning_rate": ["constant", "invscaling", "adaptive"],
"activation": ["identity", "logistic", "tanh", "relu"],
"alpha": list(np.random.uniform(low=0, high=5, size=n_iter)),
"learning_rate_init": list(10.0 ** np.random.uniform(low=-6, high=-2, size=n_iter)),
"momentum": list(np.random.uniform(low=1E-2, high=1, size=n_iter)),
"nesterovs_momentum": [True, False],
"beta_1": list(np.random.uniform(low=1E-2, high=1, size=n_iter)),
"beta_2": list(np.random.uniform(low=1E-2, high=1, size=n_iter))
}
MLPR_random_search = RandomizedSearchCV(estimator=MLPR_mdl, cv=cv, n_iter=n_iter, param_distributions=MLPR_param_distributions, n_jobs=n_jobs)
MLPR_start = time.perf_counter()
MLPR_result = MLPR_random_search.fit(X_train, y_train)
MLPR_end = time.perf_counter()
MLPR_y_pred = MLPR_result.predict(X=X_test)
## KerasRegressor
# Function to create model, required for KerasClassifier
def create_model(n_layers=n_layers, units=10, input_dim=input_dim, output_dim=output_dim,
optimizer="rmsprop", loss="binary_crossentropy",
kernel_initializer="glorot_uniform", activation="sigmoid",
kernel_regularizer="l2", kernel_regularizer_weight=0.01,
lr=0.01, momentum=0.0, decay=0.0, nesterov=False, rho=0.9, epsilon=1E-8,
beta_1=0.9, beta_2=0.999, schedule_decay=0.004):
from keras import regularizers, optimizers
# Create model
if kernel_regularizer.lower() == "l1":
kernel_regularizer = regularizers.l1(l=kernel_regularizer_weight)
elif kernel_regularizer.lower() == "l2":
kernel_regularizer = regularizers.l2(l=kernel_regularizer_weight)
elif kernel_regularizer.lower() == "l1_l2":
kernel_regularizer = regularizers.l1_l2(l1=kernel_regularizer_weight, l2=kernel_regularizer_weight)
else:
print("Warning: Kernel regularizer {0} not supported. Using default 'l2' regularizer.".format(
kernel_regularizer))
kernel_regularizer = regularizers.l2(l=kernel_regularizer_weight)
if optimizer.lower() == "sgd":
optimizer = optimizers.sgd(lr=lr, momentum=momentum, decay=decay, nesterov=nesterov)
elif optimizer.lower() == "rmsprop":
optimizer = optimizers.rmsprop(lr=lr, rho=rho, epsilon=epsilon, decay=decay)
elif optimizer.lower() == "adagrad":
optimizer = optimizers.adagrad(lr=lr, epsilon=epsilon, decay=decay)
elif optimizer.lower() == "adadelta":
optimizer = optimizers.adadelta(lr=lr, rho=rho, epsilon=epsilon, decay=decay)
elif optimizer.lower() == "adam":
optimizer = optimizers.adam(lr=lr, beta_1=beta_1, beta_2=beta_2, epsilon=epsilon, decay=decay)
elif optimizer.lower() == "adamax":
optimizer = optimizers.adamax(lr=lr, beta_1=beta_1, beta_2=beta_2, epsilon=epsilon, decay=decay)
elif optimizer.lower() == "nadam":
optimizer = optimizers.nadam(lr=lr, beta_1=beta_1, beta_2=beta_2, epsilon=epsilon,
schedule_decay=schedule_decay)
else:
print("Warning: Optimizer {0} not supported. Using default 'sgd' optimizer.".format(optimizer))
optimizer = "sgd"
model = Sequential()
model.add(
Dense(units=units, input_dim=input_dim,
kernel_initializer=kernel_initializer, activation=activation,
kernel_regularizer=kernel_regularizer))
for layer_count in range(n_layers - 1):
model.add(
Dense(units=units, kernel_initializer=kernel_initializer, activation=activation,
kernel_regularizer=kernel_regularizer))
model.add(Dense(units=output_dim,
kernel_initializer=kernel_initializer, activation="linear",
kernel_regularizer=kernel_regularizer))
# Compile model
model.compile(loss=loss, optimizer=optimizer, metrics=['accuracy'])
return model
keras_param_distributions = \
{
"units": [x for x in range(minNeuron,maxNeuron)],
"optimizer": ["sgd", "rmsprop", "adagrad", "adadelta", "adam", "adamax", "nadam"],
"kernel_initializer": ["uniform", "normal", "glorot_normal", "glorot_uniform"],
"activation": ["relu", "tanh", "sigmoid"],
"loss": ["mse"],
"kernel_regularizer": ["l1", "l2", "l1_l2"],
"kernel_regularizer_weight": list(np.random.uniform(low=1E-3, high=5, size=n_iter)),
"lr": list(10.0 ** np.random.uniform(low=-6, high=0, size=n_iter)),
"momentum": list(np.random.uniform(low=1E-4, high=1, size=n_iter)),
# "decay": list(np.random.uniform(low=1E-8, high=1E-2, size=n_iter)),
"nesterov": [True, False],
# "rho": list(np.random.uniform(low=1E-1, high=1, size=n_iter)),
# "epsilon": list(np.random.uniform(low=1E-8, high=1E-6, size=n_iter)),
# "schedule_decay": list(np.random.uniform(low=1E-4, high=1E-2, size=n_iter)),
"beta_1": list(np.random.uniform(low=1E-2, high=1, size=n_iter)),
"beta_2": list(np.random.uniform(low=1E-2, high=1, size=n_iter))
}
keras_mdl = KerasRegressor(build_fn=create_model, epochs=epochs, batch_size=batch_size, verbose=0)
keras_random_search = RandomizedSearchCV(estimator=keras_mdl, cv=cv, n_iter=n_iter, param_distributions=keras_param_distributions, n_jobs=n_jobs)
keras_start = time.perf_counter()
keras_result = keras_random_search.fit(X_train, y_train)
keras_end = time.perf_counter()
keras_y_pred = keras_result.predict(X=X_test)
## Summarize results
print("MLPRegressor")
print("============")
print("Time: {0}".format(MLPR_end - MLPR_start))
print("Score: {0}".format(MLPR_result.best_score_))
print("Parameters: {0}".format(MLPR_result.best_params_))
print("r2_score: {0}".format(sklearn.metrics.r2_score(y_true=y_test, y_pred=MLPR_y_pred)))
print("mean_absolute_error: {0}".format(sklearn.metrics.mean_absolute_error(y_true=y_test, y_pred=MLPR_y_pred)))
print("mean_squared_error: {0}".format(sklearn.metrics.mean_squared_error(y_true=y_test, y_pred=MLPR_y_pred)))
print("median_absolute_error: {0}".format(sklearn.metrics.median_absolute_error(y_true=y_test, y_pred=MLPR_y_pred)))
print("mean_absolute_percentage_error: {0}".format(mean_absolute_percentage_error(y_true=y_test, y_pred=MLPR_y_pred)))
print()
print("KerasRegressor")
print("==============")
print("Time: {0}".format(keras_end - keras_start))
print("Score: {0}".format(keras_result.best_score_))
print("Parameters: {0}".format(keras_result.best_params_))
print("r2_score: {0}".format(sklearn.metrics.r2_score(y_true=y_test, y_pred=keras_y_pred)))
print("mean_absolute_error: {0}".format(sklearn.metrics.mean_absolute_error(y_true=y_test, y_pred=keras_y_pred)))
print("mean_squared_error: {0}".format(sklearn.metrics.mean_squared_error(y_true=y_test, y_pred=keras_y_pred)))
print("median_absolute_error: {0}".format(sklearn.metrics.median_absolute_error(y_true=y_test, y_pred=keras_y_pred)))
print("mean_absolute_percentage_error: {0}".format(mean_absolute_percentage_error(y_true=y_test, y_pred=keras_y_pred)))
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment