def model_fit(param): print "Training %s" % param[0] neural_shape = [param[0], 15, 1] X_train = param[1][0] y_train = param[1][1] X_test = param[1][2] y_test = param[1][3] fit_param = {"neural_shape": neural_shape} neuralNet = NeuralFlowRegressor() neuralNet.fit(X_train, y_train, **fit_param) return param[0], np.sqrt(neuralNet.score(X_test, y_test))
def model_fit(param): print "Training %s"%param[0] neural_shape = [param[0],15,1] X_train = param[1][0] y_train = param[1][1] X_test = param[1][2] y_test = param[1][3] fit_param = { "neural_shape":neural_shape } neuralNet = NeuralFlowRegressor() neuralNet.fit(X_train,y_train,**fit_param) return param[0],np.sqrt(neuralNet.score(X_test,y_test))
def model_fit(param): print "Training %s" % param[0] X_train = param[1][0] y_train = param[1][1] X_test = param[1][2] y_test = param[1][3] neural_shape = [y_train.shape[1] * param[0], 10, y_train.shape[1]] acoNet = GAEstimator(cross_rate=0.65, mutation_rate=0.01, pop_size=50) fit_param = {"neural_shape": neural_shape} acoNet.fit(X_train, y_train, **fit_param) fit_param["weights_matrix"] = acoNet.best_archive neuralNet = NeuralFlowRegressor() neuralNet.fit(X_train, y_train, **fit_param) return param[0], np.sqrt(neuralNet.score(X_test, y_test))
def model_fit(param): print "Training %s" % param[0] neural_shape = [param[0], 15, 1] X_train = param[1][0] y_train = param[1][1] X_test = param[1][2] y_test = param[1][3] acoNet = ACOEstimator(Q=0.08, epsilon=0.55) fit_param = {"neural_shape": neural_shape} acoNet.fit(X_train, y_train, **fit_param) fit_param["weights_matrix"] = acoNet.best_archive neuralNet = NeuralFlowRegressor() neuralNet.fit(X_train, y_train, **fit_param) return param[0], np.sqrt(neuralNet.score(X_test, y_test))
def model_fit(param): print "Training %s"%param[0] neural_shape = [param[0],15,1] X_train = param[1][0] y_train = param[1][1] X_test = param[1][2] y_test = param[1][3] acoNet = GAEstimator(cross_rate=0.65,mutation_rate=0.01,pop_size=50) fit_param = { "neural_shape":neural_shape } acoNet.fit(X_train,y_train,**fit_param) fit_param["weights_matrix"] = acoNet.best_archive neuralNet = NeuralFlowRegressor() neuralNet.fit(X_train,y_train,**fit_param) return param[0],np.sqrt(neuralNet.score(X_test,y_test))
def model_fit(param): print "Training %s"%param[0] X_train = param[1][0] y_train = param[1][1] X_test = param[1][2] y_test = param[1][3] neural_shape = [y_train.shape[1]*param[0],10,y_train.shape[1]] acoNet = ACOEstimator(Q=0.08,epsilon=0.55) fit_param = { "neural_shape":neural_shape } acoNet.fit(X_train,y_train,**fit_param) fit_param["weights_matrix"] = acoNet.best_archive neuralNet = NeuralFlowRegressor() neuralNet.fit(X_train,y_train,**fit_param) return param[0],np.sqrt(neuralNet.score(X_test,y_test))
def estimator(n_windows, n_hidden_nodes): data = data_train[n_windows] X_train = data[0] y_train = data[1] X_test = data[2] y_test = data[3] fit_param = {'neural_shape': [2 * n_windows, n_hidden_nodes, 2]} neuralNet = NeuralFlowRegressor() kfold = KFold(X_train.shape[0], 5) score_lst = np.zeros(len(kfold), dtype=np.float32) for k, (train, test) in enumerate(kfold): neuralNet.fit(X_train[train], y_train[train], **fit_param) nn_shape = "%s-%s" % (2 * n_windows, n_hidden_nodes) score = neuralNet.score(X_test, y_test) neuralNet.save("tmp/score_%s" % score) return nn_shape, score
def fit(self, data=None): result = [] for train_item in self.train_bucket: X_train, y_train, X_test, y_test = train_item.getitems() n_hidden = np.array([55]) param_dict = { "cross_rate": [0.65, 0.7], "pop_size": [45, 50, 60], "mutation_rate": np.arange(0.01, 0.04, step=0.01) } estimator = GAEstimator(cross_rate=0.7, mutation_rate=0.04, pop_size=60, gen_size=100) neuralNet = NeuralFlowRegressor(learning_rate=1E-03, hidden_nodes=n_hidden) neural_shape = [X_train.shape[1], n_hidden[0], y_train.shape[1]] fit_param = {'neural_shape': neural_shape} print "Preparing for grid search" gridSearch = GridSearchCV(estimator, param_dict, n_jobs=-1, fit_params=fit_param, scoring='mean_squared_error', verbose=1) gridSearch.fit(X_train, y_train) optimizer = OptimizerNNEstimator(gridSearch.best_estimator_, neuralNet) optimizer.fit(X_train, y_train) X_test_f = self.data_source[self.train_len + 1:self.train_len + self.test_len + 1] y_pred_f = optimizer.predict(X_test) y_pred = self.fuzzy_transform.defuzzy(X_test_f, y_pred_f) score_nn = np.sqrt(mean_squared_error(y_test[1:], y_pred)) tmp = { 'score': score_nn, 'n_sliding': train_item.metadata['sliding_windows'], 'best_estimator': '%s' % gridSearch.best_estimator_ } result.append(tmp) np.savez('model_saved/%s' % score_nn, y_pred=y_pred, y_test=y_test[1:]) optimizer.save('model_saved/%s_model' % score_nn) pd.DataFrame(result).to_csv('score_grid_exhaust_ga.csv', index=None)
def estimator(n_windows,n_hidden_nodes): data = data_train[n_windows] X_train = data[0] y_train = data[1] X_test = data[2] y_test = data[3] fit_param = { 'neural_shape':[2*n_windows,n_hidden_nodes,2] } neuralNet = NeuralFlowRegressor() kfold = KFold(X_train.shape[0],5) score_lst = np.zeros(len(kfold),dtype=np.float32) for k,(train,test) in enumerate(kfold): neuralNet.fit(X_train[train],y_train[train],**fit_param) nn_shape = "%s-%s"%(2*n_windows,n_hidden_nodes) score = neuralNet.score(X_test,y_test) neuralNet.save("tmp/score_%s"%score) return nn_shape,score
X_train = X_dat[:training_set_size] X_test = X_dat[training_set_size:training_set_size+testing_set_size] y_train = fuzzy_train[1:training_set_size+1] y_test = data[training_set_size+1:training_set_size+testing_set_size+1] # # # Setup paramters of model # n_hidden = np.array([80]) # # neural_shape = [X_train.shape[1],n_hidden,y_train.shape[1]] # # Initialize ACO Estimator # estimator = ACOEstimator(Q=0.65,epsilon=0.1,number_of_solutions=130,hidden_nodes=n_hidden) # # estimator = GAEstimator() # # fit_param = {'neural_shape':neural_shape} score_nodes = {} print "Initialize estimator" for n_hidden in np.arange(28,80): neuralNet = NeuralFlowRegressor(learning_rate=1E-03,hidden_nodes=np.array([n_hidden])) neuralNet.fit(X_train,y_train) print "Score hidden nodes = %s : %s"%(n_hidden,neuralNet.score(X_train,y_train)) score_nodes["%s"%n_hidden]=neuralNet.score(X_train,y_train) print score_nodes score_df = pd.DataFrame(score_nodes.items(),columns=['Nodes','Score']) score_df.to_csv('score_lst.csv',index=None) #gridSearch = GridSearchCV(neuralNet,{'hidden_nodes':[np.arange(28,50).reshape(-1,1)]},n_jobs=-1) #gridSearch.fit(X_train,y_train) # print gridSearch.score(X_test,y_test) #print gridSearch.grid_scores_ #print "Best model %s"%gridSearch.best_estimator_ # optimizer = OptimizerNNEstimator(estimator,neuralNet) # optimizer.fit(X_train,y_train) # # # <codecell>
fuzzy_transform=FuzzyProcessor( automf=True, fuzzy_distance=0.01)) bruteGrid.transform(data) result = [] for train_item in bruteGrid.train_bucket: X_train, y_train, X_test, y_test = train_item.getitems() hidden_assume = X_train.shape[1] + y_train.shape[1] n_hidden_range = np.arange(hidden_assume, hidden_assume + 2) for hidden_node in n_hidden_range: n_hidden = np.array([hidden_node]) estimator = GAEstimator(cross_rate=0.65, mutation_rate=0.01, pop_size=45, gen_size=100) neuralNet = NeuralFlowRegressor(learning_rate=1E-03, steps=6000, hidden_nodes=n_hidden) neural_shape = [X_train.shape[1], n_hidden[0], y_train.shape[1]] fit_param = {'neural_shape': neural_shape} optimizer = OptimizerNNEstimator(estimator, neuralNet) optimizer.fit(X_train, y_train, **fit_param) X_test_f = bruteGrid.data_source[bruteGrid.train_len + 1:bruteGrid.train_len + bruteGrid.test_len + 1] # y_pred_f = neuralNet.predict(X_test) y_pred_f = optimizer.predict(X_train) # y_pred = bruteGrid.fuzzy_transform.defuzzy(X_test_f, y_pred_f) score_nn = np.sqrt(mean_squared_error(y_pred=y_pred_f, y_true=y_train)) tmp = { 'score': score_nn, 'n_sliding': train_item.metadata['sliding_windows'],
score_list = {} for n_hidden in np.arange(10, 30, step=1): # n_hidden = 80 # Define neural shape # Input layer: [n_sample*n_size] # Hidden layer: # Output layer: regression neural_shape = [dataFeeder.input_size, n_hidden, dataFeeder.output_size] # Initialize GA Estimator # estimator = GAEstimator(cross_rate=0.7,mutation_rate=0.04,pop_size=60,gen_size=100) fit_param = {'neural_shape': neural_shape} # Initialize neural network model for regression neuralNet = NeuralFlowRegressor(learning_rate=1E-03, optimize='SGD', activation='sigmoid') # There are many techniques for combining GA with NN. One of this, the optimizer solution of GA will be weights initialized of NN # optimizer = OptimizerNNEstimator(estimator,neuralNet) optimizer = neuralNet optimizer.fit(X_train, y_train, **fit_param) score = optimizer.score(X_test, y_test) print score score_list[n_hidden] = score optimizer.save("params/model_full_metric_%s" % score) # if score < 0.01: # y_pred = optimizer.predict(X_test) score_list = pd.Series(score_list) print "Optimal hidden nodes: %s, with score = %s" % (score_list.argmin(), score_list.min())
if __name__ == '__main__': best_estimator = None best_score = np.Inf for loop in np.arange(1, 20): n_input = 4 n_periodic = 1 n_hidden = 15 neural_shape = [n_input + n_periodic, n_hidden, 1] Q = 0.09 epsilon = 0.55 dataFeeder = TrafficFeeder() X_train, y_train = dataFeeder.fetch_traffic_training( n_input, 1, (40, 46)) X_test, y_test = dataFeeder.fetch_traffic_test(n_input, 1, (46, 48)) # retrieve = [n_input+1,(X_train,y_train,X_test,y_test)] acoNet = ACOEstimator(Q=Q, epsilon=epsilon) fit_param = {"neural_shape": neural_shape} acoNet.fit(X_train, y_train, **fit_param) fit_param["weights_matrix"] = acoNet.best_archive neuralNet = NeuralFlowRegressor() neuralNet.fit(X_train, y_train, **fit_param) y_pred = dataFeeder.convert(neuralNet.predict(X_test)) score = np.sqrt(mean_squared_error(y_pred, y_test)) if (score < best_score): best_estimator = acoNet print score # plot_fig(y_pred,y_test) print best_score, best_estimator
import pandas as pd import numpy as np import matplotlib.pyplot as plt from utils.SlidingWindowUtil import SlidingWindow from io_utils.GFeeder import GFeeder from estimators.NeuralFlow import NeuralFlowRegressor from utils.GraphUtil import * from sklearn.preprocessing import MinMaxScaler scaler = MinMaxScaler() dat = pd.read_csv('../sample_610_10min.csv', index_col=0, parse_dates=True) training_size = 3000 test_size = 600 gFeeder = GFeeder() dat.cpu_rate = np.array(scaler.fit_transform(dat.cpu_rate)) X_dat = np.array(list(SlidingWindow(dat.cpu_rate, sliding_number=4))) X_train = X_dat[:training_size] y_train = np.array(dat.cpu_rate[:training_size].tolist()).reshape(-1, 1) X_test = X_dat[training_size + 1:training_size + 1 + test_size] y_test = np.array(dat.cpu_rate[training_size + 1:training_size + test_size + 1].tolist()).reshape(-1, 1) nn = NeuralFlowRegressor(learning_rate=1E-03, hidden_nodes=np.array([55])) nn.fit(X_train, y_train) y_pred = nn.predict(X_test) plot_figure(y_pred=y_pred, y_true=y_test, title="Neural Flow sliding window 4")
import pandas as pd import numpy as np import matplotlib.pyplot as plt from utils.SlidingWindowUtil import SlidingWindow from io_utils.GFeeder import GFeeder from estimators.NeuralFlow import NeuralFlowRegressor from utils.GraphUtil import * from sklearn.preprocessing import MinMaxScaler scaler = MinMaxScaler() dat = pd.read_csv('../sample_610_10min.csv',index_col=0,parse_dates=True) training_size = 3000 test_size = 600 gFeeder = GFeeder() dat.cpu_rate = np.array(scaler.fit_transform(dat.cpu_rate)) X_dat = np.array(list(SlidingWindow(dat.cpu_rate,sliding_number=4))) X_train = X_dat[:training_size] y_train = np.array(dat.cpu_rate[:training_size].tolist()).reshape(-1,1) X_test = X_dat[training_size + 1:training_size + 1 + test_size] y_test = np.array(dat.cpu_rate[training_size + 1:training_size + test_size + 1].tolist()).reshape(-1,1) nn = NeuralFlowRegressor(learning_rate=1E-03,hidden_nodes=np.array([55])) nn.fit(X_train,y_train) y_pred = nn.predict(X_test) plot_figure(y_pred=y_pred,y_true=y_test,title="Neural Flow sliding window 4")
# Initialize ACO Estimator estimator = ACOEstimator(Q=0.65, epsilon=0.2, number_of_solutions=130) fit_param = {'neural_shape': neural_shape} # fuzzy before training # fuzzy step: X_train_f = fuzzy(X_train) y_train_f = fuzzy(y_train) X_test_f = fuzzy(X_test) sliding_number = 2 X_train = list(SlidingWindow(X_train_f, sliding_number)) # # Initialize neural network model for regression neuralNet = NeuralFlowRegressor() X_test_f = list(SlidingWindow(X_test_f, sliding_number)) # There are many techniques for combining GA with NN. One of this, the optimizer solution of GA will be weights initialized of NN optimizer = OptimizerNNEstimator(estimator, neuralNet) # optimizer = neuralNet optimizer.fit(X_train, y_train_f[1:], **fit_param) print optimizer.score(X_train_f, y_train_f[1:]) y_pred = optimizer.predict(X_test_f) #defuzzy step: ft = defuzzy(X_test, y_pred) #mean_squared_error print mean_squared_error(y_test, ft) plot_figure(ft, y_test, color=['blue', 'red'], title='FGANN')
from estimators.NeuralFlow import NeuralFlowRegressor from utils.GraphUtil import * if __name__ == '__main__': n_input = 4 n_periodic = 1 n_hidden = 15 neural_shape = [n_input+n_periodic,n_hidden,1] cross_rate = 0.6 mutation_rate = 0.04 pop_size = 50 dataFeeder = TrafficFeeder() X_train,y_train = dataFeeder.fetch_traffic_training(n_input,1,(40,46)) X_test,y_test = dataFeeder.fetch_traffic_test(n_input,1,(46,48)) # retrieve = [n_input+1,(X_train,y_train,X_test,y_test)] gaEstimator = GAEstimator(cross_rate=cross_rate,mutation_rate=mutation_rate,pop_size=pop_size) fit_param = { "neural_shape":neural_shape } gaEstimator.fit(X_train,y_train,**fit_param) fit_param["weights_matrix"] = gaEstimator.best_archive neuralNet = NeuralFlowRegressor() neuralNet.fit(X_train,y_train,**fit_param) y_pred = dataFeeder.convert(neuralNet.predict(X_test)) print sqrt(mean_squared_error(y_pred,y_test)) plot_figure(y_pred,y_test)
# Initialize ACO Estimator 130 estimator = ACOEstimator(Q=0.65, epsilon=0.2, number_of_solutions=10, hidden_nodes=n_hidden) # fit_param = {'neural_shape':neural_shape} # fuzzy before training # fuzzy step: X_train_f = fuzzy(X_train) y_train_f = fuzzy(y_train) X_test_f = fuzzy(X_test) # # # Initialize neural network model for regression neuralNet = NeuralFlowRegressor(learning_rate=1E-04, hidden_nodes=n_hidden) # # There are many techniques for combining GA with NN. One of this, the optimizer solution of GA will be weights initialized of NN optimizer = OptimizerNNEstimator(estimator, neuralNet) # # optimizer = neuralNet optimizer.fit(X_train_f, y_train_f) # print optimizer.score(X_train_f,y_train_f) # y_pred = optimizer.predict(X_test_f) #defuzzy step: ft = defuzzy(X_test, y_pred) #mean_squared_error print mean_squared_error(y_test, ft) plot_figure(ft, y_test, color=['blue', 'red'], title='FGANN')