def normal_sequence_example(): input_size = 1 hidden_sizes = [25] output_size = 1 for i in range(0, 4): X = np.array([range(0, 100)]).T y = [1] values = [1] for j in range(1, 100): y.append(y[-1] + np.random.normal(0, 1)) y = np.array([y]).T X_scale = np.power(10, len(str(int(np.amax(X))))) y_scale = np.power(10, len(str(int(np.amax(y))))) X = X / X_scale y = y / y_scale NN = NeuralNetwork(input_size, hidden_sizes, output_size) NN.train(X, y, 10000) plt.subplot(221 + i) plot_predictions(lambda x: NN.predict(x), X, y, X_scale, y_scale) plt.show()
def random_decision_boundary_example(): input_size = 2 hidden_sizes = [10, 20, 30, 20, 10] output_size = 1 np.random.seed(0) X = np.random.randn(100, 2) y = np.random.randint(0, 2, (100, 1)) NN = NeuralNetwork(input_size, hidden_sizes, output_size) NN.train(X, y, 10000) plot_decision_boundary(lambda x: NN.predict(x), X, y) plt.show()
def moons_decision_boundary_example(): input_size = 2 hidden_sizes = [5, 10, 5] output_size = 1 np.random.seed(0) X, y = make_moons(200, noise=0.20) y = np.array([y]).T NN = NeuralNetwork(input_size, hidden_sizes, output_size) NN.train(X, y, 10000) plot_decision_boundary(lambda x: NN.predict(x), X, y) plt.show()
def exponential_sequence_example(): input_size = 1 hidden_sizes = [100, 200, 100] output_size = 1 sequence = np.arange(0, 10, 0.1) X = np.array([sequence]).T y = np.array([np.exp(sequence)]).T X_scale = np.power(10, len(str(int(np.amax(X))))) y_scale = np.power(10, len(str(int(np.amax(y))))) X = X / X_scale y = y / y_scale NN = NeuralNetwork(input_size, hidden_sizes, output_size) NN.train(X, y, 10000) plot_predictions(lambda x: NN.predict(x), X, y, X_scale, y_scale) plt.show()
def random_sequence_example(): input_size = 1 hidden_sizes = [25] output_size = 1 for i in range(0, 4): X = np.sort(np.random.uniform(0, 100, (25, input_size)), axis=0) X = np.sort(np.concatenate((X, X * 0.75)), axis=0) y = np.sort(np.random.uniform(0, 100, (25, output_size)), axis=1) y = np.sort(np.concatenate((y, y * 0.75)), axis=1) X_scale = np.power(10, len(str(int(np.amax(X))))) y_scale = np.power(10, len(str(int(np.amax(y))))) X = X / X_scale y = y / y_scale NN = NeuralNetwork(input_size, hidden_sizes, output_size) NN.train(X, y, 10000) plt.subplot(221 + i) plot_predictions(lambda x: NN.predict(x), X, y, X_scale, y_scale) plt.show()
class Bird(Particle): def __init__(self, brain=None): super().__init__() xRandom = random.uniform(0.09, 0.14) self.moveTo(Vector2(display.width * xRandom, display.height // 2)) if brain is None: self.brain = NeuralNetwork(6, 10, 1) else: self.brain = brain self.alive = True self.vision = [] self.fitness = 0 self.seed = random.randint(0, 7) def getBrain(self): return self.brain.copyNetwork() def getPosition(self): return self.pos def update(self, pipes): self.applyForce(gravity) self.think(pipes) self.doPhysics() if self.alive: self.fitness += 1 def think(self, pipes): inputs = [self.pos.y / display.height, self.vel.y / self.maxVelocity] self.vision = self.perceive(pipes) for v in self.vision: inputs.append(v.x / display.width) inputs.append(v.y / display.height) # inputs.append(self.pos.angle_to(v) / 360) while len(inputs) < 4: inputs.append(0) predictions = self.brain.predict(inputs) prediction = predictions.pop() if prediction > 0.50: self.jump() def perceive(self, pipescollection): # for now, I'll just look at the bottom left of pipe[0] and top left of pipe[1] # TODO: look at the next pipe in the future seen = [] pipes = pipescollection.getPipes() if len(pipes) > 0: seen.append(Vector2(pipes[0].getRect().bottomleft)) if len(pipes) > 1: seen.append(Vector2(pipes[1].getRect().topleft)) return seen def draw(self): display.drawBird(self.pos, self.vision, seed=self.seed) def kill(self): self.alive = False def isDead(self): return not self.alive def offScreen(self): return self.pos.y < 0 or self.pos.y > display.height def collide(self, pipeRects): birdRect = display.birdRect birdRect.center = self.pos return birdRect.collidelist(pipeRects) > -1 def jump(self): self.applyForce(Vector2(0, -30))
class Snake: def __init__(self, brain=None): if brain == None: self.brain = NeuralNetwork(NETWORK) # new brain else: self.brain = NeuralNetwork([], brain) # copy brain self.active = True self.ticks_alive = 0 self.body = [] self.body.append( Element( (BOARD_LEFT + BOARD_SIZE // 2, BOARD_TOP + BOARD_SIZE // 2), Direction.UP)) self.turns = [] self.think_lock = 0 # every snake has his own apple to collect self.apple = Element((0, 0)) self.placeApple() self.apples_eaten = 0 self.steps_without_apple = 0 def draw(self, window): for element in self.body: pygame.draw.circle(window, pygame.Color(SNAKE_COLOR), (element.x, element.y), RADIUS) # apple pygame.draw.circle(window, pygame.Color(APPLE_COLOR), (int(self.apple.x), int(self.apple.y)), RADIUS) def placeApple(self): good_position = False while good_position == False: self.apple.x = np.random.randint(BOARD_LEFT + RADIUS, BOARD_RIGHT - RADIUS) self.apple.y = np.random.randint(BOARD_TOP + RADIUS, BOARD_DOWN - RADIUS) good_position = True for element in self.body: if self.apple.calcDistance(element) < RADIUS: good_position = False break def addTail(self): self.apples_eaten += 1 dir = self.body[-1].direction x = self.body[-1].x + (dir == Direction.LEFT) * \ 2 * RADIUS - (dir == Direction.RIGHT) * 2 * RADIUS y = self.body[-1].y + (dir == Direction.UP) * 2 * \ RADIUS - (dir == Direction.DOWN) * 2 * RADIUS self.body.append(Element((x, y), dir)) def calcFitness(self): self.fitness = self.ticks_alive * np.power(2, self.apples_eaten) def changeDir(self, dir): if dir.value == self.body[0].direction.value * ( -1) or self.body[0].direction == dir: return self.turns.append((self.body[0].x, self.body[0].y, dir)) self.steps_without_apple += 1 def move(self): self.think_lock -= 1 self.ticks_alive += 1 # change position for element in self.body: for turn in self.turns: if element.x == turn[0] and element.y == turn[1]: element.direction = turn[2] if element == self.body[-1]: self.turns.remove(turn) element.x += -(element.direction == Direction.LEFT) * \ SPEED + (element.direction == Direction.RIGHT) * SPEED element.y += -(element.direction == Direction.UP) * \ SPEED + (element.direction == Direction.DOWN) * SPEED # check for collisions # with wall if self.body[0].x < BOARD_LEFT + RADIUS or self.body[0].x > BOARD_RIGHT - RADIUS \ or self.body[0].y > BOARD_DOWN - RADIUS or self.body[0].y < BOARD_TOP + RADIUS: self.active = False # with body for element in self.body: if len(self.body) > 1 and element != self.body[0] and self.body[ 0].calcDistance(element) < RADIUS: self.active = False # with apple if self.body[0].calcDistance(self.apple) < 2 * RADIUS: self.addTail() self.placeApple() self.steps_without_apple = 0 if self.steps_without_apple > STEPS_WITHOUT_APPLE_MAX: # 15 self.active = False def think(self): if self.think_lock > 0: return input = self.getInputArray() decision = np.argmax(self.brain.predict(input)) if decision == 0: self.changeDir(Direction.UP) elif decision == 1: self.changeDir(Direction.DOWN) elif decision == 2: self.changeDir(Direction.LEFT) elif decision == 3: self.changeDir(Direction.RIGHT) self.think_lock = THINK_LOCK def checkSide(self, line, condition1, condition2, dist_value, dir=None): inputs = [0] * 3 head = self.body[0] if dir != None and head.direction.value == -1 * dir.value: inputs[0] = 1 else: for element in self.body: if element != head and element.checkCollisionWithLine( line) and condition1(element): inputs[0] = 1 break inputs[1] = 1 * \ (self.apple.checkCollisionWithLine(line) and condition2) if line[0] == None or line[0] == 0: inputs[2] = 1 / (abs(dist_value) + 0.01) else: inputs[2] = 1 / checkDist(line[0], head.x, head.y, dist_value[0], dist_value[1]) return inputs def getInputArray(self): inputs_array = [] head = self.body[0] # check up inputs_array += self.checkSide([None, head.x], lambda element: element.y < head.y, self.apple.y < head.y, head.y - RADIUS - BOARD_TOP, Direction.UP) # check down inputs_array += self.checkSide([None, head.x], lambda element: element.y > head.y, self.apple.y > head.y, head.y + RADIUS - BOARD_DOWN, Direction.DOWN) # check left inputs_array += self.checkSide([0, head.y], lambda element: element.x < head.x, self.apple.x < head.x, head.x - RADIUS - BOARD_LEFT, Direction.LEFT) # check right inputs_array += self.checkSide([0, head.y], lambda element: element.x > head.x, self.apple.x > head.x, head.x + RADIUS - BOARD_RIGHT, Direction.RIGHT) # check up right inputs_array += self.checkSide([-1, head.y + head.x], lambda element: element.y < head.y, self.apple.y < head.y, (BOARD_RIGHT, BOARD_TOP)) # check down left inputs_array += self.checkSide([-1, head.y + head.x], lambda element: element.y > head.y, self.apple.y > head.y, (BOARD_LEFT, BOARD_DOWN)) # check up left inputs_array += self.checkSide([1, head.y - head.x], lambda element: element.y < head.y, self.apple.y < head.y, (BOARD_LEFT, BOARD_TOP)) # check down right inputs_array += self.checkSide([1, head.y - head.x], lambda element: element.y > head.y, self.apple.y > head.y, (BOARD_RIGHT, BOARD_DOWN)) return inputs_array