How can I get my GA to converge? - genetic-algorithm

Question

I'm trying to write a GA to solve the following puzzle...
A binary encoding is (I think) very efficient. Each piece can be:
the original way up or flipped - 1 bit
rotated by 0 (ie none), 90, 180 or 270 degs - 2 bits
at position (x, y), where x and y go from 0 to 7 - 3 bits for each co-ordinate
This means that each piece's orientation and position can be encoded in 9 bits, making a total of 117 bits for the whole puzzle.
The fitness is calculated by placing each piece in the frame, ignoring any parts that lie out of the frame, and then adding up the number of empty squares. When that hits zero, we have a solution.
I have some standard GA methods I've used in other code (which I'll paste in below), but I can't seem to get it to converge. The fitness drops to about 11 (give or take), but never seems to go any lower. I've tried fiddling with the parameters, but can't get it any better.
At the risk of posting too much code, I'll show what I've got (where it seems relevant). If anyone can give me some idea how I could improve, it would be great. This is all in C#, but it should be clear enough to people who use other languages.
After generating an initial population of 1000 chromosomes (code not shown as it's just generating random binary strings of length 117), I enter the main loop, where on each generation, I call the Breed method, passing in the current population and some parameters...
private static List<Chromosome> Breed(List<Chromosome> population, int crossoverGene,
double mutationProbability, double mutationRate) {
List<Chromosome> nextGeneration = new List<Chromosome>();
// Cross breed half of the population number
for (int nChromosome = 0; nChromosome < population.Count / 2; nChromosome++) {
Chromosome daddy = Roulette(population);
Chromosome mummy = Roulette(population);
string babyGenes = daddy.Genes.Substring(0, crossoverGene)
+ mummy.Genes.Substring(crossoverGene);
Chromosome baby = new Chromosome(babyGenes);
baby.Fitness = Fitness(baby);
nextGeneration.Add(baby);
}
// Mutate some chromosomes
int numberToMutate = (int)(P() * 100 * mutationProbability);
List<Chromosome> mutatedChromosomes = new List<Chromosome>();
for (int i = 0; i < numberToMutate; i++) {
Chromosome c = Roulette(population);
string mutatedGenes = MutateGenes(c.Genes, mutationRate);
Chromosome mutatedChromosome = new Chromosome(mutatedGenes);
mutatedChromosome.Fitness = Fitness(mutatedChromosome);
mutatedChromosomes.Add(mutatedChromosome);
}
// Get the next generation from the fittest chromosomes
nextGeneration = nextGeneration
.Union(population)
.Union(mutatedChromosomes)
.OrderBy(p => p.Fitness)
.Take(population.Count)
.ToList();
return nextGeneration;
}
MutateGenes just flips bits at random, based on the mutation rate passed in. The main loop continues until we either hit the maximum number of generations, or the fitness drops to zero. I'm currently running for 1000 generations.
Here's the roulette method...
private static Chromosome Roulette(List<Chromosome> population) {
double totalFitness = population.Sum(c => 1 / c.Fitness);
double targetProbability = totalFitness * P();
double cumProbability = 0.0;
List<Chromosome> orderedPopulation = population.OrderBy(c => c.Fitness).ToList();
for (int i = 0; i < orderedPopulation.Count; i++) {
Chromosome c = orderedPopulation[i];
cumProbability += 1 / c.Fitness;
if (cumProbability > targetProbability) {
return c;
}
}
return orderedPopulation.Last();
}
Don't know if you need to see any of the other code. I was a bit wary about posting too much in case it put people off!
Anyone able to make any suggestions as to how I can get this to improve?

Answer 1

Todor Balabanov's answer is very interesting. Probably using relative coordinates and a proper packing function is the keystone.
Anyway I'd like to expand upon your idea as much as possible. A full discussion is probably too long for Stackoverflow...
TL;DR
Binary encoding does not give you any advantage.
The chosen alphabet isn't the smallest that permits a natural expression of the problem.
Considering the full range of coordinates ([0;7] x [0;7]) for every piece is excessive (and somewhat misleading for fitness evaluation).
Points (2) and (3) allow to reduce the search space from 2^117 to 2^95 elements.
A more informative fitness function is a great help.
You can use a multi-value fitness score, penalizing configurations that present holes.
Squares covered by overlapping pieces shouldn't be counted: an illegal configuration cannot have a fitness greater than a legal one.
ALPS can reduce the problem of premature convergence (reference implementation here).
I've have elaborated on these points in a GitHub wiki (it's a work in progress).

Answer 2

