class TestConjunctionMutationProbability(unittest.TestCase):
    def setUp(self):
        self.neighbors_finder = Mock()

        self.conjunction_mutation_probability = ConjunctionMutationProbability(self.neighbors_finder)

    def set_return_value_of_get_rep_plus_and_rep_minus(self):
        returned_neighborhood = set()
        returned_neighborhood.add((1, 0, 0, 1))
        returned_neighborhood.add((1, 1, 0, 0))
        returned_neighborhood.add((0, 1, 0, 1))
        returned_neighborhood.add((1, 1, 1, 1))
        self.neighbors_finder.get_rep_plus_and_rep_minus.return_value = returned_neighborhood

    def test_get_probability_of_rep_from_plus(self):
        representation = [1, 1, 0, 1]

        self.set_return_value_of_get_rep_plus_and_rep_minus()

        probability = self.conjunction_mutation_probability.get_relational_probability(representation, (1, 0, 0, 1), 1)
        self.assertEqual(0.125, probability)

    def test_get_probability_of_rep_from_plus_minus(self):
        """ the representation itself appears in the group r+- and therefore that's the param passed to 'get_relational_probability'
        :return:
        """
        representation = [0, 0, 0, 0]

        self.set_return_value_of_get_rep_plus_and_rep_minus()

        self.neighbors_finder.get_rep_plus_minus.return_value = [(0, 0, 0, 0)]

        probability = self.conjunction_mutation_probability.get_relational_probability(representation, (0, 0, 0, 0), 1)
        self.assertEqual(0.5, probability)
Ejemplo n.º 2
0
class TestConjunctionMutationProbability(unittest.TestCase):
    def setUp(self):
        self.neighbors_finder = Mock()

        self.conjunction_mutation_probability = ConjunctionMutationProbability(
            self.neighbors_finder)

    def set_return_value_of_get_rep_plus_and_rep_minus(self):
        returned_neighborhood = set()
        returned_neighborhood.add((1, 0, 0, 1))
        returned_neighborhood.add((1, 1, 0, 0))
        returned_neighborhood.add((0, 1, 0, 1))
        returned_neighborhood.add((1, 1, 1, 1))
        self.neighbors_finder.get_rep_plus_and_rep_minus.return_value = returned_neighborhood

    def test_get_probability_of_rep_from_plus(self):
        representation = [1, 1, 0, 1]

        self.set_return_value_of_get_rep_plus_and_rep_minus()

        probability = self.conjunction_mutation_probability.get_relational_probability(
            representation, (1, 0, 0, 1), 1)
        self.assertEqual(0.125, probability)

    def test_get_probability_of_rep_from_plus_minus(self):
        """ the representation itself appears in the group r+- and therefore that's the param passed to 'get_relational_probability'
        :return:
        """
        representation = [0, 0, 0, 0]

        self.set_return_value_of_get_rep_plus_and_rep_minus()

        self.neighbors_finder.get_rep_plus_minus.return_value = [(0, 0, 0, 0)]

        probability = self.conjunction_mutation_probability.get_relational_probability(
            representation, (0, 0, 0, 0), 1)
        self.assertEqual(0.5, probability)
Ejemplo n.º 3
0
def learn_DNF__basic_model():
    dnf = DNF()
    length = 58
    epsilon = (2**-53)
    tau = (epsilon / length)**3 * log(1/epsilon)

    tolerance = ConjunctionTolerance(length, epsilon)
    conjunction_performance_oracle = OneSidedPerformanceOracleWithTolerance(dnf, tau)
    performance_oracle = DNFOneSidePerformanceOracleWithTolerance(dnf, tau, epsilon,
                                                                  conjunction_performance_oracle)
    mutation_neighborhood = MonotoneConjunctionNeighborhood()
    mutation_probability = ConjunctionMutationProbability(mutation_neighborhood)

    mutator = Mutator(mutation_neighborhood, performance_oracle, tolerance, mutation_probability, epsilon)
    algorithm = ConjunctionEvolvabilityAlgorithm(mutator, length, epsilon, performance_oracle)

    print algorithm.learn_ideal_function_until_match()
    def __init__(self, is_neigh_precomp=True):
        self.length = 40
        self.epsilon = 2**-31
        self.number_of_activations = 10
        self.number_of_mutations_from_mutator = 40
        self.population_size = 200

        self.tolerance = ConjunctionTolerance(self.length, self.epsilon)
        self.tau = (self.epsilon / self.length)**3 * log(1/self.epsilon)

        self.representation_class = None

        if is_neigh_precomp:
            self.representation_class = get_set_of_all_representations_with_length(self.length)
            self.mutation_neighborhood = PrecompMonotoneConjunctionNeighborhood(self.representation_class)
        else:
            self.mutation_neighborhood = MonotoneConjunctionNeighborhood()

        self.mutation_probability = ConjunctionMutationProbability(self.mutation_neighborhood)
    def setUp(self):
        self.neighbors_finder = Mock()

        self.conjunction_mutation_probability = ConjunctionMutationProbability(self.neighbors_finder)
Ejemplo n.º 6
0
    def setUp(self):
        self.neighbors_finder = Mock()

        self.conjunction_mutation_probability = ConjunctionMutationProbability(
            self.neighbors_finder)