/** * 'Learns' the factors that are good. More of, just iterate over all possible heuristic weight * combinations and you have to observe which ones are good. * * <p>This learning does not utilise backtracking - it sticks to using one weight only. * * @param b The board to learn against * @param learnClose Whether we are learning for the 'close' weight factors or not. */ public void learn_factors(Board b, boolean learnClose) { int[] fl = learnClose ? closefactors : factors; int[] best = new int[fl.length]; int best_score = -1; Board best_board = null; ExecutorService pool = Executors.newFixedThreadPool(nThreads); for (int i = learning_starts[0]; i < 19; i++) { for (int j = learning_starts[1]; j < 19; j++) { for (int k = learning_starts[2]; k < 8; k++) { for (int l = learning_starts[3]; l < 17; l++) { fl[0] = i; fl[1] = j; fl[2] = k; fl[3] = l; Board n = solve_pndfs(b, pool); int score = n.score(); if (score > best_score) { System.arraycopy(factors, 0, best, 0, best.length); best_score = score; best_board = n; } System.out.printf("Current score: %d (%d moves)\n", score, n.nMoves()); for (int v : fl) { System.out.printf("%d ", v); } System.out.println(); } if (best_board != null) { System.out.println("Current best:"); System.out.println(best_board); System.out.printf("%d (%d moves)\n", best_board.score(), best_board.nMoves()); } for (int v : best) { System.out.printf("%d ", v); } System.out.println(); } } } for (int v : best) System.out.printf("%d ", v); System.out.println(); pool.shutdown(); }
// Edge case: As we're approaching the end of a sequence, try to maximise score... // Possible change to ncombinable: Weight combinables that increase the score significantly private int evaluate(Board b) { int[] thefactors = currentfactors; // We are close to the end of the sequence! Use different weights! if (b.nMoves() + MAX_DEPTH * 2 >= tileSequence.length) { // System.err.println(b.nMoves()); thefactors = closefactors; } return ((int) Math.pow(4, b.dof())) + thefactors[0] * b.zeros() + thefactors[1] * b.checkerboarding3() + thefactors[2] * b.smoothness() + thefactors[3] * b.nCombinable(); }
/** * Solves a board game using a depth-limited depth first search. Also makes use of some * backtracking to further optimise the result. Will also attempt to run multithreadedly. * * @param s The tile sequence * @param b The board to search * @return The final best board state that it can find. */ private Board solve_mdfs(Board b) { Ringbuffer<Board> rb = new Ringbuffer<>(6); Board current = b, choke_best = null; char fc = 0, foff = 0; // VTEC just kicked in yo ExecutorService pool = Executors.newFixedThreadPool(nThreads); fbest_score = -1; fbest = null; while (current != null && !current.finished()) { rb.push(current); current = solve_pdfs(current, pool); if (choke_best != null && choke_best != fbest) { log_info( "Recovery!: [%d:%s] %d(%d) --> %d(%d)", (int) fc, Arrays.toString(currentfactors), choke_best.score(), choke_best.nMoves(), fbest.score(), fbest.nMoves()); choke_best = null; // Test: Is it always best to stick to 18,2,2,9 where possible? // Maybe not, but some factors shouldn't be used for extended periods of time. if (fc > 3) { log_info( "Volatile weights were used; switching back to %s", Arrays.toString(choicefactors[0])); fc = 0; currentfactors = choicefactors[0]; } } if (current != null) { log_info(current); } else if (fbest != null && fbest.nMoves() < tileSequence.length) { current = rb.pop(); if (choke_best != fbest) { choke_best = fbest; foff = 1; fc = (char) ((fc + 1) % choicefactors.length); currentfactors = choicefactors[fc]; log_info("Dead-end, back-tracking two steps and trying with different weights!"); log_info( "Starting index: %d (current score %d/%d)", (int) fc, current.score(), current.nMoves()); } else if (foff++ < choicefactors.length - 1) { fc = (char) ((fc + 1) % choicefactors.length); currentfactors = choicefactors[fc]; log_info("No improvement, trying factor index %d...", (int) fc); } else { current = null; log_info("Factor exhaustion"); } } } pool.shutdown(); return fbest == null ? b : fbest; }