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)