Translated Matthews Java Code into a Python Equivalent

Currently doesn't run. We still need to connect up the script fully by resolving the bugs and translating some things into python equivalents in particular the java mappings need to be translated into a python equivalent.

Author: isabellakite

GroupProject.py

@@ -0,0 +1,44 @@
+import random
+from robot import Robot
+from environment import Environment
+from brain import EvolvableBrain
+
+# rxs = []
+# rys = []
+# ras = []
+#
+# food_xs = []
+# food_ys = []
+# water_xs = []
+# water_ys = []
+# trap_xs = []
+# trap_ys = []
+#
+# aspect_ratio_x = 2.0/3.0
+# text_size = 20
+# arena_width = 40
+# timestep = 0.04
+# iteration = 0
+
+def setup():
+	pop_size = 30
+	env = Environment()
+	evolvable_brains = []
+	robots = []
+
+	for i in range(0, pop_size):
+		b = EvolvableBrain()
+		b.randomise()
+		evolvable_brains.append(b)
+
+	for i in range(0, pop_size):
+		r = Robot()
+		r.set_brain(evolvable_brains[i])
+		r.set_environment(env)
+		robots.append(r)
+
+def main():
+	#user_input = input("Press Enter to start")
+	setup()
+
+main()

__pycache__/brain.cpython-37.pyc

@@ -0,0 +1,117 @@
+class Mapping:
+    def __init__(self):
+        self.n_points = 4
+        self.xs = []
+        self.ys = []
+
+        randomise()
+
+    def __init__(self, copy_me):
+        for i in range(0, n_points):
+            self.xs[i] = copy_me.xs[i]
+            self.ys[i] = copy_me.ys[i]
+
+    def randomise():
+        for i in range(n_points):
+            xs[i] = random.randrange(0, 2)
+            ys[i] = random.randrange(-1, 2)
+
+        xs[0] = 0.0
+        xs[n_points - 1] = 1.0
+
+    def mutate():
+        mu_1 = 0.01
+        mu_2 = 0.02
+        for i in range(i, n_points):
+            xs[i] += random_gaussian() * mu_1
+            ys[i] += random_gaussian() * mu_2
+
+            xs[i] = constrain(xs[i], 0.0, 1.0)
+            ys[i] = constrain(ys[i], -1.0, 1.0)
+
+            if random.randrange(0, 1.0) < mu_2:
+                xs[i] = random.randrange(0.0, 1.0)
+                ys[i] = random.randrange(-1.0, 1.0)
+
+        for i in range(i, n_points):
+            if xs[i] > xs[i + 1]:
+                tmp = xs[i]
+                xs[i] = xs[i + 1]
+                xs[i + 1] = tmp
+
+        xs[0] = 0.0
+        xs[n_points - 1] = 1.0
+
+    def f(x):
+        x = min(1.0, x)
+        for i in range(0, self.n_points):
+            if x <= self.xs[i + 1]:
+                output = lerp(ys[i], ys[i + 1], x - self.xs[i] / self.xs[i + 1] - self.xs[i])
+                return output
+
+        print("non-interpolatable input: error")
+        print(x)
+        exit()
+        return 0.0
+
+    def printxs(pre):
+        for i in range(0, self.n_points):
+            print(pre, end = "")
+            print("[" + i + "]=", end = "")
+            print(self.xs[i], end = "")
+            print(";")
+
+    def printys(pre):
+        for i in range(0, self.n_points):
+            print(pre, end = "")
+            print("[" + i + "]=", end = "")
+            print(self.ys[i], end = "")
+            print(";")
+
+    def draw():
+        for i in range(0, self.n_points):
+            #draw line
+            return True
+
+class EvolvableBrain:
+    def __init__(self):
+        self.n_senses = 3
+        self.n_motors = 2
+        self.maps = []
+
+        for i in range(0, self.n_senses + 1):
+            for j in range(0, self.n_motors + 1):
+                copy_me = self.maps[i][j]
+                self.maps[i][j] = Mapping(copy_me)
+
+    def randomise(self):
+        for i in range(0, self.n_senses + 1):
+            for j in range(0, self.n_motors + 1):
+                self.maps[i][j].randomise()
+
+    def imprint(self):
+        n_genes = self.maps[0][0].n_points*3*2
+        copy = EvolvableBrain(loser)
+
+        for i in range(0, self.n_senses):
+            for j in range(0, self.n_motors):
+                if random.randrange(0, 1.0) < 0.5:
+                    copy.self.maps[i][j] = Mapping(self.maps[i][j])
+                copy.self.maps[i][j].mutate()
+        return copy
+
+    def iterate(robot):
+        lm_accum = 0.5
+        rm_accum = -0.5
+
+        for sensor_i in range(0, self.n_senses):
+            leftm_ipsi = self.maps[sensor_i][0].f(robot.sensor_values[sensor_i][0])
+            right_ipsi = self.maps[sensor_i][0].f(robot.sensor_values[sensor_i][1])
+
+            leftm_contra = self.maps[sensor_i][1].f(robot.sensor_values[sensor_i][1])
+            rightm_contra = self.maps[sensor_i][1].f(robot.sensor_values[sensor_i][0])
+
+            lm_accum += leftm_ipsi + leftm_contra
+            rm_accum += right_ipsi + rightm_contra
+        robot.l_motor = lm_accum / 6.0
+        robot.r_motor = rm_accum / 6.0

__pycache__/environment.cpython-37.pyc

