AI-ParticleSwarmOptimization
view release on metacpan or search on metacpan
Samples/PSOPlatTest.pl view on Meta::CPAN
-iterations => 500,
-exitPlateau => 1,
-exitPlateauDP => 3,
-exitPlateauBurnin => 100,
-exitPlateauWindow => 60,
);
$pso->init ();
my $fitValue = $pso->optimize ();
my ($best) = $pso->getBestParticles (1);
my ($fit, @values) = $pso->getParticleBestPos ($best);
my $iters = $pso->getIterationCount ();
print $pso->getSeed();
printf ",# Fit %.5f at (%s) after %d iterations\n",
$fit, join (', ', map {sprintf '%.4f', $_} @values), $iters;
sub calcFit {
my @values = @_;
my $offset = int (-@values / 2);
Samples/PSOTest.pl view on Meta::CPAN
$pso->setParams (
-fitFunc => \&calcFit,
-dimensions => 3,
-iterations => 100,
);
for (0 .. 9) {
$pso->init () unless $_ % 5;
my $fitValue = $pso->optimize ();
my ($best) = $pso->getBestParticles (1);
my ($fit, @values) = $pso->getParticleBestPos ($best);
my $iters = $pso->getIterationCount();
printf "Fit %.4f at (%s) after %d iterations\n",
$fit, join (', ', map {sprintf '%.4f', $_} @values), $iters;
}
sub calcFit {
my @values = @_;
my $offset = int (-@values / 2);
TODO list for Perl module AI::ParticleSwarmOptimization
Add more tests
Document optimization engine methods to allow customisation through derivation
Reinit particles using best position and random velocities as option
No search size limit by default
lib/AI/ParticleSwarmOptimization.pm view on Meta::CPAN
"-dimensions must be set to 1 or greater before init or optimize is called"
unless $self->{dimensions} and $self->{dimensions} >= 1;
my $seed =
int (exists $self->{randSeed} ? $self->{randSeed} : rand (0xffffffff));
$self->{rndGen} = Math::Random::MT->new ($seed);
$self->{usedRandSeed} = $seed;
$self->{prtcls} = [];
$self->{bestBest} = undef;
$self->{bestBestByIter} = undef;
$self->{bestsMean} = 0;
$self->_initParticles ();
$self->{iterCount} = 0;
# Normalise weights.
my $totalWeight =
$self->{inertia} + $self->{themWeight} + $self->{meWeight};
$self->{inertia} /= $totalWeight;
$self->{meWeight} /= $totalWeight;
$self->{themWeight} /= $totalWeight;
lib/AI/ParticleSwarmOptimization.pm view on Meta::CPAN
my ($self, $iterations) = @_;
$iterations ||= $self->{iterations};
$self->init () unless $self->{prtcls};
return $self->_swarm ($iterations);
}
sub getBestParticles {
my ($self, $num) = @_;
my @bests = 0 .. $self->{numParticles} - 1;
my $prtcls = $self->{prtcls};
@bests = sort {$prtcls->[$a]{bestFit} <=> $prtcls->[$b]{bestFit}} @bests;
$num ||= 1;
return @bests[0 .. $num - 1];
}
sub getParticleBestPos {
my ($self, $prtcl) = @_;
return undef if $prtcl >= $self->{numParticles};
$prtcl = $self->{prtcls}[$prtcl];
return ($prtcl->{bestFit}, @{$prtcl->{bestPos}});
}
sub getIterationCount {
my ($self) = @_;
return $self->{iterCount};
}
lib/AI/ParticleSwarmOptimization.pm view on Meta::CPAN
$prtcl->{velocity}[$d] =
$self->{randStartVelocity}
? $self->_randInRange (-$self->{deltaMax}, $self->{deltaMax})
: 0;
}
$prtcl->{currFit} = $self->_calcPosFit ($prtcl->{currPos});
$self->_calcNextPos ($prtcl);
unless (defined $prtcl->{bestFit}) {
$prtcl->{bestPos}[$_] =
$self->_randInRange ($self->{posMin}, $self->{posMax})
for 0 .. $self->{dimensions} - 1;
$prtcl->{bestFit} = $self->_calcPosFit ($prtcl->{bestPos});
}
}
sub _calcPosFit {
my ($self, $pos) = @_;
return $self->{fitFunc}->(@{$self->{fitParams}}, @$pos);
}
sub _swarm {
my ($self, $iterations) = @_;
for my $iter (1 .. $iterations) {
++$self->{iterCount};
last if defined $self->_moveParticles ($iter);
$self->_updateVelocities ($iter);
next if !$self->{exitPlateau} || !defined $self->{bestBest};
if ($iter >= $self->{exitPlateauBurnin} - $self->{exitPlateauWindow}) {
my $i = $iter % $self->{exitPlateauWindow};
$self->{bestsMean} -= $self->{bestBestByIter}[$i]
if defined $self->{bestBestByIter}[$i];
$self->{bestsMean} += $self->{bestBestByIter}[$i] =
$self->{bestBest} / $self->{exitPlateauWindow};
}
next if $iter <= $self->{exitPlateauBurnin};
#Round to the specified number of d.p.
my $format = "%.$self->{exitPlateauDP}f";
my $mean = sprintf $format, $self->{bestsMean};
my $current = sprintf $format, $self->{bestBest};
#Check if there is a sufficient plateau - stopping iterations if so
last if $mean == $current;
}
return $self->{bestBest};
}
sub _moveParticles {
my ($self, $iter) = @_;
print "Iter $iter\n" if $self->{verbose} & kLogIter;
for my $prtcl (@{$self->{prtcls}}) {
@{$prtcl->{currPos}} = @{$prtcl->{nextPos}};
$prtcl->{currFit} = $prtcl->{nextFit};
my $fit = $prtcl->{currFit};
if ($self->_betterFit ($fit, $prtcl->{bestFit})) {
# Save position - best fit for this particle so far
$self->_saveBest ($prtcl, $fit, $iter);
}
return $fit if defined $self->{exitFit} and $fit < $self->{exitFit};
next if !($self->{verbose} & kLogIterDetail);
printf "Part %3d fit %8.2f", $prtcl->{id}, $fit
if $self->{verbose} >= 2;
printf " (%s @ %s)",
join (', ', map {sprintf '%5.3f', $_} @{$prtcl->{velocity}}),
lib/AI/ParticleSwarmOptimization.pm view on Meta::CPAN
print "\n";
}
return undef;
}
sub _saveBest {
my ($self, $prtcl, $fit, $iter) = @_;
# for each dimension, set the best position as the current position
@{$prtcl->{bestPos}} = @{$prtcl->{currPos}};
$prtcl->{bestFit} = $fit;
return if !$self->_betterFit ($fit, $self->{bestBest});
if ($self->{verbose} & kLogBetter) {
my $velSq;
$velSq += $_**2 for @{$prtcl->{velocity}};
printf "#%05d: Particle $prtcl->{id} best: %.4f (vel: %.3f)\n",
$iter, $fit, sqrt ($velSq);
}
$self->{bestBest} = $fit;
}
sub _betterFit {
my ($self, $new, $old) = @_;
return !defined ($old) || ($new < $old);
}
sub _updateVelocities {
my ($self, $iter) = @_;
for my $prtcl (@{$self->{prtcls}}) {
my $bestN = $self->{prtcls}[$self->_getBestNeighbour ($prtcl)];
my $velSq;
for my $d (0 .. $self->{dimensions} - 1) {
my $meFactor =
$self->_randInRange (-$self->{meWeight}, $self->{meWeight});
my $themFactor =
$self->_randInRange (-$self->{themWeight}, $self->{themWeight});
my $meDelta = $prtcl->{bestPos}[$d] - $prtcl->{currPos}[$d];
my $themDelta = $bestN->{bestPos}[$d] - $prtcl->{currPos}[$d];
$prtcl->{velocity}[$d] =
$prtcl->{velocity}[$d] * $self->{inertia} +
$meFactor * $meDelta +
$themFactor * $themDelta;
$velSq += $prtcl->{velocity}[$d]**2;
}
my $vel = sqrt ($velSq);
if (!$vel or $self->{stallSpeed} and $vel <= $self->{stallSpeed}) {
lib/AI/ParticleSwarmOptimization.pm view on Meta::CPAN
sub _randInRange {
my ($self, $min, $max) = @_;
return $min + $self->{rndGen}->rand ($max - $min);
}
sub _getBestNeighbour {
my ($self, $prtcl) = @_;
my $bestNFitness;
my $bestNIndex;
for my $neighbor (0 .. $self->{numNeighbors} - 1) {
my $prtclNIndex = ($prtcl + $neighbor) % $self->{numParticles};
if (!defined ($bestNFitness)
|| $self->{prtcls}[$prtclNIndex]{bestFit} < $bestNFitness)
{
$bestNFitness = $self->{prtcls}[$prtclNIndex]{bestFit};
$bestNIndex = $prtclNIndex;
}
}
return $bestNIndex;
}
1;
=head1 NAME
AI::ParticleSwarmOptimization - Particle Swarm Optimization (object oriented)
=head1 SYNOPSIS
use AI::ParticleSwarmOptimization;
my $pso = AI::ParticleSwarmOptimization->new (
fitFunc => \&calcFit,
dimensions => 3,
);
my $fitValue = $pso->optimize ();
my ($best) = $pso->getBestParticles (1);
my ($fit, @values) = $pso->getParticleBestPos ($best);
printf "Fit %.4f at (%s)\n",
$fit, join ', ', map {sprintf '%.4f', $_} @values;
sub calcFit {
my @values = @_;
my $offset = int (-@values / 2);
my $sum;
$sum += ($_ - $offset++) ** 2 for @values;
return $sum;
}
=head1 Description
The Particle Swarm Optimization technique uses communication of the current best
position found between a number of particles moving over a hyper surface as a
technique for locating the best location on the surface (where 'best' is the
minimum of some fitness function). For a Wikipedia discussion of PSO see
http://en.wikipedia.org/wiki/Particle_swarm_optimization.
This pure Perl module is an implementation of the Particle Swarm Optimization
technique for finding minima of hyper surfaces. It presents an object oriented
interface that facilitates easy configuration of the optimization parameters and
(in principle) allows the creation of derived classes to reimplement all aspects
of the optimization engine (a future version will describe the replaceable
engine components).
This implementation allows communication of a local best point between a
selected number of neighbours. It does not support a single global best position
that is known to all particles in the swarm.
=head1 Methods
AI::ParticleSwarmOptimization provides the following public methods. The parameter lists shown
for the methods denote optional parameters by showing them in [].
=over 4
=item new (%parameters)
lib/AI/ParticleSwarmOptimization.pm view on Meta::CPAN
next iteration. Defaults to 0.9
See also I<-meWeight> and I<-themWeight>.
=item I<-iterations>: number, optional
Number of optimization iterations to perform. Defaults to 1000.
=item I<-meWeight>: number, optional
Coefficient determining the influence of the current local best position on the
next iterations velocity. Defaults to 0.5.
See also I<-inertia> and I<-themWeight>.
=item I<-numNeighbors>: positive number, optional
Number of local particles considered to be part of the neighbourhood of the
current particle. Defaults to the square root of the total number of particles.
=item I<-numParticles>: positive number, optional
lib/AI/ParticleSwarmOptimization.pm view on Meta::CPAN
=item I<-stallSpeed>: positive number, optional
Speed below which a particle is considered to be stalled and is repositioned to
a new random location with a new initial speed.
By default I<-stallSpeed> is undefined but particles with a speed of 0 will be
repositioned.
=item I<-themWeight>: number, optional
Coefficient determining the influence of the neighbourhod best position on the
next iterations velocity. Defaults to 0.5.
See also I<-inertia> and I<-meWeight>.
=item I<-exitPlateau>: boolean, optional
Set true to have the optimization check for plateaus (regions where the fit
hasn't improved much for a while) during the search. The optimization ends when
a suitable plateau is detected following the burn in period.
lib/AI/ParticleSwarmOptimization.pm view on Meta::CPAN
If set to a non-zero value I<-verbose> determines the level of diagnostic print
reporting that is generated during optimization.
The following constants may be bitwise ored together to set logging options:
=over 4
=item * kLogBetter
prints particle details when its fit becomes bebtter than its previous best.
=item * kLogStall
prints particle details when its velocity reaches 0 or falls below the stall
threshold.
=item * kLogIter
Shows the current iteration number.
lib/AI/ParticleSwarmOptimization.pm view on Meta::CPAN
Set or change optimization parameters. See I<-new> above for a description of
the parameters that may be supplied.
=item B<init ()>
Reinitialize the optimization. B<init ()> will be called during the first call
to B<optimize ()> if it hasn't already been called.
=item B<optimize ()>
Runs the minimization optimization. Returns the fit value of the best fit
found. The best possible fit is negative infinity.
B<optimize ()> may be called repeatedly to continue the fitting process. The fit
processing on each subsequent call will continue from where the last call left
off.
=item B<getParticleState ()>
Returns the vector of position
=item B<getBestParticles ([$n])>
Takes an optional count.
Returns a list containing the best $n particle numbers. If $n is not specified
only the best particle number is returned.
=item B<getParticleBestPos ($particleNum)>
Returns a list containing the best value of the fit and the vector of its point
in hyper space.
my ($fit, @vector) = $pso->getParticleBestPos (3)
=item B<getIterationCount ()>
Return the number of iterations performed. This may be useful when the
I<-exitFit> criteria has been met or where multiple calls to I<optimize> have
been made.
( run in 0.645 second using v1.01-cache-2.11-cpan-4e96b696675 )