If you use genetic algorithms framework like Apache GA Framework you can implement chromosomes as list of shapes and you can use permutation crossover and mutation.
You will have blank spaces, which you will try to minimize (reduce them to 0). It is not a problem that you will have blanks, just count them and include them as penalty component in the fitness function.
Generally GAs are not so strong in combinatorial problems. I did many experiments like solving Rubik’s Cube with GA or solving Puzzle 15 with GA. Another experiment was 2D Optimal Cutting Problem with GA. If you are interested I can provide you the research papers and source code (GitHub). GAs are good giving you sub-optimal solution, but they are not good in giving you the optimal solution, which is even harder when it is a combinatorial problem.
The size of the population is an open question. You should do convergence investigation with different populations. Bigger population does not mean better and faster solution. Even 100 is too much for most of the problems solved with GA.
If you use absolute coordinates you will need to handle x and y, which is too complicated. Imagine that you support list of shapes. Packing procedure can get shape by shape and place each shape as close as possible to already handled shapes. It will speed-up your convergence.
/**
* Pack function which uses bounding rectangle of the polygons in the sheet
* with specified dimensions.
*
* #param width
* Sheet width.
* #param height
* Sheet height.
*/
public void pack1(int width, int height) {
int level[] = new int[width];
for (int i = 0; i < level.length; i++) {
level[i] = 0;
}
/*
* Insure pieces width according sheet width.
*/
for (Piece piece: population.get(worstIndex)) {
if (piece.getWidth() > width) {
piece.flip();
}
}
/*
* Pack pieces.
*/
int x = 0;
int y = 0;
for (Piece piece: population.get(worstIndex)) {
if (x + (int) piece.getWidth() >= width) {
x = 0;
}
/*
* Find y offset for current piece.
*/
y = 0;
for (int dx = x; dx < (x + piece.getWidth()); dx++) {
if (dx < width && y < level[dx]) {
y = level[dx];
}
}
// TODO Check the delta after subtraction.
/*
* Set current piece coordinates.
*/
piece.moveX(x - piece.getMinX());
piece.moveY(y - piece.getMinY());
/*
* Move lines for next placement.
*/
for (int dx = x; dx < (x + piece.getWidth()); dx++) {
if (dx < width) {
level[dx] = (int)(y + piece.getHeight());
}
}
// TODO Some strange behavior with the rotation.
x += (int) piece.getWidth() + 1;
}
}
/**
* Pack function which uses exact boundaries of the polygons in the sheet
* with specified dimensions.
*
* #param width
* Sheet width.
* #param height
* Sheet height.
*/
public void pack2(int width, int height) {
/*
* Pieces already placed on the sheet.
*/
List < Piece > front = new ArrayList < Piece > ();
/*
* Virtual Y boundary.
*/
double level = 0;
/*
* Place all pieces on the sheet
*/
for (Piece current: population.get(worstIndex)) {
double bestLeft = 0;
double bestTop = level;
current.moveX(-current.getMinX());
current.moveY(-current.getMinY() + level);
/*
* Move across sheet width.
*/
while (current.getMaxX() < width) {
/*
* Touch sheet bounds of touch other piece.
*/
while (current.getMinY() > 0 && Util.overlap(current, front) == false) {
current.moveY(-1);
}
// TODO Plus one may be is wrong if the piece should be part of
// the area.
current.moveY(+2);
/*
* Keep the best found position.
*/
if (current.getMinY() < bestTop) {
bestTop = current.getMinY();
bestLeft = current.getMinX();
}
/*
* Try next position on right.
*/
current.moveX(+1);
}
/*
* Put the piece in the best available coordinates.
*/
current.moveX(-current.getMinX() + bestLeft);
current.moveY(-current.getMinY() + bestTop);
/*
* Shift sheet level if the current piece is out of previous bounds.
*/
if (current.getMaxY() > level) {
level = current.getMaxY() + 1;
}
/*
* Add current piece in the ordered set and the front set.
*/
front.add(current);
}
}
/**
* Pack function which uses exact boundaries of the polygons in the sheet
* with specified dimensions.
*
* #param width
* Sheet width.
* #param height
* Sheet height.
*/
public void pack3(int width, int height) {
Polygon stack = new Polygon(
GEOMETRY_FACTORY
.createLinearRing(new Coordinate[] {
new Coordinate(0, -2, 0), new Coordinate(width - 1, -2, 0),
new Coordinate(width - 1, 0, 0), new Coordinate(0, 0, 0), new Coordinate(0, -2, 0)
}),
null, GEOMETRY_FACTORY);
/*
* Virtual Y boundary.
*/
double level = stack.getEnvelopeInternal().getMaxX();
/*
* Place all pieces on the sheet
*/
for (Piece current: population.get(worstIndex)) {
double bestLeft = 0;
double bestTop = level;
current.moveX(-current.getMinX());
current.moveY(-current.getMinY() + level);
/*
* Move across sheet width.
*/
while (current.getMaxX() < width) {
/*
* Touch sheet bounds of touch other piece.
*/
while (current.getMinY() > 0 && Util.overlap(current, stack) == false) {
current.moveY(-1);
}
// TODO Plus one may be is wrong if the piece should be part of
// the area.
current.moveY(+2);
/*
* Keep the best found position.
*/
if (current.getMinY() < bestTop) {
bestTop = current.getMinY();
bestLeft = current.getMinX();
}
/*
* Try next position on right.
*/
current.moveX(+1);
}
/*
* Put the piece in the best available coordinates.
*/
current.moveX(-current.getMinX() + bestLeft);
current.moveY(-current.getMinY() + bestTop);
/*
* Shift sheet level if the current piece is out of previous bounds.
*/
if (current.getMaxY() > level) {
level = current.getMaxY() + 1;
}
/*
* Add current piece in the ordered set and the front set.
*/
stack = (Polygon) SnapOverlayOp.union(stack, current.getPolygon()).getBoundary().convexHull();
stack.normalize();
}
}

Answer 3

You have a very interesting problem to solve. I like it very much. First of all it is a combinatorial problem, which can be very hard to solve with the classical genetic algorithms. I have some comments, but they are my subjective opinion: 1) Binary encoding does not give you any advantage (only overhead for encoding and decoding), you can use C# objects; 2) It is not smart to ignore pieces outside of the frame; 3) You will be trapped in local optimum all the time, this is the nature of genetic algorithms; 4) Population size of 1K is too much, use something smaller; 5) Do not use absolute x-y coordinates, use relative coordinates and proper packing function.