def __init__(self, numGames, genes=None): self.neuralNetwork = NeuralNetwork( ) if genes is None else NeuralNetwork(genes) self.fitness = None self.accumulatedFitness = None self.numGames = numGames self.score = [0 for i in range(numGames)] self.genes = []
def make_net(sensor_count= 16): net = NeuralNetwork([sensor_count, 7, 2], learn_rate=0.05) test_db = create_tests(sensor_count) # print "\n".join([str(x) for x in test_db]) random.shuffle(test_db) for i in range(5): answ = net.calculate(test_db[i][0]) print(test_db[i][0], test_db[i][1], answ) errs = [] for _ in range(200): epoch_error = 0 for test in test_db: y = net.calculate(test[0]) err = math.sqrt((test[1][0]-y[0])**2 + (test[1][1]-y[1])**2) if err < 1.0: net.teach(-0.004) else: net.teach(0.004) epoch_error += err epoch_error /= len(test_db) errs.append(epoch_error) print epoch_error for i in range(10): answ = net.calculate(test_db[i][0]) print(test_db[i][0], test_db[i][1], answ) if __name__=='__main__': plt.plot(errs) plt.show() return net
def get_new_brain(sensor_count): global cbrain if cbrain is None: brain = NeuralNetwork([sensor_count, 2, 2]) database = [] for line in open('memory.txt','r'): line = [float(x) for x in line.split()] database.append((line[:-2], line[-2:])) for _ in range(15): err = brain.teach_by_sample(database) print(err) cbrain = brain return cbrain
class NeuralNetworkIndividuals: def __init__(self, numGames, genes=None): self.neuralNetwork = NeuralNetwork( ) if genes is None else NeuralNetwork(genes) self.fitness = None self.accumulatedFitness = None self.numGames = numGames self.score = [0 for i in range(numGames)] self.genes = [] def calcFitness(self): averageScore = sum(self.score) / self.numGames self.fitness = averageScore if self.fitness < 0: self.fitness = 0.1 def getNetGenes(self): return self.neuralNetwork.getParams() def makemove(self, board): return self.neuralNetwork.makemove(board) def getFitness(self): return self.fitness def setFitness(self, fitness): self.fitness = fitness def getAccumulatedFitness(self): return self.accumulatedFitness def setAccumulatedFitness(self, fitness): self.accumulatedFitness = fitness def setScore(self, i, value): self.score[i] = value def printData(self): print("Winner: ", self.score) def setParams(self, genes): self.neuralNetwork.setParams(genes)
def create_brain(dna, world_constants): def dna_iter(dna): for i in range(0, len(dna), world_constants.DNA_BRAIN_VALUE_LEN): cur = dna[i:i + world_constants.DNA_BRAIN_VALUE_LEN] yield (int(cur, world_constants.DNA_BASE) - world_constants.DNA_HALF_MAX_VALUE ) / world_constants.DNA_HALF_MAX_VALUE dna = dna_iter(dna) brain = NeuralNetwork(world_constants.NEURAL_NETWORK_SHAPE) for layer in brain: for neuron in layer: neuron.w = [dna.next() for _ in range(len(neuron.w))] return brain
def __init__(self, world): self.world = world self._x = randint(0, self.world.width) self._y = randint(0, self.world.height) self.size = 7 self.angle = 0 self.sensor_count = 7 self._sensor_count_in_head = int(self.sensor_count * Animal.SENSOR_COUNT_IN_HEAD_RATIO) self._sensor_count_not_in_head = self.sensor_count - self._sensor_count_in_head self.sensor_values = [] self._sensors_positions = [] self._sensors_positions_calculated = False self.energy = self.ENERGY_FOR_BUD self.readiness_to_bud = 0 self.brain = NeuralNetwork([self.sensor_count, 2, 2])
#Clean data. Outliers removed. #Testing data. m = 66749. Locations: Nottingham and Reading. #Set up neural networks from NeuralNetwork.NeuralNetwork import NeuralNetwork import numpy as np import scipy.special import csv i_n = 11 #no. of input nodes h_n = 21 #no. of hidden nodes 11 ~ sqrt(i_n * o_n) o_n = 1 #np. of output nodes lr = 0.15 #learning rate NN1 = NeuralNetwork(i_n, h_n, o_n, lr) #setting up neural networks NN2 = NeuralNetwork(i_n, h_n, o_n, lr) NN3 = NeuralNetwork(i_n, h_n, o_n, lr) NN4 = NeuralNetwork(i_n, h_n, o_n, lr) NN5 = NeuralNetwork(i_n, h_n, o_n, lr) NN6 = NeuralNetwork(i_n, h_n, o_n, lr) NN7 = NeuralNetwork(i_n, h_n, o_n, lr) NN8 = NeuralNetwork(i_n, h_n, o_n, lr) NN1.load('a7', 'b7') NN2.load('c7', 'd7') NN3.load('e7', 'f7') NN4.load('g7', 'h7') NN5.load('i7', 'j7') NN6.load('k7', 'l7') NN7.load('m7', 'n7')
#Testing data. m = 66749. Locations: Nottingham and Reading. #Set up neural networks from NeuralNetwork.NeuralNetwork import NeuralNetwork import numpy as np import scipy.special import csv i_n = 14 #no. of input nodes h_n = 21 #no. of hidden nodes 11 ~ sqrt(i_n * o_n) o_n = 1 #np. of output nodes lr = 0.15 #learning rate epochs = 5 #no. of epochs NN1 = NeuralNetwork(i_n, h_n, o_n, lr) #setting up neural networks NN2 = NeuralNetwork(i_n, h_n, o_n, lr) NN3 = NeuralNetwork(i_n, h_n, o_n, lr) NN4 = NeuralNetwork(i_n, h_n, o_n, lr) NN5 = NeuralNetwork(i_n, h_n, o_n, lr) NN6 = NeuralNetwork(i_n, h_n, o_n, lr) NN7 = NeuralNetwork(i_n, h_n, o_n, lr) NN8 = NeuralNetwork(i_n, h_n, o_n, lr) train_data_file = open( 'X:/Documents/Carbon Emissions Data/Data/TrainingData4Final.csv', 'r') #loading training data train_data = train_data_file.readlines() train_data_file.close()
import time from NeuralNetwork.NeuralNetwork import NeuralNetwork net = NeuralNetwork(2, 1, 1, 2) inputs_outputs = [{ "input": [1, 1], "output": [0] }, { "input": [1, 0], "output": [1] }, { "input": [0, 1], "output": [1] }, { "input": [0, 0], "output": [0] }] for input_output in inputs_outputs: print( f"input = {input_output['input']} , output = {net.GetOutputs(input_output['input'])}" ) print() last_loss = 1 timer = time.time() for _ in range(8000): loss = 0 for input_output in inputs_outputs:
if (self.outputs[ip] == [[1, 0, 0]]): print("Iris-sentosa") elif (self.outputs[ip] == [[0, 1, 0]]): print("Iris-versicolor") elif (self.outputs[ip] == [[0, 0, 1]]): print("Iris-virginica") print("\nPredicted Output : ") op = nn.feedforward(self.inputs[ip]) if (op.index(max(op)) == 0): print("Iris-sentosa") elif (op.index(max(op)) == 1): print("Iris-versicolor") elif (op.index(max(op)) == 2): print("Iris-virginica") print("Continue ? (1 - Y 2 - N)") choice = int(input()) if (choice == 2): break iris = Iris() iris.extract() nn = NeuralNetwork(4, 10, 3) # iris.visualize() print("Training Model") iris.train(0.1, 30000) iris.test()
class Animal(object): DEBUG = False MAX_ENERGY = 30 ENERGY_FOR_EXIST = 0.007 MOVE_ENERGY_RATIO = 0.01 # sensor_count_in_head / sensor_count SENSOR_COUNT_IN_HEAD_RATIO = 0.5 # head angle HEAD_ANGLE = math.pi / 4.0 HALF_HEAD_ANGLE = HEAD_ANGLE / 2.0 READINESS_TO_BUD_THREADSHOULD = 30 READINESS_TO_BUD_INCREASEMENT = 0.2 ENERGY_FULLNES_TO_BUD = 0.7 ENERGY_FOR_BUD = 5 MIN_CHILD_COUNT = 1 MAX_CHILD_COUNT = 3 MUTATE_VALUE = 0.4 HALF_MUTATE_VALUE = MUTATE_VALUE / 2 MUTATE_CHANCE = 0.6 def __init__(self, world): self.world = world self._x = randint(0, self.world.width) self._y = randint(0, self.world.height) self.size = 7 self.angle = 0 self.sensor_count = 7 self._sensor_count_in_head = int(self.sensor_count * Animal.SENSOR_COUNT_IN_HEAD_RATIO) self._sensor_count_not_in_head = self.sensor_count - self._sensor_count_in_head self.sensor_values = [] self._sensors_positions = [] self._sensors_positions_calculated = False self.energy = self.ENERGY_FOR_BUD self.readiness_to_bud = 0 self.brain = NeuralNetwork([self.sensor_count, 2, 2]) # import BrainTrainer # self.brain = clone_brain(BrainTrainer.get_new_brain(self.sensor_count)) @property def sensors_positions(self): # on 45 degrees (pi/4) of main angle located 75% of all sensors if not self._sensors_positions_calculated: self._sensors_positions = [] # calc sensor positions in head delta_angle = Animal.HEAD_ANGLE / (self._sensor_count_in_head-1) angle = -Animal.HALF_HEAD_ANGLE + self.angle for _ in range(self._sensor_count_in_head): self._sensors_positions.append( (math.cos(angle) * self.size + self._x, math.sin(angle) * self.size + self._y)) angle += delta_angle # calc sensor positions in body delta_angle = (TWO_PI - Animal.HEAD_ANGLE) / (self._sensor_count_not_in_head+1) angle = Animal.HALF_HEAD_ANGLE + self.angle for _ in range(self._sensor_count_not_in_head): angle += delta_angle self._sensors_positions.append( (math.cos(angle) * self.size + self._x, math.sin(angle) * self.size + self._y)) self._sensors_positions_calculated = True return self._sensors_positions def update(self, sensor_values): self.sensor_values = sensor_values answer = self.brain.calculate(self.sensor_values) self.answer = answer self.energy -= Animal.ENERGY_FOR_EXIST if self.energy / Animal.MAX_ENERGY > Animal.ENERGY_FULLNES_TO_BUD: self.readiness_to_bud += Animal.READINESS_TO_BUD_INCREASEMENT if self.readiness_to_bud >= Animal.READINESS_TO_BUD_THREADSHOULD: self.readiness_to_bud = 0 self.bud() self.move(answer[0], answer[1]) def bud(self): child_count = randint(Animal.MIN_CHILD_COUNT, Animal.MAX_CHILD_COUNT) # if it tries to bud more child than it can - bud so many as it can and die. if child_count*Animal.ENERGY_FOR_BUD > self.energy: child_count = int(self.energy / Animal.ENERGY_FOR_BUD) self.energy = 0 for _ in range(child_count): self.energy -= Animal.ENERGY_FOR_BUD child = Animal(self.world) child.x = self.x + randint(-30, 30) child.y = self.y + randint(-30, 30) child.brain = clone_brain(self.brain) self.world.add_animal(child) def eat(self, food): value = min(World.World.EATING_VALUE, max(0, Animal.MAX_ENERGY - self.energy)) value = food.beating(value) self.energy += value def move(self, move, rotate): self.energy -= (abs(move) + abs(rotate))*Animal.MOVE_ENERGY_RATIO self._sensors_positions_calculated = False self.angle += rotate self._x += math.cos(self.angle) * move * 2.0 self._y += math.sin(self.angle) * move * 2.0 @property def x(self): return self._x @x.setter def x(self, value): self._x = value self._sensors_positions_calculated = False @property def y(self): return self._y @y.setter def y(self, value): self._y = value self._sensors_positions_calculated = False
theBoard = { '7': ' ', '8': ' ', '9': ' ', '4': ' ', '5': ' ', '6': ' ', '1': ' ', '2': ' ', '3': ' ' } board_keys = [] neural_net1 = LoadFromFile("neural_net1.pkl") if not neural_net1: neural_net1 = NeuralNetwork(27, 9, 4, 9) neural_net2 = LoadFromFile("neural_net2.pkl") if not neural_net2: neural_net2 = NeuralNetwork(27, 9, 4, 9) for key in theBoard: board_keys.append(key) ''' We will have to print the updated board after every move in the game and thus we will make a function in which we'll define the printBoard function so that we can easily print the board everytime by calling this function. ''' def printBoard(board): print(board['7'] + '|' + board['8'] + '|' + board['9']) print('-+-+-') print(board['4'] + '|' + board['5'] + '|' + board['6'])
from NeuralNetwork.NeuralNetwork import NeuralNetwork, LoadFromFile nets = [] for _ in range(100): nets.append(NeuralNetwork(1, 1, 0, 0)) best_net = None best_loss = 1 for index in range(len(nets)): nets[index] = nets[index].GetRandomizedBest([1], [1], 0.5, 100) loss = nets[index].GetLoss([1], [1]) if loss < best_loss: best_net = nets[index] best_loss = loss if loss < 0.5: nets[index] = None for _ in range(30000): best_net.CalculateSlopeValues([1], [1]) best_net.MutateSlopeValues(1) print(best_net.GetOutputs([1])) print(best_net.GetOutputs([0])) print(best_net) # best_net.SaveToFile("Neural.pkl") best_net = LoadFromFile("Neural.pkl") print("after pickle") print(best_net.GetOutputs([1]))
#Testing data. m = 66749. Locations: Nottingham and Reading. #Set up neural networks from NeuralNetwork.NeuralNetwork import NeuralNetwork import numpy as np import scipy.special import csv i_n = 14 #no. of input nodes h_n = 21 #no. of hidden nodes 11 ~ sqrt(i_n * o_n) o_n = 1 #np. of output nodes lr = 0.15 #learning rate epochs = 1 #no. of epochs NN1 = NeuralNetwork(i_n, h_n, o_n, lr) #setting up neural networks NN2 = NeuralNetwork(i_n, h_n, o_n, lr) NN3 = NeuralNetwork(i_n, h_n, o_n, lr) NN4 = NeuralNetwork(i_n, h_n, o_n, lr) NN5 = NeuralNetwork(i_n, h_n, o_n, lr) NN6 = NeuralNetwork(i_n, h_n, o_n, lr) NN7 = NeuralNetwork(i_n, h_n, o_n, lr) NN8 = NeuralNetwork(i_n, h_n, o_n, lr) NN1.load('a6', 'b6') NN2.load('c6', 'd6') NN3.load('e6', 'f6') NN4.load('g6', 'h6') NN5.load('i6', 'j6') NN6.load('k6', 'l6') NN7.load('m6', 'n6')
#Testing data. m = 66749. Locations: Nottingham and Reading. #Set up neural networks from NeuralNetwork.NeuralNetwork import NeuralNetwork import numpy as np import scipy.special import csv i_n = 11 #no. of input nodes h_n = 21 #no. of hidden nodes 11 ~ sqrt(i_n * o_n) o_n = 1 #np. of output nodes lr = 0.15 #learning rate epochs = 5 #no. of epochs NN1 = NeuralNetwork(i_n, h_n, o_n, lr) #setting up neural networks NN2 = NeuralNetwork(i_n, h_n, o_n, lr) NN3 = NeuralNetwork(i_n, h_n, o_n, lr) NN4 = NeuralNetwork(i_n, h_n, o_n, lr) NN5 = NeuralNetwork(i_n, h_n, o_n, lr) NN6 = NeuralNetwork(i_n, h_n, o_n, lr) NN7 = NeuralNetwork(i_n, h_n, o_n, lr) NN8 = NeuralNetwork(i_n, h_n, o_n, lr) train_data_file = open( 'X:/Documents/Carbon Emissions Data/Data/TrainingDataBasicFinal.csv', 'r') #loading training data train_data = train_data_file.readlines() train_data_file.close()
from NeuralNetwork.NeuralNetwork import NeuralNetwork from NeuralNetwork.Node.BasicNodeClasses import InputLinkedNode, NodeLink net = NeuralNetwork(2, 1, 1, 2) # hidden_bias = np.array([[0.2, 0.6]]) net.hidden_nodes[0].bias = 0.2 net.hidden_nodes[1].bias = 0.6 # hidden_weights = np.array([[0.8, 0.4], [0.1, 0.05]]) net.hidden_nodes[0].input_links[0].factor = 0.8 net.hidden_nodes[0].input_links[1].factor = 0.1 net.hidden_nodes[1].input_links[0].factor = 0.4 net.hidden_nodes[1].input_links[1].factor = 0.05 # output_bias = np.array([[0.7]]) net.output_nodes[0].bias = 0.7 # output_weights = np.array([[0.35], [0.21]]) net.output_nodes[0].input_links[0].factor = 0.35 net.output_nodes[0].input_links[1].factor = 0.21 inputs = [[0, 0], [0, 1], [1, 0], [1, 1]] expected_output = [[0], [1], [1], [0]] for index in range(4): output = net.GetOutputs(inputs[index]) print(output) net.CalculateSlopeValues(inputs[index], expected_output[index]) for node in net.node_dictionary.values():