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