Search

In order to solve the problem of time resource and hardware resource waste caused by repeated situations, based on a method proposed by the predecessors to construct a chess computer game knowledge base, this article improves the structure of the knowledge base and uses the hierarchical architecture method to expand the knowledge. The total storage capacity of the library increases the speed of operation. This article's knowledge base master records the best moves and current board situation each time the computer “thinks” through the historical heuristic Alpha-Beta algorithm. Next time, when encountering the same situation, directly search the knowledge base. To get the best move. A comparison of time consumption in the Visual Studio C++ environment demonstrates the validity of the proposed knowledge base.

AlphaZero used a combination of Monte-Carlo Tree Search as well as deep neural networks that learned without human knowledge. It demonstrated that reinforcement learning by self-play could surpass the human champions. The great success of AlphaZero seems that every AI tasks can be trained and learned without any human knowledge as well as any human heuristics. But this paper presents another viewpoint: the AlphaZero approach is good at the perspective of overall situations, and miniMax search (with alpha-beta pruning) is adept in discovering partial solutions. Therefore, we introduce the Two-Phase-Win strategy to combine AlphaZero and miniMax search with alpha-beta pruning for improving AlphaZero’s strength. It has improved the strength of the AlphaZero approach applied to Connect4. The results of experiments show that the Two-Phase-Win strategy has 58% win rate against the AlphaZero approach and doesn’t lose any game in a 100-game match.

This paper deals with realization of search algorithms used in the game solvers on the FPGA. Three algorithms namely Minimax, Alpha-Beta Pruning, and NegaScout are realized and compared amongst each other, and also with their software realization for the sake of completion. Results show that the FPGA based implementations are exceptionally faster than their software counterparts, with the NegaScout algorithm outperforming the conventionally used Alpha-Beta Pruning, and the Minimax algorithm, both in software and hardware. The NegaScout algorithm is 1.3 times faster than the Alpha-Beta Pruning algorithm and 2.6 times faster than the Minimax algorithm on hardware, while incurring a nominal cost in terms of FPGA resource utilization.

Most approaches to computerized chess involve some variation of brute force, lookup tables, and Alpha Beta pruning to reduce the width of search trees. Given today's extensive computational power, this is a reasonable approach to designing a program that will win games. Since this method is very different from (and much less efficient than) the way that humans play chess and other similar strategy games, it is desirable for those interested in artificial intelligence to investigate other approaches that rely less on brute force. Our solution was to develop an adaptive program that uses a genetic algorithm in combination with a neural network that can learn after each game it plays. The entire genetic algorithm/neural network component is part of the evaluation function used to rank each board. Given a board configuration, ten attributes are evaluated, each of which is used as the input to the Neural Network. The weights used in the neural network are optimized using the genetic algorithm. Each time the evaluation function is called, the neural network outputs the value for a given board configuration, which will then be used in a recursive search algorithm that uses Alpha-Beta pruning. The weights are adjusted at the end of the game based on its outcome. Sets of weights and game scores are broadcast over a network to enable fully distributed learning.

Turn-based strategy games are interesting testbeds for developing artificial players because their rules present developers with several challenges. Currently, Monte-Carlo tree search variants are often utilized to address these challenges. However, we consider it worthwhile introducing minimax search variants with pruning techniques because a turn-based strategy is in some points similar to the games of chess and Shogi, in which minimax variants are known to be effective. Thus, we introduced three forward-pruning techniques to enable us to apply alpha beta search (as a minimax search variant) to turn-based strategy games. This type of search involves fixing unit action orders, generating unit actions selectively, and limiting the number of moving units in a search. We applied our proposed pruning methods by implementing an alpha beta-based artificial player in the Turn-based strategy Academic Package (TUBSTAP) open platform of our institute. This player competed against first- and second-rank players in the TUBSTAP AI competition in 2016. Our proposed player won against the other players in five different maps with an average winning ratio exceeding 70%.

This article presents our hardware architecture of an alpha-beta based hardware engine for Loop Trax board game presented in the 2nd National Digital System Design Contest of Iran. In our proposed architecture, we used minimax algorithm with a highly efficient alpha-beta pruning and hardware parallelization to speed up the most time-consuming tasks. We also included a technique called Path Based Memory, which causes sensible reduction of data storage and simplification of calculations. The results show that our design can run up to 50MHz on Altera DE2 platform and requires 27k LEs.

Aiming at how to find the possible existence of the threat paths in Connect6, this paper puts forward to a new searching algorithm — Alpha-Beta-TSS. The algorithm couples Alpha-Beta Pruning Search to TSS (Threat Space Search). It has the strong ability of solving and the solution has a high accuracy.

Blokus Duo is an abstract strategy game for two players. In this paper, we describe our FPGA implementation of Blokus Duo player for ICFPT2014 design contest, which is the revised version of the previous design for ICPFT2013 design contest. Our design consists of hardware logic part and software part using soft IP processor. The hardware logic part calculates evaluation value of the board status which is a heavy task for the software part. Our implementation uses recursive Alpha-Beta pruning and iteration deepening algorithm by the software part, which are complex to implement as the hardware logic circuit. The current version of our implementation on Xilinx Artix7 can run at 142MHz. The hardware logic part evaluates about 90,000 nodes in one second at the beginning of the game.

