Esempio n. 1
0
        public void BoolMutation()
        {
            var db         = new Database(TestHelpers.GetCleanDatabase());
            var protoChrom = Initialization.MakeProtoChromosome();
            var protoRun   = new ProtoRun(db, "MixtureCrossoverTest", -1, protoChrom, 2, 6, 4, 10, 0.05);
            var run        = new Run(protoRun, protoChrom);

            int trues  = 0;
            int falses = 0;

            var chrom = Initialization.MakeRandomChromosome(NetworkType.Rnn, protoChrom, 0);

            Lists.Repeat(10000, _ => {
                chrom = Functions.MutateChromosome(chrom, run);
                if (chrom.UsePCA)
                {
                    trues++;
                }
                else
                {
                    falses++;
                }
            });

            Trace.WriteLine("Trues: " + trues);
            Trace.WriteLine("Falses: " + falses);
            ((double)trues / falses).ShouldBeGreaterThan(0.9).ShouldBeLessThan(1.1);
        }
Esempio n. 2
0
        public void InitialPopulationTest()
        {
            var mongoDb  = TestHelpers.GetCleanDatabase();
            var db       = new Database(mongoDb);
            var protoRun = new ProtoRun(db, "InitialPopulationTest", 3, Initialization.MakeFastestProtoChromosome(), 10, 6, 4, 5, 0.05);
            var gen      = Initialization.MakeInitialGeneration(MakeTrainingSet(db, "11/11/2001", "12/11/2001"),
                                                                new Run(protoRun, Initialization.MakeFastestProtoChromosome()),
                                                                new LocalParallelTrainer());

            foreach (var mixture in gen.Mixtures)
            {
                var ordered = mixture.Chromosomes.OrderBy(c => c.OrderInMixture).ToArray();
                var rnns    = ordered.Take(6).ToArray();
                var rbfs    = ordered.Skip(6).ToArray();
                rnns.Length.ShouldEqual(6);
                rbfs.Length.ShouldEqual(4);
                rnns.Select(c => c.NetworkType).Distinct().Single().ShouldEqual(NetworkType.Rnn);
                rbfs.Select(c => c.NetworkType).Distinct().Single().ShouldEqual(NetworkType.Rbf);
            }
        }
Esempio n. 3
0
        public void GetObject()
        {
            var mongoDb  = TestHelpers.GetCleanDatabase();
            var db1      = new Database(mongoDb);
            var protoRun = new ProtoRun(db1, "", 0, null, 0, 0, 0, 0, 0);
            var run      = new Run(protoRun, Initialization.MakeProtoChromosome());
            var id       = run.Id;

            var db2    = new Database(mongoDb);
            var db2Run = db2.Get <Run>(id);

            db2Run.Database.ShouldNotBeNull();
            db2Run.Database.ShouldNotEqual(db1);
            db2Run.Id.ShouldEqual(run.Id);
            db2Run.ProtoChromosome.ShouldLookLike(run.ProtoChromosome);

            var db2Run2 = db2.Get <Run>(id);

            db2Run2.ShouldLookLike(db2Run);
        }
Esempio n. 4
0
        //[Test]
        public void LocalEvolveTest()
        {
            var mongoDb = TestHelpers.GetCleanDatabase();
            var db      = new Database(mongoDb);

            var protoRun      = new ProtoRun(db, "LocalEvolveTest", 4, Initialization.MakeProtoChromosome(), 10, 6, 4, 4, 0.05);
            var trainingStart = "11/11/2001";
            var validationEnd = "05/12/2003";
            var dataSets      = MakeTrainingAndValidationSets(db, trainingStart, validationEnd);
            var run           = Functions.Evolve(protoRun, new LocalParallelTrainer(), dataSets.Item1, dataSets.Item2);

            Trace.WriteLine("Generation fitnesses: " + run.Generations.Select(x => x.Evaluated.Fitness).Join(", "));
            var bestMixtures = run.Generations.SelectMany(g => g.Mixtures).OrderByDescending(m => m.Evaluated.Fitness).Take(10).ToList();

            var testingSet = MakeTrainingSet(db, validationEnd, "12/12/2003");

            Lists.Repeat(bestMixtures.Count, i => {
                var predictor     = new MixturePredictor(bestMixtures[i], testingSet);
                var testedFitness = Functions.ComputeFitness(predictor, testingSet, 20);
                Trace.WriteLine(string.Format("Tested fitness for best mixture #{0}: {1}", i, testedFitness));
            });
        }
