def create_model(self): model = nn.Model() model.add(nn.Layer_Dense(6, 128)) model.add(nn.Activation_ReLU()) model.add(nn.Layer_Dense(128, 128)) model.add(nn.Activation_ReLU()) model.add(nn.Layer_Dense(128, 128)) model.add(nn.Activation_ReLU()) model.add(nn.Layer_Dense(128, env.ACTION_SPACE_SIZE)) model.add(nn.Activation_Linear()) model.set(loss=nn.Loss_MeanSquaredError(), optimizer=nn.Optimizer_Adam(learning_rate=0.0005), accuracy=nn.Accuracy_Regression()) model.finalize() return model
def main(): path = get_path(file) male, female = loader.read_bmi(path) dataset = male plot(dataset, title='Data', show=True) n_in = len(dataset.inputs[0]) n_out = len(dataset.outputs[0]) train_data, test_data = split(dataset, test_size=0.4) model = nn.Model(nn.Linear(n_in, 32, nn.sigmoid), nn.Linear(32, 8, nn.sigmoid), nn.Linear(8, n_out, nn.sigmoid)) bmi = nn.Classifier(model) bmi.train(train_data, test_data, target_acc=0.92) res = result(bmi, dataset) plot(dataset, categories, n_cols=2, title='Data') plot(res, categories, title='Prediction', show=True, num=2, n_cols=2)
import gym import math import matplotlib.pyplot as plt import numpy as np import nn agent = nn.Model() env = gym.make('CartPole-v0') state = env.reset() done = False scores = [] for i in range(200): score = 0 for j in range(100): env.render() action = agent.predict(state) state_, r, done, info = env.step(action) if score > 10: agent.remember(state, r, action, done, state_) agent.train() score += 1 state = state_
import matplotlib.pyplot as plt import numpy as np import gym import multiprocessing as mp import sys env = gym.make('CarRacing-v0') # plt.ion() # define network architecture x = i = nn.Input((2*96//8*96//8*3//3,)) x = nn.Dense(20)(x) x = nn.Dense(3)(x) net = nn.Model(i, x) del x, i # vectorized weights and original shape information outw, outs = nn.get_vectorized_weights(net) # run car racing problem def fitness_car_race(w, render: bool=False, steps=1000): score = 0 nn.set_vectorized_weights(net, w, outs) n = 2 for _ in range(n): # env._max_episode_steps = steps
def ask(self): cppns = self.neat.ask() self.gen = self.neat.gen return [self.create_network(cppn) for cppn in cppns] def tell(self, scores: list): self.neat.tell(scores) self.gen = self.neat.gen if __name__ == "__main__": i = x = nn.Input((2, )) x = nn.Dense(2, activation='sigmoid')(x) x = nn.Dense(1, activation='sigmoid')(x) x = nn.Model(i, x) m_cfg = x.get_config() del i, x pop = None fit = None attempts = 100 success = 0 gens = 0 for i in range(attempts): hn = HyperNeat( m_cfg, { 'n_pop': 500, 'max_species': 100,
predictions = model.predict(X) return getPredFrameAndScore(Y, predictions) train, label, test = load_data(data_dir) X = scale_data(train) y = onehot_labels(label) Xtrain = X[:59000] Ytrain = y[:59000] Xtest = X[59000:60000] #unseen Ytest = np.array(label)[59000:60000] #unseen layers_dim = [128, 64, 32, 16, 8, 8, 10] model = nn.Model(layers_dim) model.train(Xtrain, Ytrain, num_passes=3001, epsilon=0.0002, reg_lambda=0.01, print_loss=True) testUnseenFrame, testUnseenAcc = generatePredictionScore(model, Xtest, Ytest) #Review it's working by testing a subset of the train data testSeenFrame, testSeenAcc = generatePredictionScore(model, Xtrain[:5000], np.array(label)[:5000])
import numpy as np import nn from DataPreProcessing import DataPreProcessing as Data model = nn.Model(nn.Layer(size=(4, 5), activation='Relu'), nn.Layer(size=(5, 3), activation='Relu'), nn.Layer(size=(3, 10), activation='sigmoid'), nn.Layer(size=(10, 6), activation='ReLU'), nn.Layer(size=(6, 1), activation='ReLU')) # import and preprocess data x, label = Data.get_data("data_banknote_authentication.csv") x = Data.normalize(x) X_train, X_test, label_train, label_test = Data.split_data(x, label) # Train the model model.fit(X_train, label_train, 'SGD', 'MSE', alpha=0.0001, epoch=15, graph_on=True) # evaluate the model [accuracy, f1_score, confusion_matrix ] = model.evaluate(X_test, label_test, metric=['accuracy', 'f1 score', 'confusion matrix']) print(f"accuracy: {accuracy}") print(f"f1_score: {f1_score}")
epoch_size = 1000 print("Reading data") # random sample input data X = ds.read_train_images(epoch_size) y = ds.read_train_labels(epoch_size) X_test_images = ds.read_validation_images() y_test_labels = ds.read_validation_labels() print("Processing data") p = [] for col in range(epoch_size): entry = (X[:, col].reshape(28 * 28, 1), y[:, col].reshape(10, 1)) p.append(entry) validation_data = [] for col in range(10000): entry = (X_test_images[:, col].reshape(28 * 28, 1), y_test_labels[:, col].reshape(10, 1)) validation_data.append(entry) model = nn.Model([30], 28 * 28, 10) print("Fitting model") model.fit(p, 3, 5, 10, validation_data)