Exemple #1
0
    def test_reuse_checks(self):
        path = darwin_test_utils.reserve_universe('python_bindings.darwin')
        universe = darwin.create_universe(path)
        population = darwin.Population('neat')
        domain = darwin.Domain('unicycle')

        experiment_a = universe.new_experiment(domain, population, name='A')

        # currently, once a population or a domain _instance_ is used by an experiment,
        # it cannot be reused in other experiments

        new_population = darwin.Population('neat')
        with self.assertRaises(RuntimeError):
            experiment_b = universe.new_experiment(domain,
                                                   new_population,
                                                   name='B')

        new_domain = darwin.Domain('unicycle')
        with self.assertRaises(RuntimeError):
            experiment_c = universe.new_experiment(new_domain,
                                                   population,
                                                   name='C')

        # after the experiment is disposed, we can reuse the population and domain
        experiment_a = None
        experiment_d = universe.new_experiment(domain, population, name='D')
Exemple #2
0
    def test_experiment_name(self):
        path = darwin_test_utils.reserve_universe('python_bindings.darwin')
        universe = darwin.create_universe(path)
        population = darwin.Population('neat')
        domain = darwin.Domain('unicycle')

        experiment = universe.new_experiment(domain, population, name='foo')
        self.assertEqual(experiment.name, 'foo')
        self.assertRegex(repr(experiment), "'foo'")

        experiment.name = ' a new  name  with  lots of  spaces! '
        self.assertRegex(repr(experiment),
                         "' a new  name  with  lots of  spaces! '")

        experiment.name = None
        self.assertRegex(repr(experiment), 'Unnamed')

        # invalid name (empty)
        with self.assertRaises(RuntimeError):
            experiment.name = ''

        experiment.name = 'final'

        experiment.initialize_population()

        # can't set the name after the experiment is initialized
        with self.assertRaises(RuntimeError):
            experiment.name = 'baz'

        second_population = darwin.Population('cne.lstm')
        second_domain = darwin.Domain('tic_tac_toe')

        # duplicate name
        with self.assertRaises(RuntimeError):
            second_experiment = universe.new_experiment(
                domain=second_domain,
                population=second_population,
                name='final')

        second_experiment = universe.new_experiment(
            domain=second_domain, population=second_population, name='baz')

        # ok...
        second_experiment.name = 'new name'

        # duplicate name
        with self.assertRaises(RuntimeError):
            second_experiment.name = 'final'
Exemple #3
0
 def test_available_domains(self):
     domains = darwin.available_domains()
     self.assertTrue(domains)
     for name in domains:
         domain = darwin.Domain(name)
         self.assertEqual(name, domain.name)
         self.assertIsNotNone(domain.config)
Exemple #4
0
    def test_basic_evolution(self):
        path = darwin_test_utils.reserve_universe('python_bindings.darwin')
        universe = darwin.create_universe(path)

        population = darwin.Population('neat')
        population.size = 10

        domain = darwin.Domain('unicycle')

        experiment = universe.new_experiment(domain, population)

        # basic evolution cycle
        experiment.initialize_population()
        for generation in range(5):
            summary = experiment.evaluate_population()
            experiment.create_next_generation()

        # evolution trace
        trace = experiment.trace
        self.assertEqual(trace.size, 5)
        self.assertEqual(trace.size, len(trace))
        self.assertEqual(trace[4].champion.fitness, summary.champion.fitness)
        self.assertEqual(trace[4].champion.fitness, trace[-1].champion.fitness)
        self.assertEqual(trace[0].champion.fitness, trace[-5].champion.fitness)

        with self.assertRaises(IndexError):
            tmp = trace[5]
        with self.assertRaises(IndexError):
            tmp = trace[-6]

        universe.close()
Exemple #5
0
 def test_property_attributes(self):
     d = darwin.Domain('conquest')
     for prop_name in dir(d.config):
         prop = d.config.__getattr__(prop_name)
         self.assertEqual(prop.name, prop_name)
         self.assertTrue(prop.description)
         self.assertTrue(prop.default_value)
Exemple #6
0
    def test_genotype_lifetime(self):
        path = darwin_test_utils.reserve_universe('python_bindings.darwin')
        universe = darwin.create_universe(path)

        population = darwin.Population('cne.feedforward')
        domain = darwin.Domain('tic_tac_toe')

        population.size = 10

        experiment = universe.new_experiment(domain, population)

        experiment.initialize_population()

        genotype = population[0]

        json_checkpoint_1 = genotype.to_json()

        experiment.evaluate_population()

        # this is fine, although our genotype may be ranked to a different index now
        json_checkpoint_2 = genotype.to_json()

        experiment.create_next_generation()

        # the old genotype is no longer owned by the population
        json_checkpoint_3 = genotype.to_json()

        experiment.reset()

        # the old population is no longer owned by the experiment
        json_checkpoint_4 = genotype.to_json()

        self.assertEqual(json_checkpoint_1, json_checkpoint_2)
        self.assertEqual(json_checkpoint_1, json_checkpoint_3)
        self.assertEqual(json_checkpoint_1, json_checkpoint_4)
