Esempio n. 1
0
        public EvolutionEngine(int maximumNumberOfGenerations, FitnessEvaluator fitnessEvaluator, PopulationMutator populationMutator, IFittestIdentifier fittestIdentifier)
        {
            if (maximumNumberOfGenerations <= 0)
            {
                throw new ArgumentOutOfRangeException(nameof(maximumNumberOfGenerations));
            }

            _maximumNumberOfGenerations = maximumNumberOfGenerations;
            _fitnessEvaluator           = fitnessEvaluator;
            _populationMutator          = populationMutator;
            _fittestIdentifier          = fittestIdentifier;
        }
Esempio n. 2
0
        public IMeal Solve(IEnumerable <DietaryReferenceIntake> maxWeight, IEnumerable <Food> items, int iterationCount)
        {
            MaxWeight      = maxWeight;
            Items          = items;
            IterationCount = iterationCount;

            var population = PopulationInitializer.InitializePopulation(MaxWeight, items);

            for (int i = 0; i < IterationCount; i++)
            {
                if (IsDebug)
                {
                    Console.WriteLine($"{population.GetFittest().TotalCostSum:F2}");
                }

                population.RemoveNotFit();
                PopulationCrossoverer.CrossoverPopulation(population);
                PopulationMutator.MutatePopulation(population);
                population.MergeNewGeneration();
            }

            return(population.GetFittest());
        }
