Historia gry w warcaby sięga 3000 lat p.n.e. kiedy to w starożytnym Egipcie, znana była planszowa gra Senet - prekursorka dzisiejszych warcabów. Jej twórcą, wedle wierzeń dawnych Egipcjan, był bóg Tot - bóg mądrości i wynalazca pisma (hieroglifów). W starożytnej Helladzie Grecy pasjonowali się grą w Petteia (kamyki) - warcaby greckie. Według mitologii greckiej jeden z jej bohaterów Palamades wynalazł grę w warcaby podczas oblężenia Troi. Grecka Petteia w starożytnym Rzymie przekształciła sie w Latrunculi (grę w rozbójników) - obecnie znana głównie pod nazwą warcabów rzymskich. Współczesne warcaby, powstałe na południu Europy w średniowieczu, pochodzą prawdopodobnie od gry nazywanej Alquerque (opartej na znanej przed 1000 r. Arabom grze El-Quirkat). Istnieją uzasadnione podejrzenia, że to właśnie do gry w Alquerque, na południu Francji, pierwszy raz użyto planszy złożonej z ułożonych na przemian jasnych i ciemnych pól - czyli dzisiaj znanej nam szachownicy.
W pierwszej połowie XVIII w. na terenie Francji pojawiła się nowa wówczas odmiana gry w warcaby na 100-polowej planszy nazwana przez samych Francuzów "warcabami na wzór polski", dziś nosząca miano warcabów międzynarodowych. Według legendy twórcą nowych warcabów miał być polski oficer Franciszek Żubr. Z Francji poprzez Belgię i Holandię warcaby polskie podbiły niemal cały kontynent europejski. Dziś są najbardziej znaną oraz popularną odmianą warcabów na całym świecie, szczególnie jako dyscyplina sportowa.
Istnieje bardzo wiele odmian gry w warcaby. Odmiany te różnią się głównie:
Mniej istotne różnice dotyczą:
Przykłady najpopularniejszych odmian:
Program checkers4, który wykorzystano w projekcie można ściągnąć z serwera
http://rusi.cjb.net/ za pomocą CVS. (np.
poleceniem cvs -d :pserver:anonymous@rusi.cjb.net:/cvsroot/public co checkers4).
Jest to program napisany w języku Java rozpowszechniany na licencji GNU GPL. Dzięki niemu nie trzeba było pisać
interfejsu użytkownika. Zasady, które zostały ustalone dla gry są nietypowe, są to w gruncie rzeczy warcaby angielskie. To znaczy:
Jednak w programie checker4 plansza jest "odwrócona do góry nogami" w stosunku do planszy w warcabach angielskich, a pierwszy ruch wykonuje gracz grający jasnymi pionkami (kiedy w warcabach angielskich pierwszy ruch należy do ciemnych pionków). Każdy "gracz" w programie jest reprezentowany jako (odpowiednia) klasa.
Wybór ruchu dokonywany jest na podstawie wartości funkcji oceniającej. Wykorzystany jest standardowy algorytm MinMax, jeśli wiele ruchów ma tą samą (maksymalną) wartość, to wybierany jest losowo jeden z nich. W celu przyspieszenia działania programu zastosowano odcięcia alfa-beta.
Jest kilka sposobów uczenia się. Jednym z ciekawszych i wykorzystywanych
w praktyce jest uczenie się ze wzmocnieniem (ang. reinforcement learning).
Metoda uczenia się ze wzmocnieniem nie zakłada, że agent (ucząca się maszyna)
ma jakąkolwiek wiedzę początkową. Celem jest nauczenie się na podstawie
własnych doświadczeń, własnych sukcesów i porażek. To co jest porażką, a
co sukcesem musi zostać sprecyzowane na początku (jeśli chodzi o gry
nie ma z tym żadnego problemu). W metodzie uczenia się ze wzmocnieniem
agent po każdej wykonanej akcji dostaje nagrodę lub karę (ogólnie wartość
liczbową, czyli wzmocnienie), na podstawie której może zmienić swoje późniejsze
zachowanie. W programie przyjęto, że agent dostaje nagrodę +1 po
zwycięskim zakończeniu partii (po ostatnim ruchu), -1 po przegranej
(również po ostatnim ruchu), natomiast 0 we wszystkich pozostałych
przypadkach, tzn po ruchach nie doprowadzających jeszcze do rozstrzygnięcia
oraz po remisach. Głównym celem agenta jest nauczenie się uzyskiwania jak
największej nagrody, a więc w przypadku gry - nauczenie się wygrywać.
Agent musi w jakiś sposób wybierać swoje akcje, dlatego potrzebna jest
mu funkcja oceniająca poszczególne stany. Wraz z nauką, wartości tej funkcji
powinny zmieniać się, tak aby agent nauczył się dokonywać optymalnych wyborów.
Najprostszą formą takiej funkcji jest odwzorowanie ze stanów na ich wartości.
Agent musi więc nauczyć się prawidłowych wartości wszystkich stanów.
Wraz ze zdobywanym doświadczeniem wartości te można poprawiać według wzoru:
s1, s2, ..., sn to kolejne stany, w których
znajduje się agent, alfa to współczynnik uczenia się (z przedziału (0,1]),
im mniejszy tym uczenie jest powolniejsze, ale dokładniejsze, gamma to również
parametr algorytmu, dopierany do konkretnego problemu.
Najczęściej nie jest fizycznie możliwe obliczenie wartości wszystkich stanów,
ze względu na ich ogromna liczbę.
Rozwiązaniem jest funkcja aproksymująca te wartości na podstawie
pewnych cech stanów. Takie właśnie rozwiązanie wybrano w programie. Używana jest
liniowa funkcja kilku cech planszy:
gdzie f to liczba cech, w to wagi - współczynniki cech planszy (a).
Oto wzory pokazujące jak poprawiane są współczynniki tej funkcji:
Innym pojęciem związanym z omawianą metodą jest "śledzenie wybieralności"
(ang. eligibility traces). W metodzie tej podczas poprawiania wartości stanów
pod uwagę brane są wartości wielu poprzednich stanów, a nie tylko jednego,
jak jest w standardowej metodzie. Przy korzystaniu z funkcji aproksymującej
branie są pod uwagę również te cechy, które wystąpiły w poprzednich
stanach. Tak wygląda powyższy wzór po uwzględnieniu tego mechanizmu.:
W wzorze tym występuje gradient, dlatego metodę "śledzenia wybieralności"
z jego wykorzystaniem nazywa się zmniejszaniem gradientowym
(ang. gradien-descent). W przypadku liniowej
funkcji aproksymującej gradient wyraża się prostym wzorem:
Tak jak wspominano wyżej funkcja oceniające planszę jest liniową funkcją kilku jej cech. W tabelce poniżej znajduje się opis użytych cech. Aktywną stroną nazwano stronę dla której jest liczona wartość planszy, pasywną - stronę przeciwną.
pieceCount[0] | Liczba zwykłych pionków aktywnej strony |
pieceCount[1] | Liczba damek aktywnej strony |
pieceCount[2] | Liczba zwykłych pionków pasywnej strony |
pieceCount[3] | Liczba damek pasywnej strony |
thretend[0] | Liczba bić (włączając wielokrotne), które może wykonać aktywna strona |
thretend[1] | Liczba bić (włączając wielokrotne), które może wykonać pasywna strona |
cent[0] | Liczba środkowych pól planszy, na których znajdują się zwykłe pionki aktywnej strony |
cent[1] | Liczba środkowych pól planszy, na których znajdują się zwykłe pionki pasywnej strony |
kcent[0] | Liczba środkowych pól planszy, na których znajdują się damki aktywnej strony |
kcent[1] | Liczba środkowych pól planszy, na których znajdują się damki pasywnej strony |
cntr[0] | Liczba środkowych pól planszy, na których znajdują się lub mogą znaleźć się po jednym ruchu jakiekolwiek pionki aktywnej strony |
cntr[1] | Liczba środkowych pól planszy, na których znajdują się lub mogą znaleźć się po jednym ruchu jakiekolwiek pionki pasywnej strony |
thret[0] | Liczba pól na które aktywna strona może się poruszyć i w ten sposób zagrozić biciem drugiej stronie |
thret[1] | Liczba pól na które pasywna strona może się poruszyć i w ten sposób zagrozić biciem drugiej stronie |
mob[0] | Liczba pól na które aktywna strona może się poruszyć (nie biorąc pod uwagę, że mogą istnieć skoki (bicia)) |
mob[1] | Liczba pól na które pasywna strona może się poruszyć (nie biorąc pod uwagę, że mogą istnieć skoki (bicia)) |
deny[0] | Liczba pól opisanych w mob[0] i takich że w następnym ruchu pionek zajmujący to pole może być zbity bez wymiany |
deny[1] | Liczba pól opisanych w mob[1] i takich że w następnym ruchu pionek zajmujący to pole może być zbity bez wymiany |
mobil[0] | mob[0] - deny[0] |
mobil[1] | mob[1] - deny[1] |
Wśród wszystkich graczy, najczęściej stosowana jest funkcja z mniejszą liczbą składowych, np. 4, 14. Dalej opisane są różnice występujące u graczy, a później tabela podsumowująca (z nazwami, numerami i opisami).
W celu przeprowadzenia testów napisano kilkunastu graczy. Głównym celem było dobranie jak najlepszej wersji algorytmu i jak najlepszych jego parametrów.
Aby sprawdzić możliwości uczenia się danej wersji algorytmu, gracz wielokrotnie grał sam ze sobą, później grał kilkukrotnie z innymi graczami. Po "nauczeniu" w opisany sposób kilku graczy porównywano ich możliwości organizując gry między nimi. Na koniec zorganizowano również dwa turnieje, w którym wzięli udział wszyscy gracze. Podczas pierwszego turnieju gracze nie uczyli się w trakcie (tzn. nie poprawiali swoich funkcji oceniających). Miał on na celu sprawdzenie, którzy gracze najlepiej umieli wykorzystać swoje doświadczenie (czyli wcześniejszy trening) i wyliczyli możliwie najlepsze wagi funkcji aproksymującej. Podczas drugiego turnieju gracze uczyli się w trakcie jego trwania. Miał on na celu sprawdzenie, którzy gracze najlepiej uczą się od swoich przeciwników. W dalszej części najpierw następuje bezpośrednie porównanie i omówienie wersji zastosowanego algorytmu, dalej znajdują się wyniki turniejów.
Wzór poprawiający funkcję oceniającą może być stosowane po każdym wykonanym ruchu jak następuje:
double delta = r + gamma*estimate(thisState) - estimate(previousState); for (int j = 0; j < weights.length; j++) weights[j] += alfa * delta * thisState[j];
lub dopiero po całej skończonej rozgrywce. W tym drugim przypadku można dokonać obliczeń niejako wstecz, tzn w następującej pętli:
for (i = s.length - 2; i >= 0; --i) double delta = r + gamma*estimate(s[i+1]) - estimate(s[i]); r = 0.0; for (j = 0; j < weights.length; ++j) weights[j] += alfa * delta * s[i][j];
Nagroda r przyjmuje wartość +1/-1 (ewentualnie 0 przy remisie) tylko po ostatnim ruchu w partii (w pozostałych jest równe 0), kiedy poprawia się funkcję po każdym ruchu, nagroda wpływa na wartości tylko raz, natomiast w powyższej pętli jest propagowana dalej, wpływa (pośrednio) na całość obliczeń. Wyniki bezpośredniego porównania nie są zaskakujące. Po każdej rundzie każdy z graczy grał kilkadziesiąt razy sam ze sobą, jak widać gracz uczący się na końcu (RafalBack) okazał się być lepszy, choć w późniejszych turniejach przewaga ta nie była zbyt widoczna, RafalForw był tylko nieznacznie gorszy.
RafalForw | RafalBack |
---|---|
13 | 11 |
7 | 17 |
8 | 17 |
6 | 19 |
Wartość gamma we wzorze można ustalić zależnie od konkretnego problemu. Przeprowadzono eksperymenty z wartościami 1.0, 0,9, 0,8, i 0,7. W bezpośrednim porównaniu najlepsza okazała się wartość 0.8. Pokazuje to fragment tabeli z drugiego turnieju:
RafalBack | RafalGamma09 | RafalGamma08 | RafalGamma07 | |
---|---|---|---|---|
RafalBack | 9-1 10-0 | 2-8 0-10 | 5-5 4-6 |
|
RafalGamma09 | 7-3 8-2 | 6-4 2-8 | 6-4 9-1 |
|
RafalGamma08 | 4-6 10-0 | 10-0 10-0 | 2-8 6-4 |
|
RafalGamma07 | 7-3 8-2 | 6-4 7-3 | 2-8 2-8 |
Gracze ujęci w powyższej tabeli brali pod uwagę 4 cechy planszy. Wśród graczy którzy wykorzystują więcej cech znalazło się też dwóch którzy mieli wartości gamma równe 0.8, jednak wypadli oni znaczenie gorzej od analogicznych graczy z gamma = 1.0. Jak widać ciężko jest dobrać odpowiednią wartość tego parametru, jednak 1.0 wydaje sie być najbardziej uniwersalną (i najczęściej stosowaną wśród implementacji wykorzystujących uczenie sie ze wzmocnieniem do rozwiązywania jakiś problemów).
Wartości cech mogą przyjmować wiele wartości lub być binarne. Cechy wielowartościowe można często w łatwy sposób odzwierciedlić za pomocą wielu cech binarnych. Jeśli dana cecha przyjmuje wartości całkowite (dyskretne) to można użyć w zamian tylu cech binarnych ile wartości przyjmuje ta cecha (tak właśnie uczyniono w tym eksperymencie). W przypadku cech o wartościach ciągłych można przedział wartości podzielić na pewną liczbę przedziałów i użyć tylu cech binarnych ile jest przedziałów. Przeprowadzenie tego eksperymentu zostało zainspirowane faktem, iż w książce Reinforcement learning - An Introdution we wszystkich przykładach ilustrujących użycie funkcji aproksymujących cechy były zawsze binarne. Okazało się jednak, że w większości przypadków lepsi okazali się gracze korzystający z cech wielowartościowych niż z cech binarnych.
Jak powiedziano wcześniej metoda ta ma na celu branie pod uwagę większej liczby wartości poprzednich stanów. Wartości te muszą być mnożenie przez pewien współczynnik - lambda, 0 <= lambda < 1, który wskazuje jak wiele poprzednich stanów chcemy brać pod uwagę. Dla każdego współczynnika w[j] utrzymujemy wartość e[j], która mówi jak często występowała dana cecha stanu (planszy) b[j] wśród poprzednich stanów. Kiedy dana cecha wystąpi można kumulować jej wartość (e[j] = e[j] + a[j]) lub zastępować ją (e[j] = a[j]). Pętla poprawiająca współczynniki funkcji wygląda więc następująco:
for (i = bs.length - 2; i >= 0; --i) for (j = 0; j < features; ++j) { e[j] *= gamma * lambda; e[j] += s[i][j]; // kumulacja albo: e[j] = s[i][j]; // zamiana double delta = r + gamma*estimate(s[i+1]) - estimate(s[i]); r = 0.0; for (j = 0; j < weights.length; j++) weights[j] += alfa * delta * e[j];
Podczas szukania informacji na temat gry w warcaby i uczenia się ze wzmocnieniem znalazłem stronę dr. Marka Burge'a. To właśnie tam natrafiłem na program checkers4 (napisany przez jednego z jego studentów), który był wykorzystywany podczas jednego z kursów prowadzonych przez dr. Burge'a. W materiałach (niedostępnych obecnie na jego stronach) przedstawia on inny niż w książce Reinforcement learning - An Introdution sposób poprawiania współczynników funkcji aproksymującej:
Vt[b.length - 1] = r; for (i = b.length - 1; i >= 0; --i) double err = Vt[i] - estimate(b[i]); for (j = 0; j < weights.length; ++j) weights[j] += alfa * err * s[i][j]; if (i > 0) Vt[i-1] = estimate(bs[i]);
Okazał się on być niezwykle dobry, gracz RafalBurge realizujący go przegrywał tylko z RafalMore oraz z graczami, którzy wykorzystywali więcej niż on cech planszy.
Numer | Nazwa | Opis |
---|---|---|
1 | RafalBack | 4 cechy, uczenie się na końcu |
2 | RafalForw | 4 cechy, uczenie się na bieżąco (wszyscy pozostali gracze uczą się na końcu) |
3 | RafalGamma09 | 4 cechy, uczenie się na bieżąco, gamma = 0.9 (jeśli nie jest napisane ile wynosi gamma (przy innych graczach), to jest ona równa 1.0) |
4 | RafalGamma08 | j.w. ale gamma = 0.8 |
5 | RafalGamma07 | j.w. ale gamma = 0.7 |
6 | RafaMore | 14 cech |
7 | RafalMore08 | 14 cech, gamma = 0.8 |
8 | RafalMore08ETrepl005 | j.w. oraz użycie "śledzenia wybieralności" z zastępowaniem |
9 | RafalBurge | Implementacja wzoru zaczerpnięta od dr. Burge'a |
10 | RafalBin | 4 cechy binarne |
11 | RafalMMore | 20 cech |
12 | RafalBinETacc001 | 4 cechy binarne, użycie "śledzenia wybieralności" z akumulacją, lambda = 0.01 |
13 | RafalBinETacc01 | j.w. ale lambda = 0.1 |
14 | RafalBinETacc05 | j.w. ale lambda = 0.5 |
15 | RafalMMoreD | tak samo jak RafalMMore, ale głębokość algorytmu przeszukiwania MinMax równa 7 |
16 | RafalMoreD | tak samo jak RafalMore, ale głębokość algorytmu przeszukiwania MinMax równa 7 |
Konkurs został zdominowany głównie przez ostatniego gracza, co było spowodowane, tym że miał on największą głębokość przeszukiwania w algorytmie MinMax. Warto jednak zwrócić uwagę na gry RafalMore (numer 6), który wygrał wszystkie pojedynki, w tym również z RafalMMore (numer 11), który bierze pod uwagę więcej cech planszy od gracza RafalMore i ma dokładnie te same parametry algorytmu. Może to oznaczać, że bardzo trudno nauczyć się prawidłowych współczynników dla tych dodatkowych cech. W kolejnym turnieju wprowadzono jeszcze jednego gracza - RafalMoreD, miał on z założenia pokonać wszystkich (włącznie z RafalMMoreD), tak też się stało. Zrezygnowano natomiast z przeprowadzenia wszystkich gier z RafalMoreD, ponieważ są one dość czasochłonne i nie wprowadziłyby zapewne nowych informacji.
x | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 |
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
1 | 5-5 | 7-3 | 5-5 | 5-5 | 0-10 | 6-4 | 5-5 | 0-10 | 10-0 | 2-8 | 8-1 | 7-3 | 7-3 | 1-9 | |
2 | 5-5 | 6-4 | 6-4 | 4-6 | 0-10 | 5-5 | 4-6 | 0-8 | 9-1 | 1-9 | 8-2 | 6-4 | 8-2 | 1-9 | |
3 | 5-5 | 5-5 | 5-5 | 3-7 | 1-9 | 5-5 | 7-3 | 0-10 | 10-0 | 3-7 | 8-2 | 5-5 | 7-3 | 0-10 | |
4 | 7-3 | 5-5 | 3-7 | 4-6 | 1-9 | 5-5 | 7-3 | 1-9 | 10-0 | 3-7 | 6-4 | 7-3 | 8-2 | 0-10 | |
5 | 6-4 | 4-6 | 6-4 | 6-4 | 0-10 | 6-4 | 6-4 | 0-10 | 10-0 | 5-5 | 8-2 | 7-3 | 5-5 | 1-8 | |
6 | 9-1 | 9-1 | 10-0 | 10-0 | 9-1 | 10-0 | 10-0 | 10-0 | 9-0 | 10-0 | 10-0 | 9-1 | 10-0 | 1-9 | |
7 | 7-3 | 9-1 | 7-3 | 6-4 | 6-4 | 1-9 | 5-5 | 0-10 | 10-0 | 3-7 | 7-2 | 6-4 | 9-1 | 1-8 | |
8 | 1-9 | 8-2 | 5-5 | 8-2 | 5-5 | 3-7 | 4-6 | 1-9 | 10-0 | 7-3 | 7-3 | 7-3 | 6-4 | 0-10 | |
9 | 10-0 | 10-0 | 10-0 | 8-1 | 9-1 | 0-10 | 9-1 | 10-0 | 10-0 | 10-0 | 10-0 | 10-0 | 10-0 | 0-0 | |
10 | 1-9 | 1-9 | 1-9 | 1-9 | 0-10 | 0-10 | 0-9 | 0-10 | 0-10 | 1-9 | 2-7 | 5-5 | 3-7 | 0-10 | |
11 | 9-1 | 7-3 | 7-3 | 7-3 | 7-3 | 0-10 | 9-1 | 4-6 | 10-0 | 10-0 | 10-0 | 9-1 | 10-0 | 0-10 | |
12 | 3-7 | 3-7 | 4-6 | 2-7 | 2-8 | 0-10 | 3-7 | 4-6 | 0-10 | x | 0-10 | 4-6 | 5-5 | 0-10 | |
13 | 2-8 | 5-5 | 2-8 | 3-7 | 2-8 | 1-9 | 4-6 | 5-5 | 0-10 | 8-2 | 0-10 | 6-4 | 5-5 | 0-10 | |
14 | 4-6 | 6-4 | 3-7 | 3-7 | 3-7 | 0-10 | 1-9 | 1-9 | 0-10 | 5-4 | 0-10 | 7-3 | 6-4 | 0-10 | |
15 | 10-0 | 10-0 | 10-0 | 10-0 | 10-0 | 10-0 | 10-0 | 10-0 | 0-10 | 10-0 | 10-0 | 10-0 | 10-0 | 10-0 |
W konkursie z uczeniem się każdy pojedynek składał się z dwóch rund po 10 gier każda, pomiędzy rundami gracze grali kilkadziesiąt razy (20-30) sami ze sobą. W niektórych pojedynkach różnice pomiędzy wynikami pierwszej i drugiej rundy były diametralnie różne. Najwyraźniej widać to u graczy, gdzie gamma była mniejsza od 1, po niewielkiej liczbie gier potrafili (z niektórymi graczami) wygrać lub zremisować w drugiej rundzie po przegraniu pierwszej.
x | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 |
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
1 | 5-5 6-4 | 9-1 10-0 | 2-8 0-10 | 5-5 4-6 | 2-8 2-8 | 9-1 4-6 | 6-4 1-9 | 4-6 0-4 | 9-1 8-2 | 10-0 7-3 | 9-1 9-1 | 10-0 9-0 | 10-0 8-2 | 6-4 0-10 | 0-10 0-10 | |
2 | 4-6 6-4 | 9-1 10-0 | 6-4 0-10 | 1-9 6-4 | 2-7 1-9 | 7-3 6-4 | 10-0 7-3 | 8-1 0-5 | 10-0 8-1 | 10-0 6-1 | 9-1 10-0 | 10-0 9-1 | 10-0 9-0 | 6-4 0-10 | 1-9 1-9 | |
3 | 7-3 8-2 | 7-3 9-3 | 6-4 2-8 | 6-4 9-1 | 0-10 7-3 | 9-1 4-6 | 6-4 9-1 | 2-8 0-8 | 9-1 9-1 | 10-0 10-0 | 8-2 7-3 | 9-1 9-1 | 10-0 9-0 | 0-10 2-8 | 0-10 0-10 | |
4 | 4-6 10-0 | 10-0 10-0 | 10-0 10-0 | 2-8 6-4 | 1-9 1-7 | 1-9 2-8 | 9-1 10-0 | 1-9 1-9 | 9-1 0-10 | 7-3 5-5 | 10-0 10-0 | 10-0 7-3 | 6-4 9-1 | 0-10 0-10 | 0-10 0-10 | |
5 | 7-3 8-2 | 7-3 10-0 | 6-4 7-3 | 2-8 2-8 | 0-10 1-9 | 8-2 2-8 | 3-7 5-5 | 1-9 8-2 | 10-0 10-0 | 1-9 1-9 | 2-7 4-6 | 5-5 8-2 | 8-2 5-4 | 0-10 4-6 | 1-9 1-9 | |
6 | 10-0 10-0 | 10-0 10-0 | 10-0 10-0 | 9-1 6-3 | 8-2 9-1 | 10-0 9-1 | 9-1 10-0 | 10-0 10-0 | 9-0 10-0 | 10-0 10-0 | 10-0 10-0 | 10-0 10-0 | 10-0 10-0 | 1-9 4-6 | 2-4 0-10 | |
7 | 4-6 10-0 | 9-1 9-1 | 7-3 8-2 | 10-0 10-0 | 10-0 9-1 | 5-5 7-2 | 7-3 7-3 | 1-8 1-9 | 10-0 10-0 | 10-0 1-8 | 7-3 9-1 | 8-2 10-0 | 9-1 10-0 | 2-8 2-8 | 2-8 1-9 | |
8 | 10-0 10-0 | 10-0 10-0 | 10-0 9-1 | 7-3 10-0 | 8-2 4-6 | 7-3 4-6 | 7-3 2-8 | 0-9 1-9 | 8-2 10-0 | 10-0 10-0 | 9-1 9-1 | 9-1 8-2 | 7-3 9-1 | 0-10 1-9 | 0-10 1-9 | |
9 | 9-0 10-0 | 9-1 10-0 | 10-0 9-1 | 9-1 10-0 | 10-0 10-0 | 2-8 5-1 | 9-0 8-2 | 9-0 9-0 | 8-0 7-0 | 7-1 1-0 | 10-0 10-0 | 9-1 7-1 | 10-0 9-1 | 0-5 0-10 | 0-1 0-3 | |
10 | 1-9 0-10 | 1-8 4-6 | 4-6 1-8 | 4-6 2-7 | 4-6 2-7 | 0-10 0-10 | 3-7 1-9 | 2-8 2-8> | 0-10 0-9 | 0-10 0-10 | 7-3 9-1 | 6-4 5-5 | 2-6 4-6 | 3-5 0-10 | 0-10 0-10 | |
11 | 7-3 7-3 | 9-1 10-0 | 9-1 9-0 | 8-1 7-3 | 9-1 9-0 | 7-3 7-2 | 9-1 8-1 | 10-0 0-10 | 0-10 0-10 | 6-4 10-0 | 10-0 9-0 | 8-2 8-2 | 9-1 9-1 | 0-10 2-8 | 2-4 1-9 | |
12 | 1-9 7-3 | 5-5 1-9 | 2-8 2-7 | 1-9 0-10 | 1-9 5-5 | 0-10 0-10 | 2-8 4-6 | 2-8 0-10 | 0-9 1-8 | 7-3 4-6 | 0-10 1-9 | 7-3 9-1 | 7-3 7-3 | 0-10 0-10 | 0-10 0-10 | |
13 | 0-10 1-9 | 2-8 5-5 | 3-6 4-6 | 1-9 0-10 | 1-9 2-8 | 9-1 0-10 | 1-9 1-9 | 2-8 1-9 | 0-8 1-9 | 6-4 9-1 | 0-10 0-9 | 5-5 2-8 | 5-5- 5-5 | 0-10 0-10 | 0-10 0-10 | |
14 | 5-5 4-5 | 4-5 3-7 | 6-4 4-6 | 2-8 0-10 | 4-6 1-9 | 0-10 0-9 | 2-8 1-9 | 2-8 2-8 | 0-10 0-10 | 8-2 5-4 | 0-10 1-9 | 6-4 4-6 | 4-6 4-6 | 1-9 0-10 | 0-10 0-10 | |
15 | ||||||||||||||||
16 | 10-0 10-0 | 10-0 10-0 | 10-0 10-0 | 10-0 10-0 | 10-0 10-0 | 8-1 8-1 | 10-0 9-0 | 10-0 10-0 | 10-0 10-0 | 10-0 10-0 | 10-0 8-0 | 10-0 10-0 | 10-0 10-0 | 10-0 10-0 | 4-2 4-0 |
Stworzeni gracze nie są arcymistrzami i nigdy nimi nie będą, jednak nie można ich pokonać grając bezmyślnie. Ich autor ma bardzo duże trudności w doprowadzeniu do swojej wygranej z najsilniejszymi graczami, jest on jednak graczem amatorem. Nieco łatwiej jest doprowadzić do remisu. Graczom brakuje inwencji jak zakończyć grę, mimo ewidentnej przewagi (np 2 damki przeciwko 5). Rozwiązaniem tego problemu mogła by być baza danych z wszystkimi możliwymi zakończeniami dla 2-3 pionków przeciwnika na planszy. Takie metody stosuje się w najlepszych programach do gry w warcaby (oprócz tego są stosowane bazy danych rozpoczęć gry). W czasie turnieju okazało się, że faworyt (gracz biorący pod uwagę największą liczbę cech planszy) zawiódł. Lepszy okazał sie gracz oceniający planszę z użyciem kilku cech mniej, było to zaskoczeniem.
1. Reinforcement Learning: An Introduction Richard S. Sutton, Andrew G. Barto
2. Some studies in machine learning using the game of checkers, A. L. Samuel
3. Some Studies in Machine Learning Using the Game of Checkers. II - Recent Progress, A. L. Samuel
4. Reinforcement Learning: A Survey Leslie Pack Kaelbling, Michael L. Littman
6. Strona z programem checkers4
7. Reinforcement Learning Repository
8. Chinook - niepokonany przez człowieka program grający w warcaby