SlugGo: A Computer
Baduk Program
by David G Doshay, Charlie McDowell
Presenter: Ling Zhao
April 4, 2006
Introduction
SlugGo is a parallel version of Gnu
Go, and with many enhancements.
 The name comes from banana slug,
the mascot of UCSC.
 One of the strongest Go program in
the world.

SlugGo Vs. Gnu Go
Parallel computing.
 Whole-board lookahead (Gnu Go uses
local lookahead, and only for capture
races and ladders).
 New algorithm to determine best
move.

Basic Idea
Exhaustive search in Go not feasible
on one CPU – How about 24 CPUs?
 The deeper the search is, the more
accurate the evaluation will be.
 Two-step approach:
1. Generate candidate moves.
2. Do a global search for each move.

Parallel Computing
A cluster of Apple G4/G5 CPUs (11, 26
or 72 processors).
 MPI is used for parallel programming.
 Master-slave architecture
with a task queue.

Move Generation





Gnu Go move generator provides a list of
moves with values (ggValue) using pattern
matching and local search – possible moves.
SlugGo select a subset of the list for global
search – candidate moves.
Parallel lookahead for each move using Gnu
Go move generator.
Static evaluation in the end: influence and
territory.
Final value of a move is a function of ggValue,
influence, territory, and boostValue.
Boost Value
Go proverb: Your opponent’s move is
your own.
 SlugGo: Your best move may be close
to your opponent’s best move.
 boostValue = ggValue of the
opponent’s move * proximity factor

Boost Value
The maximum of the applicable boost values
is chosen as boostValue.
Candidate List




One move list for
us with boostValue
added to ggValue.
One move list for
opponent without
boostValue.
Combine two lists
and select the best
N moves.
The best move
from opponent’s list
is always chosen (if
legal).
Influence and Territory
Gnu Go Influence function: Bouzy’s
algorithm using mathematical
morphology.
 Use influence function to determine
the probability of each point controlled
by one side, and the sum is the
territory score.

Temporal Factors for
Influence and Territory
Final Move Selection
Smart Go bases the decision on the
state of the final lookahead
configuration.
 SlugGo considers the initial evaluation
as well:

All values have been normalized.
Branching
Original design: linear lookahead
 Linear branching:

24 CPUs:



24 candidate moves for linear lookahead.
4 candidate moves for 6-way branching in
one of the lookahead steps.
8 candidate moves for 3-way branching in
one of the lookahead steps.
Cache
Cache stores game positions and
suggested moves by Gnu Go.
 Only 10% increase of performance.
 Reason 1: Saving in parallel computing
is determined by the weakest link.
 Reason 2: Huge game tree.

Experimental Results







Lookahead depth: up to 16.
Candidate moves: up to 26.
Branching during lookahead.
Weights for ggValue, boostValue, influence
and territory to compute final score.
Normalization of ggValue.
Boost factors.
Weights to compute influence and territory.
SlugGo Vs. Gnu Go
91% winning percentage with 2-stone
handicap.
 Evil-twin syndrome:

 SlugGo
knows almost exactly Gnu
Go’s response to any move.
 SlugGo looks beyond Gnu Go’s
horizon.
SlugGo vs. Many Faces
of Go
Normalize ggValue





Normalize ggValue(us) and ggValue(them).
Approach 1: Combine and normalize: can
be disastrous.
Approach 2: Normalize each list individually.
Hybrid approach: if MAX(ggValue(us))
>MAX(ggValue(them)) use approach 1,
otherwise choose approach 2.
Hybrid approach is better than approach 2.
Branching
No branching is the best and no need
for more than 20 candidate moves.
Lookahead Depth
Deep search may decreases the
chance of correct prediction.
Future Work
Machine learning to adjust parameters.
 Why does branching reduce strength?
 Thinking in opponent’s time.
 Parallelize Gnu Go move generation
steps.

Conclusions





Whole-board lookahead based on a Go
proverb is successful.
If lookahead explores the path that the
game is likely to follow, it can increase
strength substantially.
Branching and deep search seems no use.
No need for more than 24 CPUs.
Some experiments are missing.