CS4701FinalPresentation (1)x

strangerwineAI and Robotics

Oct 19, 2013 (3 years and 9 months ago)

80 views

GoogolHex

CS4701

Final Presentation

Anand Bheemarajaiah

Chet Mancini

Felipe Osterling

Problem Definition


Build an intelligent agent that can play the 2
-
player
modified Chinese Checkers game.


The
board setup consists of individual tiles that are
hexagonal and a set of pieces that must move from their
start positions by moving individually or “jumping” one
another to a set of end positions.


The motivation for this project is to implement and
evaluate various AI ideas into an intelligent agent that
plays the game against other intelligent agents.

Summary
-

Tournament
Performance


Our agent has performed at about the
average or slightly below.

Method
-

Board Representation


Since the Greedy player provided
implemented the same design concepts we
specified in our initial presentation, we
decided to only slightly modify the provided
Board object.


We added some helper methods, and we
added an extra jump function that maintained
a depth counter of the current depth of a
player.

Method
-

Agent


As specified in our initial presentation, we
decided to continue with an AB
-
pruned
Minimax adversarial search to allow us to find
optimal moves within a reasonable visibility.

Limiting Minimax Search


Clearly, a basic Minimax search would
explode far too quickly with the size of the
board and number of moves.



We still identified an adversarial search as
the most straightforward solution to find
intelligent moves.


Limiting Minimax Search (cont)


Limit the search depth to 6.


Don't bother searching tree of the two
backwards
-
oriented directions from each
peg.


Don't bother moving towards sides of board.


After realizing a depth of 4 was far preferable,
we decided to limit depth to 2, and continue
search again of depth 2 on most optimistic
paths. This gets a functional depth of 4
without the time complexity (and a small
optimality tradeoff risk).

Method
-

Search Heuristic Design


We use a composite heuristic by weighting and summing
the following weighted sub
-
heuristics:


Simple
-

Distances to the farthest free slot, using the
Board.dist(...) implementation provided.


Distance
-

The total Euclidean distance from the goal
(i.e. the sum of the Euclidean distances of each player
from the goal)


Total Moves
-

Inverse of total number of moves taken
(making a move subtracts)


Marbles At Goal
-

Strongly weight actually getting
marbles into goal slots.

Related Work


Our board representation ideas came from
Paula Ulfahake at Lund University


(who also implemented her agent with a
modified Minimax search)

System Architecture


OOP Design


GoogolHexPlayer extends standard player
interface.


Move Logic with Strategy Pattern.


Provide standard "getMove" interface
method for strategies.


Provide standard "getValue" inteface method
for heuristics.

Experimental Evaluation


In our testing our agent consistently won
against the greedy player by a considerable
margin
--
always several moves ahead.



Shortcomings/Future Work


We implemented a neural network, but were
not able to use it effectively in our approach.



We would like to further investigate different
evaluations and classifications of training
data in order to optimize our performance or
experiment in more detail in learning
algorithms.

Shortcomings/Future Work (cont)


Our project would have been much easier to
test and debug with a unit test framework we
could use against the board and heuristic
methods.



This is a somewhat involved setup process
and learning curve for JUnit and Eclipse, but
it could have been quite beneficial.

Acknowledgements


We would like to thank our TA, Jason
Yosinski for his assessments and suggesions
during the project.

Conclusion


In this project we have developed an agent
that fulfills our goals, attempted a variety of
AI
-
related strategies, and ended up with a
solid search for finding good moves in
Chinese Checkers.