def baseline_model(): # create model model = Sequential() rbflayer = RBFLayer(30, initializer=InitCentersRandom(Xtrain), betas=1.0, input_shape=(6, )) model.add(rbflayer) model.add( Dense(50, input_dim=30, kernel_initializer='normal', activation='relu')) model.add(Dense(25, kernel_initializer='normal', activation='relu')) model.add(Dense(12, kernel_initializer='normal', activation='relu')) #model.add(GaussianNoise(0.1)) model.add(Dense(1, kernel_initializer='normal')) # Compile model model.compile(loss='mean_squared_error', optimizer='adam', metrics=["mean_squared_error"]) # Training model.fit(Xtrain, ytrain, batch_size=10, epochs=10, verbose=0) #model.fit(X_train, y_train, batch_size = 32, epochs=20, verbose=2) scores = model.evaluate(Xtest, ytest, verbose=0) model.save("model-DNNGP.h5") return model
def train(X_train, y_train, epochs = 50): # dataset_sz = X.shape[0] # test_sz = X_test.shape[0] train_sz = X_train.shape[0] X_train = np.reshape(X_train, (train_sz, 1)) y_train = np.reshape(y_train, (train_sz, 1)) # Initialising the RBF regressor = Sequential() # Adding the input layer and the first layer and Drop out Regularization regressor.add(RBFLayer(500, initializer=InitCentersRandom(X_train), betas=2.0, input_shape=(1,))) regressor.add(Dropout(.2)) # Adding the output layer regressor.add(Dense(units = 1, kernel_initializer = 'uniform', activation = 'sigmoid')) # Compiling the RBF regressor.compile(optimizer = 'adam', loss = 'mean_squared_error') # Fitting the RBF to the Training set regressor.fit(X_train, y_train, batch_size = 32, epochs = epochs) return regressor
def RBFNN(X_train, X_test, y_train, y_test): model = Sequential() rbflayer = RBFLayer(10, initializer=InitCentersRandom(X_train), betas=2.0, input_shape=(len(X_train[0]), )) model.add(rbflayer) model.add(Dense(1)) model.compile(loss='mean_squared_error', optimizer=RMSprop()) model.fit(X_train, y_train, batch_size=50, epochs=2000, verbose=0) row = getRow(X_test, y_test) result1 = model.predict(row) y_pred = model.predict(X_test) return result1, y_pred
def create_network(train_set, trainingConfig): model = Sequential() # Create the RBF layer if trainingConfig.use_kmeans: initializer = InitCentersKMeans(train_set, trainingConfig.k_num) layer_exit_num = trainingConfig.k_num else: initializer = InitCentersRandom(train_set, trainingConfig.random_samples_num) layer_exit_num = trainingConfig.random_samples_num rbflayer = RBFLayer(layer_exit_num, initializer, betas=trainingConfig.betas, input_shape=(784, )) # First layer is the RBF layer model.add(rbflayer) if trainingConfig.hidden_layers_num > 0: if trainingConfig.use_kmeans: hidden_layer_output = trainingConfig.k_num else: hidden_layer_output = trainingConfig.random_samples_num # Add the hidden layers, Dense neural is used in combination with Dropout hidden_layers_range = range(trainingConfig.hidden_layers_num) for n in hidden_layers_range: model.add(Dropout(trainingConfig.dropoutRate)) model.add( Dense(units=hidden_layer_output, activation=trainingConfig.hidden_layer_act_func)) # last classification layer, output dim is 10, 10 possible classes model.add(Dense(units=10, activation=trainingConfig.last_layer_act_func)) model.summary() model.compile( loss='categorical_crossentropy', optimizer=RMSprop(), # Used for multiclass problems metrics=['accuracy' ]) # Accuracy because the problem solved is classification return (model, rbflayer)
print("X_train after transform \n", X_train) #print("reshaped shape 1 Xtrain ", X_train.shape, "X_trrain 941 element ", X_train[940]) print("y_train with size ", y_train.shape) ############ Building the RBF ############ # Initialising the RBF regressor = Sequential() # Adding the input layer and the first layer and Drop out Regularization #Anti gia X_train[0] sto InitCentersRandom vazw kai X_lookback # betas = 2.0 regressor.add( RBFLayer(units, input_dim=lookback, initializer=InitCentersRandom(X_train[0]), betas=1.0, input_shape=(1, lookback))) regressor.add(Dropout(.2)) # Adding the 2nd hidden layer #regressor.add(LSTM(10, input_shape=(1, lookback))) #regressor.add( RBFLayer(50, initializer=InitCentersRandom(X_all_2nd_layer), betas=2.0, input_shape=(1, units))) #regressor.add(Dropout(.2)) #regressor.add(Dense(units=50, kernel_initializer='uniform', activation='relu')) #regressor.add(Dropout(.2)) # Adding the output layer regressor.add( Dense(units=step_size, kernel_initializer='uniform', activation='linear'))
def load_data(): data = np.loadtxt("data/data.txt") X = data[:, :-1] y = data[:, -1:] return X, y if __name__ == "__main__": X, y = load_data() model = Sequential() rbflayer = RBFLayer(10, initializer=InitCentersRandom(X), betas=2.0, input_shape=(1,)) model.add(rbflayer) model.add(Dense(1)) model.compile(loss='mean_squared_error', optimizer=RMSprop()) model.fit(X, y, batch_size=50, epochs=2000, verbose=1) y_pred = model.predict(X)
for j in range(10): slices = KFold(n_splits=K_FOLD, shuffle=True) oData = Data(len(oDataSet.labelsNames), 31, samples=50) oData.random_training_test_by_percent( np.unique(classes, return_counts=True)[1], 0.8) grid_result = np.zeros((len(GRID_NEURON), len(GRID_B), K_FOLD)) for g1, g_param in enumerate(GRID_NEURON): for g2, g2_param in enumerate(GRID_B): k_slice = 0 for train, test in slices.split(oData.Training_indexes): K.clear_session() model = Sequential() rbflayer = RBFLayer( g_param, initializer=InitCentersRandom( oDataSet.attributes[oData.Training_indexes[train]]), betas=g2_param, input_shape=(base.shape[1], )) model.add(rbflayer) model.add( Dense(len(oDataSet.labelsNames), activation='sigmoid')) model.compile(loss='categorical_crossentropy', optimizer=_OPTIMIZER) model.fit(oDataSet.attributes[oData.Training_indexes[train]], binarizer( oDataSet.labels[oData.Training_indexes[train]]), batch_size=50, epochs=epochs, verbose=0) y_pred = model.predict(
outputlayer = Dense(1, kernel_initializer=InitFromFile("weights.npy"), use_bias=False) print("output layer created") model2 = Sequential() model2.add(rbflayer) model2.add(outputlayer) res2 = model2.predict(X).squeeze() print(f"MSE: {MSE(y, res2):.4f}") print("Same responses: ", all(res == res2)) if __name__ == "__main__": X, y = load_data() # test simple RBF Network with random setup of centers test(X, y, InitCentersRandom(X)) # test simple RBF Network with centers set up by k-means test(X, y, InitCentersKMeans(X)) # test simple RBF Networks with centers loaded from previous # computation test(X, y, InitFromFile("centers.npy")) # test InitFromFile initializer test_init_from_file(X, y)
y_train = scaler.transform(y_train) y_val = scaler.transform(y_val) return x_train, y_train, x_val, y_val, test, scaler, y_val_nostandard, y_train_nostandard # Get Data path_train = '../dataset_cajamar/Dataset_Salesforce_Predictive_Modelling_TRAIN.txt' path_test = '../dataset_cajamar/Dataset_Salesforce_Predictive_Modelling_TEST.txt' x_train, y_train, x_val, y_val, test, scaler, y_val_nostandard, y_train_nostandard = data( path_train, path_test) model = Sequential() rbflayer = RBFLayer(10, initializer=InitCentersRandom(x_train), betas=2.0, input_shape=(76, )) model.add(rbflayer) model.add(Dense(512)) model.add(BN()) model.add(GN(0.3)) model.add(Activation('relu')) model.add(Dense(1)) model.add(Activation('relu')) model.compile(loss='mape', optimizer=RMSprop(), metrics=['mse']) model.fit(x_train,
X_test = np.reshape(X_test, (X_test.shape[0], 1, X_test.shape[1])) print("AFTER RESHAPE train_sz: ", X_train.shape, "\ntest_sz: ", X_test.shape, "\nall_sz: ", X_all.shape) print("X_train after transform \n", X_train) print("reshaped shape 1 Xtrain ", X_train.shape, "X_trrain 941 element ", X_train[940]) print("y_train with size ", y_train.shape) ############ Building the RBF ############ # Initialising the RBF regressor = Sequential() # Adding the input layer and the first layer and Drop out Regularization regressor.add( RBFLayer(60, input_dim=lookback, initializer=InitCentersRandom(X_train[0]), betas=2.0, input_shape=(1, lookback))) regressor.add(Dropout(.2)) # Adding the output layer regressor.add(Dense(units=1, kernel_initializer='uniform', activation='linear')) # Compiling the RBF regressor.compile(optimizer='adam', loss='mean_squared_error') regressor.summary() # Fitting the RBF to the Training set regressor.fit(X_train, y_train, batch_size=1, epochs=5, shuffle=False) ############ Save & load Trained Model ############ # Save Trained Model regressor.save('TICKER-RBF.h5')