Esempio n. 5
0
        public void MixtureCrossover()
        {
            var db         = new Database(TestHelpers.GetCleanDatabase());
            var protoChrom = Initialization.MakeProtoChromosome();
            var protoRun   = new ProtoRun(db, "MixtureCrossoverTest", -1, protoChrom, 2, 6, 4, 10, 0.05);
            var run        = new Run(protoRun, protoChrom);
            var seed       = MakeTrainingSet(db, "11/11/2001", "12/11/2001");
            var gen        = Initialization.MakeInitialGeneration(seed, run, new LocalParallelTrainer());

            gen.Mixtures.Length.ShouldEqual(2);
            var m1 = gen.Mixtures[0];
            var m2 = gen.Mixtures[1];

            var prev = Tuple2.Create(m1.Chromosomes, m2.Chromosomes);
            var cmis = Functions.CombineTwoMixtures(gen.Mixtures.Select(m => new MixtureEval(m, 1)).ToList());
            var curr = Tuple2.Create(cmis.Item1.Chromosomes, cmis.Item2.Chromosomes);

            for (int i = 0; i < m1.Chromosomes.Length; i++)
            {
                AssertIsCrossedOverVersionOf(Tuple2.Create(curr.Item1[i], curr.Item2[i]),
                                             Tuple2.Create(prev.Item1[i], prev.Item2[i]));
            }
        }
Esempio n. 6
0
        public void Querying()
        {
            var mongoDb  = TestHelpers.GetCleanDatabase();
            var db1      = new Database(mongoDb);
            var protoRun = new ProtoRun(db1, "", 0, null, 0, 0, 0, 0, 0);
            var run1     = new Run(protoRun, Initialization.MakeProtoChromosome());
            var run2     = new Run(protoRun, Initialization.MakeProtoChromosome());

            var db2   = new Database(mongoDb);
            var runs1 = db2.QueryAll <Run>(_ => true);

            runs1.Length.ShouldEqual(2);
            runs1[0].Id.ShouldEqual(run1.Id);
            runs1[1].Id.ShouldEqual(run2.Id);

            var runs2       = db2.QueryAll <Run>(x => x.Id == run1.Id);
            var runs2Single = runs2.Single();

            runs2Single.Id.ShouldEqual(run1.Id);
            runs2Single.ShouldLookLike(runs1[0]);
            runs2Single.ShouldNotEqual(runs1[0]);
            runs2Single.Database.ShouldEqual(db2);
        }
Esempio n. 7
0
        public void EvolveTest()
        {
            var mongoDb = TestHelpers.GetCleanDatabase();
            var db      = new Database(mongoDb);

            var protoRun = new ProtoRun(db, "EvolveTest", 3, Initialization.MakeFastestProtoChromosome(), 10, 6, 4, 5, 0.05);
            var dataSets = MakeTrainingAndValidationSets(db, "11/11/2001", "02/12/2002");
            var run      = Functions.Evolve(protoRun, new LocalParallelTrainer(), dataSets.Item1, dataSets.Item2);

            run.Id.ShouldBeOfType <ObjectId>();
            run.ProtoChromosome.Genes.Length.ShouldEqual(11);

            run.Generations.Length.ShouldEqual(3);
            run.Generations[0].Order.ShouldEqual(0);
            run.Generations[1].Order.ShouldEqual(1);
            run.Generations[2].Order.ShouldEqual(2);

            var dbTypes = run.Generations[1].Mixtures.First().Experts.Select(x => x.Chromosome.DatabaseType).Distinct();

            dbTypes.Count().ShouldEqual(2);

            var gen2 = run.Generations[2];

            gen2.Id.ShouldBeOfType <ObjectId>();
            gen2.Mixtures.Count().ShouldEqual(10);
            gen2.Mixtures.First().Experts.Count(x => x.Chromosome.NetworkType == NetworkType.Rnn).ShouldEqual(6);
            gen2.Mixtures.First().Experts.Count(x => x.Chromosome.NetworkType == NetworkType.Rbf).ShouldEqual(4);

            foreach (var gen in run.Generations)
            {
                foreach (var mixture in gen.Mixtures)
                {
                    mixture.Chromosomes.Select(x => x.OrderInMixture).ShouldEnumerateLike(
                        mixture.Chromosomes.OrderBy(x => x.OrderInMixture).Select(x => x.OrderInMixture));
                }
            }
        }