コード例 #1
0
        public void Cross_ParentsWithDiffLength_Cross()
        {
            var target      = new CutAndSpliceCrossover();
            var chromosome1 = MockRepository.GenerateStub <ChromosomeBase>(4);

            chromosome1.ReplaceGenes(0, new Gene[]
            {
                new Gene(1),
                new Gene(2),
                new Gene(3),
                new Gene(4),
            });
            chromosome1.Expect(c => c.CreateNew()).Return(MockRepository.GenerateStub <ChromosomeBase>(4));

            var chromosome2 = MockRepository.GenerateStub <ChromosomeBase>(5);

            chromosome2.ReplaceGenes(0, new Gene[]
            {
                new Gene(5),
                new Gene(6),
                new Gene(7),
                new Gene(8),
                new Gene(9),
            });
            chromosome2.Expect(c => c.CreateNew()).Return(MockRepository.GenerateStub <ChromosomeBase>(5));

            var repository = new MockRepository();
            var rnd        = repository.StrictMock <IRandomization>();

            using (repository.Ordered())
            {
                rnd.Expect(r => r.GetInt(1, 4)).Return(2);
                rnd.Expect(r => r.GetInt(1, 5)).Return(2);
            }

            repository.ReplayAll();

            RandomizationProvider.Current = rnd;

            var actual = target.Cross(new List <IChromosome>()
            {
                chromosome1, chromosome2
            });

            Assert.AreEqual(2, actual.Count);
            Assert.AreEqual(5, actual[0].Length);
            Assert.AreEqual(4, actual[1].Length);

            Assert.AreEqual(1, actual[0].GetGene(0).Value);
            Assert.AreEqual(2, actual[0].GetGene(1).Value);
            Assert.AreEqual(3, actual[0].GetGene(2).Value);
            Assert.AreEqual(8, actual[0].GetGene(3).Value);
            Assert.AreEqual(9, actual[0].GetGene(4).Value);

            Assert.AreEqual(5, actual[1].GetGene(0).Value);
            Assert.AreEqual(6, actual[1].GetGene(1).Value);
            Assert.AreEqual(7, actual[1].GetGene(2).Value);
            Assert.AreEqual(4, actual[1].GetGene(3).Value);
        }
コード例 #2
0
        public void Cross_ParentsWithDiffLength_Cross()
        {
            var target      = new CutAndSpliceCrossover();
            var chromosome1 = Substitute.ForPartsOf <ChromosomeBase>(4);

            chromosome1.ReplaceGenes(0, new Gene[]
            {
                new Gene(1),
                new Gene(2),
                new Gene(3),
                new Gene(4),
            });
            chromosome1.CreateNew().Returns(Substitute.ForPartsOf <ChromosomeBase>(4));

            var chromosome2 = Substitute.ForPartsOf <ChromosomeBase>(5);

            chromosome2.ReplaceGenes(0, new Gene[]
            {
                new Gene(5),
                new Gene(6),
                new Gene(7),
                new Gene(8),
                new Gene(9),
            });
            chromosome2.CreateNew().Returns(Substitute.ForPartsOf <ChromosomeBase>(5));

            var rnd = Substitute.For <IRandomization>();

            rnd.GetInt(1, 4).Returns(2);
            rnd.GetInt(1, 5).Returns(2);

            RandomizationProvider.Current = rnd;

            var actual = target.Cross(new List <IChromosome>()
            {
                chromosome1, chromosome2
            });

            Assert.AreEqual(2, actual.Count);
            Assert.AreEqual(5, actual[0].Length);
            Assert.AreEqual(4, actual[1].Length);

            Assert.AreEqual(1, actual[0].GetGene(0).Value);
            Assert.AreEqual(2, actual[0].GetGene(1).Value);
            Assert.AreEqual(3, actual[0].GetGene(2).Value);
            Assert.AreEqual(8, actual[0].GetGene(3).Value);
            Assert.AreEqual(9, actual[0].GetGene(4).Value);

            Assert.AreEqual(5, actual[1].GetGene(0).Value);
            Assert.AreEqual(6, actual[1].GetGene(1).Value);
            Assert.AreEqual(7, actual[1].GetGene(2).Value);
            Assert.AreEqual(4, actual[1].GetGene(3).Value);
        }
