def test_levenberg_marquardt_exceptions(self): with self.assertRaises(ValueError): algorithms.LevenbergMarquardt( layers.Input(2) > layers.Sigmoid(3) > layers.Sigmoid(1), loss='categorical_crossentropy') with self.assertRaises(ValueError): # Doesn't have step parameter algorithms.LevenbergMarquardt( layers.Input(2) > layers.Sigmoid(3) > layers.Sigmoid(1), step=0.01)
def test_levenberg_marquardt(self): dataset = datasets.load_diabetes() data, target = dataset.data, dataset.target data_scaler = preprocessing.MinMaxScaler() target_scaler = preprocessing.MinMaxScaler() x_train, x_test, y_train, y_test = train_test_split( data_scaler.fit_transform(data), target_scaler.fit_transform(target), train_size=0.85) # Network lmnet = algorithms.LevenbergMarquardt(connection=[ layers.SigmoidLayer(10), layers.SigmoidLayer(40), layers.OutputLayer(1), ], mu_increase_factor=2, mu=0.1, show_epoch=10, use_bias=False) lmnet.train(x_train, y_train, epochs=100) y_predict = lmnet.predict(x_test) error = rmsle(target_scaler.inverse_transform(y_test), target_scaler.inverse_transform(y_predict).round()) error self.assertAlmostEqual(0.4372, error, places=4)
def test_levenberg_marquardt(self): dataset = datasets.make_regression(n_samples=50, n_features=2) data, target = dataset data_scaler = preprocessing.MinMaxScaler() target_scaler = preprocessing.MinMaxScaler() x_train, x_test, y_train, y_test = train_test_split( data_scaler.fit_transform(data), target_scaler.fit_transform(target.reshape(-1, 1)), test_size=0.15) lmnet = algorithms.LevenbergMarquardt( connection=[ layers.Input(2), layers.Sigmoid(6), layers.Sigmoid(1), ], mu_update_factor=2, mu=0.1, verbose=False, show_epoch=1, ) lmnet.train(x_train, y_train, epochs=4) error = lmnet.prediction_error(x_test, y_test) self.assertAlmostEqual(0.006, error, places=3)
def Levenberg_Marquardt(self): #etoimh methodos apo tin ergaleiothiki del self.beta lm=algorithms.LevenbergMarquardt(connection=self.Initialize_Connection()) lm.fit(self.inputs,self.targets) lm.train(self.inputs,self.targets,epochs=self.epochs,epsilon=self.errorTolerance) for i in lm.errors: self.errors.append(i) predictTest=lm.predict(self.xtest) self.estimating(predictTest) return
def select_algorithm(self, algorithm, options=None): try: self.network = algorithms.LevenbergMarquardt(self.layers) opt = options print(opt[1]) print("Wybrano optymalizator: " + str(algorithm)) except RecursionError: print("Problem rekursji") return None if algorithm == 'GradientDescent': self.network = algorithms.GradientDescent(self.layers) if algorithm == 'LevenbergMarquardt': self.network = algorithms.LevenbergMarquardt(connection=self.layers, mu=opt[0], mu_update_factor=opt[1]) if algorithm == 'Adam': self.network = algorithms.Adam(self.layers) if algorithm == 'QuasiNewton': self.network = algorithms.QuasiNewton(self.layers) if algorithm == 'Quickprop': self.network = algorithms.Quickprop(self.layers) if algorithm == 'MinibatchGradientDescent': self.network = algorithms.MinibatchGradientDescent(self.layers) if algorithm == 'ConjugateGradient': self.network = algorithms.ConjugateGradient(self.layers) if algorithm == 'Hessian': self.network = algorithms.Hessian(self.layers) if algorithm == 'HessianDiagonal': self.network = algorithms.HessianDiagonal(self.layers) if algorithm == 'Momentum': self.network = algorithms.Momentum(self.layers) if algorithm == 'RPROP': self.network = algorithms.RPROP(self.layers) if algorithm == 'IRPROPPlus': self.network = algorithms.IRPROPPlus(self.layers) if algorithm == 'Adadelta': self.network = algorithms.Adadelta(self.layers) if algorithm == 'Adagrad': self.network = algorithms.Adagrad(self.layers) if algorithm == 'RMSProp': self.network = algorithms.RMSProp(self.layers) if algorithm == 'Adamax': self.network = algorithms.Adamax(self.layers)
def run(self): self.prepareData() self.showData() # net = Net(1,8,2) lmnet = algorithms.LevenbergMarquardt([ layers.Input(1), layers.Sigmoid(8), layers.Sigmoid(2), ], verbose=True, shuffle_data=True) self.showNetData(lmnet, 'dumb') # net.Train(self.input, self.output) a = np.array(self.input) b = np.array(self.output) lmnet.fit(a, b, epochs=100) self.showNetData(lmnet, 'trained') plt.show()
def LevenbergMarquardt(col_predict, no_of_output_para, input_par, link, epoch, units, tf): global graph with graph.as_default(): dataset = pd.read_excel(link) #check for empty column cols_out = dataset.columns[col_predict:col_predict + 1] for col in cols_out: if "Unnamed" in col: return 0 X = dataset.iloc[:, no_of_output_para + 1:dataset.values[0].size].values Y = dataset.iloc[:, col_predict].values # np.random.seed(0) X_train = np.array(X) y_train = np.array(Y) X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.2, random_state=0) sc = StandardScaler() X_train = sc.fit_transform(X_train) X_test = sc.transform(X_test) network = Input(input_par) >> Sigmoid(int(units / 10) + 1) >> Relu(1) optimizer = algorithms.LevenbergMarquardt([network], verbose=False, shuffle_data=False) optimizer.train(X_train, y_train, epochs=epoch) joblib.dump(optimizer, link + "-" + str(col_predict) + ".pkl")
'Moving_av', 'Upper_volatility', 'Lower_volatility', 'Short_resistance', 'Short_support', 'Long_resistance', 'Long_support', 'Adj Close' ]].values scaler = StandardScaler() dataset = scaler.fit_transform(dataset) scaler = MinMaxScaler(feature_range=[0, 1]) dataset = scaler.fit_transform(dataset) scaler_filename = 'scalers/' + stock + '_complete_' + interval + '.save' pickle.dump(scaler, open(scaler_filename, 'wb')) X, y = split_sequences(dataset[-300:-samples_test], n_steps_in, n_steps_out) n_features = X.shape[2] y = y[:, :, -1:] x_train = X.reshape(len(X), n_steps_in * n_features) y_train = y.reshape(len(X), n_steps_out) network = Input( n_steps_in * n_features) >> Sigmoid(50) >> Sigmoid(n_steps_out) model = algorithms.LevenbergMarquardt(network, verbose=False, show_epoch=5) model.fit(x_train, y_train, epochs=epochs) filename = 'models/complete_' + stock + '-LevenbergMarquardt-' + interval + '.pickle' with open(filename, 'wb') as f: pickle.dump(model, f)
train_size = int(t.shape[0] * 0.9) train_size X_train = t[:train_size] y_train = x[:train_size] X_test = t[train_size:] y_test = x[train_size:] scaler_x = StandardScaler() scaler_y = StandardScaler() tmp_train_scaled_x = scaler_x.fit_transform(X_train[:, np.newaxis]) tmp_test_scaled_x = scaler_x.transform(X_test[:, np.newaxis]) tmp_train_scaled_y = scaler_y.fit_transform(y_train[:, np.newaxis]) lmnet = algorithms.LevenbergMarquardt((Input(1), Tanh(60), Linear(1)), verbose=True) lmnet.train(X_train, y_train, epochs=100) pred_x = lmnet.predict(X_train) mse = sklearn.metrics.mean_squared_error(y_train, pred_x.flatten()) print(f'RMSE = {np.sqrt(mse)}') plt.plot(X_train, y_train, label='train') plt.plot(X_train, pred_x, label='predict') plt.legend() pred_x = lmnet.predict(X_test) mse = sklearn.metrics.mean_squared_error(y_test, pred_x.flatten()) print(f'RMSE = {np.sqrt(mse)}')
import numpy as np from neupy import algorithms, plots x_train = np.array([[1, 2], [3, 4]]) y_train = np.array([[1], [0]]) lmnet = algorithms.LevenbergMarquardt((2, 3, 1)) lmnet.train(x_train, y_train) plots.error_plot(lmnet)
def test_levenberg_marquardt_assign_step_exception(self): with self.assertRaises(ValueError): algorithms.LevenbergMarquardt((2, 3, 1), step=0.01)
def test_levenberg_marquardt_invalid_error_exceptions(self): with self.assertRaises(ValueError): algorithms.LevenbergMarquardt((2, 3, 1), error='categorical_crossentropy')
Y = np.array(Y) # the first 2500 out of 3000 emails will serve as training data x_train = X[0:3067] y_train = Y[0:3067] # the rest 500 emails will serve as testing data x_test = X[3067:] y_test = Y[3067:] lmnet = algorithms.LevenbergMarquardt( [ layers.Input(57), layers.Sigmoid(7), layers.Sigmoid(1), ], verbose=True, shuffle_data=True, mu=0.1, mu_update_factor=1.2, error="mse", ) lmnet.train(input_train=x_train, target_train=y_train, epochs=200) plots.error_plot(lmnet) y_train_predicted = lmnet.predict(x_train).round() y_test_predicted = lmnet.predict(x_test).round() print(metrics.classification_report(y_train_predicted, y_train)) print(metrics.confusion_matrix(y_train_predicted, y_train)) print()
# lbl_test[lbl_test==0] = -1 #normalise by zero mean, 1 std sc = StandardScaler() dbdt_train = sc.fit_transform(dbdt_train) dbdt_test = sc.transform(dbdt_test) #Build input array, where a sounding and its neighbours are stacked dbdt_train = build_array_skytem(3, dbdt_train) dbdt_test = build_array_skytem(3, dbdt_test) network = join( Input(51), Tanh(30), Tanh(1), ) model2 = algorithms.LevenbergMarquardt(network, verbose=True) model2.train(dbdt_train.T, lbl_train.T, epochs=10) # ## compute metrics lbl_pred_scor = model2.predict(dbdt_test.T) lbl_pred = lbl_pred_scor > 0 print(lbl_pred) print(sum(lbl_pred[0] == lbl_test) / len(lbl_test)) from sklearn.metrics import classification_report, confusion_matrix print(confusion_matrix(lbl_test, lbl_pred)) print(classification_report(lbl_test, lbl_pred)) # # plot_training(history) # plot_misclassified(timestamp[r+1:-1], dbdt_testOG, lbl_test, lbl_pred)