Is evaluation what makes a chess player better?

[Nicky]

Archived from groups: rec.games.chess.computer (More info?)

i finally have come to the conclusion that the best chess engine is
characterized by only its ability to evaluate a certain
board position.
Who ever evaluates better wins.

Calculation is not an issue since all comps can calculate to the last
node of a given thread.

In the final analysis, it's only board positions REACHED by various
move orders, and that board position needs evaluating.
Is my above concept correct?

For example all chess engines should evaluate that white is better if
at the finale white is left with K and R against a black's K and start
playing the thread that reaches to that last node (board position).
But his was just an easy and simple material advantage evaluation

But then what makes one chess engine evalutae better than an other one?

Is it true that all depends on how good is the algorithm of an
evaluation function?

 

[Nicky]

Archived from groups: rec.games.chess.computer (More info?)

Thank you but still it aint too clear for me to understand.

I though that calculation cane be done the same way for all chess
engines cause cant every chess engine calculate one node after another
until it reaches the last node(board position) of a given thread?

Hence, i beleive that evaluation is more important that
calculation(search).

I maybe wrong but i think that search is all about calculate whats the
legal moves after each move and so on and that can ne found by every
search algorithm.

So finally we have the search function tries to find all thge next
possible legal moves that we can play in a given position but then the
evaluation function is the one that will decide which score each board
positions gets(depending on material advantage and positional advantage
and the higher score wins, meaning that we play that very first move
that leades to the final node with the highest value.

 

[Guest]

Archived from groups: rec.games.chess.computer (More info?)

Nicky wrote:

> Thank you but still it aint too clear for me to understand.
>
> I though that calculation cane be done the same way for all chess
> engines cause cant every chess engine calculate one node after another
> until it reaches the last node(board position) of a given thread?

That would be the crudest form of brute search algorithm that visits
every node. All modern games engines use some heuristic like alpha-beta
pruning to avoid looking at hopeless lines for longer than necessary.

Depending on how the program refines its search and allocates time to
moves the outcome even with the same evaluation function could be quite
different in some positions.

> Hence, i beleive that evaluation is more important that
> calculation(search).
>
> I maybe wrong but i think that search is all about calculate whats the
> legal moves after each move and so on and that can ne found by every
> search algorithm.

They can, but a good evaluation function will help to order the moves so
that the program benefits from the maximum amount of tree pruning.

And the search algorithms have always been designed to look for a
quiescent end position (classically by swapping off exchanges) although
modern ones do special case tricks for forced moves. A naive fixed depth
search tends to produce bizarre horizon effects where the program does
odd things to put off losing its queen by one more move.
>
> So finally we have the search function tries to find all thge next
> possible legal moves that we can play in a given position but then the
> evaluation function is the one that will decide which score each board
> positions gets(depending on material advantage and positional advantage
> and the higher score wins, meaning that we play that very first move
> that leades to the final node with the highest value.

The optimum tradeoff between a very good evaluation function and a deep
search is distinctly non-trivial. Some engines have both a slow and
accurate evaluation and a quick and dirty one to go faster down
non-critical lines with only a slight risk of potential error.

Regards,
Martin Brown

 

[Guest]

Archived from groups: rec.games.chess.computer (More info?)

"Hi" <kaqs.1662@bumpymail.com> wrote in message
news:1124212899_2985@spool6-east.superfeed.net...
> "Nicky" <hackeras@gmail.com> wrote in message
> news:1124182095.317739.40280@g14g2000cwa.googlegroups.com...
> >i finally have come to the conclusion that the best chess engine is
> > characterized by only its ability to evaluate a certain
> > board position.
> > Who ever evaluates better wins.
> >
> > Calculation is not an issue since all comps can calculate to the last
> > node of a given thread.
> >
> > In the final analysis, it's only board positions REACHED by various
> > move orders, and that board position needs evaluating.
> > Is my above concept correct?
>
> Not really. It's a bit too simplistic.
>
> First and foremost, chess is *soley* a tactical game. There are no
concepts
> such as 'positional' factors or random chance. It's a pure tactical game.
>
> What makes it 'positional' (and hence, the evaluation of a position) is
that
> neither humans or computers are able to deal with the vast number of moves
> possible.
>
> So we simplify that into "positional" factors. Things that are *likely*
to
> be true, but not always.
>
> That's what a chess program does. It tries to over simplify a board
> position into a score by using its positional evaluator.
>
> But, since that's not even vaguely good enough (remember, chess *is*
> tactics), it only does that as a last resort. It first examines the
search
> tree, then when it reaches the point where it has to give up, it then
> evaluates the positional aspects.
>
> How a chess program goes about doing the search can have a major effect on
> how deeply the program searches. Not every method is equal. There can be
a
> big difference in how many nodes can be searched in the same length of
time
> by different nodes.
>
> Then, there are the more advanced methods that actually ignore certain
parts
> of the tree. Techniques that do this are: Quiscience extensions, Static
> Exchange Evaluator, Null move, futility cutoffs, and other pruning
methods.
> Then, of course, things like move ordering (and how much gets pruned)
> contributes to how many nodes can be searched. Inefficient programs may
> search as many nodes, but the usefulness may be lower and they may not be
> able to search as deeply.
>
> The choices made there can have a signifcant impact on the tactical
ability
> of a program. Give two programs identical evaluators but different search
> methods, and you'll discover that they play very different types of games.
>
> Then we get into the positional evaluator itself... Everybody has
different
> ideas about what should be in there. Not every idea is a good one.
> Different people have different ideas about what the relative weights
should
> be. (And on top of that, the weights don't stay constant... They can vary
> as the game progresses.) And a bunch of other factors.
>
> The evaluator is trying to guess what score to give a position... But
since
> chess is a tactical game, these evaluators can never be completely
accurate.
> They are only guesses.
>
>
> The evaluator is indeed very important. It's try to guess at things it
> doesn't really understand.
>
> But putting a good evaluator into a program with poor search algorithms
> isn't going to make the program a good one.
>
> On the other hand, putting a poor evaluator into a program that searches
> lots and lots of nodes, the program *can* be a good chess program.
> (Depending on just how simplistic the evaluator is, of course.) The
reason
> is the tree search itself... After all, chess is a tactical game. And
doing
> a poor evaluator very deeply in the tree can overcome a lot of the
problems
> of the evaluator.
>
>
> So, no, it's not that simple.

I can agree with most of this.
There are many ways to play chess game and not lose. Deep search finds
blunder moves and avoids them. This makes game of computer engines with
equal search depth free of even minor tactical errors. Such engines exchange
pieces accurately and come into endgame with equal material (or almost
equal). Then decision is made using endgame tablebases. Endgame tablebase
gives either win to one of the sides or draw. And this ETB decision may
become random for engines with dubious evaluation function and deep
searcher.
This scenario we can see in all games between engines. But this is all due
to the fact that engines don't know how to play games with good strategy,
how to organize attacks like this one
http://onegoodmove.org/chess/viewer/kasparovfritz3.htmld/ in game 3 between
Kasparov and X3D Frtitz. In this game with closed position engine just
didn't recognize that whites were preparing devastating attack in the last
40 moves. Engines don't play positional chess well due to lack of some meta
chess knowledge. And the only way to play positional chess well is to have
smart evaluation function.
Evaluation function leads its engine into some game tree direction, when
engine cannot choose between moves with equal material outcome of its
tactical depth. IMHO this choice is required in 60-80% of moves by each
side. The rest of moves are forced by opponent actions, like recapture,
escape after check, etc. But even in the case of forced moves there still
can be choice between equal recaptures or equal escaping moves for the king.
This is all should be controlled by evaluation function.
Look at the game I mentioned above again and notice that kasparov didn't
make queen side castling. Instead he made long manoeuvre to put his king
into its final location. Engines either castle in their books, or they
stimulate castling in evaluation function or not castle at all if not forced
to do it due to some tactical reason. In any case engines don't know if it
is worth to do castling at all in the particular game or not. They just do
it because in general castling puts king into safer position than before.
But this is not always correct. Engines with simple evaluation function and
deep searcher don't know "... to be or not to be... ". Because engines don't
see the particular game as a whole.
There are at least two reasons for oversimplified dubious evluation
functions:
- smart evaluation function for chess is not invented. IMHO programmers
don't know how to make engines to play positional games well.
- smart evaluation function should calculate many complex factors and this
requires too much time. Heavy evaluation function shouldn't allow to reach
great depth, so this can weaken tactical strength of engines and they will
start to lose to more dubious but more depth searchers.

 

[Guest]

Archived from groups: rec.games.chess.computer (More info?)

If you look at the theory of zero-sum games you'll find that there exist
alpha-beta algorithm for best move search. Its effectiveness depends on the
order of in-depth game-tree traversal. But there is minimal game-tree that
have to be searched for some particular evaluation function that proves
found move to be best. The best ordering procedures don't reach minimal
game-tree traversal, so they always make additional redundant search. So
first of all searchers are different at reaching minimal game-tree.
There is no strong chess engine without quiescent and selective search. Both
of them are specific to each engine and determine tactical strength of
engine.
There can be other differences in how engines perform search, thus
evaluation function is important for strong strategy, while search algorithm
is important for absence of tactical blunders. I cannot choose what is more
important strategy or tactics.

"Nicky" <hackeras@gmail.com> wrote in message
news:1124272163.740499.20320@z14g2000cwz.googlegroups.com...
> Thank you but still it aint too clear for me to understand.
>
> I though that calculation cane be done the same way for all chess
> engines cause cant every chess engine calculate one node after another
> until it reaches the last node(board position) of a given thread?
>
> Hence, i beleive that evaluation is more important that
> calculation(search).
>
> I maybe wrong but i think that search is all about calculate whats the
> legal moves after each move and so on and that can ne found by every
> search algorithm.
>
> So finally we have the search function tries to find all thge next
> possible legal moves that we can play in a given position but then the
> evaluation function is the one that will decide which score each board
> positions gets(depending on material advantage and positional advantage
> and the higher score wins, meaning that we play that very first move
> that leades to the final node with the highest value.
>