forked from science-ation/science-ation
413 lines
11 KiB
PHP
413 lines
11 KiB
PHP
<?
|
|
|
|
/*
|
|
* This file is part of the 'Science Fair In A Box' project
|
|
* Science-ation Website: https://science-ation.ca/
|
|
*
|
|
* Copyright (C) 2005-2008 Sci-Tech Ontario Inc <info@scitechontario.org>
|
|
* Copyright (C) 2008-2012 Youth Science Ontario <info@youthscienceontario.ca>
|
|
* Copyright (C) 2005-2012 James Grant <james@lightbox.org>
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public
|
|
* License as published by the Free Software Foundation, version 2.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; see the file COPYING. If not, write to
|
|
* the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
* Boston, MA 02111-1307, USA.
|
|
*/
|
|
?>
|
|
<?
|
|
|
|
class annealer
|
|
{
|
|
var $num_buckets;
|
|
var $bucket;
|
|
var $bucket_cost;
|
|
var $bucket_cost_new;
|
|
var $cost;
|
|
|
|
var $start_temp,
|
|
$start_moves;
|
|
|
|
var $cost_function_callback;
|
|
var $pick_move_callback;
|
|
var $update_callback;
|
|
var $delta_cost_bucket_ids_callback;
|
|
var $iterations;
|
|
var $items_per_bucket;
|
|
var $max_items_per_bucket;
|
|
var $rate;
|
|
var $move_bucket_ids;
|
|
|
|
function annealer(
|
|
$num_buckets,
|
|
$start_temp,
|
|
$start_moves,
|
|
$rate,
|
|
$cost_function_cb,
|
|
$items
|
|
) {
|
|
$this->num_buckets = $num_buckets;
|
|
$this->start_temp = $start_temp;
|
|
$this->start_moves = $start_moves;
|
|
$this->cost_function_callback = $cost_function_cb;
|
|
unset($this->pick_move_callback);
|
|
unset($this->update_callback);
|
|
unset($this->delta_cost_bucket_ids_callback);
|
|
|
|
$this->bucket_cost = array();
|
|
$this->bucket_cost_old = array();
|
|
$this->bucket = array();
|
|
$this->iterations = 0;
|
|
$this->items_per_bucket = ceil(count($items) / $num_buckets);
|
|
$this->rate = $rate;
|
|
$this->max_items_per_bucket = 0;
|
|
$ipb = ceil($this->items_per_bucket);
|
|
$i = 0;
|
|
$this->cost = 0;
|
|
/* Assign to buckets */
|
|
for ($x = 0; $x < $num_buckets; $x++) {
|
|
unset($b);
|
|
$b = array();
|
|
for ($y = 0; $y < $ipb; $y++) {
|
|
if ($i == count($items))
|
|
break;
|
|
$b[] = $items[$i];
|
|
$i++;
|
|
}
|
|
$this->bucket[] = $b;
|
|
}
|
|
|
|
/* Then do costs after all bucket assignments are done */
|
|
for ($x = 0; $x < $num_buckets; $x++) {
|
|
$c = $this->cost_function($x);
|
|
$this->bucket_cost[] = $c;
|
|
$this->cost += $c;
|
|
}
|
|
TRACE("Annealer setup: T={$this->start_temp}, "
|
|
. "M={$this->start_moves}, Bkts={$this->num_buckets}, "
|
|
. "Cost={$this->cost}\n");
|
|
}
|
|
|
|
function set_pick_move($func)
|
|
{
|
|
$this->pick_move_callback = $func;
|
|
}
|
|
|
|
function set_update_callback($func)
|
|
{
|
|
$this->update_callback = $func;
|
|
}
|
|
|
|
function set_delta_cost_bucket_ids_callback($func)
|
|
{
|
|
$this->delta_cost_bucket_ids_callback = $func;
|
|
}
|
|
|
|
function set_max_items_per_bucket($num)
|
|
{
|
|
$this->max_items_per_bucket = $num;
|
|
}
|
|
|
|
function pick_move()
|
|
{
|
|
/* Pick a bucket and item */
|
|
while (1) {
|
|
$b1 = rand(0, $this->num_buckets - 1);
|
|
if (count($this->bucket[$b1]) > 0)
|
|
break;
|
|
}
|
|
$i1 = rand(0, count($this->bucket[$b1]) - 1);
|
|
|
|
/* Pick a second bucket that is different than the first */
|
|
$b2 = rand(0, $this->num_buckets - 2);
|
|
if ($b2 >= $b1)
|
|
$b2++;
|
|
|
|
if ($this->max_items_per_bucket > 0 && count($this->bucket[$b2]) >= $this->max_items_per_bucket) {
|
|
/*
|
|
* Can't move b1 into b2, it would exceed the max items per bucket, pick an
|
|
* item to swap with
|
|
*/
|
|
$i2 = rand(0, count($this->bucket[$b2]) - 1);
|
|
} else {
|
|
/* Pick an item, or a blank, in the second bucket */
|
|
$i2 = rand(0, count($this->bucket[$b2]));
|
|
if ($i2 == count($this->bucket[$b2]))
|
|
$i2 = -1;
|
|
}
|
|
// TRACE("Move ($b1,$i1)<->($b2,$i2)\n");
|
|
return array($b1, $i1, $b2, $i2);
|
|
}
|
|
|
|
function cost_function($b)
|
|
{
|
|
$bkt = $this->bucket[$b];
|
|
$cb = $this->cost_function_callback;
|
|
$c = $cb($this, $b, $bkt);
|
|
// $this->print_bucket($b);
|
|
// print("Computed cost to be: $c\n");
|
|
return $c;
|
|
}
|
|
|
|
function compute_delta_cost($move)
|
|
{
|
|
list($b1, $i1, $b2, $i2) = $move;
|
|
|
|
if ($b1 == $b2) {
|
|
echo "Called on same bucket, not supported!\n";
|
|
exit;
|
|
// return $this->compute_delta_cost_same_bucket($move);
|
|
}
|
|
|
|
$cost = 0;
|
|
|
|
/* Save the old lists for easy restore */
|
|
$b1_old = $this->bucket[$b1];
|
|
$b2_old = $this->bucket[$b2];
|
|
|
|
/* Setup new costs */
|
|
$this->bucket_cost_new = $this->bucket_cost;
|
|
|
|
/* Compute new lists with swapped elements */
|
|
if ($i2 != -1) { /* Swap */
|
|
array_splice($this->bucket[$b1], $i1, 1, $b2_old[$i2]);
|
|
array_splice($this->bucket[$b2], $i2, 1, $b1_old[$i1]);
|
|
} else { /* Move one to other */
|
|
array_splice($this->bucket[$b1], $i1, 1);
|
|
$this->bucket[$b2][] = $b1_old[$i1];
|
|
}
|
|
|
|
/*
|
|
* Get the lists of buckets we need to recompute, by default
|
|
* just b1 and b2
|
|
*/
|
|
if (isset($this->delta_cost_bucket_ids_callback)) {
|
|
$cb = $this->delta_cost_bucket_ids_callback;
|
|
$ids = $cb($this, $b1);
|
|
$ids = array_unique(array_merge($ids, $cb($this, $b2)), SORT_NUMERIC);
|
|
} else {
|
|
$ids = array($b1, $b2);
|
|
}
|
|
|
|
// TRACE("Recompute IDs:\n");
|
|
// TRACE_R($ids);
|
|
|
|
/* Save that list */
|
|
$this->move_bucket_ids = $ids;
|
|
|
|
/* Compute a delta cost, recompute all costs for all buckets */
|
|
foreach ($ids as $bucket_id) {
|
|
/* Compute costs */
|
|
$cost -= $this->bucket_cost[$bucket_id];
|
|
$this->bucket_cost_new[$bucket_id] = $this->cost_function($bucket_id);
|
|
$cost += $this->bucket_cost_new[$bucket_id];
|
|
}
|
|
|
|
/* Save the new lists */
|
|
$b1_new = $this->bucket[$b1];
|
|
$b2_new = $this->bucket[$b2];
|
|
|
|
/* Return to the original bucket lists */
|
|
$this->bucket[$b1] = $b1_old;
|
|
$this->bucket[$b2] = $b2_old;
|
|
|
|
return array($cost, array($b1_new, $b2_new));
|
|
}
|
|
|
|
/*
|
|
* function compute_delta_cost_same_bucket($move)
|
|
* {
|
|
* list($b1, $i1, $b2, $i2) = $move;
|
|
*
|
|
* $cost = 0;
|
|
*
|
|
* $b_old = $this->bucket[$b1];
|
|
*
|
|
* $b_new = array();
|
|
* /* Make a new bucket list
|
|
* for($x=0; $x<count($b_old); $x++) {
|
|
* if($x == $i1) {
|
|
* /* Swap or remove this index
|
|
* if($i2 != -1) $b_new[] = $b_old[$i2];
|
|
* } else if($x == $i2) {
|
|
* $b_new[] = $b_old[$i1];
|
|
* } else {
|
|
* $b_new[] = $b_old[$x];
|
|
* }
|
|
* }
|
|
*
|
|
* /* Assign the new item lists to the buckets
|
|
* $this->bucket[$b1] = $b_new;
|
|
*
|
|
* /* Compute costs
|
|
* $cost -= $this->bucket_cost[$b1];
|
|
*
|
|
* $c1 = $this->cost_function($b1);
|
|
* $cost += $c1;
|
|
*
|
|
* /* Return to the original bucket lists
|
|
* $this->bucket[$b1] = $b_old;
|
|
*
|
|
* return array($cost, array($c1, $b_new, 0, array()));
|
|
* }
|
|
*/
|
|
|
|
function accept_move($move, $movedata)
|
|
{
|
|
list($b1, $i1, $b2, $i2) = $move;
|
|
list($b1_new, $b2_new) = $movedata;
|
|
|
|
$this->bucket[$b1] = $b1_new;
|
|
if ($b1 != $b2)
|
|
$this->bucket[$b2] = $b2_new;
|
|
|
|
$this->bucket_cost = $this->bucket_cost_new;
|
|
}
|
|
|
|
function anneal()
|
|
{
|
|
$temperature = $this->start_temp;
|
|
$current_cost = $this->cost;
|
|
$last_cost = 0;
|
|
$last_cost_count = 0;
|
|
|
|
if ($this->num_buckets <= 1) {
|
|
TRACE("Only one Bucket, nothing to anneal.\n");
|
|
return;
|
|
}
|
|
// $this->print_buckets();
|
|
$estimated_iterations = ceil(log(0.1 / $this->start_temp, $this->rate));
|
|
|
|
// print_r($this);
|
|
$iterations = 0;
|
|
while (1) {
|
|
$moves = $this->start_moves;
|
|
for ($m = 0; $m < $moves; $m++) {
|
|
// $this->print_buckets();
|
|
/* Pick 2 moves at random */
|
|
if (isset($this->pick_move_callback)) {
|
|
$cb = $this->pick_move_callback;
|
|
$move = $cb($this);
|
|
} else {
|
|
$move = $this->pick_move();
|
|
}
|
|
/* See what the new cost is compared to the old */
|
|
list($delta_c, $movedata) =
|
|
$this->compute_delta_cost($move);
|
|
|
|
$r = floatval(rand()) / floatval(getrandmax());
|
|
/* Decide if we want to keep it */
|
|
$e = exp(-$delta_c / $temperature);
|
|
// TRACE("r=$r, exp=$e, delta=$delta_c\n");
|
|
if ($r < exp(-$delta_c / $temperature)) {
|
|
/* Yes, we do, record the move */
|
|
$this->accept_move($move, $movedata);
|
|
$current_cost += $delta_c;
|
|
$n_accepted++;
|
|
// if($current_cost < $this->cost)
|
|
$this->cost = $current_cost;
|
|
|
|
// TRACE("Move accepted, cost=$current_cost\n");
|
|
} else {
|
|
// TRACE("Move rejected\n");
|
|
}
|
|
$this->iterations++;
|
|
if ($this->iterations % 10000 == 0) {
|
|
TRACE(" {$this->iterations} iterations, cost={$this->cost}, temperature=$temperature\n");
|
|
// $this->print_buckets();
|
|
}
|
|
|
|
if ($this->cost == 0) {
|
|
/*
|
|
* If we manage to get to a 0 cost
|
|
* solution, don't look any more
|
|
*/
|
|
break;
|
|
}
|
|
}
|
|
$iterations++;
|
|
|
|
if (isset($this->update_callback)) {
|
|
$cb = $this->update_callback;
|
|
$cb($iterations, $estimated_iterations);
|
|
}
|
|
if ($this->cost == 0)
|
|
break;
|
|
|
|
if ($this->cost == $last_cost) {
|
|
$last_cost_count++;
|
|
} else {
|
|
$last_cost = $this->cost;
|
|
$last_cost_count = 0;
|
|
}
|
|
|
|
if ($temperature < 0.1 && $last_cost_count > 10)
|
|
break;
|
|
|
|
// if we go 1 million iterations without changing the cost, lets give up
|
|
if ($last_cost_count > 1000000)
|
|
break;
|
|
|
|
// TRACE("Cost is {$this->cost}\n");
|
|
$temperature *= $this->rate;
|
|
|
|
/*
|
|
* FIXME: README: NOTE: TODO:
|
|
* From Kris, 2009-03-24
|
|
* Dave do you think we should consider something like this?
|
|
*
|
|
* <Kris_School_1> here's the schedule i use in my academic annealer:
|
|
* if( _params._useVPRTempSchedule ) {
|
|
* // This is VPR's temperature schedule...
|
|
* if( successRate > 0.96 ) {
|
|
* _temp *= 0.5;
|
|
* } else if( successRate > 0.8 ) {
|
|
* _temp *= 0.9;
|
|
* } else if( successRate > 0.15 || !windowsSized ) {
|
|
* _temp *= 0.95;
|
|
* } else {
|
|
* _temp *= 0.8;
|
|
* }
|
|
* } else {
|
|
* // This is identical to Aaarts and Van Laarhaven.
|
|
* real64 kappa = _params._tempReduction; // 1.0 == slow, 10 = reasonable, 100 == fast
|
|
* real64 sqrvar = std::sqrt( variance );
|
|
* if( variance <= EPSNEG || sqrvar <= EPSNEG ) {
|
|
* _temp = 0.;
|
|
* } else {
|
|
* _temp = _temp * ( sqrvar / ( sqrvar + kappa * _temp ) );
|
|
* }
|
|
* }
|
|
*/
|
|
}
|
|
TRACE("Annealing complete. {$this->iterations} iterations. Final cost is {$this->cost}\n");
|
|
}
|
|
|
|
function print_bucket($x)
|
|
{
|
|
$b = $this->bucket[$x];
|
|
print("Bucket $x: (cost: {$this->bucket_cost[$x]})\n");
|
|
print(' ');
|
|
for ($y = 0; $y < count($b); $y++) {
|
|
print("{$b[$y]} ");
|
|
}
|
|
print("\n");
|
|
}
|
|
|
|
function print_buckets()
|
|
{
|
|
for ($x = 0; $x < $this->num_buckets; $x++) {
|
|
$this->print_bucket($x);
|
|
}
|
|
}
|
|
}
|
|
?>
|