Yes, I walk both chains looking for duplicates. This is quite fast if done
efficiently, since group merging is rare enough. I found keeping the
liberty arrays to be slower since they are big, so there is more copy
overhead in the UCT tree, and they are not cache friendly.
David
-Original
Thanks. What about linked lists?
They seem to be both compact and fast to merge and detect duplicates.
Why have you abandoned them?
Lukasz
On Tue, Apr 7, 2009 at 17:42, David Fotland fotl...@smart-games.com wrote:
Yes, I walk both chains looking for duplicates. This is quite fast if done
On Tue, Apr 7, 2009 at 12:33 PM, Łukasz Lew lukasz@gmail.com wrote:
Thanks. What about linked lists?
They seem to be both compact and fast to merge and detect duplicates.
Why have you abandoned them?
Lukasz
Or a Hash Set, which has constant time insert, delete, contains, and
size
This reminds me of a related question I had a while back. In a single
MCTS/UCT search node, how do people store the children? Does a node
contain summaries of all their children, or just pointers to the
children?
Pure pointers are simple but requires allocating many more objects,
Hi,
I was wondering what are the good (fast/accurate) ways of evaluating
program strength.
The most accurate one is to play many games against gnugo or on KGS.
But it is quite slow as many games are needed.
Another one is to have set of labeled positions (win/loss) and make
your program predict
computer-go-boun...@computer-go.org wrote on 07-04-2009 18:33:34:
Thanks. What about linked lists?
They seem to be both compact and fast to merge and detect duplicates.
Why have you abandoned them?
Linked lists have a terrible cache behaviour: every pointer (or index)
dereference has a nearly
Predicting pro-moves has very low correlation to strength. I think it is
next to useless. No experience but I think in this respect traditional
programs probably are better but certainly lose in strength. Cooperation
of moves is what matter not single moves.
Could be hard to come up with
Łukasz Lew lukasz@gmail.com:
Another one is to have set of labeled positions (win/loss) and make
your program predict the labels. (This is what MoGo guys did)
It is much faster. But how well it is correlated with the true strength?
I think it could be good if the set of positions is
From: Łukasz Lew lukasz@gmail.com
I was wondering what are the good (fast/accurate) ways of evaluating
program strength.
The most accurate one is to play many games against gnugo or on KGS.
But it is quite slow as many games are needed.
Another one is to have set of labeled positions
Another idea is to try to predict moves in a set of (pro) games.
Is the prediction rate well correlated with program strength?
No, very poorly correlated. I think that's well known.
It is well known that systems created for pro move prediction using no
search like MoyoGo, similat Microsoft's
Łukasz Lew wrote:
I would like to rephrase my question:
Let's measure prediction of pro moves of a whole engine while
modifying heavy playouts / MCTS in the engine.
How well might it work?
Probably not well. Because what matters is not how often you play strong
moves, but how often you avoid
otherwise pair-go wouldn't be as funny to watch.
s.
On Tue, Apr 7, 2009 at 8:05 PM, Michael Williams
michaelwilliam...@gmail.com wrote:
Łukasz Lew wrote:
I would like to rephrase my question:
Let's measure prediction of pro moves of a whole engine while
modifying heavy playouts / MCTS in
Amen to that. When using positions to judge the strength of a program, one
would need to test not just one pro move, but a sequence of plays --
including some which don't appear in pro games. A pro knows how to deal
decisively not only with the optimal plays of other pros, but also with
13 matches
Mail list logo