Exemple #7
0
    def test_evaluate_population(self):
        path = darwin_test_utils.reserve_universe('python_bindings.darwin')
        universe = darwin.create_universe(path)

        population = darwin.Population('neat')
        domain = darwin.Domain('tic_tac_toe')

        population.size = 10
        experiment = universe.new_experiment(domain, population)

        experiment.initialize_population()
        summary = experiment.evaluate_population()

        self.assertEqual(population.size, 10)
        self.assertEqual(population.size, len(population))

        # generation summary
        self.assertEqual(summary.generation, 0)
        self.assertEqual(summary.best_fitness, summary.champion.fitness)

        # population fitness values
        self.assertGreaterEqual(population[0].fitness, population[-1].fitness)
        self.assertEqual(population[0].fitness, summary.champion.fitness)

        prev_fitness = summary.champion.fitness
        for genotype in population:
            self.assertLessEqual(genotype.fitness, prev_fitness)
            prev_fitness = genotype.fitness

        universe.close()
Exemple #8
0
    def test_indexing(self):
        path = darwin_test_utils.reserve_universe('python_bindings.darwin')
        universe = darwin.create_universe(path)

        population = darwin.Population('cne.feedforward')
        domain = darwin.Domain('tic_tac_toe')

        population.size = 10

        experiment = universe.new_experiment(domain, population)

        # can't index into an uninitialized population
        with self.assertRaises(RuntimeError):
            genotype = population[0]

        experiment.initialize_population()

        # correct indexing
        genotype = population[0]
        genotype = population[9]
        genotype = population[-1]
        genotype = population[-10]

        # out of bounds
        with self.assertRaises(IndexError):
            genotype = population[10]
        with self.assertRaises(IndexError):
            genotype = population[-11]
Exemple #9
0
    def test_json_support(self):
        d = darwin.Domain('conquest')
        d.config.max_steps = 100
        d.config.points_draw = 0.4
        d.config.board = 'hexagon'
        d.config.tournament_type = 'swiss'
        d.config.tournament_type.variant.rematches = False

        json_str = d.config.to_json()

        # roundtrip
        d = darwin.Domain('conquest')
        d.config.from_json(json_str)
        self.assertEqual(d.config.max_steps.auto, 100)
        self.assertEqual(d.config.points_draw.auto, 0.4)
        self.assertEqual(d.config.board.auto, 'hexagon')
        self.assertEqual(d.config.tournament_type.auto, 'swiss')
        self.assertEqual(d.config.tournament_type.variant.rematches.auto, False)
Exemple #10
0
    def test_config_assignment(self):
        d1 = darwin.Domain('pong')
        d2 = darwin.Domain('tic_tac_toe')

        # this is ok, we can bind to config instances
        c = d1.config
        c = d2.config

        # ... but we can't set the config
        with self.assertRaises(AttributeError):
            d1.config = d2.config

        # ... even self assignments
        with self.assertRaises(AttributeError):
            d1.config = d1.config

        # ... or setting to None
        with self.assertRaises(AttributeError):
            d1.config = None
Exemple #11
0
 def test_new_experiment(self):
     path = darwin_test_utils.reserve_universe('python_bindings.darwin')
     with darwin.create_universe(path) as universe:
         p = darwin.Population('neat')
         d = darwin.Domain('unicycle')
         exp = universe.new_experiment(population=p, domain=d)
         self.assertRegex(repr(exp), p.name)
         self.assertRegex(repr(exp), d.name)
         self.assertIs(exp.population, p)
         self.assertIs(exp.domain, d)
         self.assertIs(exp.universe, universe)
Exemple #12
0
    def test_sealed_state(self):
        path = darwin_test_utils.reserve_universe('python_bindings.darwin')
        universe = darwin.create_universe(path)
        population = darwin.Population('neat')
        domain = darwin.Domain('unicycle')
        experiment = universe.new_experiment(domain, population)

        # changes are ok
        population.size = 10
        population.config.normalize_input = False
        domain.config.gravity = 10.5
        experiment.config.save_genealogy = True
        experiment.core_config.mutation_std_dev = 0.5

        d_config = domain.config
        d_config.max_torque = 100

        # initializing the population will seal all configuration values
        experiment.initialize_population()

        # shouldn't be able to change sealed state
        with self.assertRaises(RuntimeError):
            population.size = 10
        with self.assertRaises(RuntimeError):
            population.config.normalize_input = True
        with self.assertRaises(RuntimeError):
            domain.config.gravity = 0
        with self.assertRaises(RuntimeError):
            experiment.config.save_genealogy = False
        with self.assertRaises(RuntimeError):
            experiment.core_config.mutation_std_dev = 0
        with self.assertRaises(RuntimeError):
            d_config.max_torque = 0

        # make sure the values were not changed
        self.assertEqual(population.size, 10)
        self.assertEqual(population.config.normalize_input.auto, False)
        self.assertEqual(domain.config.gravity.auto, 10.5)
        self.assertEqual(experiment.config.save_genealogy.auto, True)
        self.assertEqual(experiment.core_config.mutation_std_dev.auto, 0.5)
        self.assertEqual(d_config.max_torque.auto, 100)

        # resetting the experiment allows configuration changes again
        experiment.reset()

        population.size = 1
        population.config.normalize_input = 'true'
        domain.config.gravity = 0.1
        experiment.config.save_genealogy = False
        experiment.core_config.mutation_std_dev = '0.1'
        d_config.max_torque = 1.5

        universe.close()
