TalkChess.com

[Ted Wong]

Other than limiting the number of nodes and depths, any suggestions on how to reduce the playing strength as realistic as possible? I've found that limiting the number of nodes isn't working very well.

Also, what'd be the best way to tune the parameters?

[Edmund Moshammer]

1) weaken the evaluation
a) Add a random factor to the value returned by the evaluation function. You should chose a distribution that on average returns the true value.
b) Remove knowledge

2) weaken the search
a) with a certain probability don't continue the search but fail high/low depending on the side the engine is playing and the current side to move.
b) bias certain moves (e.g. always add a bonus of 10 to the evaluation of any king-move)

You will find that 1.a) becomes increasingly useless for higher depths.

Note: any random choices you take should be deterministic. This ensures that a certain position is weakened exactly the same way at every iteration and is necessary for a stable search. A possible way to achieve that is through basing any random values used on the hash value of the position.


Regarding parameter-optimization, the latest state of the art is Rémi Coulom's great program CLOP.

[Ted Wong]

It's a bit vague. Any concrete examples such as source code or like articles?

[Pawel Koziol]

We have implemented the stuff Edmund described in Glass and it works reasonably well, except that it doesn't scale with time control. Thus, an engine that performs as about 2000 Elo at blitz feels like 1800 in a longer game.

Edmund is right that it's better to get pseudorandom values from position hash ( randomPercentage = hashKey % 100 rather than randomPercentage = rand() % 100 )

later You can code something like

for all moves
{
if ( randomPercentage < errorPercentage
&& ply > canErrFromPly ) newScore = alpha;
else newScore = Search(...)
}

be sure, though, that engine actually tries at least one legal move, otherwhise You might get a false mate score.

Another useful thing is slowing the engine down - humans tend to move faster when an engine replies instantly, and thus they play much weaker chess. Also, the algorithm described here results in engine reporting intimidating (if fake) depth, which looks plain ugly without a slowdown.

You might also want to look at the Phalanx source code - it also has a routine that allows forgetting about certain moves during search, depending on the move properties (for example longer moves and backward moves tend to be omitted more often)
_________________
Pawel Koziol
http://www.pkoziol.cal24.pl/rodent/rodent.htm

[Ted Wong]

Would that be possible to distribute a copy of the source for Glass? Reducing strength is one last thing I can't seem to do properly before my initial release.

[Ferdinand Mosca]

[Robert Houdart]

[Ed Schroder]

A couple of ideas I have used.

1. Cripple the piece values. If a queen has a similar value as a pawn then even a beginner makes a chance to win. Disadvantage: it still will find mates.

2. Force pawns to move by giving it a (random) bonus at the root.

3. A more advanced technique (I called it Club Player) is to give a random bonus / penalty for all root moves in such a way it only occasionally makes a blunder, just like most of us poor chess players like to do.

[Mike Robinson]

[Robert Hyatt]