def __init__(self, controller_class, input_size, output_size, memory_locations=256, memory_word_size=64, memory_read_heads=4, shift_range=1, batch_size=1): """ constructs a complete DNC architecture as described in the "Neural Turing Machines" paper https://arxiv.org/abs/1410.5401 Parameters: ----------- controller_class: BaseController a concrete implementation of the BaseController class input_size: int the size of the input vector output_size: int the size of the output vector memory_locations: int the number of words that can be stored in memory memory_word_size: int the size of an individual word in memory memory_read_heads: int the number of read heads in the memory shift_range: int allowed integer shifts batch_size: int the size of the data batch """ self.input_size = input_size self.output_size = output_size self.memory_locations = memory_locations self.word_size = memory_word_size self.read_heads = memory_read_heads self.batch_size = batch_size self.shift_range = shift_range self.memory = Memory(self.memory_locations, self.word_size, self.read_heads, self.batch_size) self.controller = controller_class(self.input_size, self.output_size, self.read_heads, self.word_size, self.shift_range, self.batch_size) # input data placeholders self.input_data = tf.compat.v1.placeholder( tf.float32, [batch_size, None, input_size], name='input') self.target_output = tf.compat.v1.placeholder( tf.float32, [batch_size, None, output_size], name='targets') self.sequence_length = tf.compat.v1.placeholder(tf.int32, name='sequence_length') self.build_graph()
def __init__(self, controller_class, input_size, output_size, max_sequence_length, memory_words_num=256, memory_word_size=64, memory_read_heads=4, batch_size=1): """ constructs a complete DNC architecture as described in the DNC paper http://www.nature.com/nature/journal/vaop/ncurrent/full/nature20101.html Parameters: ----------- controller_class: BaseController a concrete implementation of the BaseController class input_size: int the size of the input vector output_size: int the size of the output vector max_sequence_length: int the maximum length of an input sequence memory_words_num: int the number of words that can be stored in memory memory_word_size: int the size of an individual word in memory memory_read_heads: int the number of read heads in the memory batch_size: int the size of the data batch """ self.input_size = input_size self.output_size = output_size self.max_sequence_length = max_sequence_length self.words_num = memory_words_num self.word_size = memory_word_size self.read_heads = memory_read_heads self.batch_size = batch_size self.memory = Memory(self.words_num, self.word_size, self.read_heads, self.batch_size) self.controller = controller_class(self.input_size, self.output_size, self.read_heads, self.word_size, self.batch_size) # input data placeholders self.input_data = tf.compat.v1.placeholder( tf.float32, [batch_size, None, input_size], name='input') self.target_output = tf.compat.v1.placeholder( tf.float32, [batch_size, None, output_size], name='targets') self.sequence_length = tf.compat.v1.placeholder(tf.int32, name='sequence_length') self.build_graph()
def __init__(self, params): #params.actions = env.actions() #self.num_actions = env.actions() self.episodes = params.episodes self.steps = params.steps self.train_steps = params.train_steps self.update_freq = params.update_freq self.save_weights = params.save_weights self.history_length = params.history_length self.discount = params.discount self.eps = params.init_eps self.eps_delta = (params.init_eps - params.final_eps) / params.final_eps_frame self.replay_start_size = params.replay_start_size self.eps_endt = params.final_eps_frame self.random_starts = params.random_starts self.batch_size = params.batch_size self.ckpt_file = params.ckpt_dir+'/'+params.game self.global_step = tf.Variable(0, trainable=False) if params.lr_anneal: self.lr = tf.train.exponential_decay(params.lr, self.global_step, params.lr_anneal, 0.96, staircase=True) else: self.lr = params.lr self.buffer = Buffer(params) self.memory = Memory(params.size, self.batch_size) with tf.variable_scope("train") as self.train_scope: self.train_net = ConvNet(params, trainable=True) with tf.variable_scope("target") as self.target_scope: self.target_net = ConvNet(params, trainable=False) self.optimizer = tf.train.RMSPropOptimizer(self.lr, params.decay_rate, 0.0, self.eps) self.actions = tf.placeholder(tf.float32, [None, self.num_actions]) self.q_target = tf.placeholder(tf.float32, [None]) self.q_train = tf.reduce_max(tf.multiply(self.train_net.y, self.actions), reduction_indices=1) self.diff = tf.subtract(self.q_target, self.q_train) half = tf.constant(0.5) if params.clip_delta > 0: abs_diff = tf.abs(self.diff) clipped_diff = tf.clip_by_value(abs_diff, 0, 1) linear_part = abs_diff - clipped_diff quadratic_part = tf.square(clipped_diff) self.diff_square = tf.multiply(half, tf.add(quadratic_part, linear_part)) else: self.diff_square = tf.multiply(half, tf.square(self.diff)) if params.accumulator == 'sum': self.loss = tf.reduce_sum(self.diff_square) else: self.loss = tf.reduce_mean(self.diff_square) # backprop with RMS loss self.task = self.optimizer.minimize(self.loss, global_step=self.global_step)
def __init__(self, program1, program2): self.memory = Memory(4096) self.memory.load(program1, 0) self.memory.load(program2, 2048) if len(program1) * 32 > 2048 or len(program2) * 32 > 2048: raise ValueError self.process_queue = [[Process()], [Process()]] self.player1 = self.process_queue[0] # process queue of program1 self.player2 = self.process_queue[1] # process queue of program2 self.state = None
def __init__(self): self.quads = [] self.data = 0 self.fd = FunctionDirectory() self.memory = Memory() self.vt = VarTable() self.start_time = 0 self.end_time = 0 self.adidtg = AddressIdTable() self.faux = FuncionAux()
def test_get(self): target = 'b' x, y = (1, 1) memory = Memory(['abc', 'd' + target + 'd']) result = memory.get(x, y) self.assertEqual(result, target, 'get result doesnt match target')
def __init__(self, sess, eps_schedule, lr_schedule): self.dqn_online = Agent._make_dqn('online') self.dqn_target = Agent._make_dqn('target') self.sess = sess self.eps_schedule = eps_schedule self.lr_schedule = lr_schedule self.memory = Memory(MEMORY_SIZE) self.step = 0
def test1(self): a = Memory(ph_cells=4) a.addprocess(2) a.addprocess(4) for i in range(0, 10): process, page = a.choosepagevm() self.assertGreaterEqual(page, 0) self.assertGreaterEqual( len(a.vm.processes[process].allocation) - 1, page) self.assertIn(process, [0, 1])
def __init__(self, config): self.MS_PER_UPDATE = 1000.0 / 60 self.config = config self.screen = pygame.display.get_surface() self.game_done = False self.CLOCK = pygame.time.Clock() self.memory = Memory() self.cpu = CPU(self.memory, self.config.debug)
def era_operation(current_quad): current_function_name.push(current_quad.getResult()) current_era = ActivationRecord(globalScope.functionDirectory.local_memory) local_memory_handler.push(current_era) # globalScope.functionDirectory.local_memory.clear_Memory() new_memory = Memory("Local/Temporal", 2000, 3999) new_era = ActivationRecord(new_memory) local_memory_handler.push(new_era)
def __init__(self, fn): self.main = True self.mode = Mode.edit self.mem = Memory(fn) self.cursor = (1, 0) self.win_y_loc = 0 self.lr = 16 self.height = 4 self.selected_area = None self.buffer = b''
def test_play_matches_fake_neural_network(self): memory = Memory(config.MEMORY_SIZE) player1 = Agent('random_agent_1', config.GRID_SHAPE[0] * config.GRID_SHAPE[1], config.GRID_SHAPE[1], config.MCTS_SIMS, config.CPUCT, GenRandomModel()) player2 = Agent('random_agent_2', config.GRID_SHAPE[0] * config.GRID_SHAPE[1], config.GRID_SHAPE[1], config.MCTS_SIMS, config.CPUCT, GenRandomModel()) logger = lg.logger_main logger.setLevel(logging.DEBUG) scores, memory, points, sp_scores = play_matches.playMatches(player1, player2, config.EPISODES, logger, turns_until_tau0 = config.TURNS_UNTIL_TAU0, memory = memory)
def test_cache_write_byte(): mem = Memory(lines=2**8, delay=0) cache = Cache(lines=2**4, words_per_line=1, delay=0, next_level=mem) cache.write(0x0, 0x0, only_byte=True) cache.write(0x1, 0x1, only_byte=True) cache.write(0x2, 0x2, only_byte=True) cache.write(0x3, 0x3, only_byte=True) assert (cache.data[0][1] == 0x03020100) assert (mem.data[0] == 0x03020100)
def load_checkpoint(self, filename): with open(filename, "r") as json_file: data = json.load(json_file) self.last_step = data['last_step'] self.current_episode = data['current_episode'] self.model_name = data['model_name'] if self.memory is None: self.config = Config(self.config_file) self.memory = Memory(max_len=self.config.max_queue_length) self.memory.load(data['memory'])
def exit_process(self, process): "Exit the current process, for any reason" process_memory = Memory(lower_bound=process.pcb.lower_bound, upper_bound=process.pcb.upper_bound) self.recycle_memory_algo(self.empty_memory, process_memory) self.used_memory.remove(process_memory) return
def test_cache_read_byte(): mem = Memory(lines=2**8, delay=1) mem.data[0] = 1 # mem has data: 0x0: 1, 0x1: 0, 0x2: 0, 0x3: 0 cache = Cache(lines=2**4, words_per_line=4, delay=0, next_level=mem) assert (cache.read(0, only_byte=True) == 'wait') assert (cache.read(0, only_byte=True)[0] == 1) assert (cache.read(1, only_byte=True)[0] == 0) assert (cache.read(2, only_byte=True)[0] == 0) assert (cache.read(3, only_byte=True)[0] == 0)
def __init__(self, state_size, action_size, replay_size=32): """ state_size : int 状態空間の次元数 action_size : int 行動空間の次元数 """ self.brain = Brain(state_size, action_size) self.memory = Memory() self.replay_size = replay_size
def reset(self): """Función que resetea los valores viejos de ejecuciones pasadas que fueron guardados en recursos compartidos """ global_vars.init() self.virtual_machine.mem = Memory() st.SymbolsTable.function_dictionary = {} self.canvas.delete("all") self.console.delete(1.0, tk.END) q.Quadruple.quadruple_list = []
def __init__(self, input_shape, action_count, steps=0, model_path=None): self.steps = steps self.epsilon = MAX_EPSILON if steps == 0 else self.__calc_epsilon( steps) self.brain = Brain(action_count, input_shape=input_shape, model_path=model_path) self.memory = Memory(MEMORY_CAPACITY) self.input_shape = input_shape self.action_count = action_count
def __init__(self, library, program_name): self.computer_name = 'HAL' self.cpu = CPU() self.io = IO() self.memory = Memory() self.program = Program(library[program_name]) self.halt_condition = False self.ip = 0
def initialize(self, base_instructions): self.memory = Memory(20) self.error = Error() self.internal_state = Internal_State() self.io = IO() self.base_instructions = base_instructions self.max_mem_pages = 2 self.remaining_mem_pages = 2 self.new_memory = [0] * self.max_mem_pages print(self.new_memory)
def setUp(self): self.sys = MemSys("Test Platform", 64) self.memory = Memory(self.sys, 4, 4, 4, 2, 64, 1866, True, None) self.l2c = Cache(self.sys, 1037000, 0, 1, 16, 8, 534288, 64, 3, True, self.memory.get_component_id()) self.l1c0 = Cache(self.sys, 1037000, 0, 0, 16, 8, 16384, 64, 1, True, self.l2c.get_component_id()) self.cu0 = ComputeUnit(self.sys, 1037000, 0, True, self.l1c0.get_component_id()) self.sys.build_map()
def main(): price_db = leveldb.LevelDB(config.PRICE_DB) trade_db = leveldb.LevelDB(config.TRADE_DB) price_memory = Memory( price_db, trade_db ) # price data of latest period, multiple frequency and period length maybe pool = Pool(100000, 0) my_hand = Hand(pool) my_brain = brain.Brain(price_memory, my_hand)
def reset(self): super().reset() if self.log is not None: self.log.close() self.log = open( f'{os.path.abspath(os.getcwd())}' f'\\data\\logs\\log_{self.__class__.__name__}_game_{self.episodes-1}.txt', 'w') self.game_step = 0 self.memory = Memory()
def run(seed, noise_type, layer_norm, **kwargs): """Configure things.""" rank = MPI.COMM_WORLD.Get_rank() if rank != 0: logger.set_level(logger.DISABLED) """Create Simulation envs.""" # env = PegintoHoles() """Create True envs""" env = Env_robot_control() """Parse noise_type""" action_noise = None param_noise = None nb_actions = env.action_dim for current_noise_type in noise_type.split(','): current_noise_type = current_noise_type.strip() if current_noise_type == 'none': pass elif 'adaptive-param' in current_noise_type: _, stddev = current_noise_type.split('_') # action_noise = OrnsteinUhlenbeckActionNoise(mu=np.zeros(nb_actions), # sigma=float(0.05) * np.ones(nb_actions)) param_noise = AdaptiveParamNoiseSpec(initial_stddev=float(stddev), desired_action_stddev=float(stddev)) elif 'normal' in current_noise_type: _, stddev = current_noise_type.split('_') action_noise = NormalActionNoise(mu=np.zeros(nb_actions), sigma=float(stddev) * np.ones(nb_actions)) elif 'ou' in current_noise_type: _, stddev = current_noise_type.split('_') action_noise = OrnsteinUhlenbeckActionNoise(mu=np.zeros(nb_actions), sigma=float(stddev) * np.ones(nb_actions)) else: raise RuntimeError('unknown noise type "{}"'.format(current_noise_type)) """Configure components.""" memory = Memory(limit=int(1e5), action_shape=env.action_dim, observation_shape=env.state_dim) critic = Critic(layer_norm=layer_norm) actor = Actor(nb_actions, layer_norm=layer_norm) """Seed everything to make things reproducible.""" seed = seed + 1000000 * rank logger.info('rank {}: seed={}, logdir={}'.format(rank, seed, logger.get_dir())) tf.reset_default_graph() set_global_seeds(seed) """Disable logging to avoid noise.""" start_time = time.time() """Train the model""" training.train(env=env, param_noise=param_noise, action_noise=action_noise, actor=actor, critic=critic, memory=memory, **kwargs) """Eval the result""" logger.info('total runtime: {}s'.format(time.time() - start_time))
def __init__(self, memory_size=1024 * 8): # ************************************************************* # Memory Control Part # Initialize the memory of the System # Partner System for memory managing self.empty_memory = [ Memory(lower_bound=0, upper_bound=memory_size - 1) ] self.used_memory = [] self.space_enough = True self.threshold = 16 # Arranging a max size of the pcb, imitating the real os self.pcb_max_size = 128 # ************************************************************* # The ID of the process allocated for the process self.pid = 0 # ************************************************************* # ALGORITHM AREA self.apply_memory_algorithm = algorithm_memory_apply_best_adapt self.recycle_memory_algo = algorithm_memory_recycle # ************************************************************* # EVENT CONTROL AREA self.clock = YidanTime(0) self.time_period = YidanTime(0) self.events = [ Event(name="event1", semaphore=2), Event(name="event2", semaphore=1), Event(name="event3", semaphore=2), Event(name="event4", semaphore=1), Event(name="event5", semaphore=2) ] self.current_event = [] self.event_sustain = YidanTime(0) self.menu_show = True # ************************************************************* # LIST MANAGE PART self.blocked_list = {} for event in self.events: self.blocked_list[event.name] = [] self.ready_list = {} for event in self.events: self.ready_list[event.name] = [] self.running_process = None
def __init__(self, no_display=False, zoom=1): self.ram = Memory(0x2000, offset=0x8000, randomized=True, name="Display RAM") self.vblank_duration = 1.1 self.fps = 59.7 self.frames = 0 self.frame_start = time.clock() # pseudo-registers self.LY = 0 self.SCY = 0 self.SCX = 0 self.BGPAL = 0 self._LCDCONT = 0 self.scanlines = 154 self.turned_on = False # Actual display area self.vwidth = 256 self.vheight = 256 # Shown area self.width = 160 self.height = 144 if not no_display: self.window = HostDisplay("GameBoy", zoom=zoom) self.tile_window = HostDisplay("Tiles", zoom=zoom, height=128) else: self.window = NoDisplay() self.tile_window = NoDisplay() self.window.show() self.window.clear(0x474741) self.tile_window.clear(0x474741) self.window.update() self.tile_window.update() self.palette = { 0: 0xffffff, 1: 0xaaaaaa, 2: 0x555555, 3: 0x000000, } # Maps color to (x,y) pairs. Stupid, but that's how SDL wants it. self.pixels = {0: [], 1: [], 2: [], 3: []} self.tile_pixels = {0: [], 1: [], 2: [], 3: []}
def process(program, test_case_num): pid = str(uuid.uuid1()) if not isinstance(program, Program): program = Program.deserialize(program) program_length = program.length program_trace = {str(n): [] for n in range(program_length+1)} sampled_test_cases = random.sample(program.test_cases, test_case_num) for tid, test_case in enumerate(sampled_test_cases): memory = Memory() inputs = test_case.inputs for i in inputs: entry = MemoryEntry( name=i["variable_name"], value=i["value"], data_type=i["data_type"], opt=None ) memory.write(i["variable_name"], entry) expressions = program.expressions() idx = 0 while idx < len(expressions): expression = expressions[idx] curr_trace = str(program_length - idx) program_trace[curr_trace].append({ "test_case_id": tid, "step": int(curr_trace), "output": test_case.output, "func": expression[1], "args": expression[2:], "memory": memory.serialize() }) interpreter.interpret(memory, expression) idx += 1 program_trace["0"].append({ "test_case_id": tid, "step": 0, "output": test_case.output, "func": None, "args": [], "memory": memory.serialize() }) result = dict() for key, value in program_trace.items(): result[key] = { "program_id": pid, "program_length": program.length, "detail": value } return result
def test_simulator(): # Create a simulator sim = Simulator() # Test for pipelineing being off sim.enable_pipeline = False # Set Memory DRAM = Memory(lines=2**12, delay=10) L2 = Cache(lines=32, words_per_line=4, delay=1, associativity=1, next_level=DRAM, name="L2") L1 = Cache(lines=8, words_per_line=4, delay=0, associativity=1, next_level=L2, name="L1") sim.memory_heirarchy = [L1, L2, DRAM] # Set initial register values for debugging sim.R = list(range(0, 32)) # Load some instructions with open('test/IF_test.asm') as f: file_contents = f.read() instructions, data = assemble_to_numerical(file_contents) sim.set_instructions(instructions) # Step a few times; it will take 10 + 1 + 1 steps to load the first instruction for i in range(12): assert (sim.buffer == [ sim.IF_NOOP, sim.ID_NOOP, sim.EX_NOOP, sim.MEM_NOOP ]) sim.step() # After the initial compulsory miss, with four words per line, # our first four fetches should now be cache hits. # Ensure that the first buffer contains the next instruction after each step for i in range(4): # assert(sim.buffer[0] == [instructions[i], (i + 1) * 4]) sim.step() # $r4 has initial value of 4. After LW completes, it should have value 0 # This should take 10 cycles to load the next block of instructions, # then five cycles for the instruction to go through the pipeline # and 11 delay cycles to load the word from memory print(sim.memory_heirarchy[0].data) for i in range(50): sim.step()
def run(self): while self.global_ep.value < max_episode: self.local_model.pull_from_global_model(self.global_model) done = False score = 0 steps = 0 state = self.env.reset() state = torch.Tensor(state) state = state.unsqueeze(0) memory = Memory(n_step) while True: policy, value = self.local_model(state) action = self.get_action(policy, self.num_actions) next_state, reward, done, _ = self.env.step(action) next_state = torch.Tensor(next_state) next_state = next_state.unsqueeze(0) mask = 0 if done else 1 reward = reward if not done or score == 499 else -1 action_one_hot = torch.zeros(2) action_one_hot[action] = 1 memory.push(state, next_state, action_one_hot, reward, mask) score += reward state = next_state if len(memory) == n_step or done: batch = memory.sample() loss = self.local_model.push_to_global_model( batch, self.global_model, self.global_optimizer) self.local_model.pull_from_global_model(self.global_model) memory = Memory(n_step) if done: running_score = self.record(score, loss) break self.res_queue.put(None)