Computer Chess Club Archives


Search

Terms

Messages

Subject: User Centered Learning

Author: Ratko V Tomic

Date: 10:22:42 08/12/99


I have been playing chess computers & PC software
since early 1980s. One needless time-wasting annoyance
with all the programs so far (and I have lost count how
many I had tried over years) is that when we get into
the same position we had played before, the program
goes off and thinks it from scratch (to come up
with the same move, unless set to random, which tends
to make its play subotimal).

Of course, I could avoid this kind of waste of time,
by wasting as much time in typing in the lines of
play (or something of that sort) into the program.


There is no technical reason why a PC program couldn't
automatically save all previously played positions,
with all needed data (depth, time, evaluations for top N
moves, etc), so that the next time it runs into this
position, it can either pick up where it left off and
deepen the analysis or play the original move (e.g.
if the same time controls are set and it didn't find
out few moves later it was a bad move).

User would be able to set which way (deepen or play
immediately) he wishes this feature to work. Also, in
the case of "play immediately," user could set whether
to play the same move or to let the program pick
alternative if the original move turned out bad later.

In conjuction with memorizing the positions and
evaluations, user should be able to let the program
think overnight through the positions (e.g. the most
frequent ones or the most recent ones or the user
selected ones etc). The result of such analysis would
update the older evaluations and would be reusable the
same way. It would also allow program to find and fix
its mistakes, since it had the subsequent moves of the
game. Even if the critical move is too far away from
its realization that something went wrong, it could at
least back off gradually, not via the full width search
(since it can't reach that deep in this case), but by
playing against itself, using the line played as the
skeleton of the simulated play (i.e. the opponents line
is tried out if possible).


The basic point of this feature is to make the computer
play more similar to playing with a rival-friend, where
the two players meet daily in the club or at the beach,
then often go quickly over the same circle of lines,
each occasionally thinking them over and springig up
a surprise the next time. Thus the program would learn
about its human opponent just as two humans players would
about each other.

Since this knowledge (from the play & the overnight
computation) would accumulate in many places, it would
be important to be able to merge such knowledge bases.
The program manufacturer could even setup on their web
page a data submission & download facility, so that
users could upload their data base and download the
most current one (or some of its subsets, e.g. based on
openings). Of course, not all would make it into the
common data-base. A filter program could eliminate dupes,
(keeping only the deepest analysis submitted) or it could
keep the results only from the stronger players (since
having the game data it can automatically decide whose
positions & moves are worth keeping).

The merge facility would add more variety to this type
of play and would strenghten the program. In the
rival-friend analogy, this would be equivalent of one
friend going, say, to a tournament and coming back
with more ideas and knowledge.

This would prevent the program not only from
falling twice into the same losing line anywhere,
but from wasting user's time thinking for several
minutes on a move it has already though about for
as long or longer (locally or anywhere else).


In present multi-gigabyte disk era, using say 100
bytes per position (although this includes the eval
data, it is still probably a very generous amount), a
million of positions is still only 100Mb, no big
deal nowdays.  A single player might accumulate
a few tens of thousands of positions, which is in
a few Mb range, hard to notice.

For the common data base (at the manufacturer's
web page), a more compact tree representation can
be kept (for accumulation and exchange purposes),
where positions are derived via moves from earlier
positions, and the moves are in a tree, thus the
next position may take under 1 byte for piece
positions, plus whatever evaluations take.
Once downloaded, the data would be expanded into
a quickly searchable format (e.g. with 64 bit
hash values, followed by move generator from
a set of anchor positions to derive the exact
position).

Hopefully, there will be something of this sort
available in the near future. If someone knows of
program that already has this kind of feature,
I'd like to try it out.



This page took 0 seconds to execute

Last modified: Thu, 15 Apr 21 08:11:13 -0700

Current Computer Chess Club Forums at Talkchess. This site by Sean Mintz.