Esempio n. 3
0
        public static int Run(ProgramSettings settings)
        {
            ThreadPool.SetMaxThreads(Environment.ProcessorCount, Environment.ProcessorCount);

            PrintSettings(settings);

            (var trainDataset, var testDataset) = DatasetLoader.LoadDatasets(
                trainDataFilename: settings.TrainDataPath,
                trainLabelsFilename: settings.TrainLabelsPath,
                testDataFilename: settings.TestDataPath,
                testLabelsFilename: settings.TestLabelsPath,
                classificationType: settings.ClassificationType);

            Console.WriteLine();
            PrintTrainDatasetInformation(trainDataset);
            Console.WriteLine();

            var hyperRectangleCoverageComputer = new HyperRectangleCoverageComputer(dataset: trainDataset);

            var featureTestIntervalConveter = new FeatureTestDimensionIntervalConverter(trainDataset);

            var ruleAntecedentHyperRectangleConverter = new RuleAntecedentHyperRectangleConverter(featureTestIntervalConveter);

            var seedSelector = new CFSBESeedFinder(
                ruleConverter: ruleAntecedentHyperRectangleConverter,
                coverageComputer: hyperRectangleCoverageComputer);

            var antecedentCreator = new AntecedentCreator(ruleAntecedentHyperRectangleConverter: ruleAntecedentHyperRectangleConverter);

            var consequentCreator = settings.ClassificationType switch
            {
                ClassificationType.SingleLabel => (IConsequentCreator) new SingleLabelConsequentCreator(dataset: trainDataset),
                ClassificationType.MultiLabel => (IConsequentCreator) new MultiLabelConsequentCreator(dataset: trainDataset, threshold: settings.RuleConsequentThreshold),
                _ => throw CommonExceptions.UnknownClassificationType,
            };

            var hyperRectangleIntersector            = new HyperRectangleIntersector(trainDataset);
            var nonIntersectingHyperRectangleCreator = new NonIntersectingRectangleCreator(hyperRectangleIntersector);

            var ruleCreator = new CoverageAwareRuleCreator(
                seedSelector: seedSelector,
                boxConverter: ruleAntecedentHyperRectangleConverter,
                boxCreator: nonIntersectingHyperRectangleCreator,
                coverageComputer: hyperRectangleCoverageComputer,
                antecedentCreator: antecedentCreator,
                consequentCreator: consequentCreator,
                hyperRectangleIntersector: hyperRectangleIntersector,
                targetNumberOfInstancesToCover: settings.TargetNumberOfInstancesToCoverDuringRuleCreationg,
                runExpensiveSanityChecks: settings.SkipExpensiveSanityChecks);

            var individualMutationChooser = BiasedOptionChooser <IndividualMutationType> .Create(
                new Dictionary <IndividualMutationType, int>() {
                [IndividualMutationType.AddRule]    = settings.IndividualMutationAddRuleWeight,
                [IndividualMutationType.ModifyRule] = settings.IndividualMutationModifyRuleWeight,
                [IndividualMutationType.RemoveRule] = settings.IndividualMutationRemoveRuleWeight
            });

            var ruleSwappingindividualMutator = new RuleSwappingIndividualMutator(
                mutationChooser: individualMutationChooser,
                ruleCreator: ruleCreator);

            var populationMutator = new PopulationMutator(
                individualMutator: ruleSwappingindividualMutator,
                mutantsPerGeneration: settings.MutantsPerGeneration,
                maximumFailedAttemptsPerGeneration: settings.MaximumFailedMutationAttemptsPerGeneration);

            var trainMetrics = IMetricParser.ParseMetrics(
                dataset: trainDataset,
                metricsNames: settings.MetricNames,
                classificationType: settings.ClassificationType);

            var trainFitnessEvaluator = new FitnessEvaluator(trainMetrics);

            var testMetrics = IMetricParser.ParseMetrics(
                dataset: testDataset,
                metricsNames: settings.MetricNames,
                classificationType: settings.ClassificationType);

            var testFitnessEvaluator = new FitnessEvaluator(testMetrics);

            var fittestIdentifier = IFittestIdentifierParser.Parse(
                name: settings.SelectionAlgorithm,
                fittestCount: settings.PopulationSize);

            var individualCreator = new SingleRuleIndividualCreator(ruleCreator: ruleCreator);

            var initialPopulation = CreateInitialPopulation(
                individualCreator: individualCreator,
                settings: settings);

            var modelSerializer = new ModelSerializer();

            var populationFitnessSerializer = new PopulationFitnessSerializer(
                trainFitnessEvaluator: trainFitnessEvaluator,
                testFitnessEvaluator: testFitnessEvaluator);

            var trainPredictionsSerializer = new PredictionsSerializer(dataset: trainDataset);
            var testPredictionsSerializer  = new PredictionsSerializer(dataset: testDataset);

            var persistentOutputManager = new PersistentOutputManager(
                outputDirectory: settings.OutputDirectory,
                saveModels: settings.SaveModels,
                saveTrainPredictions: settings.SaveTrainPredictions,
                saveTestPredictions: settings.SaveTestPredictions,
                modelSerializer: modelSerializer,
                populationFitnessSerializer: populationFitnessSerializer,
                trainPredictionsSerializer: trainPredictionsSerializer,
                testPredictionsSerializer: testPredictionsSerializer);

            //var consistencyChecker = new RuleConsistencyChecker(
            //	ruleAntecedentHyperRectangleConverterconverter: ruleAntecedentHyperRectangleConverter,
            //	hyperRectangleIntersector: hyperRectangleIntersector);

            var evolutionEngine = new EvolutionEngine(
                maximumNumberOfGenerations: settings.MaximumGenerations,
                fitnessEvaluator: trainFitnessEvaluator,
                populationMutator: populationMutator,
                fittestIdentifier: fittestIdentifier);

            var lastGenerationSummary = evolutionEngine.Run(initialPopulation);

            if (lastGenerationSummary.GenerationNumber == settings.MaximumGenerations)
            {
                Console.WriteLine($"Evolution cycle stopped. Reason: maximum number of generations reached.");
            }
            else
            {
                Console.WriteLine($"Evolution cycle stopped. Reason: maximum number of generations reached.");
            }

            persistentOutputManager.SaveWhatMustBeSaved(population: lastGenerationSummary.Population);

            Console.WriteLine("Done.");

            return(0);
        }