def setUp(self): self.real_translator = EncoderDecoder(min_value=0, max_value=255, encoding_bits=8) self.condition = BitConditionRealEncoding( encoders=self.real_translator, center_spreads=[(3, 2), (5, 1)], mutation_strength=.1, mutation_prob=.2)
def __init__(self, size: int, alogger: logging.Logger): self.logger = alogger self.world = SimWorld(size=size, toroidal=True) self.world.place_ball() self.reset() self.real_translators = [ EncoderDecoder(min_value=0, max_value=self.world.max_distance, encoding_bits=8), EncoderDecoder(min_value=-180, max_value=180, encoding_bits=8) ]
def _encode(self, center_spreads: List[Tuple[float, float]]) -> CoreBitString: result = CoreBitString('') for ((center, spread), encoder) in zip(center_spreads, self.real_translators): result += encoder.encode(center) spread_encoder = EncoderDecoder( min_value=0, max_value=encoder.extremes[1] - encoder.extremes[0], encoding_bits=encoder.encoding_bits) result += spread_encoder.encode(spread) return result
def test_clip(self): encoder = EncoderDecoder(min_value=0, max_value=1, encoding_bits=4) for _ in range(1000): center = random() spread = random() nc, ns = BitConditionRealEncoding.clip_center_spread_class( encoder, (center, spread)) if center - spread >= encoder.extremes[0]: if center + spread <= encoder.extremes[1]: self.assertEqual(center, nc) self.assertEqual(spread, ns) else: self.assertEqual(ns, encoder.extremes[1] - nc) else: if center + spread <= encoder.extremes[1]: self.assertEqual(ns, nc - encoder.extremes[0]) else: self.assertEqual( ns, min(encoder.extremes[1] - nc, nc - encoder.extremes[0])) self.assertEqual(center, nc) self.assertTrue(nc - ns >= encoder.extremes[0]) and ( nc + ns <= encoder.extremes[1])
def clip_center_spread_class( cls, encoder: EncoderDecoder, center_spread: Tuple[float, float]) -> Tuple[float, float]: """Clips an interval in a way that it represents a valid range of values.""" center, spread = center_spread center = encoder.clip(center) # spread = encoder.clip(spread) spread = min( spread, min(center - encoder.extremes[0], encoder.extremes[1] - center)) return center, spread
def test_encoding_decoding_mutation(self): encoding_bits = 4 m = -10 M = 20 enc_dec = EncoderDecoder(min_value=m, max_value=M, encoding_bits=encoding_bits) for _ in range(10): factor = random() # print("With factor = %.2f" % (factor)) max_spread = (M - m) * factor for _ in range(10): d = random() * (M - m) + m r = enc_dec.mutate_float(d, factor=factor) # print("%.2f -> %d" % (d, r)) self.assertTrue((r >= m) and (r <= M)) current_spread = abs(r - d) self.assertTrue( current_spread <= max_spread, "Spread ~ %.2f, but max spread = (%.2f - %.2f)*%.2f ~ %.2f" % (current_spread, M, m, factor, max_spread))
def test_encoding_decoding(self): for encoding_bits in [2, 4, 5, 8, 10]: print("******************* [encoding bits = %d]" % (encoding_bits)) m = -10 M = 20 enc_dec = EncoderDecoder(min_value=m, max_value=M, encoding_bits=encoding_bits) # all_ds = [m + random() * (M - m) for _ in range(10)] all_ds = list( set([m, M] + [m + random() * (M - m) for _ in range(10)]) ) # sample(list(range(m, M)), min(10, M - m)))) all_ds.sort() for d in all_ds: r = enc_dec.encode_as_int(d=d) print("%.2f -> %d" % (d, r)) self.assertTrue((r >= 0) and (r <= (math.pow(2, encoding_bits) - 1))) self.assertLessEqual(r.bit_length(), encoding_bits) a_bitstring = enc_dec.encode(d) self.assertEqual(enc_dec.decode(a_bitstring), r)
def __init__(self): self.gym_env = gym.make('CartPole-v0') # TODO: ('CartPole-v0') ? self.observation = self.gym_env.reset() self.episode_done = False self.reward_on_episode = 0 highs = self.gym_env.observation_space.high lows = self.gym_env.observation_space.low if not isinstance(highs, np.ndarray): highs = [highs] lows = [lows] print(highs) print(lows) self.the_min = -1 self.the_max = 1 self.real_translators = [EncoderDecoder(min_value=max(CartpoleProblem.MIN_VALUE, low), max_value=min(CartpoleProblem.MAX_VALUE, high), encoding_bits=4) for low, high in zip(lows, highs)]
def __init__(self, path_to_data: str, training_cycles: int, alogger: logging.Logger): self.possible_actions = (True, False) self.logger = alogger self.data = pd.read_csv(path_to_data) self.correct_response = None self.remaining_cycles = training_cycles self.real_translators = [ EncoderDecoder(min_value=1, max_value=3, encoding_bits=2), # passenger class EncoderDecoder(min_value=-0, max_value=1, encoding_bits=1), # sex EncoderDecoder(min_value=-0, max_value=100, encoding_bits=6), # age EncoderDecoder(min_value=-0, max_value=10, encoding_bits=3), # siblings or spouses EncoderDecoder(min_value=-0, max_value=10, encoding_bits=3), # parents or children EncoderDecoder(min_value=-0, max_value=520, encoding_bits=9), # fare EncoderDecoder(min_value=-0, max_value=2, encoding_bits=2), # port of embarcation ]
def test_crossover(self): a_translator = EncoderDecoder(min_value=-255, max_value=255, encoding_bits=8) for a_length in [2, 3] + sample(range(4, 50), 25): cond1 = BitConditionRealEncoding.random(encoders=a_translator, mutation_strength=.1, mutation_prob=.2, length=a_length) cond2 = BitConditionRealEncoding.random(encoders=a_translator, mutation_strength=.1, mutation_prob=.2, length=a_length) for cross_points in ([1] if a_length == 2 else [1, 2]): kid1, kid2 = cond1.crossover_with(cond2, cross_points) self.assertEqual(len(kid1), len(kid2)) self.assertEqual(len(kid1), len(cond1)) self.assertTrue((kid1 != kid2) or (cond1 == cond2)) for kid in [kid1, kid2]: for i, (center, spread) in enumerate(kid): self.assertTrue((cond1[i][0] == center) or (cond2[i][0] == center)) self.assertTrue((cond1[i][1] == spread) or (cond2[i][1] == spread))
class TestBitCondition(unittest.TestCase): def setUp(self): self.real_translator = EncoderDecoder(min_value=0, max_value=255, encoding_bits=8) self.condition = BitConditionRealEncoding( encoders=self.real_translator, center_spreads=[(3, 2), (5, 1)], mutation_strength=.1, mutation_prob=.2) def test_init(self): for _ in range(10): condition = BitConditionRealEncoding.random(self.real_translator, mutation_strength=.1, mutation_prob=.2, length=2) comp_array = [ condition.clip_center_spread( (center, spread), self.real_translator) == (center, spread) for center, spread in condition.center_spreads ] self.assertTrue(all(comp_array), comp_array) def test_contains(self): for _ in range(10): condition = BitConditionRealEncoding.random(self.real_translator, mutation_strength=.1, mutation_prob=.2, length=randint(2, 20)) for center_spread in condition.center_spreads: self.assertTrue(center_spread in condition) def test_iter(self): for (center, spread) in self.condition: print("(%.2f, %.2f)" % (center, spread)) for value in BitString(encoders=self.real_translator, reals=[4, 5]): print("value: %.2f" % (value)) def test_matched(self): for _ in range(10): condition = BitConditionRealEncoding.random(self.real_translator, mutation_strength=.1, mutation_prob=.2, length=randint(2, 20)) # situation(s) reals = [ self.real_translator.clip( random_in(center - spread, center + spread)) for center, spread in condition.center_spreads ] situation = BitString(self.real_translator, reals) # print(condition) # print(situation) self.assertTrue(condition(situation)) # condition(s) self.assertTrue(self.condition(self.condition)) a_condition = BitConditionRealEncoding(encoders=self.real_translator, center_spreads=[(3, 1), (5, 0)], mutation_prob=.2, mutation_strength=.1) self.assertTrue(self.condition(a_condition)) def test_not_matched(self): # situation(s) situation = BitString(encoders=self.real_translator, reals=[14, 5]) self.assertFalse(self.condition(situation)) # condition(s) a_condition = BitConditionRealEncoding(encoders=self.real_translator, center_spreads=[(1, 1), (6, 2)], mutation_prob=.2, mutation_strength=.1) self.assertFalse(self.condition(a_condition)) def test_crossover(self): a_translator = EncoderDecoder(min_value=-255, max_value=255, encoding_bits=8) for a_length in [2, 3] + sample(range(4, 50), 25): cond1 = BitConditionRealEncoding.random(encoders=a_translator, mutation_strength=.1, mutation_prob=.2, length=a_length) cond2 = BitConditionRealEncoding.random(encoders=a_translator, mutation_strength=.1, mutation_prob=.2, length=a_length) for cross_points in ([1] if a_length == 2 else [1, 2]): kid1, kid2 = cond1.crossover_with(cond2, cross_points) self.assertEqual(len(kid1), len(kid2)) self.assertEqual(len(kid1), len(cond1)) self.assertTrue((kid1 != kid2) or (cond1 == cond2)) for kid in [kid1, kid2]: for i, (center, spread) in enumerate(kid): self.assertTrue((cond1[i][0] == center) or (cond2[i][0] == center)) self.assertTrue((cond1[i][1] == spread) or (cond2[i][1] == spread)) @unittest.skip("interval mutation is not used currently") def test_mutate_interval_by_translation(self): for _ in range(10): situation = BitString.random_from(self.real_translator, randint(2, 20)) for _ in range(10): a_condition = situation.cover(.33) self.assertTrue(a_condition(situation)) # just to check. idx = randint(0, len(situation) - 1) an_interval = a_condition.center_spreads[idx] a_value = situation.as_reals[idx] another_interval = a_condition._mutate_interval_by_translation( interval=an_interval, value=a_value) self.assertLessEqual(a_value, another_interval[0] + another_interval[1]) self.assertGreaterEqual( a_value, another_interval[0] - another_interval[1]) # center, spread = an_interval bottom, top = center - spread, center + spread self.assertTrue( (an_interval != another_interval) or # either: the intervals are different, or (spread == 0) or # the interval is length = 0, or (top - bottom == self.real_translator.extremes[1] - self.real_translator.extremes[0] )) # the interval occupies the whole space @unittest.skip("interval mutation is not used currently") def test_mutate_interval_by_stretching(self): for _ in range(10): situation = BitString.random_from(self.real_translator, randint(2, 20)) for _ in range(10): a_condition = situation.cover(.33) self.assertTrue(a_condition(situation)) # just to be sure idx = randint(0, len(situation) - 1) a_value = situation.as_reals[idx] an_interval = a_condition.center_spreads[idx] another_interval = a_condition._mutate_interval_by_stretching( interval=an_interval, value=a_value) self.assertNotEqual(an_interval, another_interval, str(an_interval)) self.assertLessEqual(a_value, another_interval[0] + another_interval[1]) self.assertGreaterEqual( a_value, another_interval[0] - another_interval[1]) def test_mutate(self): for _ in range(10): situation = BitString.random_from(self.real_translator, randint(2, 20)) # print("***************") # print(situation) for _ in range(10): a_condition = situation.cover(.33) self.assertTrue(a_condition(situation)) # just to check. mutated_condition = a_condition.mutate(situation) # print(a_condition) # print(mutated_condition) self.assertTrue(mutated_condition(situation)) @unittest.skip("On original paper they don't clip. Let's try.") def test_clip(self): encoder = EncoderDecoder(min_value=0, max_value=1, encoding_bits=4) for _ in range(1000): center = random() spread = random() nc, ns = BitConditionRealEncoding.clip_center_spread_class( encoder, (center, spread)) if center - spread >= encoder.extremes[0]: if center + spread <= encoder.extremes[1]: self.assertEqual(center, nc) self.assertEqual(spread, ns) else: self.assertEqual(ns, encoder.extremes[1] - nc) else: if center + spread <= encoder.extremes[1]: self.assertEqual(ns, nc - encoder.extremes[0]) else: self.assertEqual( ns, min(encoder.extremes[1] - nc, nc - encoder.extremes[0])) self.assertEqual(center, nc) self.assertTrue(nc - ns >= encoder.extremes[0]) and ( nc + ns <= encoder.extremes[1])
def __init__(self): self.gym_env = gym.make('Bowling-ram-v0') self.observation = self.gym_env.reset() self.games_to_play = 10 # a pixel can take values in the (0,255) range, and I will encode the values with 8 bits. self.real_translator = EncoderDecoder(min_value=0, max_value=255, encoding_bits=8)
def setUp(self): self.real_translator = EncoderDecoder(min_value=0, max_value=255, encoding_bits=8)