Move pruning is a technique used in game tree search which incorporates heuristic knowledge to reduce the number of moves under consideration from a particular game state. This paper investigates Heuristic Move Pruning on the strategic card game Lords of War. We use heuristics to guide our pruning and experiment with different techniques of applying pruning and their relative effectiveness. We also present a technique of artificially rolling forward a game state in an attempt to more accurately determine which moves are appropriate to prune from the decision tree. We demonstrate that heuristic move pruning is effective in Lords of War, and also that artificially rolling forward the game state can increase the effectiveness of heuristic move pruning.

We propose Error Allowing Minimax, an algorithm resolving indifferences in the choices of pure minimax players in games of perfect information, to give the opponent the biggest possible target for errors. In contrast to the usual approach of defining a domain-specific static evaluation function with an infinite codomain, we achieve fine-grained positional evaluations by general considerations of the game tree only. To achieve applicability to real-world situations we develop Error Allowing Alpha-Beta, a variant of the standard Alpha-Beta algorithm, and a variant hybridizing these two algorithms, allowing full control over the trade-off between accuracy and computational complexity. We investigate the impact of the algorithm applying it to the perfect information game Dots and Boxes.

Game tree search is a classical problem in the field of game theory and artificial intelligence. Fast game tree algorithm is critical for computer games asking for real-time responses. In this paper, we focus on how to leverage massive parallelism capabilities of GPUs to accelerate the speed of game tree algorithms and propose a concise and general parallel game tree algorithm on GPUs. The performance model of the algorithm is presented and analyzed theoretically. We also implement the algorithm for a real computer game called Connect6 and use it to verify the effectiveness and efficiency of our algorithm. Experiments support our theoretical results and show good performance of our approach. Compared to classical CPU-based game tree algorithms, our algorithm can achieve speedup of 70.8 in case of no pruning. When pruning is considered (which means the practical performance of our algorithm), the speedup can reach about 7.0. The insight of our work is that using GPUs is a feasible way to improve the performance of game tree algorithms.

This paper discusses the design and implementation of a highly efficient MiniMax algorithm for the game Abalone. For perfect information games with relatively low branching factor for their decision tree (such as Chess, Checkers etc.) and a highly accurate evaluation function, Alpha-Beta search proved to be far more efficient than Monte Carlo Tree Search. In recent years many new techniques have been developed to improve the efficiency of the Alpha-Beta tree, applied to a variety of scientific fields. This paper explores several techniques for increasing the efficiency of Alpha-Beta Search on the board game of Abalone while introducing some new innovative techniques that proved to be very effective. The main idea behind them is the incorporation of probabilistic features to the otherwise deterministic Alpha-Beta search.

The efficiency of the alpha-beta algorithm is largely dependent on the order in which its branches are searched; a well-ordered search can give a considerable reduction in the number of nodes processed by pruning ineffectual paths. This paper describes ‘CLAMP’ (an acronym for Chunk Learning And Move Prompting) which uses ‘chunk knowledge’ to order the moves on a chessboard in their likelihood to be played. Test results show, despite CLAMP having no knowledge of the rules of chess, ordering moves by using chunk knowledge gives an approximate 50% decrease in the number of nodes searched when compared to a random ordering of the same moves. This paper focuses on the alpha-beta function within a chess-playing program but as CLAMP has no knowledge of the rules of the game the same method can be applied to optimise searching in other domains.

The game playing is an import domain of heuristic search, and its procedure is represented by a special and/or tree. Alpha-beta pruning is always used for problem solving by searching the game-playing-tree. In this paper, the plan which child nodes are inserted into game-playing-tree from large value of estimation function to small one when the node of no receiving fixed ply depth is expand is proposed based on alpha-beta pruning. It improves effect of search

Trappy minimax is a game-independent extension of the minimax adversarial search algorithm that attempts to take advantage of human frailty. Whereas minimax assumes best play by the opponent, trappy minimax tries to predict when an opponent might make a mistake by comparing the various scores returned through iterative-deepening. Sometimes it chooses a slightly inferior move, if there is an indication that the opponent may fall into a trap, and if the potential profit is high. The algorithm was implemented in an Othello program named Desdemona, and tested against both computer and human opponents. Desdemona achieved a higher rating against human opposition on Yahoo! Games when using the trappy algorithm than when it used standard minimax.

The game of Go has simple rules to learn but requires complex strategies to play well, and, the conventional tree search algorithm for computer games is not suited for Go program. Thus, the game of Go is an ideal problem domain for machine learning algorithms. This paper examines the performance of a 19/spl times/19 computer Go player, using heuristic dynamic programming (HDP) and parallel alpha-beta search. The neural network based Go player learns good Go evaluation functions and wins about 30% of the games in a test series on 19/spl times/19 board.