def __init__(self,
inputLayer,
hiddenLayerSizes,
outputLayer,
existingAlgoPath=None):
super(QLearningNeuralNetwork, self).__init__()
self.lr_drop_rate = 0.9999
# Easy copy hack
self.tmp_nn = MLPRegressor(warm_start=True,
max_iter=5,
verbose=0,
tol=-1,
solver='sgd',
alpha=0.001,
learning_rate_init=0.005,
learning_rate='constant',
batch_size=32,
hidden_layer_sizes=hiddenLayerSizes)
if existingAlgoPath is None:
self.Q = MLPRegressor.set_params(self.tmp_nn)
self.QTarget = MLPRegressor.set_params(self.Q)
else:
self.Q = joblib.load(existingAlgoPath + ".pkl")
self.QTarget = MLPRegressor.set_params(self.Q)
self.tmp_nn = MLPRegressor.set_params(self.Q)
self.outputLayer = outputLayer
def test_config(mlp_params: Dict,
data: Tuple[np.ndarray, np.ndarray],
metadata: Dict[str, Any] = {},
n_iter: int = 100) -> pd.DataFrame:
"""
Tests an MLP with the specified parameters on the specified data. N
iterations will be run, each on a diffferent -- random -- test/training
split of the data.
:param mlp_params: Parameters to build the MLP with.
:param data: A tuple containing (inputs, outputs) for training and
validation.
:param metadata: Metadata to be included in the output DataFrame. Each
key will become a column, and the values will be assigned to all the rows
in the output.
:param n_iter: The number of iterations to run.
:return: A DataFrame with the results.
"""
X, Y = data
mse = np.zeros(n_iter)
train_times = np.zeros(n_iter)
mlp = MLPRegressor()
mlp.set_params(**mlp_params)
with warnings.catch_warnings():
# ignore some annoying warnings
warnings.simplefilter("ignore")
for i in range(n_iter):
# get a random train-test split
X_train, X_test, y_train, y_test = train_test_split(X, Y)
# train the estimator
# time this for analysis
ti = time.monotonic()
mlp.fit(X_train, y_train)
dt = time.monotonic() - ti
# get the MSE for the testing data
# store the result
y_pred = mlp.predict(X_test)
mse[i] = mean_squared_error(y_test, y_pred)
train_times[i] = dt
result = pd.DataFrame({'mse': mse, 'training_time': train_times})
for layer, nodes in enumerate(mlp_params['hidden_layer_sizes']):
result[f'layer{layer}_nodes'] = nodes
result['alpha'] = mlp_params['alpha']
for k, v in metadata.items():
result[k] = v
print(f'Processed MLP with params {mlp_params} and metadata {metadata}.')
return result
def train_and_save_final_model(X, y, X_train, y_train, params, save_model_file_path, test_data):
mlpr=MLPRegressor(random_state=0)
mlpr.set_params(**params)
if test_data == None:
mlpr.fit(X_train, y_train)
else:
mlpr.fit(X, y)
#save model
model_file_path = save_model_file_path + 'mlpr.sav'
pickle.dump(mlpr, open(model_file_path, 'wb'))
def fit(self, weight=1.0, boosted=False):
prev_loss = float("inf")
if boosted:
np.random.shuffle(self.data)
yhat = self.predict(self.data[:, :-1])
gradients = self.data[:, -1] - yhat
weak_model = MLPRegressor()
weak_model.set_params(**self.weak_regressor_parameter)
weak_model.fit(self.data[:, :-1], gradients)
self.models.append((self.l_rate, weak_model))
else:
for n_epoch in range(self.n_epochs):
np.random.shuffle(self.data)
for batch in folds(
self.data,
ceil(self.data.shape[0] / float(self.batch_size))):
batch_X, batch_Y = batch[:, :-1], batch[:, -1]
yhat = self.predict(batch_X)
error = (batch_Y - yhat) * yhat * (1.0 - yhat)
self.intercept += weight * self.l_rate * sum(error)
self.coefficients += weight * self.l_rate * np.sum(
error[:, None] * batch_X, axis=0)
self.l_rate = max(self.l_rate * self.l_decay, 0.01)
yhat = self.predict(self.data[:, :-1])
loss = -1 * np.mean(self.data[:, -1] * np.log(yhat) +
(1 - self.data[:, -1]) * np.log(1 - yhat))
if self.verbose:
print "\tEpoch %d, Loss = %f" % (n_epoch, loss)
if abs(prev_loss - loss) < self.tol:
if self.verbose:
print "Training loss did not improve more than tol=%f for two consecutive epochs. Stopping." % self.tol
return
prev_loss = loss
if self.verbose:
print
def updateTarget(self):
# Easy save hack
self.tmp_nn.coefs_ = self.Q.coefs_
self.tmp_nn.intercepts_ = self.Q.intercepts_
self.tmp_nn.learning_rate_init = self.Q.learning_rate_init
self.Q = deepcopy(self.tmp_nn)
self.QTarget = MLPRegressor.set_params(self.Q)
print("TARGET UPDATED")
print("Current LR is", self.Q.learning_rate_init)
def fit(self, weight=1.0, boosted=False):
if boosted == True:
eta = 0
self.converged = True
for _ in range(0, 5):
yhat = self.predict(self.X)
gradients = self.Y - yhat
weak_model = MLPRegressor()
weak_model.set_params(**self.weak_regressor_parameters)
weak_model.fit(self.X, gradients)
eta = self.get_best_weight(weak_model)
if self.verbose == True:
print
print "eta: %f" % eta
print
if eta != 0:
self.converged = False
if eta >= 0.1:
break
self.models.append((eta, weak_model))
else:
self.init_model.fit(self.X, self.Y)
if self.direct == False:
self.bias_input = np.array(self.init_model.intercepts_[0])
self.bias_hidden = np.array(self.init_model.intercepts_[1])
self.coefficients_input = np.array(self.init_model.coefs_[0])
self.coefficients_hidden = np.array(self.init_model.coefs_[1])
if self.verbose == True:
print
def grid_searh_NN(wine,model_setup,param_grid,max_epochs =1000,n_cores=-1,verbose=0) :
mlp = MLPRegressor(**model_setup)
mlp.set_params(max_iter=max_epochs)
X_train, Y_train, X_test, Y_test = prepare_data(u.get_wine(wine))
grid_search = model_selection.GridSearchCV(mlp, param_grid, return_train_score=True, cv=5,
scoring='neg_mean_absolute_error', n_jobs=n_cores, verbose=verbose)
t0 = time()
grid_search.fit(X_train, Y_train)
f_path = ""
for i in param_grid.keys() :
f_path += i + "_"
u.savegrid(grid_search, "nn", wine, f_path)
print("done in %0.3fs" % (time() - t0))
print()
print("Best score: %0.3f" % grid_search.best_score_)
print("Best parameters set:")
best_parameters = grid_search.best_estimator_.get_params()
print(best_parameters)
return grid_search
def fun_ann_fs(x, *args):
X, y, flag, n_splits, random_seed = args
n_samples, n_var = X.shape
#n_hidden = int(round(x[1]))
#hidden_layer_sizes = tuple( int(round(x[2+i])) for i in range(n_hidden))
n_hidden = int(round(x[3]))
hidden_layer_sizes = tuple(int(round(x[4 + i])) for i in range(n_hidden))
af = {
0: 'logistic',
1: 'identity',
2: 'relu',
3: 'tanh',
}
s = {
0: 'lbfgs',
1: 'sgd',
2: 'adam',
}
p = {
'activation': af[int(round(x[0]))],
'hidden_layer_sizes': hidden_layer_sizes,
#'alpha':1e-5, 'solver':'lbfgs',
'solver': s[int(round(x[1]))],
'alpha': x[2],
}
clf = MLPRegressor(random_state=int(random_seed), warm_start=False)
clf.set_params(**p)
if len(x) <= 9:
ft = np.array([1 for i in range(n_var)])
ft = np.where(ft > 0.5)
else:
ft = np.array([1 if k > 0.5 else 0 for k in x[4::]])
ft = np.where(ft > 0.5)
#x[4::] = [1 if k>0.5 else 0 for k in x[4::]]
#ft = np.array([1 if k>0.5 else 0 for k in x[4::]])
#ft = np.where(ft>0.5)
try:
#cv=KFold(n_splits=n_splits, shuffle=True, random_state=random_seed)
#cv=KFold(n=n_samples, n_folds=5, shuffle=True, ranwarm_start=Falsedom_state=int(random_seed))
cv = KFold(n_splits=n_splits,
shuffle=True,
random_state=int(random_seed))
y_p = cross_val_predict(clf, X, np.ravel(y), cv=cv, n_jobs=1)
r = RMSE(y_p, y)
r2 = MAPE(y_p, y)
r3 = RRMSE(y_p, y)
r4 = -r2_score(y_p, y)
#r = mean_squared_error(y,y_p)**0.5
#r = MAPE(y,y_p)
#r = -accuracy_score(y,y_p)
#r = -f1_score(y,y_p,average='weighted')
except:
# print("except")
y_p = [None]
r = 1e12
#print(r,'\t',p,)#'\t',ft)
if flag == 'eval':
return r
else:
clf.fit(X[:, ft].squeeze(), y)
return {
'Y_TRUE': y,
'Y_PRED': y_p,
'EST_PARAMS': p,
'PARAMS': x,
'EST_NAME': 'ANN',
'ESTIMATOR': clf,
'ACTIVE_VAR': ft,
'DATA': X,
'SEED': random_seed,
'ERROR_TRAIN': {
'RMSE': r,
'MAPE': r2,
'RRMSE': r3,
'R2_SCORE': r4
}
}
def make_nn_pred(df, next_week, debug=0):
"""
This method creates predicitions using a neural network.
"""
#Tuned##
rand_space = {
'hidden_layer_sizes': [(100, ), (500, ), (1000, )],
'activation': ['tanh', 'relu'],
'solver': ['lbfgs', 'sgd', 'adam'],
'shuffle': [True, False],
'alpha': [1, 10, 100, 500],
'learning_rate': ['constant', 'invscaling', 'adaptive'],
'max_iter': [1, 10, 1000, 10000, 100000],
'early_stopping': [True, False]
}
space = {
'hidden_layer_sizes': [(500, ), (550, ), (600, ), (650, ), (700, )],
'activation': ['tanh'],
'solver': ['lbfgs'],
'shuffle': [False],
'alpha': [5, 6, 7, 8],
'learning_rate': ['constant'],
'max_iter': [4, 5, 6, 7],
'early_stopping': [True]
}
params_old = {
'hidden_layer_sizes': (600, ),
'activation': 'tanh',
'solver': 'lbfgs',
'alpha': 4,
'learning_rate': 'constant',
'max_iter': 6,
'shuffle': False,
'early_stopping': True
}
params = {
'hidden_layer_sizes': (1000, ),
'activation': 'tanh',
'solver': 'lbfgs',
'alpha': 1,
'learning_rate': 'invscaling',
'max_iter': 10000,
'early_stopping': True
}
X_train, X_test, Y_train, Y_test = process_data(df, next_week)
multi_nnr = MLPRegressor()
multi_nnr.set_params(**params)
#best_random = random_search(multi_nnr, rand_space, next_week, 100, 3, X_train, Y_train)
#best_random = grid_search(multi_nnr, space, next_week, 3, X_train, Y_train)
multi_nnr.fit(X_train, Y_train)
next_week[Y_train.columns] = multi_nnr.predict(next_week[X_train.columns])
if debug:
y_pred_untrain = multi_nnr.predict(X_train)
print(next_week)
print("Score: ", multi_nnr.score(X_train, Y_train) * 100)
print("MSE: ", metrics.mean_squared_error(Y_train, y_pred_untrain))
print(
"CV: ",
ms.cross_val_score(multi_nnr,
Y_train,
y_pred_untrain,
cv=10,
scoring='neg_mean_squared_error'))
return next_week
import matplotlib.pyplot as plt
from sklearn.neural_network import MLPRegressor
from time import time
data = pd.read_csv('data_sheet_III/data_function_approximation.txt', sep=' ')
data.columns = ['x', 'y']
X = data['x'].values.reshape(-1, 1)
y = data['y'].values
mlp = MLPRegressor(solver='lbfgs', activation='logistic', random_state=0)
architecture = [(2, 3), (7, 5), (7, 5, 3), (5), (3), (15)]
fig, ax = plt.subplots(3, 2)
fig.tight_layout()
ax = ax.ravel()
y_pred = []
X_test = np.linspace(0, 20, num=100).reshape(-1, 1)
for arch, axis in zip(architecture, ax):
print(arch)
start_time = time()
mlp.set_params(hidden_layer_sizes=arch)
mlp.fit(X, y)
fit_time = np.round_(time() - start_time, decimals=4)
y_pred.append(mlp.predict(X_test))
axis.plot(X, y)
axis.plot(X_test, y_pred[-1])
axis.set_title(str(arch) + ' (' + str(fit_time) + ' sec.)')
axis.label_outer()
print('loss', mlp.loss_ * 10**5)
plt.show()
print('success split')
#dataset
#dataresult
reg = linear_model.LinearRegression()
reg.fit(trainingX,trainingY)
print('LR Error rates:')
regError = calculateErrorRates(reg, testX, testY)
# ANN
ann = MLPRegressor(hidden_layer_sizes = (3),alpha = 1e-10)
ann.fit(trainingX,trainingY)
print('ANN Error rates for layer 3:')
annError3 = calculateErrorRates(ann, testX, testY)
ann.set_params(hidden_layer_sizes=(2))
ann.fit(trainingX,trainingY)
print('ANN Error rates for layer 2:')
annError2 = calculateErrorRates(ann, testX, testY)
ann.set_params(hidden_layer_sizes=(1))
ann.fit(trainingX,trainingY)
print('ANN Error rates for layer 1:')
annError1 = calculateErrorRates(ann, testX, testY)
#Ridge
ridge = linear_model.Ridge (alpha = .5)
ridge.fit(trainingX,trainingY)
print('Ridge Error rates:')
ridgeError = calculateErrorRates(ridge, testX, testY)
