def __call__(self): print('Start testing!') test_sequences = iter(self.sequences) sequence = next(test_sequences) # create tapes input_tape = Tape(1, self.total_length, self.params.num_symbols, self.params.in_move_table, initial=sequence) mem_tape = Tape(1, self.total_length, self.params.rnn_hidden, self.params.mem_move_table) output_tape = Tape(1, self.params.max_length, self.params.num_symbols, self.params.out_move_table, initial=np.ones((1, self.params.max_length, self.params.num_symbols)) * -1) step = np.zeros((1, 1, self.params.num_symbols + self.params.rnn_hidden + 3)) target = np.zeros((1, 1, self.params.num_symbols)) state = np.zeros((2, 1, self.params.rnn_hidden)) last_in_moves = np.ones((1, 1)) last_mem_moves = np.ones((1, 1)) last_out_moves = np.ones((1, 1)) input_tape.print_tape() for i in range(sequence.shape[1]): print("=======================") print("step : ", i) # read input, memory from tape step_input = input_tape.read_tape() step_memory = mem_tape.read_tape() last_moves = np.concatenate((last_in_moves, last_mem_moves, last_out_moves), axis=1) step_concat = np.concatenate((step_input, step_memory, last_moves), axis=1) step[:, 0, :] = step_concat target[:, 0, :] = sequence[:, i, :] prediction, moves, hidden, state_tuple = self.sess.run([self.model.prediction, self.model.moves, self.model.hidden, self.model.state], {self.input: step, self.state: state, self.target: target}) # update state state[0] = state_tuple[0] state[1] = state_tuple[1] # sample moves from logits # in_sample = sample(moves[0][:, 0, :]) # mem_sample = sample(moves[1][:, 0, :]) # out_sample = sample(moves[2][:, 0, :]) in_sample = np.argmax(moves[0][:, 0, :], axis=1) mem_sample = np.argmax(moves[1][:, 0, :], axis=1) out_sample = np.argmax(moves[2][:, 0, :], axis=1) in_move = last_in_moves[:, 0] = input_tape.index_to_moves(in_sample) mem_move = last_mem_moves[:, 0] = mem_tape.index_to_moves(mem_sample) out_move = last_out_moves[:, 0] = output_tape.index_to_moves(out_sample) # if out_move, write to output_tape output_tape.write_tape(prediction[:, 0, :], out_move) # write memory mem_tape.write_tape(hidden[:, 0, :]) # move ptrs input_tape.move_ptr(in_move) mem_tape.move_ptr(mem_move) output_tape.move_ptr(out_move) print("in_logits :", moves[0], ", in_move :", in_move, ", in_pos :", input_tape.get_ptr()) print("mem_logits :", moves[1], ", mem_move :", mem_move, ", mem_pos :", mem_tape.get_ptr()) print("out_logits :", moves[2], ", out_move :", out_move, ", out_pos :", output_tape.get_ptr()) if out_move[0] == 1: print("prediction") print(prediction[:, 0, :]) print("==> ", np.argmax(prediction[:, 0, :], axis=1)) print("=======================") output_tape.print_max_indexes()
def _optimization(self, batch): # create tapes input_tape = Tape(batch.shape[0], batch.shape[1], batch.shape[2], self.params.in_move_table, initial=batch) mem_tape = Tape(batch.shape[0], batch.shape[1], self.params.rnn_hidden, self.params.mem_move_table) output_tape = Tape(batch.shape[0], batch.shape[1] // self.params.dup_factor, batch.shape[2], self.params.out_move_table) # generate fake moves in_moves = np.zeros((batch.shape[0], batch.shape[1], self.params.in_move_table.__len__())) mem_moves = np.zeros((batch.shape[0], batch.shape[1], self.params.mem_move_table.__len__())) out_moves = np.zeros((batch.shape[0], batch.shape[1], self.params.out_move_table.__len__())) in_moves[:, :, 2] = np.ones((batch.shape[0], batch.shape[1])) mem_moves[:, :, 1] = np.ones((batch.shape[0], batch.shape[1])) out_moves[:, :, 0] = np.ones((batch.shape[0], batch.shape[1])) out_moves[:, 0::self.params.dup_factor, 0] \ = np.zeros((batch.shape[0], batch.shape[1] // self.params.dup_factor)) out_moves[:, 0::self.params.dup_factor, 1] \ = np.ones((batch.shape[0], batch.shape[1] // self.params.dup_factor)) last_in_moves = np.ones((batch.shape[0], 1)) last_mem_moves = np.ones((batch.shape[0], 1)) last_out_moves = np.ones((batch.shape[0], 1)) # output mask out_mask = np.zeros((batch.shape[0], batch.shape[1])) out_mask[:, 0::self.params.dup_factor] \ = np.ones((batch.shape[0], batch.shape[1] // self.params.dup_factor)) input_track = step = np.zeros((batch.shape[0], batch.shape[1], batch.shape[2] + self.params.rnn_hidden + 3)) state = init_state = np.zeros((2, batch.shape[0], self.params.rnn_hidden)) for i in range(batch.shape[1]): # read from input_tape, memory_tape step_input = input_tape.read_tape() step_memory = mem_tape.read_tape() last_moves = np.concatenate((last_in_moves, last_mem_moves, last_out_moves), axis=1) step_concat = np.concatenate((step_input, step_memory, last_moves), axis=1) step[:, 0, :] = step_concat input_track[:, i, :] = step_concat moves, hidden, state_tuple = self.sess.run([self.model.moves, self.model.hidden, self.model.state], {self.state: state, self.input: step, self.target: batch, self.in_move: in_moves, self.mem_move: mem_moves, self.out_move: out_moves, self.out_mask: out_mask}) # update state state[0] = state_tuple[0] state[1] = state_tuple[1] # -- use fake moves for only-supervised-learning in_move_logits = in_moves[:, i, :].astype(np.int32) mem_move_logits = mem_moves[:, i, :].astype(np.int32) out_move_logits = out_moves[:, i, :].astype(np.int32) # write to memory mem_tape.write_tape(hidden[:, 0, :]) # move ptrs in_move = last_in_moves[:, 0] = input_tape.index_to_moves(np.argmax(in_move_logits, axis=1)) mem_move = last_mem_moves[:, 0] = mem_tape.index_to_moves(np.argmax(mem_move_logits, axis=1)) out_move = last_out_moves[:, 0] = output_tape.index_to_moves(np.argmax(out_move_logits, axis=1)) input_tape.move_ptr(in_move) mem_tape.move_ptr(mem_move) output_tape.move_ptr(out_move) cost, _ = self.sess.run((self.model.cost, self.model.optimize), {self.state: init_state, self.input: input_track, self.target: batch, self.in_move: in_moves, self.mem_move: mem_moves, self.out_move: out_moves, self.out_mask: out_mask}) print(cost) self.costs.append(cost)