コード例 #3
0
ファイル: Program.cs プロジェクト: karolg58/Genetic
        static void Main(string[] args)
        {
            DataModel   data_model   = new DataModel();
            InputReader input_reader = new InputReader();

            ReadWatch.Start();
            // input_reader.ReadDataFromFile("data/me_at_the_zoo.in");
            input_reader.ReadDataFromFile("data/videos_worth_spreading.in");
            // input_reader.ReadDataFromFile("data/trending_today.in");
            // input_reader.ReadDataFromFile("data/kittens.in");
            ReadWatch.Stop();
            Console.WriteLine($"{ReadWatch.ElapsedMilliseconds}");
            var selection = new EliteSelection();
            var crossover = new CutAndSpliceCrossover();
            var mutation  = new AddGenesMutation(10);

            var fitness    = new Fitness();
            var chromosome = new Chromosome(3000);
            var population = new Population(1000, 1000, chromosome);

            var ga = new GeneticAlgorithm(population, fitness, selection, crossover, mutation);

            ga.MutationProbability = 0.25f;
            ga.Termination         = new GenerationNumberTermination(250);
            int i = 0;

            ga.GenerationRan += (_, __) => {
                var bestC = ga.BestChromosome as Chromosome;
                SaveToFile.Save(bestC, @"data\output");
                Console.WriteLine($@"G.num.: {i++}, Fitness: {ga.BestChromosome.Fitness}, Lenght: {ga.BestChromosome.Length}, generation time = {GenerationWatch.ElapsedMilliseconds}, Fitness time = {WholeFitnessWatch.ElapsedMilliseconds}, Fitness percentage: {((float)WholeFitnessWatch.ElapsedMilliseconds/(float)GenerationWatch.ElapsedMilliseconds)}");

                GenerationWatch.Restart();
                WholeFitnessWatch.Reset();
            };

            Console.WriteLine("GA running...");
            GenerationWatch.Start();
            ga.Start();
            Console.WriteLine($"GA done in {ga.GenerationsNumber} generations.");

            var bestChromosome = ga.BestChromosome as Chromosome;

            Console.WriteLine($"Best solution found has fitness: {bestChromosome.Fitness}.");

            Console.WriteLine("Done");
        }
コード例 #4
0
        public void Run()
        {
            var selection  = new InitialStrategySelection();
            var crossover  = new CutAndSpliceCrossover();
            var mutation   = new TworsMutation();
            var fitness    = new InitialStrategyFitness();
            var chromosome = new InitialStrategyChromosome();


            var population = new Population(50, 70, chromosome);

            var ga = new GeneticAlgorithm(population, fitness, selection, crossover, mutation);

            ga.Termination = new FitnessStagnationTermination(20);

            Console.WriteLine("GA running...");
            ga.Start();

            Console.WriteLine("Best solution found has {0} fitness.", ga.BestChromosome.Fitness);
        }
コード例 #5
0
        public void Play2048PatternTest()
        {
            var selection  = new EliteSelection();
            var crossover  = new CutAndSpliceCrossover();
            var mutation   = new PartialShuffleMutation();
            var fitness    = new ClosestToMillion();
            var chromosome = new Play2048Chromosome(20, new List <string>()
            {
                "up", "down", "left", "right"
            });
            var population = new CustomPopulation(2, 4, chromosome);

            var ga = new GeneticAlgorithm(population, fitness, selection, crossover, mutation);

            ga.Termination = new GenerationNumberTermination(10);

            Console.WriteLine("GA running...");
            ga.GenerationRan += Ga_GenerationRan;


            Console.WriteLine("Best solution found has {0} fitness was born in generation {1}", ga.BestChromosome.Fitness, bestGen);
        }
