Better Chess through Genetic Programming

Better Chess Through Genetic Programming Christopher Swenson [email_address]

Overview
The Problem
The Solution
How the Solution works
 minimax strategy
Genetic Programming

Programming Chess
Easy to learn, difficult to master games
Until recently, almost impossible for computers to play at the grandmaster level
State space incredible 2 8000 raw, 2 600 with pruning
Programming for chess is an expensive process, requiring chess experts to work with programmers for years
Requirements
Cheap
Fast
Minimize development time

Solution
Use a standard technique (  minimax)
Looks at all possible future moves to a certain depth
4 ≈ Novice
8 ≈ Expert
12 ≈ Grandmaster
Branch factor for chess is around 40, 7–8 with good pruning techniques (8 12 ≈ 70 billion)
Requires an “evaluation function” for choosing which future is preferable
Evaluation function:
Gives a board a numerical score (utility)
This is the real meat of 

 Minimax
 – Keeps track of best move for us to make (we want to max imize the utility the worst situation we can get ourselves into)
 – Keeps track of best move for opponent to make (we want to mini mize the utility of our opponent’s best situation)
Works by looking at all possible decisions you could make, by estimating all possible decision your opponent could make, etc

Minimax Tree

Evaluation Functions
Just a simple function to give a board a score
Evaluate the leaf nodes, and then let  minimax determine which path is optimal
For chess, should incorporate which pieces are still on the board, position, etc
This is where the hard work comes in

Example

Genetic Algorithms
Method allowing you to generate near-optimal solutions with little knowledge, using the properties of evolution
Solutions guaranteed to reach near optimality over time (Schema Theorem)
Solutions represented as fixed-length “chromosomes”
Crossover operations  offspring
Mutations  variation
Best suited for ≥ NP problems
Traveling Salesperson Problem

Genetic Programming
John Koza, late 1980s
Extension of Genetic Algorithms, with variable length chromosomes (programs)
Express programs as LISP-like trees
4 + 5

Crossover Function A Function B (# Queens x 9) + (# Pawns) # Knights / 2 Select two functions from gene pool at random

Crossover (cont’d.) Function A Function B (# Queens x 9) + (# Pawns) # Knights / 2 Select a node on each function at random for crossover

Crossover (cont’d.) New Function A New Function B (# Queens x 9) + (# Knights / 2) # Pawns Swap

Gene Pool
100 Generations
512 Chromosomes in the Gene Pool / Generation
The next generation is determined by randomly selecting two chromosomes, mutating and crossing them over, and letting them play a chess match
Each time the best is calculated by holding a tournament

Why Genetic Programming?
Advantages
Easy to program
Fast
Shown to work in other research
Disadvantages
Problems with depth on first several moves
Limited by expressivity of “function set” (genes)
High amount of branching
Strategy often complex

Simpler Task
Vinciperdi – aka “Loser’s Chess”
Same as chess, but to win you must lose all of your pieces or force your opponent to checkmate you
If there is a capture available, you must make it

Why Loser’s Chess?
Simpler than regular chess
Branching reduced by forced captures
Faster than regular chess
Openings lead to captures very fast
Games tend to be end fast, since captures occur almost every move
A simple evaluation function set is sufficient for most modeling
Much of the work for Loser’s Chess can be extended to regular chess

Work So Far
In Spring 2003, I began implementation of these concepts in Java
Implemented multi-threaded genetic programming library and  minimax tree searching
Picked up work again in Fall 2004, starting with implementing rules for Loser’s Chess
Currently at about 4,000 lines of source code

Preliminary Results
Difficult to judge progress
Program generates incredibly complicated solutions (hundreds of points)
Takes long time to run (several days for 100 generations) due to the complexity of calculations on a chess board (~ 2 hours / generation)
Each generation increases the average complexity in the gene pool, and therefore increases execution time

Some Example Chromosomes for Normal Chess
1 st generation – 15 points
*(+(*(# Pawns, 7),+(1,# Attacked Pieces)),-(*(# Attacking Pieces,# Attacked Pieces),+(# Queens, 5)))
8 th generation – 15 points
+(-(/(# Rooks, 15),+(# Queens, # Attacking Pieces)),*(*(# Attacking Pieces, # Attacked Pieces),*(# Bishops, # Queens)))

8 th Generation (White) vs. 1 st Generation (Black)

But What About Humans?
These programs are designed to play each other, and therefore many flaws may go undiscovered until humans play some of the games
It is possible to incorporate a Java Chess Applet into the genetic functions, allowing human players to affect the outcome

Future Work
More Expressivity in Function Set
Conditionals
Better Chess functions
Time
 pruning
Human Java Applet interface
FICS interface (freechess.org)
Parallel computing ability
Use FICS?

http://www.caswenson.com	33
http://www.slideshare.net	9
http://www.health.medicbd.com	1

Better Chess through Genetic Programming

by caswenson on May 17, 2009

Accessibility

Categories

Tags

Upload Details

Usage Rights

3 Embeds 43

Statistics

Better Chess through Genetic Programming — Presentation Transcript