Exemple #13
0
    def test_experiment_reset(self):
        path = darwin_test_utils.reserve_universe('python_bindings.darwin')
        universe = darwin.create_universe(path)
        population = darwin.Population('neat')
        domain = darwin.Domain('unicycle')

        population.size = 5
        experiment_a = universe.new_experiment(domain, population)

        for i in range(3):
            experiment_a.name = f'A{i}'  # name must be unique
            experiment_a.initialize_population()
            experiment_a.evaluate_population()
            experiment_a.create_next_generation()
            experiment_a.reset()
Exemple #14
0
    def test_reinitialize_population(self):
        path = darwin_test_utils.reserve_universe('python_bindings.darwin')
        universe = darwin.create_universe(path)

        population = darwin.Population('neat')
        population.size = 10

        domain = darwin.Domain('unicycle')

        experiment = universe.new_experiment(domain, population)

        # multiple runs of the same experiment variation
        for evolution_run in range(3):
            # reinitialize the population (which would result in a new evolution trace)
            experiment.initialize_population()
            for generation in range(2):
                experiment.evaluate_population()
                experiment.create_next_generation()

        universe.close()
Exemple #15
0
    def test_variant_property_sets(self):
        d = darwin.Domain('tic_tac_toe')
        config = d.config

        # not all the properties have sub-variants
        with self.assertRaises(RuntimeError):
            dummy = config.ann_type.variant

        d = None # stress the ownership/lifetimes management
        prop = config.tournament_type
        config.tournament_type = 'swiss'
        swiss_tournament = prop.variant
        config.tournament_type = 'simple'
        simple_tournament = prop.variant
        prop = None # stress the ownership/lifetimes management
        config.tournament_type.variant.eval_games = 123
        config = None # stress the ownership/lifetimes management

        self.assertEqual(int(swiss_tournament.rounds), 20)
        self.assertEqual(int(simple_tournament.eval_games), 123)
Exemple #16
0
    def test_auto_cast(self):
        d = darwin.Domain('conquest')

        d.config.max_steps = 100
        d.config.points_draw = 0.4
        d.config.board = 'hexagon'
        d.config.tournament_type = 'swiss'
        d.config.tournament_type.variant.rematches = False

        self.assertIs(type(d.config.max_steps.auto), int)
        self.assertIs(type(d.config.points_draw.auto), float)
        self.assertIs(type(d.config.board.auto), str)
        self.assertIs(type(d.config.tournament_type.auto), str)
        self.assertIs(type(d.config.tournament_type.variant.rematches.auto), bool)

        self.assertEqual(d.config.max_steps.auto, 100)
        self.assertEqual(d.config.points_draw.auto, 0.4)
        self.assertEqual(d.config.board.auto, 'hexagon')
        self.assertEqual(d.config.tournament_type.auto, 'swiss')
        self.assertEqual(d.config.tournament_type.variant.rematches.auto, False)
Exemple #17
0
    def test_genotype_and_brain(self):
        path = darwin_test_utils.reserve_universe('python_bindings.darwin')
        universe = darwin.create_universe(path)

        population = darwin.Population('cne.feedforward')
        population.size = 10

        domain = darwin.Domain('tic_tac_toe')
        domain.config.ann_type = 'value'

        experiment = universe.new_experiment(domain, population)
        experiment.initialize_population()

        genotype = population[0].clone()
        self.assertEqual(genotype.to_json(), population[0].to_json())

        brain = genotype.grow()
        for index in range(9):
            brain.set_input(index, 0)
        brain.think()
        board_value = brain.output(index=0)
Exemple #18
0
    def test_cast_attributes(self):
        d = darwin.Domain('conquest')

        d.config.int_unit_scale = 10
        d.config.points_draw = 0.4
        d.config.board = 'hexagon'

        self.assertEqual(int(d.config.int_unit_scale), 10)
        self.assertEqual(float(d.config.points_draw), 0.4)
        self.assertEqual(repr(d.config.board), 'hexagon')
        self.assertEqual(str(d.config.board), 'hexagon')

        d.config.tournament_type = 'swiss'
        d.config.tournament_type.variant.rematches = 'true'
        self.assertEqual(bool(d.config.tournament_type.variant.rematches), True)
        d.config.tournament_type.variant.rematches = 'false'
        self.assertEqual(bool(d.config.tournament_type.variant.rematches), False)

        # invalid cast
        with self.assertRaises(RuntimeError):
            value = int(d.config.board)
Exemple #19
0
 def test_config_lifetime(self):
     d = darwin.Domain('conquest')
     config = d.config
     d = None
     self.assertTrue(repr(config))
Exemple #20
0
 def test_property_lifetime(self):
     d = darwin.Domain('conquest')
     property = d.config.board
     d = None
     self.assertEqual(str(property), 'hexagon')