コード例 #6
0
        private void EvolveGeneticStrategyButton_Click(object sender, RoutedEventArgs e)
        {
            OutputTextBlock.Text = "Evolving...";

            Task.Run(() =>
            {
                var chromosome = new BlackjackChromosome();
                var fitness    = new BlackjackFitness();
                var population = new Population(Settings.GeneticSettings.MinPopulationSize, Settings.GeneticSettings.MaxPopulationSize, chromosome);

                ISelection selection;

                switch (Settings.GeneticSettings.SelectionType)
                {
                case SelectionType.Elite:
                    selection = new EliteSelection();
                    break;

                case SelectionType.RouletteWheel:
                    selection = new RouletteWheelSelection();
                    break;

                case SelectionType.StochasticUniversalSampling:
                    selection = new StochasticUniversalSamplingSelection();
                    break;

                case SelectionType.Tournament:
                    selection = new TournamentSelection(Settings.GeneticSettings.TournamentSize);
                    break;

                default:
                    throw new InvalidOperationException();
                }

                ICrossover crossover;

                switch (Settings.GeneticSettings.CrossoverType)
                {
                case CrossoverType.AlternatingPosition:
                    crossover = new AlternatingPositionCrossover();
                    break;

                case CrossoverType.CutAndSplice:
                    crossover = new CutAndSpliceCrossover();
                    break;

                case CrossoverType.Cycle:
                    crossover = new CycleCrossover();
                    break;

                case CrossoverType.OnePoint:
                    crossover = new OnePointCrossover();
                    break;

                case CrossoverType.TwoPoint:
                    crossover = new TwoPointCrossover();
                    break;

                case CrossoverType.OrderBased:
                    crossover = new OrderBasedCrossover();
                    break;

                case CrossoverType.Ordered:
                    crossover = new OrderedCrossover();
                    break;

                case CrossoverType.PartiallyMapped:
                    crossover = new PartiallyMappedCrossover();
                    break;

                case CrossoverType.PositionBased:
                    crossover = new PositionBasedCrossover();
                    break;

                case CrossoverType.ThreeParent:
                    crossover = new ThreeParentCrossover();
                    break;

                case CrossoverType.Uniform:
                    crossover = new UniformCrossover(Settings.Current.GeneticSettings.MixProbability);
                    break;

                case CrossoverType.VotingRecombination:
                    crossover = new VotingRecombinationCrossover();
                    break;

                default:
                    throw new InvalidOperationException();
                }

                var mutation     = new UniformMutation();
                var termination  = new FitnessStagnationTermination(Settings.Current.GeneticSettings.NumStagnantGenerations);
                var taskExecutor = new ParallelTaskExecutor();

                var ga = new GeneticAlgorithm(
                    population,
                    fitness,
                    selection,
                    crossover,
                    mutation);

                ga.Termination          = termination;
                ga.TaskExecutor         = taskExecutor;
                ga.MutationProbability  = Settings.GeneticSettings.MutationProbability;
                ga.CrossoverProbability = Settings.GeneticSettings.CrossoverProbability;

                var latestFitness = double.MinValue;

                ga.GenerationRan += (s, o) =>
                {
                    geneticStrategy = (IStrategy)ga.BestChromosome;

                    var generationNumber = ga.GenerationsNumber;
                    var bestFitness      = ga.BestChromosome.Fitness.Value;
                    var avgFitness       = ga.Population.CurrentGeneration.Chromosomes.Average(c => c.Fitness.Value);

                    Dispatcher.Invoke(() =>
                    {
                        if (generationNumber == 1)
                        {
                            OutputTextBlock.Text = string.Empty;
                        }

                        OutputTextBlock.Text = $"Gen: {generationNumber}\tFit: {bestFitness}\tAvg: {avgFitness.ToString("0")}\n" + OutputTextBlock.Text;

                        if (bestFitness != latestFitness)
                        {
                            latestFitness = bestFitness;

                            var savedImageName = Settings.Current.GeneticSettings.SaveImagePerGeneration ? "gen" + generationNumber : null;

                            StrategyViewer.Draw(GeneticStrategyCanvas, geneticStrategy, $"Best from generation {generationNumber}", savedImageName);
                        }
                    }, DispatcherPriority.Background);
                };

                ga.TerminationReached += (s, o) =>
                {
                    Dispatcher.Invoke(() =>
                    {
                        OutputTextBlock.Text = "Termination reached.\n" + OutputTextBlock.Text;
                        TestGeneticStrategyButton.IsEnabled = true;
                    }, DispatcherPriority.Background);
                };

                ga.Start();
            });
        }
