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)