Shogo Takeuchi

Evaluation of Game Tree Search Methods by Game Records

This paper presents a method of evaluating game tree search methods including standard min-max search with heuristic evaluation functions and Monte Carlo tree search, which recently achieved drastic improvements in the strength of Computer Go programs. The basic idea of this paper is to use an averaged win probability of positions having similar evaluation values. Accuracy measures of evaluation values with respect to win probabilities can be used to assess the performance of game tree search methods. A plot of win probabilities against evaluation values should have consistency and monotonicity if the evaluation values are produced by a good game tree search method. By inspecting whether the plot has the properties for some subset of positions, we can detect specific deficiencies in the game tree search method. We applied our method to Go, Shogi, and Chess, and by comparing the results with empirical understanding of the performance of various game tree search methods and with the results of self-plays, we show that our method is efficient and effective.

Evaluation of Monte Carlo tree search and the application to Go

Recent improvements to Monte Carlo tree search have produced strong computer Go programs. This paper presents a method of measuring the accuracy of Monte Carlo tree search in game programming. We use the win percentage of positions in a large database of game records as a benchmark and compare the win probability obtained by simulations with the benchmark. By applying our method to Monte Carlo tree search in Go, we found differences between search methods and their parameters, and the effect of the properties of positions such as the move numbers and the existence of stones in threats. This paper also introduces numerical metrics to evaluate the performance of search methods. Our experiments in Go, as well as Chess, Othello, and Shogi revealed that the metrics were quite close to our empirical understanding of the performance of various search methods and their parameters.

Enumerating Eulerian Trails via Hamiltonian Path Enumeration

Given an undirected graph G, we consider enumerating all Eulerian trails, that is, walks containing each of the edges in G just once. We consider achieving it with the enumeration of Hamiltonian paths with the zero-suppressed decision diagram (ZDD), a data structure that can efficiently store a family of sets satisfying given conditions. First we compute the line graph L(G), the graph representing adjacency of the edges in G. We also formulated the condition when a Hamiltonian path in L(G) corresponds to an Eulerian trail in G because every trail in G corresponds to a path in L(G) but the converse is not true. Then we enumerate all Hamiltonian paths in L(G) satisfying the condition with ZDD by representing them as their sets of edges.

Superset Generation on Decision Diagrams

Generating all supersets from a given set family is important, because it is closely related to identifying cause-effect relationship. This paper presents an efficient method for superset generation by using the compressed data structures BDDs and ZDDs effectively. We analyze the size of a BDD that represents all supersets. As a by-product, we obtain a non-trivial upper bound for the size of a BDD that represents a monotone Boolean function in a fixed variable ordering.

A General Framework for Parallel Unary Operations on ZDDs

A zero-suppressed binary decision diagram is a compressed data structure that represents families of sets. There are various basic operations to manipulate families of sets over ZDDs such as union, intersection, and difference. They can be efficiently computed without decompressing ZDDs. Among them, there are many important unary operations such as computing the ZDD for all extremal sets (maximal sets or minimal sets) from an input ZDD. Unary operations are useful in various fields such as constraint programming, data mining, and artificial intelligence. Therefore, they must be efficiently computed. In this paper, we propose a general framework for parallel unary operations on ZDDs. We analyze the computational complexity and evaluate the effectiveness of our method by performing computational experiments.

Shared-Memory Parallel Frontier-Based Search

Knuth’s Simpath algorithm is an efficient algorithm enumerating all paths between two locations. This paper presents three approaches to parallelizing frontier-based search in Simpath in shared-memory environments: node-based, range-based and edge-based approaches. Our results on solving grid graphs show that the lock-free edge-based approach performs best and achieves seven-fold speedup with 32 CPU cores, while the others suffer from severe synchronization overhead due to locks, resulting in performance saturation with more than 12 cores.