@@ -0,0 +1,125 @@
+import random
+import enum
+
+arena_width = 50
+# timestep
+# mode_evolve
+
+class ThingType(enum.Enum):
+	Food = 1
+	Water = 2
+	Trap = 3
+
+class Thing:
+	def __init__(self, ntype):
+		self.x = random.randrange(0, arena_width)
+		self.y = random.randrange(0, arena_width)
+
+		self.amount = 1.0
+		self.radius = 1.0
+
+		self.type = ntype
+
+		if type == ThingType.Food:
+			food_xs.add(self.x)
+			food_ys.add(self.y)
+
+		elif type == ThingType.Water:
+			water_xs.add(self.x)
+			water_ys.add(self.y)
+
+		elif type == ThingType.Trap:
+			trap_xs.add(self.x)
+			trap_ys.add(self.y)
+
+	# def __init__(self, nx, ny, ntype):
+	# 	self.x = nx
+	# 	self.y = ny
+	#
+	# 	self.type = ntype
+	#
+	# 	self.amount = 1.0
+	# 	self.radius = 1.0
+
+	def draw():
+		#
+		return True
+
+	def update():
+		if self.amount < 0.0:
+			self.amount = 1.0
+			self.x = random.randrange(0, arena_width)
+			self.y = random.randrange(0, arena_width)
+
+			if type == ThingType.Food:
+				self.food_xs.append(self.x)
+				self.food_ys.append(self.y)
+			elif type == ThingType.Water:
+				self.water_xs.append(self.x)
+				self.water_ys.append(self.y)
+			elif type == ThingType.Trap:
+				self.trap_ys.append(self.x)
+				self.trap_ys.append(self.y)
+
+class Environment:
+
+	def __init__(self):
+		self.foods = []
+		self.waters = []
+		self.traps = []
+
+		#create 4 food sources and 4 water sources
+		for i in range(0, 4):
+			self.foods.append(ThingType.Food)
+			self.waters.append(ThingType.Water)
+
+		#create 2 traps
+		self.traps.append(Thing(ThingType.Trap))
+		self.traps.append(Thing(ThingType.Trap))
+
+	def reset():
+		for thing in self.foods:
+			thing.amount = -1.0
+			thing.update()
+		for thing in self.waters:
+			thing.amount = -1.0
+			thing.update()
+		for thing in self.traps:
+			thing.amount = -1.0
+			thing.update()
+
+	def interact_with_robot(robot):
+		consumption_rate = 0.25 * 10.0
+		fill_rate = 0.25
+		#draw stroke here
+
+		for thing in self.foods:
+			if dist(thing.x, thing.y, robot.x, robot.y) < thing.radius:
+				thing.amount -= consumption_rate * timestep
+				robot.food_battery += fill_rate * timestep
+
+
+		for thing in self.waters:
+			if dist(thing.x, thing.y, robot.x, robot.y) < thing.radius:
+				thing.amount -= consumption_rate * timestep
+				robot.water_battery += fill_rate * timestep
+
+
+		for thing in self.traps:
+			if dist(thing.x, thing.y, robot.x, robot.y) < thing.radius:
+				robot.food_battery = 0.0
+				robot.water_battery = 0.0
+				robot.is_alive = False
+
+
+	def update():
+		for thing in self.foods:
+			thing.update()
+		for thing in self.waters:
+			thing.update()
+		for thing in self.traps:
+			thing.update()
+
+	def draw():
+		#draw stuff
+		return True

__pycache__/robot.cpython-37.pyc

@@ -0,0 +1,24 @@
+import random
+import robot
+
+def iterate_evolve():
+	tournament+=1
+	a_id = random.randrange(0, population_size)
+	b_id = random.randrange(0, population_size)
+
+	while (a_id == b_id):
+		random.randrange(0, population_size)
+
+	print(a_id, b_id)
+
+	#a = robot()
+	#a.set_brain(evolvable_brains[a_id])
+	#a.set_environment(env)
+	#b = robot()
+	#b.set_brain(evolvable_brains[b_id])
+	#b.set_environment(env)
+
+def main():
+	tournament = 1
+	evolvable_brains = []
+	iterate_evolve()

brain.py

@@ -0,0 +1,69 @@
+generation = 0
+tournament = 0
+
+trial_length = 1500
+n_trials = 1
+fitnesses = []
+history_size = 500
+
+mean_fitness_history = []
+peak_fitness_history = []
+
+
+def iterate_evolve():
+	tournament+=1
+	a_id = random.randrange(0, pop_size)
+	b_id = random.randrange(0, pop_size)
+
+	while (a_id == b_id):
+		random.randrange(0, pop_size)
+
+	a = Robot()
+	a.set_brain(evolvable_brains[a_id])
+	a.set_environment(env)
+	b = robot()
+	b.set_brain(evolvable_brains[b_id])
+	b.set_environment(env)
+
+	a_fitness = 0
+	b_fitness = 0
+
+	for i in range(0, n_trials):
+		env.reset()
+		a.reset()
+		b.reset()
+
+	for i in range(0, trial_length):
+		if a.is_alive:
+			a.calculate_change()
+			a.update()
+			a_fitness += (a.food_battery + a.water_battery)/2.0/trial_length
+		if b.is_alive:
+			b.calculate_change()
+			b.update()
+			b_fitness += (b.food_battery + a.water_battery)/2.0/trial_length
+		env.update()
+		if not a.is_alive and not b.is_alive:
+			break
+
+	a_fitness /= n_trials
+	b_fitness /= n_trials
+
+	fitnesses[a_id] = a_fitness
+	fitnesses[b_id] = b_fitness
+
+	winner_id = b_id
+	loser_id = a_id
+
+	if fitnesses[a_id] > fitnesses[b_id]:
+		winner_id = a_id
+		loser_id = b_id
+
+	evolvable_brains[loser_id] = evolvable_brains[winner_id].imprint(evolvable_brains[loser_id])
+
+def main():
+	tournament = 1
+	evolvable_brains = []
+	iterate_evolve()
+
+main()