Re: [gnugo-devel] SlugGo v.s. Many Faces

[David G Doshay]

On Aug 24, 2004, at 4:55 AM, address@hidden wrote:

> David Doshay wrote:
>
> > We are now confident that we are indeed much stronger than GNU Go
> > because of our results against Many Faces of Go.
>
> David Fotland wrote:
>
> > When you say you look ahead depth 16, what do you mean?

From each candidate move we use GNU Go's engine to generate 15
more moves, and then evaluate the resulting boards. The results from
evaluating the final whole boards are combined with the GNU Go value
to determine which candidate move we play.

> >   How do you select the move(s) to try?

GNU Go has an array the size of the board upon which it sprinkles values
from a variety of algorithms. GNU Go would select the point with the  
largest
value to be the move. We generate 2 of these arrays, one from our  
perspective,
the US array, and one from the opponent's perspective if we were to  
pass, the
THEIR array, and cull some number of candidate moves from the top values
in the two arrays. (see supplied link below)

> > How many moves do you try at each ply?

At the very first ply we split out as many as 8 ways, although the  
algorithm
does not always try 8 different paths. Depending upon how quickly the
GNU Go move values drop off we might do as few as 2, and if the US and
the THEIR moves are both the same then there is only one choice.

For the results presented in the original email there was no further  
branching
on the lookahead paths out to depth 16. As a quite interesting and as  
yet
unexplained note, a lookahead depth of 12 is horrible, while depths of  
10, 8,
6, and 4 all show a monotonic and somewhat smooth decrease from the  
results
for a lookahead depth of 16. I have no idea why 12 would stand out as  
giving
such poor results, but we see it consistently.

> > Impressive results.

Thanks, it has us smiling!

> Indeed, this is excellent. As David Fotland's comment indicates,
> a better description of your search strategy would be very
> desirable.

Check out the diagrams at
        
http://cowboy.directgames.net:81/research/SlugGo/documentation/sluggo- 
system_overview.pdf

We have not yet implemented the hash table functions indicated on the  
diagrams. These
functions are being implemented in an attempt to save the time of  
recalculating the
lookahead moves we have previously generated.

The curves on page 5 indicate weighting functions that are used as  
multipliers for the
values returned by the influence and territory functions.

I see that there is a typo on page 6 in the cloud where it should say  
"reply" rather than
replay.

I want to emphasize that these results were obtained with very little  
tuning of the very
many parameters we have in our additions to GNU Go, and thus these  
results are still
preliminary. There are a large number of things we can do which we  
believe will make
the play stronger.

In the "Big Picture" sense, we have applied some simple ideas with lots  
of computing
power to see what we could find. With respect to the recent thread on  
the subject of
fast v.s. slow computing, I think this is only a glimpse of what can be  
done with plenty
of silicon and longer compute times.

Cheers,
David