def trial_report(): # Hard Coded for Report rf = RandomForestRegressor rf_info = Pipe(rf, 'rf', iters=1) mlp = MLPRegressor mlp_params = [ # ('0', {'hidden_layer_sizes': (49, )}), # ('1', {'hidden_layer_sizes': (49, 16)}), ('2', { 'hidden_layer_sizes': (49, 49) }), ('hls_49x49x49', { 'hidden_layer_sizes': (49, 49, 49) }), # ('test_49x49x16', {'hidden_layer_sizes': (49, 49, 16)}), # ('3D', {'hidden_layer_sizes': (49, 49, 32)}), # ('3E', {'hidden_layer_sizes': (49, 49, 80)}), # ('5A', {'hidden_layer_sizes': (80, 20)}), # ('5B', {'hidden_layer_sizes': (80, 40)}), # ('6C', {'hidden_layer_sizes': (80, 80)}), # ('7A', {'hidden_layer_sizes': (100, 100)}), # ('7B', {'hidden_layer_sizes': (100, 80)}), # ('7C', {'hidden_layer_sizes': (100, 120)}), # ('7D', {'hidden_layer_sizes': (100, 100, 49)}), # ('7E', {'hidden_layer_sizes': (100, 100, 80)}), # ('7F', {'hidden_layer_sizes': (100, 100, 100)}), # ('7G', {'hidden_layer_sizes': (100, 100, 100, 49)}), # ('7H', {'hidden_layer_sizes': (100, 100, 100, 100)}), # ('8', {'hidden_layer_sizes': (120, 120, 100, 49)}), # ('9', {'hidden_layer_sizes': (160, 200, 160, 49)}), # ('10', {'hidden_layer_sizes': (200, 200, 100, 49)}), # ('11', {'hidden_layer_sizes': (150, 200, 150, 50)}), # ('12A', {'hidden_layer_sizes': (300, 400, 200, 100)}), # ('12B', {'hidden_layer_sizes': (400, 400, 300, 200)}), # ('12C', {'hidden_layer_sizes': (400, 500, 200, 200)}), # ('DIM7_A', {'hidden_layer_sizes': (2000, 3000, 3000, 2000, 1000, 600, 600)}), # ('DIM7_B', {'hidden_layer_sizes': (1600, 2000, 2000, 1600, 1000, 600, 600)}) ] mlp_info = Pipe(mlp, 'mlp', iters=10, batch=1000, agent_batch=0, agent_monitor=False, model_params=mlp_params, save=True, fresh=False) mdls = [rf_info, mlp_info] b = [(4, 4), (6, 6)] rs = [True, False] classifier_reports(mdls, b, rs) return mdls
def __init__(self, memory, in_pipe=None, out_pipe=None, status_reg=None, args=[]): self.memory = memory self.instruction_pointer = 0 self.relative_base = 0 self.in_pipe = ConcurrentPipe() if not in_pipe else in_pipe self.out_pipe = ConcurrentPipe() if not out_pipe else out_pipe self.status_reg = Pipe() if not status_reg else status_reg self.args = args
def start_game(self): """ Creates Pipes in game Sets up game enviroment """ self.root.ids.player_score.text = "0" self.root.ids.leaderboardbutton.disabled = True self.root.ids.leaderboardbutton.opacity = 0 self.was_colliding = False self.root.ids.title.opacity = 0 self.root.ids.jay.opacity = 1 self.amount_pipes = [] self.frames = Clock.schedule_interval(self.next_frame, 1 / 60.) num_pipes = 5 pipe_dist = Window.width / (num_pipes - 1) for i in range(num_pipes): pipe = Pipe() pipe.pipe_center = randint(112 + 100, self.root.height - 100) pipe.size_hint = (None, None) pipe.pos = (Window.width + i * pipe_dist, 112) pipe.size = (64, self.root.height - 112) self.amount_pipes.append(pipe) self.root.add_widget(pipe)
def setup(): pygame.init() screen = pygame.display.set_mode((width, height)) agents = [] bird = Bird() agents.append(bird) pipes = [] new_pipe = Pipe() pipes.append(new_pipe) running = True pipe_time = 0 while running: for event in pygame.event.get(): if event.type == pygame.QUIT: running = False if event.type == pygame.KEYDOWN: if event.key == pygame.K_SPACE: agents[0].go_up() if pipe_time == 3000: new_pipe = Pipe() pipes.append(new_pipe) pipe_time = 0 for agent in agents: agent.update() for pipe in pipes: pipe.update() if (pipe.left_x + pipe.width < 0): pipes.remove(pipe) for agent in agents: if not agent.dead: agent.score += 1 for agent in agents: agent.hit(pipes) draw(screen, agents, pipes) pipe_time += 1
# passage for bird between pipes will be randomized per pass space = random.randint(80, 100) ready = False yloc = random.randint(32, 400 - 32 - space) # we will determine this by a random call # size of the pipes LxW xsize = 100 ysize = random.randint(100, 325) # speed to draw a pipe, make pipe visual on screen pipespeed = 4.0 # initialize and group top and bottom pipes bottomPipe = Pipe(1, xloc, yloc, space) topPipe = Pipe(0, xloc, bottomPipe.rect.y, space) allPipes = pygame.sprite.Group() # IMPORTANT THIS GOES FIRST OR IT WONT CALCULATE IT CORRECTLY allPipes.add(topPipe) allPipes.add(bottomPipe) # initialize window with black screen pygame.draw.rect(screen, black, [0, 300, 400, 60]) # start game screen and do initial startup tasks start = False while not start: pygame.display.flip() screen.blit(startscreen, [0, 0]) for event in pygame.event.get():
import vm from pipes import Pipe p = vm.Parser('day9.txt') program = p.parse() pipe = Pipe() m1 = vm.Machine(program.copy(), pipe, pipe, [1]) m2 = vm.Machine(program.copy(), pipe, pipe, [2]) m1.execute() print("Day 9 part 1:", pipe.inspect()) m2.execute() print("Day 9 part 2:", pipe.inspect())
from pipes import Pipe from functools import reduce from itertools import permutations import vm, threading def amplifier(in_pipe, out_pipe, args): vm.Parser(file, vm.Machine(in_pipe, out_pipe, args)).parse() file = 'day7.txt' outputs = [] perms = permutations([0, 1, 2, 3, 4]) pipes = [Pipe() for _ in range(5)] for perm in perms: vm.Parser(file, vm.Machine(pipes[0], pipes[1], [0, perm[0]])).parse() vm.Parser(file, vm.Machine(pipes[1], pipes[2], [perm[1]])).parse() vm.Parser(file, vm.Machine(pipes[2], pipes[3], [perm[2]])).parse() vm.Parser(file, vm.Machine(pipes[3], pipes[4], [perm[3]])).parse() vm.Parser(file, vm.Machine(pipes[4], pipes[0], [perm[4]])).parse() outputs.append(pipes[0].get_input()) print("Day 7 Part 1: ", reduce(max, outputs, 0)) perms = permutations([5, 6, 7, 8, 9]) outputs = [] for perm in perms: a0 = threading.Thread(target=amplifier, args=( pipes[0], pipes[1],
import vm, threading from pipes import ConcurrentPipe, Pipe program = vm.Parser('day13.txt').parse() in_pipe = ConcurrentPipe() out_pipe = ConcurrentPipe() status = Pipe() tile_set = {0: '.', 1: '#', 2: '@', 3: '-', 4: 'o'} def run(program, in_pipe, out_pipe, status): brain = vm.Machine(program, in_pipe, out_pipe, status, []) brain.execute() def draw(tiles, width, height): for y in range(height): for x in range(width): if (x, y) in tiles.keys(): print(tile_set[tiles[(x, y)]], end='') else: print('.', end='') print() print("score: {0}".format(tiles[(-1, 0)])) def initialize(tiles, width, height, pipe): count = 0 while count != (width * height): x = out_pipe.get_input()
x += 1 elif direction == Direction.West: x -= 1 return x, y def run(program_memory, input_pipe, output_pipe, status_register): vm.Machine(program_memory, input_pipe, output_pipe, status_register, []).execute() program = vm.Parser('day15.txt').parse() in_pipe = ConcurrentPipe() out_pipe = ConcurrentPipe() status = Pipe() current_position = (0, 0) explored = dict() explored[current_position] = 1 brain = threading.Thread(target=run, args=(program.copy(), in_pipe, out_pipe, status)) brain.start() stack = [] for key, value in directions.items(): stack.append(key) stack.append(value) while len(stack) != 0: direction = stack.pop()
class Machine: def __init__(self, memory, in_pipe=None, out_pipe=None, status_reg=None, args=[]): self.memory = memory self.instruction_pointer = 0 self.relative_base = 0 self.in_pipe = ConcurrentPipe() if not in_pipe else in_pipe self.out_pipe = ConcurrentPipe() if not out_pipe else out_pipe self.status_reg = Pipe() if not status_reg else status_reg self.args = args def execute(self): while self.memory[self.instruction_pointer] != Instruction.HALT.value: self.interpret() self.interpret() def interpret(self): """" ABCDE 1202 DE - two-digit opcode, 02 == opcode 2 C - mode of 1st parameter, 2 == relative mode B - mode of 2nd parameter, 1 == immediate mode A - mode of 3rd parameter, 0 == position mode, omitted due to being a leading zero """ instruction = self.memory[self.instruction_pointer] opcode = (instruction % 100) mode3 = instruction // 10000 mode2 = (instruction % 10000) // 1000 mode1 = (instruction % 1000) // 100 if opcode == Instruction.ADD.value: parameter_1 = self.read() parameter_2 = self.read() parameter_3 = self.read() input_1 = self.get_memory(mode1, parameter_1) input_2 = self.get_memory(mode2, parameter_2) self.set_memory(mode3, parameter_3, (input_1 + input_2)) elif opcode == Instruction.MUL.value: parameter_1 = self.read() parameter_2 = self.read() parameter_3 = self.read() input_1 = self.get_memory(mode1, parameter_1) input_2 = self.get_memory(mode2, parameter_2) self.set_memory(mode3, parameter_3, (input_1 * input_2)) elif opcode == Instruction.READ.value: parameter_1 = self.read() if len(self.args) != 0: input_2 = self.args.pop() else: input_2 = self.in_pipe.get_input() self.set_memory(mode1, parameter_1, input_2) elif opcode == Instruction.WRITE.value: parameter_1 = self.read() output = self.get_memory(mode1, parameter_1) self.out_pipe.set_output(output) elif opcode == Instruction.JMPT.value: parameter_1 = self.read() parameter_2 = self.read() input_1 = self.get_memory(mode1, parameter_1) if input_1 != 0: input_2 = self.get_memory(mode2, parameter_2) self.instruction_pointer = input_2 - 1 elif opcode == Instruction.JMPF.value: parameter_1 = self.read() parameter_2 = self.read() input_1 = self.get_memory(mode1, parameter_1) if input_1 == 0: input_2 = self.get_memory(mode2, parameter_2) self.instruction_pointer = input_2 - 1 elif opcode == Instruction.LESS.value: parameter_1 = self.read() parameter_2 = self.read() parameter_3 = self.read() input_1 = self.get_memory(mode1, parameter_1) input_2 = self.get_memory(mode2, parameter_2) self.set_memory(mode3, parameter_3, (1 if input_1 < input_2 else 0)) elif opcode == Instruction.EQUAL.value: parameter_1 = self.read() parameter_2 = self.read() parameter_3 = self.read() input_1 = self.get_memory(mode1, parameter_1) input_2 = self.get_memory(mode2, parameter_2) self.set_memory(mode3, parameter_3, (1 if input_1 == input_2 else 0)) elif opcode == Instruction.RELB.value: parameter_1 = self.read() input_1 = self.get_memory(mode1, parameter_1) self.relative_base += input_1 elif opcode == Instruction.HALT.value: self.status_reg.set_output(Status.HALT.value) else: self.status_reg.set_output(Status.ERR.value) raise ValueError("Invalid OPCODE @ IP:{0} CODE:{1}".format( self.instruction_pointer, opcode)) self.instruction_pointer += 1 def read(self): self.instruction_pointer += 1 return self.memory[self.instruction_pointer] def __lookup(self, pointer): val = 0 if pointer in self.memory.keys(): val = self.memory[pointer] else: self.memory[pointer] = 0 return val def get_memory(self, mode, parameter): if mode == Mode.POSITIONAL.value: value = self.__lookup(parameter) elif mode == Mode.IMMEDIATE.value: value = parameter elif mode == Mode.RELATIVE.value: value = self.__lookup(self.relative_base + parameter) return value def set_memory(self, mode, parameter, result): if mode == Mode.POSITIONAL.value: address = parameter elif mode == Mode.IMMEDIATE.value: self.status_reg.set_output(Status.ERR.value) raise ValueError("Immediate mode in output!") address = parameter elif mode == Mode.RELATIVE.value: address = parameter + self.relative_base self.memory[address] = result