private static PsoParameters SetupOptimizer(PsoParameters initialSettings, out FitnessFunction function)
{
var particlesNum = initialSettings.ParticlesCount;
var settings = initialSettings;
settings.TargetValueCondition = false;
settings.IterationsLimitCondition = true;
function = new FitnessFunction(Problem.evaluateFunction);
FunctionFactory.SaveToCache(Problem.Id, function);
var upper = Problem.getLargestValuesOfInterest();
var bounds =
Problem.getSmallestValuesOfInterest()
.Select((x, i) => new DimensionBound(x, upper[i]))
.ToArray();
function.FitnessDim = Problem.getNumberOfObjectives();
function.LocationDim = Problem.getDimension();
settings.FunctionParameters = new FunctionParameters
{
Dimension = function.LocationDim,
SearchSpace = bounds,
FitnessFunctionType = Problem.Id
};
settings.FunctionParameters.SearchSpace = bounds;
return(settings);
}
public void StartCalculation(PsoParameters parameters, NetworkNodeInfo mainNodeInfo)
{
Debug.WriteLine("{0}: starting calculations.", Info.Id);
if (StartCalculations != null)
{
StartCalculations(parameters, mainNodeInfo);
}
}
public void Run(PsoParameters psoParameters, NetworkNodeInfo mainNodeInfo)
{
_mainNodeInfo = mainNodeInfo;
if (!_psoController.CalculationsRunning)
{
_psoController.Run(psoParameters, PsoRingManager.GetProxyParticles());
}
}
/// <summary>
/// Creates PsoAlgorithm with specific parameters to solve given problem using precreated particles
/// </summary>
/// <param name="parameters">takes PsoParameters to check what stop conditions are defined.
/// PsoAlgorithm looks for TargetValue, Epsilon, TargetValueCondition, IterationsLimit, IterationsLimitCondition
/// </param>
/// <param name="fitnessFunction">function whose optimum is to be found</param>
/// <param name="particles"> particles traversing the search space </param>
/// <param name="logger"></param>
public PsoAlgorithm(PsoParameters parameters, IFitnessFunction <double[], double[]> fitnessFunction, IParticle[] particles, ILogger logger = null)
{
_parameters = parameters;
_fitnessFunction = fitnessFunction;
_particles = particles;
_iteration = 0;
_logger = logger;
_optimizer = PsoServiceLocator.Instance.GetService <IOptimization <double[]> >();
}
public void StartCalculations(PsoParameters parameters, PsoParameters parametersToSend = null)
{
if (_psoController.CalculationsRunning)
{
return;
}
NetworkNodeManager.StartCalculations(parametersToSend ?? parameters);
Run(parameters, NetworkNodeManager.NodeService.Info);
}
public void StartCalculation(PsoParameters parameters, NetworkNodeInfo mainNodeInfo)
{
try
{
Proxy.StartCalculation(parameters, mainNodeInfo);
}
catch
{
}
}
public void StartCalculations(PsoParameters parameters, NetworkNodeInfo target)
{
var client = new TcpNodeServiceClient(target);
try
{
client.StartCalculation(parameters, NodeService.Info);
}
catch
{
Debug.WriteLine("cannot start calculations on {0}", parameters);
}
}
private static List <IParticle> CreateParticles(PsoParameters parameters, IFitnessFunction <double[], double[]> function)
{
var particles = new List <IParticle>();
foreach (var particle in parameters.Particles)
{
for (int i = 0; i < particle.Count; i++)
{
var p = ParticleFactory.Create(particle.ParticleType, parameters.FunctionParameters.Dimension, 1, function, parameters.Epsilon, parameters.ParticleIterationsToRestart, parameters.FunctionParameters.SearchSpace);
particles.Add(p);
}
}
return(particles);
}
private List <IParticle> PrepareParticles(PsoParameters psoParameters, IParticle[] proxyParticleServices, CudaParticle cudaParticle)
{
var particles = CreateParticles(psoParameters, _function);
if (proxyParticleServices != null)
{
particles.AddRange(proxyParticleServices);
}
if (cudaParticle != null)
{
particles.Add(cudaParticle);
}
return(particles);
}
public void StartCalculations(PsoParameters parameters)
{
foreach (var client in NodeServiceClients)
{
try
{
client.StartCalculation(parameters, NodeService.Info);
}
catch
{
Debug.WriteLine("cannot start calculations on {0}", parameters);
}
}
}
public void Run(PsoParameters psoParameters, IParticle[] proxyParticleServices = null)
{
_function = FunctionFactory.GetFitnessFunction(psoParameters.FunctionParameters);
var useGpu = psoParameters.GpuParameters.UseGpu && GpuController.AnySupportedGpu();
CudaParticle cudaParticle = null;
if (useGpu)
{
cudaParticle = PrepareCudaAlgorithm(psoParameters);
}
var particles = PrepareParticles(psoParameters, proxyParticleServices, cudaParticle);
RunningParameters = psoParameters;
_algorithm = new PsoAlgorithm(psoParameters, _function, particles.ToArray());
_cudaReadyLock = new AutoResetEvent(false);
if (useGpu)
{
RunningCudaAlgorithm = Task <ParticleState> .Factory.StartNew(() =>
{
_cudaAlgorithm.Initialize();
_cudaReadyLock.Set();
var result = _cudaAlgorithm.Run(_cudaTokenSource.Token);
_function.Evaluate(result.Location);
_cudaAlgorithm.Dispose();
return(result);
}, _cudaTokenSource.Token);
}
else
{
_cudaReadyLock.Set();
}
RunningAlgorithm = Task <ParticleState> .Factory.StartNew(delegate
{
_cudaReadyLock.WaitOne();
_cudaReadyLock.Dispose();
return(StartAlgorithm(_tokenSource.Token));
}, _tokenSource.Token);
}
private CudaParticle PrepareCudaAlgorithm(PsoParameters psoParameters)
{
var parts = psoParameters.FunctionParameters.FitnessFunctionType.Split('_');
var functionNr = int.Parse(parts[1].Substring(1));
var instanceStr = parts[2];
var instanceNr = int.Parse(instanceStr.Substring(1));
var gpu = GpuController.Setup(
new CudaParams
{
FitnessFunction = _function,
FitnessDimensions = 1,
LocationDimensions = psoParameters.FunctionParameters.Dimension,
FunctionNumber = functionNr,
InstanceNumber = instanceNr,
Iterations = psoParameters.GpuParameters.Iterations,
ParticlesCount = psoParameters.GpuParameters.ParticlesCount,
SyncWithCpu = true
});
_cudaAlgorithm = gpu.Item2;
return(gpu.Item1);
}
public void StartPsoAlgorithm(PsoParameters parameters, PsoParameters paramsToSend = null)
{
_vCpuManagers[0].StartCalculations(parameters, paramsToSend);
}
