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); }