コード例 #7
0
        private static IAlgoritmo CriaAlgoritmoGenetico(Dictionary <string, string[]> dict, List <string> flat, Problema problema)
        {
            int         populacaoMin, populacaoMax;
            IPopulation population;

            ISelection   selection;
            ICrossover   crossover;
            IMutation    mutation;
            ITermination termination;
            IReinsertion reinsertion;
            float        crossoverProbability, mutationProbability;



            var p = dict.ValueOrDefault("p", "50,100").Split(new[] { ',' });

            if (p.Length != 2 || !int.TryParse(p[0], out populacaoMin) || !int.TryParse(p[1], out populacaoMax))
            {
                throw new ArgumentException("Faixa de população inválida.");
            }

            population = new Population(populacaoMin, populacaoMax, new CromossomoViajante(problema.Mapa.Locais.Count));

            switch (dict.ValueOrDefault("s", "t"))
            {
            case "e":
                selection = new EliteSelection();
                break;

            case "r":
                selection = new RouletteWheelSelection();
                break;

            case "s":
                selection = new StochasticUniversalSamplingSelection();
                break;

            case "t":
                selection = new TournamentSelection();
                break;

            default:
                throw new ArgumentException("Seleção inválida.");
            }

            switch (dict.ValueOrDefault("c", "o"))
            {
            case "s":
                crossover = new CutAndSpliceCrossover();
                break;

            case "c":
                crossover = new CycleCrossover();
                break;

            case "o":
                crossover = new OrderedCrossover();
                break;

            case "ob":
                crossover = new OrderBasedCrossover();
                break;

            case "op":
                crossover = new OnePointCrossover();
                break;

            case "pm":
                crossover = new PartiallyMappedCrossover();
                break;

            case "p":
                crossover = new PositionBasedCrossover();
                break;

            case "tpa":
                crossover = new ThreeParentCrossover();
                break;

            case "tp":
                crossover = new TwoPointCrossover();
                break;

            case "u":
                crossover = new UniformCrossover();
                break;

            default:
                throw new ArgumentException("Crossover inválido.");
            }

            switch (dict.ValueOrDefault("m", "r"))
            {
            case "d":
                mutation = new DisplacementMutation();
                break;

            case "f":
                mutation = new FlipBitMutation();
                break;

            case "i":
                mutation = new InsertionMutation();
                break;

            case "s":
                mutation = new PartialShuffleMutation();
                break;

            case "r":
                mutation = new ReverseSequenceMutation();
                break;

            case "t":
                mutation = new TworsMutation();
                break;

            case "u":
                mutation = new UniformMutation();
                break;

            default:
                throw new ArgumentException("Mutação inválida.");
            }

            switch (dict.ValueOrDefault("t", "s"))
            {
            case "s":
                termination = new FitnessStagnationTermination();
                break;

            case "t":
                termination = new FitnessThresholdTermination();
                break;

            case "g":
                termination = new GenerationNumberTermination();
                break;

            default:
                throw new ArgumentException("Terminação inválida.");
            }

            switch (dict.ValueOrDefault("e", "e"))
            {
            case "e":
                reinsertion = new ElitistReinsertion();
                break;

            case "p":
                reinsertion = new PureReinsertion();
                break;

            case "u":
                reinsertion = new UniformReinsertion();
                break;

            default:
                throw new ArgumentException("Reinserção inválida.");
            }

            if (!float.TryParse(dict.ValueOrDefault("cp", "0,75"), out crossoverProbability))
            {
                throw new ArgumentException("Probabilidade de crossover inválida.");
            }

            if (!float.TryParse(dict.ValueOrDefault("mp", "0,25"), out mutationProbability))
            {
                throw new ArgumentException("Probabilidade de mutação inválida.");
            }


            return(new AlgoritmoGenetico(problema, population, selection, crossover, crossoverProbability, mutation, mutationProbability, termination, reinsertion));
        }
コード例 #8
0
        public IList <IChromosome> CutAndSpliceCrossover()
        {
            var target = new CutAndSpliceCrossover();

            return(target.Cross(CreateTwoParents()));
        }