class PicnicLisp(cmd.Cmd): def __init__(self): cmd.Cmd.__init__(self) """ Setup attributes of the command line prompt """ self.prompt = 'PicnicLisp$ ' self.parser = Parser() self.evaluator = Evaluator() def emptyline(self): """ On empty line, do nothing. Default impl repeats previous command """ pass def processLine(self, line): """ Parses and evaluates a line. Separate function for testing purposes """ try: tokenized = self.parser.parse(line) value = self.evaluator.eval(tokenized) return value except Exception as e: print e.message def default(self, line): """ Accepts all atoms and lists """ interpreted = self.processLine(line) if interpreted != None: print interpreted else: print "Ok"
def _negamax(self, depth, player, alpha, beta): # If game is over or depth limit reached if depth == 0 or self._board.is_game_over(): return Evaluator.eval(self._board, self._mycolor) * ( -1 if player != self._mycolor else 1) color = self._board._flip(player) # If player cannot move, opponent turn if not self._board.at_least_one_legal_move(player): return -self._negamax(depth - 1, color, -beta, -alpha) compute = True currentHash = self._boardHash() if ( self._checkTable(currentHash) ): # we check in table whether or not we have to compute the best move # if(self._getDepth(currentHash)==depth): compute = False self._tableUsage += 1 value = -sys.maxsize - 1 if compute: for m in self._board.legal_moves(): self._board.push(m) value = max(value, -self._negamax(depth - 1, color, -beta, -alpha)) self._board.pop() alpha = max(alpha, value) if alpha >= beta: break # Cutoff self._addToTable(currentHash, depth, value) else: value = self._getHeuristic(currentHash) return value
def _play(self): # Killer move detection # # Corner max_value = -sys.maxsize - 1 best_move = None corners = [[0, 0], [0, self._board.get_board_size() - 1], [self._board.get_board_size() - 1, 0], [ self._board.get_board_size() - 1, self._board.get_board_size() - 1 ]] for m in self._board.legal_moves(): self._board.push(m) (_, x, y) = m if [x, y] in corners: max_value = max(max_value, Evaluator.eval(self._board, self._mycolor)) best_move = m self._board.pop() if best_move is not None: return best_move # # Blocking move max_value = -sys.maxsize - 1 best_move = None for m in self._board.legal_moves(): self._board.push(m) if not self._board.at_least_one_legal_move(self._opponent): max_value = max(max_value, Evaluator.eval(self._board, self._mycolor)) best_move = m self._board.pop() if best_move is not None: return best_move # Opening move if self._OB_active: move = self._opening_book.get_following_move(self._move_history) if move is not None: return move # Else self._OB_active = False # minimax return self._start_negamax(4)
def main(argv): rd = Reader() ev = Evaluator() pr = Printer() program = rd.read(argv[1]) pr.prnt(program) value = ev.eval(program) pr.prnt(value)
def run(self, train_batches, test_batches): # training and validation error collector ec = ErrorCollector() print("-----ModelTester-----") logging.info("-----ModelTester-----") for n_hidden in self.n_hidden: for n_layer in self.n_layer: if self.is_res_net: self.models.append( ResNetModel(n_in=self.n_in, n_hidden=n_hidden, n_out=self.n_out, n_layer=n_layer, activation='relu')) else: for activation in self.activation: # create models self.models.append( Model(n_in=self.n_in, n_hidden=n_hidden, n_out=self.n_out, n_layer=n_layer, activation=activation)) for model in self.models: trainer = Trainer(model, train_batches, ec) for learning_rate in self.learning_rates: trainer.train(learning_rate, self.epochs, early_stop_lim=25) # print error plots ec.plotTrainTestError(model, train_batches.batch_size, learning_rate, self.epochs, model.activation) ec.plotTrainTestAcc(model, train_batches.batch_size, learning_rate, self.epochs, model.activation) ec.resetErrors() evaluator = Evaluator(model, test_batches, trainer.getSaveFilePath()) test_loss, test_acc = evaluator.eval() trainer.resetBestScore() if self.best_test_acc == 0 or test_acc > self.best_test_acc: self.best_test_acc = test_acc self.best_model_param = 'Param_' + model.name + '_ep-' + str( self.epochs) + '_hidu-' + str( model.n_hidden) + '_hidl-' + str( model.n_layer) + '_lr-' + str(learning_rate) print( "-----ModelTester finished, best test acc: [%.6f] with model: %s " % (self.best_test_acc, self.best_model_param)) logging.info( "-----ModelTester finished, best test acc: [%.6f] with model: %s " % (self.best_test_acc, self.best_model_param))
def _negamax(self, depth, player, alpha, beta): alpha_origin = alpha self._table_usage += 1 # Transposition table lookup current_hash = self._get_board_hash() tt_entry = self._hash_table.get_table_entry(current_hash) # Check in table whether or not we have to compute the best move if tt_entry is not None and tt_entry.depth >= depth: if tt_entry.flag == self._hash_table._EXACT: return tt_entry.value elif tt_entry.flag == self._hash_table._LOWERBOUND: alpha = max(alpha, tt_entry.value) else: # tt_entry.flag == self._hash_table._UPPERBOUND: beta = min(beta, tt_entry.value) if alpha >= beta: return tt_entry.value self._table_usage -= 1 # If game is over or depth limit reached if depth == 0 or self._board.is_game_over(): return Evaluator.eval(self._board, self._mycolor) * ( -1 if player != self._mycolor else 1) color = self._board._flip(player) # If player cannot move, opponent turn if not self._board.at_least_one_legal_move(player): return -self._negamax(depth - 1, color, -beta, -alpha) value = -sys.maxsize - 1 for m in self._board.legal_moves(): self._board.push(m) value = max(value, -self._negamax(depth - 1, color, -beta, -alpha)) self._board.pop() alpha = max(alpha, value) if alpha >= beta: break # Cutoff # Store in transposition table tt_entry = TableEntry() tt_entry.value = value if value <= alpha_origin: tt_entry.flag = self._hash_table._UPPERBOUND elif value >= beta: tt_entry.flag = self._hash_table._LOWERBOUND else: tt_entry.flag = self._hash_table._EXACT tt_entry.depth = depth self._hash_table.store(current_hash, tt_entry) return value
def run(self, train_batches, test_batches): # training and validation error collector ec = ErrorCollector() # setup logging log_file_name = 'logs' + os.sep + 'Model_Trainer.log' logging.basicConfig(filename=log_file_name, level=logging.INFO) print("-----ModelTester-----") logging.info("-----ModelTester-----") for n_hidden in self.n_hidden: for n_layer in self.n_layer: # create models self.models.append( Model(n_in=self.n_in, n_hidden=n_hidden, n_out=self.n_out, n_layer=n_layer)) for model in self.models: trainer = Trainer(model, train_batches, ec) for learning_rate in self.learning_rates: trainer.train(learning_rate, self.epochs, early_stop_lim=25) # print error plots ec.plotTrainTestError(model, train_batches.batch_size, learning_rate, self.epochs) ec.plotTrainTestAcc(model, train_batches.batch_size, learning_rate, self.epochs) ec.resetErrors() evaluator = Evaluator(model, test_batches, trainer.getSaveFilePath()) test_loss, test_acc = evaluator.eval() trainer.resetBestScore() if self.best_test_acc == 0 or test_acc > self.best_test_acc: self.best_test_acc = test_acc self.best_model_param = 'Param_ep-' + str( self.epochs) + '_hidu-' + str( model.n_hidden) + '_hidl-' + str( model.n_layer) + '_lr-' + str(learning_rate) print( "-----ModelTester finished, best test acc: [%.6f] with model: %s " % (self.best_test_acc, self.best_model_param)) logging.info( "-----ModelTester finished, best test acc: [%.6f] with model: %s " % (self.best_test_acc, self.best_model_param))
def _negamax(self, depth, player, alpha, beta): # If game is over or depth limit reached if depth == 0 or self._board.is_game_over(): return Evaluator.eval(self._board, self._mycolor) * (-1 if player != self._mycolor else 1) color = self._board._flip(player) # If player cannot move, opponent turn if not self._board.at_least_one_legal_move(player): return -self._negamax(depth - 1, color, -beta, -alpha) value = - sys.maxsize - 1 for m in self._board.legal_moves(): self._board.push(m) value = max(value, -self._negamax(depth - 1, color, -beta, -alpha)) self._board.pop() alpha = max(alpha, value) if alpha >= beta: break # Cutoff return value
def run(self, batches): # training and validation error collector ec = ErrorCollector() print("-----ModelTester-----") logging.info("-----ModelTester-----") # create models for n_hidden in self.n_hidden: for n_layer in self.n_layer: for rnn_unit in self.rnn_unit: print("RNN with max seq len: ", batches.max_seq_len) self.models.append(RnnModel(self.n_symbols, n_hidden, self.n_out, rnn_unit, batches.max_seq_len, n_layer, self.adam_optimizer)) # training and evaluation plot_id = 0 for model in self.models: trainer = Trainer(model, batches, ec) for learning_rate in self.learning_rates: plot_id += 1 trainer.train(learning_rate, self.epochs, adam_optimizer=self.adam_optimizer, early_stopping=True, early_stop_lim=10) # print error plots ec.plotTrainTestError(model, batches.batch_size, learning_rate, self.epochs, plot_id) ec.resetErrors() evaluator = Evaluator(model, batches, trainer.getSaveFilePath()) test_loss = evaluator.eval() # get best conversion time if trainer.best_epoch < self.best_conv_time: self.best_conv_time = trainer.best_epoch self.best_model_param = 'Param_' + model.name + '_ep-' + str(self.epochs) + '_hidu-' + str(model.n_hidden) + '_hidl-' + str(model.n_layer) + '_lr-' + str(learning_rate) + '_id-' + str(plot_id) # reset scores trainer.resetBestScore() # print convergence times ec.convergenceTimeMeanAndStd() print("-----ModelTester finished, best test error: [%.6f] and conv time (epochs): [%i] with model: %s " % (self.best_test_loss, self.best_conv_time, self.best_model_param)) logging.info("-----ModelTester finished, best test error: [%.6f] and conv time (epochs): [%i] with model: %s " % (self.best_test_loss, self.best_conv_time, self.best_model_param))
epochs = 5 #learning_rate = 0.001 learning_rate = 0.01 model = Model(n_in=X.shape[1], n_hidden=300, n_out=26, n_layer=1) batch_size = 40 # setup logging log_file_name = 'logs' + os.sep + 'Log' + '_ep' + str( epochs) + '_hidu' + str(model.n_hidden) + '_hidl' + str( model.n_layer) + '_lr' + str(learning_rate) + '.log' logging.basicConfig(filename=log_file_name, level=logging.INFO) # Batch Normalize bn = BatchNormalizer(X, C, batch_size=batch_size, shuffle=True) train_batches = bn.getBatches(X, C, is_validation=False) test_batches = bn.getBatches(X_tst, C_tst, test=True) print('examples to train: ', train_batches.examples_train.shape) # Training trainer = Trainer(model, train_batches, ec) trainer.train(learning_rate, epochs, early_stop_lim=25) # print error plots ec.plotTrainTestError(model, batch_size, learning_rate, epochs) ec.plotTrainTestAcc(model, batch_size, learning_rate, epochs) # Testing evaluator = Evaluator(model, test_batches, trainer.getSaveFilePath()) evaluator.eval()