Пример #1
0
        public void MOFWOptimizerTest2()
        {
            MOFWOptimizer optimizer = new MOFWOptimizer();
            FWParams      param     = new FWParams(20, 5, 0.1, 2, 5, 0.2);

            MOOptimizationProblem problem = new MOOptimizationProblem(
                new List <Func <IReadOnlyList <double>, double> >()
            {
                Obj1,
                Obj2
            },
                Enumerable.Repeat(0.0, 5).ToArray(),
                Enumerable.Repeat(1.0, 5).ToArray()
                );

            optimizer.Minimize(param, problem);

            Assert.True(optimizer.ParetoFront.Count() == param.NP);
        }
Пример #2
0
        private static void Main(string[] args)
        {
            IMOOptProblem problem = new ZDT1(Enumerable.Repeat(0.0, 10).ToArray(), Enumerable.Repeat(1.0, 10).ToArray());

            MOFWOptimizer optimizer = new MOFWOptimizer();

            FWParams parameters = new FWParams(50, 200, 20, 10, 30, 2);

            ProgressReporter reporter = new ProgressReporter();

            optimizer.Minimize(parameters, problem, reporter);

            foreach (Agent agent in optimizer.ParetoFront)
            {
                Console.WriteLine($"F1 = {agent.Objs[0]} F2 = {agent.Objs[1]}");
            }

            Console.ReadKey();
        }
Пример #3
0
        private static void SolveFW(INamedMOProblem Problem, string PathToOutDir, int MaxRun)
        {
            MappedDiagnosticsContext.Set("thread_id", $"_{Thread.CurrentThread.ManagedThreadId}_");

            Logger logger = LogManager.GetLogger("Main");

            const int numParams = 6;

            object[][] parameters =
            {
                //new object[numParams] {250, 600, 10, 20, 30, 1.1},
                new object[numParams] {
                    300, 700, 20, 8, 15, 0.025
                },
                new object[numParams] {
                    300, 1000, 25, 8, 17, 0.05
                },
                new object[numParams] {
                    400, 900, 15, 8, 12, 0.1
                },
                new object[numParams] {
                    350, 750, 20, 10, 19, 0.15
                }
            };

            string pathToXml = Path.Combine(PathToOutDir, $"{Problem.Name}_res.xml");

            logger.Info($"Open a xml file. '{pathToXml}'");

            var normalGen = new NormalGen();
            var contGen   = new ContGen();

            MOFWOptimizer opt = new MOFWOptimizer(contGen, normalGen);

            using (XmlWriter writer = XmlWriter.Create(pathToXml))
            {
                writer.WriteStartDocument();
                writer.WriteStartElement("Problem");

                Dictionary <string, string> problemDesc = new Dictionary <string, string>
                {
                    ["Name"]   = Problem.Name,
                    ["DimDec"] = Problem.LowerBounds.Count.ToString(),
                    ["DimObj"] = Problem.CountObjs.ToString(),
                };

                foreach (var name in problemDesc)
                {
                    writer.WriteAttributeString(name.Key, name.Value);
                }

                writer.WriteStartElement("Bounds");

                foreach (var bound in Problem.LowerBounds.Zip(Problem.UpperBounds, (low, upp) => (Lower: low, Upper: upp)))
                {
                    writer.WriteStartElement("Bound");
                    writer.WriteAttributeString("LowerB", bound.Lower.ToString());
                    writer.WriteAttributeString("UpperB", bound.Upper.ToString());
                    writer.WriteEndElement();
                }

                writer.WriteEndElement();

                logger.Info("Start solving with MOFW.");

                foreach (var par in Enumerable.Range(0, parameters.Length).Zip(parameters, (num, par) => (Num: num, Parameters: par)))
                {
                    logger.Info($"Try to find solution with {par.Num}th configuration of {parameters.Length}");

                    writer.WriteStartElement("Experiment");
                    writer.WriteStartElement("OptParams");

                    FWParams pars = CreateParams <FWParams>(par.Parameters);

                    var paramsType = pars.GetType();

                    foreach (var prop in paramsType.GetProperties())
                    {
                        if (prop.PropertyType == typeof(bool))
                        {
                            continue;
                        }

                        writer.WriteStartElement("Param");
                        writer.WriteAttributeString(prop.Name, prop.GetValue(pars).ToString());
                        writer.WriteEndElement();
                    }

                    writer.WriteEndElement();

                    writer.WriteStartElement("Runs");

                    for (int i = 0; i < MaxRun; i++)
                    {
                        logger.Info($"Run {i} of {MaxRun}");

                        writer.WriteStartElement("Run");

                        try
                        {
                            opt.Minimize(pars, Problem);

                            writer.WriteStartElement("Decisions");

                            foreach (var agent in opt.ParetoFront)
                            {
                                writer.WriteStartElement("Point");

                                for (int coordIndex = 0; coordIndex < agent.Point.Count; coordIndex++)
                                {
                                    writer.WriteAttributeString($"x{coordIndex + 1}", agent.Point[coordIndex].ToString());
                                }

                                writer.WriteEndElement();
                            }

                            writer.WriteEndElement();

                            writer.WriteStartElement("Targets");

                            foreach (var agent in opt.ParetoFront)
                            {
                                writer.WriteStartElement("Target");

                                for (int coordIndex = 0; coordIndex < agent.Objs.Count; coordIndex++)
                                {
                                    writer.WriteAttributeString($"F{coordIndex + 1}", agent.Objs[coordIndex].ToString());
                                }

                                writer.WriteEndElement();
                            }

                            writer.WriteEndElement();
                        }
                        catch (Exception exc)
                        {
                            logger.Error(exc, "Error was in optimization process.");
                            logger.Info("Recreate optimization method.");
                            opt = new MOFWOptimizer();
                            logger.Info($"Skip run {i}.");
                        }

                        writer.WriteEndElement();
                    }

                    writer.WriteEndElement();
                    writer.WriteEndElement();
                }
            }
            logger.Info("Close a xml file.");

            MappedDiagnosticsContext.Remove("thread_id");
        }