def main(): start_time = time.time() data_directory = "/Users/soonerfan237/Desktop/MerckActivity/TrainingSet5/" files = glob.glob(data_directory + "ACT*.csv") activity_list = [] for file in files: print(file) match = re.search(r'ACT([0-9]+)', file) activity_list.append(int(match.group(1))) feature_dict, molecule_dict_filter = CombineData.CombineData( data_directory) print("TOTAL MOLECULES: " + str(len(molecule_dict_filter))) molecule_dict_filter = NormalizeActivity.NormalizeActivity( molecule_dict_filter, activity_list) feature_dict_filter, molecule_dict_filter = FindVariableFeatures.FindVariableFeatures( data_directory, feature_dict, molecule_dict_filter) molecule_dict_filter = FindCorrelatedFeatures.FindCorrelatedFeatures( feature_dict_filter, molecule_dict_filter, activity_list) molecule_dict_filter = RemoveOutliers.RemoveOutliers(molecule_dict_filter) for i in activity_list: NeuralNet.NeuralNet( data_directory, i, molecule_dict_filter) #i corresponds to activity number to predict #ConvNeuralNet.ConvNeuralNet(data_directory, i, molecule_dict_filter) GenerativeAdversarialNetwork.GenerativeAdversarialNetwork( data_directory, i, molecule_dict_filter, 100) elapsed_time = (time.time() - start_time) / 60 print("This took " + str(elapsed_time) + " minutes.") print("DONE!")
def mutateThatJohn(neuralNetToMutate, nodes_per_layer): #don't mutate the activation functions activation_funcs=neuralNetToMutate.activation_funcs #creates new neural network neuralNetToReturn= nn.NeuralNet(activation_funcs,nodes_per_layer) weightsOf=neuralNetToMutate.weights #turn weights to one dimension weights1d= turnThreeToOne(weightsOf) #get total amount of weights totalAmtOfWeights=len(weights1d) b=0 c=0 #loop until we get two different indices while c==b: b= random.randInt(0,totalAmtOfWeights) c= random.randInt(0,totalAmtOfWeights) #grab sublist from those indices if b<c: subList=weights1d[b:c] else: subList=weights1d[c:b] #reverse the list subList.reverse() #replace elements in the list with reversed list if b<c: weights1d[b:c]=subList else: weights1d[c:b]=subList #need it back in three dimensions weightsBack=turnOneToThree(weights1d, nodes_per_layer) #set mutated weights to new neural net neuralNetToReturn.weights=weightsBack #return mutated neural net return neuralNetToReturn
def q1Test(testFile): if 'sigmoid' in testFile.name and 'Activation' not in testFile.name: value = float(testFile.readline().strip()) sPercep = NeuralNet.Perceptron() solution = sPercep.sigmoid(value) else: testFuncName = testFile.readline().strip() getData = getattr(NeuralNetUtil, testFuncName) examples, tests = getData() testRangeStart = testFile.readline().strip() testRangeEnd = testFile.readline().strip() testRangeStart = 0 if testRangeStart=='None' else int(testRangeStart) testRangeEnd = len(examples) if testRangeEnd=='None' else int(testRangeEnd) examples = examples[testRangeStart:testRangeEnd] if 'feedforward' in testFile.name: sNet = NeuralNet.NeuralNet([16,24,10]) file = open('test_cases/nnet') net = cPickle.load(file) copyWeights(sNet,net) solution = [] for example in examples: solution.append(sNet.feedForward(example[0])) elif 'Activation' in testFile.name: file = open('test_cases/percep') percep = cPickle.load(file) sPercep = NeuralNet.Perceptron(inSize = percep.inSize-1, weights = percep.weights) solution = [] for example in examples: solution.append(sPercep.sigmoidActivation(example[0])) return solution
def q4Test(testFile, module=NeuralNet): testFuncName = testFile.readline().strip() getData = getattr(NeuralNetUtil, testFuncName) examples = getData() testRangeStart = testFile.readline().strip() testRangeEnd = testFile.readline().strip() testRangeStart = 0 if testRangeStart == 'None' else int(testRangeStart) testRangeEnd = len(examples) if testRangeEnd == 'None' else int( testRangeEnd) examples = (examples[0][testRangeStart:testRangeEnd], examples[1][testRangeStart:testRangeEnd]) alph = float(testFile.readline()) weight = float(testFile.readline()) file = open('test_cases/nnet', 'rb') net = pickle.load(file) sNet = NeuralNet.NeuralNet([16, 24, 10]) copyWeights(sNet, net) solution = NeuralNet.buildNeuralNet(examples, alpha=alph, weightChangeThreshold=weight, startNNet=sNet) return solution[1]
def runNeuralNet(): import NeuralNet nn = NeuralNet.NeuralNet(trainingData='PLANKTON', hiddenLayersSize=[59, 59], activationFunctions=['sigmoid'] * 3) print[np.shape(ob) for ob in nn.Thetas] nn.train(maxNumIts=5000, regParams=[0.01] * 3, trainToMax=True)
def genRandom(population, nodes_per_layer): neuralNets=[] layers=len(nodes_per_layer) for p in range(0,population): activation_funcs=[] for q in range(0,layers): activation_funcs.append(random.randInt(0,9)) net= nn.NeuralNet(activation_funcs,nodes_per_layer) neuralNets.append(net) return neuralNets
def __init__(self, screen, startPos, fitness=0.0): # Call the parent's constructor super().__init__() # Create a player self.width = 40 #width of player self.height = 60 #height of player self.enemy = None #initialize the opponent self.enemyPos = None #Later, will be used to track where the opponent is self.maxHearts = 4 #max "health" self.numHearts = 4 #track how many hits we've taken self.numDeaths = 0 #track how many times we've died self.numKills = 0 #track how many times we've killed the opponent self.numGoals = 0 #How many times have we made it to the other side of the board? self.numHits = 0 #How many times the player has made a successful attack self.runningDistance = 0 #How far have the player moved (running total per life) self.maxDistance = 0 #How far the player moved during the round self.fitness = fitness #the total fitness of this player self.sword = None self.isAttacking = False self.attackDelay = 30 #30 frames between each attack self.jumpDelay = 30 self.respawnDelay = 30 #Don't redraw the player upon death for 30 frames self.direction = "right" self.image = pygame.image.load('Images/playerrightangry.png') # So our player can modify the overall screen self.screen = screen #The Neural Net (initialized) self.brain = None # Set a referance to the image rect. self.rect = self.image.get_rect() #coordinate point self.startPos = startPos self.startx = self.startPos[0] self.starty = self.startPos[1] # Set speed vector of player self.change_x = 0 self.change_y = 0 # List of sprites we can bump against self.level = None self.genomeInputs = 6 self.genomeOutputs = 4 self.brain = NeuralNet(self.genomeInputs, self.genomeOutputs) self.vision = []
def __init__(self, skip_neural=False): self.sensors = [Button(i) for i in cfg.SENSE_PINS] self.buffer_size = cfg.window_update_hz * cfg.window_size_s self.buffer = [0x00] * self.buffer_size self.idle = True self.score = 0.5 self.last_NN_outputs = None if not skip_neural: self.neuralModel = NeuralNet(model_path=cfg.model_path) self.neuralModel.load_weights()
def crossover(neuralNetwork1, neuralNetwork2, nodes_per_layer): #get the weights of each neural network weights1=neuralNetwork1.weights weights2=neuralNetwork2.weights #get the activation functions of each neural network activation1=neuralNetwork1.activation_funcs activation2=neuralNetwork2.activation_funcs #get number of activation functions actives=len(activation1) #get random int for one-point crossover of activation functions cross=random.randInt(0,actives) activation_funcs=[] for a in range(0,actives): if a<cross: activation_funcs.append(activation1[a]) else: activation_funcs.append(activation2[a]) #create initial neural net to return net= nn.NeuralNet(activation_funcs,nodes_per_layer) #get total amount of weights totalAmtOfWeights=0 for a in range(0,len(weights)): for b in range(0,len(weights[a])): for c in range(0,len(weights[a][b])): totalAmtOfWeights+=1 #grab two random ints for two-point crossover b=0 c=0 while b==c: b= random.randInt(0,totalAmtOfWeights) c= random.randInt(0,totalAmtOfWeights) #find the lower index if b<c: first=b second=c else: first=c second=b counter=0 #crossover weights to child for a in range(0,len(weights)): for b in range(0,len(weights[a])): for c in range(0,len(weights[a][b])) if counter<first: net.weights[a][b][c]=weights1[a][b][c] else if counter>=first and counter<second: net.weights[a][b][c]=weights2[a][b][c] else: net.weights[a][b][c]=weights1[a][b][c] counter+=1 #return child return net
def build_model(learning_rate, last_activation=softmax): num_of_features = 9 dim_hidden_1 = 12 dim_hidden_2 = 6 dim_hidden_3 = 2 layer = Layer(num_of_features, dim_hidden_1, ReLU) layer1 = Layer(dim_hidden_1, dim_hidden_2, tanh_f) layer2 = SkipLayer(dim_hidden_2, num_of_features) layer3 = Layer(dim_hidden_2, dim_hidden_3, last_activation) return NeuralNet([layer, layer1, layer2, layer3], skip_layer=layer2, learning_rate=learning_rate)
def run_main(features, labels): max_iteration = FLAGS.max_iteration n_layer = FLAGS.n_layer # the last layer is the output of network n_feat = FLAGS.n_feat n_nodes = FLAGS.n_nodes nn_model = nn.NeuralNet(n_layer, n_nodes, n_feat, FLAGS.func_num) # datatuple = tuple([features, labels, [], [], [], []]) # nn_train.StochasticGradientDescent(datatuple, nn_model) w0 = dict_to_nparray(nn_model.model) print gradientCheck(gradfunc, objfunc, w0, [features[1]], [labels[1]], max_iteration, nn_model)
def genRandom(population, nodes_per_layer): neuralNets=[] layers=len(nodes_per_layer) for p in range(0,population): activation_funcs=[] for q in range(0,layers-1): #we only want tanh, arctan, or constant activation alpha=random.randint(0,2) #if 2, change to 3 which is constant if(alpha==2): activation_funcs.append(3) else: activation_funcs.append(alpha) net= nn.NeuralNet(activation_funcs,nodes_per_layer) neuralNets.append(net) return neuralNets
def main(): xOrNet = NN.NeuralNet(layers=[2, 3, 1]) inpt = [1, 1] outpt = [0] xOrNet.updateInput(inpt) setInitialWeights(xOrNet) xOrNet.fireNet(func='sigmoid') print(AF.sigmoid(xOrNet.getOutput())) erOut = 0.0 - AF.sigmoid(xOrNet.getOutput()) dOut = AF.dsigmoid(xOrNet.getOutput()) * erOut print(dOut)
def q3Test(testFile,module=NeuralNet): testFuncName = testFile.readline().strip() getData = getattr(NeuralNetUtil, testFuncName) examples, tests = getData() testRangeStart = testFile.readline().strip() testRangeEnd = testFile.readline().strip() testRangeStart = 0 if testRangeStart=='None' else int(testRangeStart) testRangeEnd = len(examples) if testRangeEnd=='None' else int(testRangeEnd) examples = examples[testRangeStart:testRangeEnd] sNet = NeuralNet.NeuralNet([16,24,10]) file = open('test_cases/nnet') net = cPickle.load(file) copyWeights(sNet,net) solution = sNet.backPropLearning(examples,0.1) return solution
def generateOffspring(parents, populationSize, mutationRate): offspring = [] for i in range(populationSize - len(parents)): # Randomly select 2 parents parentIndicies = random.sample(range(0, len(parents)), 2) weightsOffSpring, biasVecOffSpring = crossover( parents[parentIndicies[0]], parents[parentIndicies[1]]) newWeights, newBiasVec = mutate(weightsOffSpring, biasVecOffSpring, mutationRate) offspringMatrix = vectorToMat(numpy.array([newWeights]), numpy.array([parents[0].layers]))[0] offspringNN = NN.NeuralNet() offSpringBiasVectors = splitBiasVector(newBiasVec, offspringMatrix) offspringNN.setLayers(offspringMatrix) offspringNN.setBiasVectors(offSpringBiasVectors) offspring.append(offspringNN) return offspring
def __init__(self, root): self.root = root root.title("Movie Reccomendation") self.canvas = tk.Canvas(root, width=1000, height=1000) self.canvas.place(x=0, y=0, anchor=tk.NW) self.nMoviesPicked = 0 self.nMaxMoviesPicked = 10 #The total number of movies the user will pick as "Liked" or "Not Liked" self.Network = NeuralNet.NeuralNet(dfMovieData) self.imDB = imdb.IMDb() self.font = "SourceCodePro" self.listMoviesReccomend = [] self.movieSample = None self.placeButtons() self.askMovie() # Start
def main(viz=False): tic() data = load_mnist() print ("Data loaded in %.1fs" % toc()) # Create a neural network with matching input/output dimensions # cfg = NeuralNetCfg(L1=1e-6,init_scale=0.05) cfg.input(data.Xshape) cfg.hidden(800,"logistic",dropout=0.5) cfg.hidden(800,"logistic",dropout=0.25) cfg.output(data.Yshape,"softmax") model = NeuralNet(cfg) # Rescale the data to match the network's domain/range # data.rescale(model.ideal_domain(),model.ideal_range()) # Train the network # report_args = { 'verbose' : True, 'interval' : 5, # how many epochs between progress reports (larger is faster) 'window_size' : "compact", 'visualize' : viz} trainer = TrainingRun(model,data,report_args, learn_rate=2, learn_rate_decay=.995, momentum=[(0,.5),(400,0.9)], batchsize=64) print "Memory available after data loaded:", memory_info(gc=True) tic() trainer.train(100) # train for several epochs print ("Training took %.1fs" % toc())
def __init__(self, x, y, angle): #dimensions of car self.length = 20 self.width = 15 #Angle between center of bumper, car center of mass and side of bumper. self.cornerAngle = math.atan(self.width / self.length) #position of car self.x = x self.y = y #speed of wheels, and angle away from forward self.v = 0 self.wheelAngle = 0 #angle car makes with north, counterclockwise self.angle = angle #The distance to an obstruction at left, right and front, frontLeft, and frontRight self.fDist = 0 self.flDist = 0 self.lDist = 0 self.rDist = 0 self.frDist = 0 #The car is coupled to a Neural Net, it has 1 hidden layer, 5 inputs (the above 5 distances) #8 neurons in the hidden layer, and two outputs, which determine if the car steers left or right. self.neuralnet = NeuralNet(3, 2, 1, 8)
def reproduce(self, other, crossRate, mutRate): weights1, weights2 = self.NN.getFlattenedValues( ), other.NN.getFlattenedValues() #assert(len(weights1) == len(weights2)) childWeights = copy.copy(weights1) #crossover stage if (random.random() < crossRate): pos = random.randint(0, len(childWeights) - 1) childWeights[pos:] = weights2[pos:] #mutation stage for i in range(len(childWeights)): if (random.random() < mutRate): weight = childWeights[i] changePercent = (2 * random.random()) - 1 weight = weight * (1 + changePercent) #mutate childWeights[i] = weight childNumInputs = self.NN.numInputs childNumOutputs = self.NN.numOutputs childNumHiddenLayerNeurons = self.NN.numLayerNeurons[:-1] childNN = NeuralNet.NeuralNet(childNumInputs, childNumOutputs, childNumHiddenLayerNeurons, childWeights) return individual(childNN)
def main(): start_time = time.time() time_periods = ['day', 'week', 'month', 'year'] fileObject = open("stock_symbol_list.pickle", 'rb') symbols = pickle.load(fileObject) fileObject.close() #symbols = ['DVN', 'MMM', 'YYY', 'AAPL','ADBE','AMZN'] #symbols = ['DVN'] result_list = [] random.shuffle(symbols) #for time_period in time_periods: # result_list.append("==================") # result_list.append(time_period) # stockdata_dict, max_num_of_days = DownloadData.DownloadData(symbols[:1], time_period) # stockdata_dict = RemoveOutliers.RemoveOutliers(stockdata_dict) # for i in range(10, 1000, 10): # if i < max_num_of_days: # r_squared, rmse = NeuralNet.NeuralNet(stockdata_dict, max_num_of_days, i) # result_list.append("num of days: "+str(i)) # result_list.append("r_squared: "+str(r_squared)) # result_list.append("rmse: " + str(rmse)) # fileObject = open("result_list.pickle",'wb') # open the file for writing # pickle.dump(stockdata_dict,fileObject) # fileObject.close() fileObject = open("stockdata_dict_year_FULL_tuesday.pickle", 'rb') max_num_of_days = 13 stockdata_dict = pickle.load(fileObject) #stockdata_dict = RemoveOutliers.RemoveOutliers(stockdata_dict) fileObject.close() r_squared, rmse = NeuralNet.NeuralNet(stockdata_dict, max_num_of_days, 10) elapsed_time = (time.time() - start_time) / 60 print("This took " + str(elapsed_time) + " minutes.") print("DONE!")
import numpy as np import copy import NeuralNet import load_datasets # X = (hours sleeping, hours studying), y = score on test X = ([2, 9], [1, 5], [3, 6]) y = np.array(([92], [86], [89]), dtype=float) X = [[0,0,1], [0,1,1], [1,0,1], [1,1,1]] y = [0, 1, 1, 0] n= 1; train_iris, train_labels_iris, test_iris, test_labels_iris = load_datasets.load_iris_dataset(0.03) train_votes, train_labels_votes, test_votes, test_labels_votes = load_datasets.load_congressional_dataset(0.02) train_monks, train_labels_monks, test_monks, test_labels_monks = load_datasets.load_monks_dataset(n) train = train_votes labels = train_labels_votes NN = NeuralNet.NeuralNet(1, 2, len(train[0]), 1) for i in xrange(1000): NN.train(train, labels) print "Actual Output: \n" + str(labels) print "Predicted Output: \n" + str(NN.forward(train).T[0]) # [0,1,0,1,1,1,0,0,0,0,0,0,1,1,2,1], 0))
return frame, self.reward, self.game_over def get_frames(self): return np.array(list(self.frames)) def get_ambient_data(self): return [self.ball_x - (self.paddle_x + self.PADDLE_WIDTH / 2)] if __name__ == "__main__": game = CatchGame() NAME = 'weuler' brain = NeuralNet.NeuralNet([], [], 1, 5, 1, saved_weight1=w1, saved_weight2=w2) game.reset() input_t = game.get_frames() game_over = False report = [] while not game_over: output = brain.get_output(game.get_ambient_data()) if output > 0.5: action = 2 else:
#print("Model weights after training",self.model.get_weights()); return [train_loss_results, train_accuracy_results] def plotStats(self, train_loss_results, train_accuracy_results): fig, axes = plt.subplots(2, sharex=True, figsize=(12, 8)) fig.suptitle('Training Metrics - Call, Raise, or Fold') axes[0].set_ylabel("Loss", fontsize=14) axes[0].plot(train_loss_results) axes[1].set_ylabel("Accuracy", fontsize=14) axes[1].set_xlabel("Epoch", fontsize=14) axes[1].plot(train_accuracy_results) plt.show() if __name__ == '__main__': import tensorflow as tf import NeuralNet #pdb.set_trace(); tf.enable_eager_execution() net = NeuralNet.NeuralNet( train=False, csvPath="/home/the2b/Documents/school/ai/project/src/test6.csv", dataUrl="http://127.0.0.1/test6.csv") trainingRes = net.trainModel(epochs=501, batchSize=72, bufferSize=10000) net.plotStats(trainingRes[0], trainingRes[1])
__author__ = 'Aaron' # IMPORTS import sys from States import * from constants import * from NeuralNet import * # GLOBAL VARIABLES clock = pygame.time.Clock() ann = NeuralNet(NUM_INPUTS, NUM_OUTPUTS, NUM_HIDDEN, NUM_PER_HIDDEN) # STATE MANAGER class StateManager(object): def __init__(self, ann=None): """ Initializes the state manager. Contains "global" variables to hold neural network and score. """ self.ann = ann self.fitness = 0 self.state = None self.go_to(MenuState()) def go_to(self, state): self.state = state self.state.manager = self
from NeuralNet import * from Config import Config import tflowtools as TFT import sys from CaseManager import * import numpy as np import mnist.mnist_basics as mnist from Case import * import CSVReader if __name__ == '__main__': args = ArgumentParser.parseArgs() config = Config(args) caseManager = CaseManager( config, cfunc=lambda: config.src_function(*config.src_args ), # * unpacks list arguments vfrac=config.vfrac, tfrac=config.tfrac, case_fraction=config.case_fraction, src_function=config.src_function, src_args=config.src_args, src_path=config.src_file_path) nn = NeuralNet(config, caseManager) nn.do_training() # nn.do_testing() # TFT.fireup_tensorboard('probeview')
import matplotlib.pyplot as plt import sys import load_datasets import NeuralNet # importer la classe du Reseau de Neurones import DecisionTree # importer la classe de l'Arbre de Decision # importer dautres fichiers et classes si vous en avez developpes # importer dautres bibliotheques au besoin, sauf celles qui font du machine learning decision_tree_iris = DecisionTree.DecisionTree() decision_tree_congress = DecisionTree.DecisionTree() decision_tree_monks1 = DecisionTree.DecisionTree() decision_tree_monks2 = DecisionTree.DecisionTree() decision_tree_monks3 = DecisionTree.DecisionTree() rn_iris = NeuralNet.NeuralNet() rn_congress = NeuralNet.NeuralNet() rn_monks1 = NeuralNet.NeuralNet() rn_monks2 = NeuralNet.NeuralNet() rn_monks3 = NeuralNet.NeuralNet() # Charger/lire les datasets (train_iris, train_labels_iris, test_iris, test_labels_iris) = load_datasets.load_iris_dataset(0.7) (train_congress, train_labels_congress, test_congress, test_labels_congress) = load_datasets.load_congressional_dataset(0.7) (train_monks1, train_labels_monks1, test_monks1, test_labels_monks1) = load_datasets.load_monks_dataset(1) (train_monks2, train_labels_monks2, test_monks2, test_labels_monks2) = load_datasets.load_monks_dataset(2) (train_monks3, train_labels_monks3, test_monks3,
import numpy as np import matplotlib.pylab as plt import matplotlib.animation as anima import NeuralNet def animate(i): NN.train([input_vector, true_outcomes], iterations=i) yar = NN.output_values ax1.clear() ax1.plot(input_vector, yar) Fs = 100 f = 5 sample = 100 input_vector = np.arange(100., sample+100, 0.1) test_vector = np.arange(0., sample+100, 0.1) true_outcomes = np.sin(2 * np.pi * f * input_vector / Fs) NN = NeuralNet.NeuralNet(len(input_vector), len(true_outcomes), 20) fig = plt.figure() ax1 = fig.add_subplot(1, 1, 1) ani = anima.FuncAnimation(fig, animate, interval=1) plt.show() outcome = NN.predict(test_vector) plt.plot(test_vector, outcome)
from NeuralNet import * inputs = 2 myRange = 1 myNet1 = NeuralNet(3, 3, inputs) myNet2 = NeuralNet(3, 3, inputs) myinput = myNet1.shapeInput([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) myNet1.updateNeurons(myinput, myRange) myinput = myNet1.shapeInput([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) myNet2.updateNeurons(myinput, myRange) myinput = myNet1.shapeInput(myNet2.speak()) ###conversation change = 0 for i in range(10000): myinput = myNet1.shapeInput(myNet2.winning) myNet1.updateNeurons(myinput, myRange) print "Person 1: ", myNet1.winning myinput = myNet1.shapeInput(myNet2.winning) myNet2.updateNeurons(myinput, myRange) print "Person 2: ", myNet2.winning distance = float( math.sqrt((((myNet1.winning[0] - myNet1.winning[1])**2)) +
import numpy as np import matplotlib.pyplot as plt import random import sys #import load_datasets as loader import NeuralNet # importer la classe du Réseau de Neurones #import DecisionTree # importer la classe de l'Arbre de Décision # importer d'autres fichiers et classes si vous en avez développés # importer d'autres bibliothèques au besoin, sauf celles qui font du machine learning nn = NeuralNet.NeuralNet(4, 3) test_data_location = 'data/mnist_test.csv' train_data_location = 'data/mnist_train.csv' test1 = np.loadtxt(test_data_location, encoding='utf-8', dtype=int, skiprows=1, delimiter=',') train1 = np.loadtxt(train_data_location, encoding='utf-8', dtype=int, skiprows=1, delimiter=',') test_labels1 = test1[:, 0].astype(int) train_labels1 = train1[:, 0].astype(int) train1 = train1[:, 1:] / 255 test1 = test1[:, 1:] / 255
def main_NN(): n = 50 np.random.seed(1) X, x_grid, y_grid, z, z_true = Franke_dataset(n, noise=0.0) z = np.reshape(z, (n * n, 1)) iters = 5000 lmbd = 0.0 gamma = 1e-5 n_categories = 1 n_params = 5 n_gammas = 3 params = np.zeros(n_params) params[1:] = np.logspace(1, -2, n_params - 1) gammas = np.logspace(-5, -6, n_gammas) print(params) print(gammas) test_frac = 0.3 n_test = int(test_frac * n**2) X_train, X_test, z_train, z_test = train_test_split(X, z, test_size=test_frac, random_state=123) z_test_1d = np.ravel(z_test) train_single_NN = True # plot_surf(x_grid, y_grid, z.reshape(n,n), cm.coolwarm, 1) # plt.show() if train_single_NN == True: # config = [4,16,4] # config = [30,20,30,20,30,20] config = [100, 50] hidden_a_func = ['tanh', 'tanh'] output_a_func = '' # config = [16,8,4] NN = NeuralNet(X_train, z_train, config, hidden_a_func, output_a_func, 'reg') NN.train(iters, gamma, lmbd=lmbd) z_pred = NN.predict_regression(X_test) r2_score = metrics.r2_score(z_test_1d, z_pred) mse = metrics.mean_squared_error(z_test_1d, z_pred) print("gamma =", gamma) print("lmbd =", lmbd) print("r2 =", r2_score) print("mse =", mse) print("--------------\n") # x_test, y_test = np.meshgrid(X_test[:,0], X_test[:,1]) # n_test_1d = int(np.sqrt(n_test)) # x_grid, y_grid = get_grid(X_test) # plot_surf(x_grid, y_grid, z_pred.reshape(n_test_1d, n_test_1d), cm.coolwarm) # plot_surf(x_grid, y_grid, z_test.reshape(n_test_1d, n_test_1d), cm.gray, alpha=0.5) # plt.show() # plt.imshow(z_pred.reshape(n,n)) # plt.show() # # plt.imshow(z_train.reshape(n,n)) # plt.show() # exit() config = [80, 60] hidden_a_func = ['sigmoid', 'tanh'] NN_grid = NeuralNet(X_train, z_train, config, hidden_a_func, '', 'reg') NN_grid.grid_search(X_test, z_test_1d, params, gammas, 'reg', config) # Iterate over multiple hidden layer configurations # for i in range(1, 6): # for j in range(0, i+1): # for k in range(0, 1): # config = [i, j, k] # NN_grid.grid_search(X_test, y_test, params, gammas, config) best_accuracy, best_config, best_lmbd, best_gamma = NN_grid.return_params() print("\n--- Grid search done ---") print('Best accuracy:', best_accuracy) print("with configuration", best_config, "lmbd =", best_lmbd, "gamma =", best_gamma)