def test_binary_tournament(self): """ Test that binary tournament works as expected """ self.config.max_generations = 3 self.config.fitness_function_type = FitnessType.FULL_MATCH self.config.selection_type = SelectionType.BINARY_TOURNAMENT p = Population(self.samples, self.grammar, self.stats) mating_pool = p.selection(p.generation) super().assertNotEqual(p.generation, mating_pool)
def test_random_one_point_crossover(self): """ Test that crossover 'random one point' works as expected """ self.config.max_generations = 3 self.config.fitness_function_type = FitnessType.BASIC self.config.selection_type = SelectionType.BINARY_TOURNAMENT self.config.recombination_type = RecombinationType.RANDOM_ONE_POINT_CROSSOVER p = Population(self.samples, self.grammar, self.stats) mating_pool = p.selection(p.generation) p.offspring = p.recombination(mating_pool, p.generation) super().assertNotEqual(p.generation, p.offspring)
def test_evolve(self): """ Tests that an evolution works, preserving a fitted individual """ self.config.max_generations = 3 self.config.fitness_function_type = FitnessType.BASIC p = Population(self.samples, self.grammar, self.stats) self.config.mutation_probability = 0.0 p.generation[0] = Individual(self.samples, self.grammar, self.stats, '01110101100101100110010110010101') self.config.mutation_probability = 0.5 p.evolve() super().assertLessEqual(0.25, p.generation[0].fitness_value)
def test_best_challenge(self): """ Tests that the most fitted individual occupies the population's best_individual slot """ self.config.max_generations = 3 self.config.fitness_function_type = FitnessType.BASIC p = Population(self.samples, self.grammar, self.stats) self.config.mutation_probability = 0.0 p.generation[0] = Individual(self.samples, self.grammar, self.stats, '01110101100101100110010110010101') self.config.mutation_probability = 0.5 p.evolve() super().assertGreaterEqual(p.best_individual.fitness_value, 0.2)
def test_mu_lambda_no_elite(self): """ Tests that replacement 'mu lambda without elitism' works as expected """ self.config.replacement_type = ReplacementType.MU_LAMBDA_WITHOUT_ELITISM p = Population(self.samples, self.grammar, self.stats) mating_pool = p.selection(p.generation) p.offspring = p.recombination(mating_pool, p.generation) p.generation, p.offspring = p.replacement(p.generation, p.offspring) super().assertListEqual(p.offspring, [])
def test_mu_plus_lambda(self): """ Tests that replacement 'mu plus lambda' works as expected """ self.config.replacement_type = ReplacementType.MU_PLUS_LAMBDA p = Population(self.samples, self.grammar, self.stats) mating_pool = p.selection(p.generation) p.offspring = p.recombination(mating_pool, p.generation) p.generation, p.offspring = p.replacement(p.generation, p.offspring) super().assertListEqual(p.offspring, [])
def test_sr_update(self): """ Check SR is updated if a solution is found for the run """ stats = Stats() self.config.max_generations = 1 self.config.population_size = 3 self.config.fitness_function_type = FitnessType.BASIC self.config.mutation_probability = 0.0 self.config.success_threshold = 0.0 p = Population(self.samples, self.grammar, stats) p.generation[0] = Individual(self.samples, self.grammar, stats, '01110101100101100110010110010101') p.evolve() super().assertListEqual([True], stats.success_rate_accumulator) self.config.success_threshold = 1.0 self.config.population_size = 1 p = Population(self.samples, self.grammar, stats) p.generation[0] = Individual(self.samples, self.grammar, stats, '00000000000000000000000000000000') p.evolve() super().assertListEqual([True, False], stats.success_rate_accumulator)
def test_k_tournament(self): """ Test that k tournament raises error """ self.config.selection_type = SelectionType.K_TOURNAMENT p = Population(self.samples, self.grammar, self.stats) with super().assertRaises(NotImplementedError): _ = p.selection(p.generation)
def test_initialize(self): """ Tests that a population is correctly filled with Individuals """ p = Population(self.samples, self.grammar, self.stats) super().assertIsInstance(p.generation[0], Individual)
def test_best_challenge_changes_best_individual(self): """ Covers best challenge cases """ self.config.mutation_probability = 0.0 self.config.fitness_function_type = FitnessType.BASIC p = Population(self.samples, self.grammar, self.stats) i1 = Individual(self.samples, self.grammar, self.stats, dna='00000000000000000000000000000000') i2 = Individual(self.samples, self.grammar, self.stats, dna='01110101100101100110010110010101') # When there's no best individual yet, population's best individual is updated p.best_individual = None p.generation = [i2] p._best_challenge() super().assertEqual(p.best_individual, p.generation[0]) # When a better individual is better fitted in a new generation, population's best individual is updated p.best_individual = i1 p.generation = [i2] p._best_challenge() super().assertEqual(p.best_individual, p.generation[0]) # When a worse individual is the most fitted in a new generation, population's best individual remains the same p.best_individual = i2 p.generation = [i1] p._best_challenge() super().assertEqual(i2, p.best_individual)
def find_patterns( samples: List[str], configuration: Union[str, None] = None, spacy_language_model_name: Union[str, None] = None) -> List[Tuple[Any, ...]]: """ Given some samples, this function finds optimized patterns to be used by the Spacy's Rule Based Matcher. Args: samples: List of strings from where to find common linguistic patterns configuration: (str) Optional configuration file path to to be loaded (Fallbacks to default configuration) spacy_language_model_name: (str) Optional valid Spacy Language Model (Fallbacks to Spacy's en_core_web_sm) Returns: List of patterns found and list of each pattern matching score against the samples """ LOG.info(f'Loading language model {spacy_language_model_name}...') if 'en-core-web-sm' not in [ d.project_name for d in pkg_resources.working_set ]: LOG.info( f'PatternOmatic\'s default spaCy\'s Language Model not installed,' f' proceeding to install en_core_web_sm, please wait...') spacy_download('en_core_web_sm') try: nlp = spacy_load(spacy_language_model_name) except OSError: LOG.warning( f'Model {spacy_language_model_name} not found, ' f'falling back to patternOmatic\'s default language model: en_core_web_sm' ) nlp = spacy_load('en_core_web_sm') LOG.info(f'Building Doc instances...') samples = [nlp(sample) for sample in samples] if isinstance(configuration, str): LOG.info( f'Setting up configuration from the following path: {configuration}...' ) config = Config(config_file_path=configuration) else: config = Config() LOG.info(f'Existing Config instance found: {config}') stats = Stats() bnf_g = dgg(samples) LOG.info('Starting Execution...') for _ in range(0, config.max_runs): start = time.monotonic() p = Population(samples, bnf_g, stats) p.evolve() end = time.monotonic() stats.add_time(end - start) stats.calculate_metrics() LOG.info(f'Execution report {stats}') stats.persist() LOG.info(f'Best individuals for this execution:') stats.most_fitted_accumulator.sort(key=lambda i: i.fitness_value, reverse=True) for individual in stats.most_fitted_accumulator: LOG.info(f'{individual}') return list( zip(*[[i.fenotype, i.fitness_value] for i in stats.most_fitted_accumulator]))