class INDIVIDUAL:
def __init__(self, i):
self.ID = i
# genome[0] = Hidden <-> Sensor Neurons
# genome[1] = Hidden <-> Motor Neurons
# genome[2] = Hidden <-> Hidden Recurrent Neurons
self.genome = [
MatrixCreate(c.numHidNeurons, 5),
MatrixCreate(c.numHidNeurons, 8),
MatrixCreate(c.numHidNeurons, c.numHidNeurons)
]
self.genome[0] = MatrixRandomize(self.genome[0], 1, -1)
self.genome[1] = MatrixRandomize(self.genome[1], 1, -1)
self.genome[2] = MatrixRandomize(self.genome[2], 1, -1)
self.fitness = 0
self.stability = 0
self.uniqueness = 0
self.touchSensorData = np.array([])
def Evaluate(self,
environment,
hideSim=True,
startPaused=False,
printFalse=False):
self.Start_Evaluation(environment=environment,
hideSim=hideSim,
startPaused=startPaused)
self.Compute_Fitness(printFit=printFalse)
self.Store_Sensor_Data()
del self.sim
def Mutate(self, s=c.sMutation):
# This will choose a random gene to mutate. but this is based on a Gauss distribution. This has been edited to
# accept 2 dimensional genes
for i in range(0, 3):
# Synapse Layer
sLayer = random.randint(0, len(self.genome) - 1)
x = random.randint(0, len(self.genome[sLayer]) - 1)
y = random.randint(0, len(self.genome[sLayer][x]) - 1)
# random.gauss(mean, sigma)
self.genome[sLayer][x, y] = random.gauss(
self.genome[sLayer][x, y],
math.fabs(self.genome[sLayer][x, y] * s))
# # This will mutate ALL genes
# for i in range(0, len(self.genome)):
# self.genome[i] = random.gauss(self.genome[i], math.fabs(self.genome[i]))
# Clip the value of Gene
self.genome[sLayer][x, y] = np.clip(self.genome[sLayer][x, y], -1,
1)
#self.genome[x, y] = max(min(1, self.genome[x, y]), -1)
def Print(self):
print('[', self.ID, self.fitness, self.uniqueness, ']', end=" ")
#print(self.fitness, end=" "),
#print(self.genome)
def Start_Evaluation(self, environment, hideSim=True, startPaused=False):
self.sim = PYROSIM(playPaused=startPaused,
playBlind=hideSim,
evalTime=c.evaluationTime)
robot = ROBOT(self.sim, self.genome)
environment.Send_To(self.sim)
self.sim.Start()
def Compute_Fitness(self, printFit=False):
self.sim.Wait_To_Finish()
# x = self.sim.Get_Sensor_Data( sensorID=4, s=0 ) # s is the flag for the desired coordinate
# y = self.sim.Get_Sensor_Data( sensorID=4, s=1 )
# z = self.sim.Get_Sensor_Data( sensorID=4, s=2 )
# the returned value is the inverse squared of the distance to light source
distLight = self.sim.Get_Sensor_Data(sensorID=4, s=0)
distX = self.sim.Get_Sensor_Data(sensorID=5, s=0)
distY = self.sim.Get_Sensor_Data(sensorID=5, s=1)
# Touch Sensor Values.... Comes in vector
for t in range(0, 4):
self.stability += sum(self.sim.Get_Sensor_Data(sensorID=t)) * 0.25
# DEBUGGING #
if printFit:
plt.plot(distLight**0.25)
plt.show()
# Fitness Computation
self.fitness += distLight[-1]**0.25
# self.fitness += np.clip(distLight[-1], 0, 0.1)
def Store_Sensor_Data(self):
touchSensorData = np.zeros(shape=(4, c.evaluationTime))
for t in range(0, 4):
touchSensorData[t, :] = self.sim.Get_Sensor_Data(sensorID=t, s=0)
self.touchSensorData = touchSensorData
# Stability Data
columnSums = np.sum(touchSensorData, axis=0)
columnThresholds = np.clip(columnSums, 0, 1)
self.stability = np.sum(columnThresholds)
def Compute_Distance_Between(self, other):
try:
self.touchSensorData
except NameError:
print("Sensor Data was not Stored")
else:
#euclideanDistance = np.linalg.norm(self.touchSensorData - other.touchSensorData)
#euclideanDistance = self.fitness - other.fitness
delta = np.sum(
np.fabs(self.touchSensorData - other.touchSensorData))
return delta
# tOnGround = np.sum(self.touchSensorData)
# tOnGround_Other = np.sum(other.touchSensorData)
# euclideanDistance = np.fabs(tOnGround - tOnGround_Other)
#
# return euclideanDistance
def Mutate_Neat(self):
# synapse layer
sLayer = random.randint(0, len(self.genome) - 1)
# Shuffles the row of that Synapse layer
self.genome[sLayer] = self.genome[sLayer][
np.random.permutation(len(self.genome[sLayer][0])), :]
class INDIVIDUAL:
def __init__(self, i):
self.ID = i
self.genome = numpy.random.random([5, 8]) * 2 - 1
self.fitness = 0
def Start_Evaluation(self, env, pp, pb):
self.sim = PYROSIM(playPaused=pp,
playBlind=pb,
evalTime=constants.evaluationTime)
robot = ROBOT(self.sim, self.genome)
env.Send_To(self.sim)
self.sim.Start()
def Compute_Fitness(self):
self.sim.Wait_To_Finish()
sensorData = self.sim.Get_Sensor_Data(sensorID=4, s=0)
currentFitness = sensorData[-1]
if (currentFitness < self.fitness):
self.fitness = currentFitness
# self.fitness = self.fitness + currentFitness
# if ( self.fitness > 10.0 ):
# self.fitness = 10.0
del self.sim
def Mutate(self):
s = random.randint(0, 4)
m = random.randint(0, 7)
self.genome[s, m] = random.gauss(self.genome[s, m],
math.fabs(self.genome[s, m]))
if (self.genome[s, m] > 1.0):
self.genome[s, m] = 1.0
if (self.genome[s, m] < -1.0):
self.genome[s, m] = -1.0
def Print(self):
print '[',
print self.ID,
print self.fitness,
print '] ',
def run_experiment(
generator_fcn,
fitness_fcn,
name,
trial_num,
pop_size,
gens,
eval_time,
env_order,
dimensions,
env_space=False,
fitness_threshold=False,
development_layers=1,
):
time_stamp = dt.datetime.now().strftime('%Y-%m-%d_%H-%M-%S')
data = {}
envs_to_train_in = [env_space[i] for i in env_order]
evolver = evolvers.AFPO(max_population_size=pop_size,
generator_fcn=generator_fcn,
fitness_fcn=fitness_fcn,
environments=envs_to_train_in,
development_layers=development_layers,
max_generations=gens,
eval_time=eval_time,
fitness_threshold=fitness_threshold)
data['pop_size'] = evolver.max_population_size
#data['fitness_function'] = fitness_function
data['development_layers'] = evolver.development_layers
data['eval_time'] = evolver.eval_time
evolved_data = evolver.Evolve()
gens = evolver.generation - 1
data['gens'] = gens
best_robot = evolved_data[gens]['pareto_front'][0]['genome']
data['data'] = evolved_data
data['best_robot'] = best_robot
data['motor_speed'] = robots.MOTOR_SPEED
data['environments'] = envs_to_train_in
data['env_space'] = env_space
data['name'] = name
data['threshold'] = fitness_threshold
data['dimensions'] = dimensions
data['num_trained_in'] = len(envs_to_train_in)
env_fitness = [0] * 16
for index, env in enumerate(env_space):
sim = PYROSIM(playBlind=True, playPaused=False, evalTime=eval_time)
ids = best_robot.Send_To_Simulator(sim, eval_time=eval_time)
env.Send_To_Simulator(sim, ID_offset=ids[0])
sim.Start()
sim.Wait_To_Finish()
sensor_data = sim.Get_Results()
env_fitness[index] = fitness_fcn(sensor_data, env)
data_folder = './Data'
file_name = name + '_' + str(trial_num) + '_' + str(
len(env_order)) + '_' + str(dimensions) + '_' + str(time_stamp)
print file_name
pickle_file_name = file_name + '.pickle'
json_file_name = file_name + '.json'
if not os.path.isdir(data_folder):
os.makedirs(data_folder)
pickle_path_to_file = data_folder + '/' + pickle_file_name
json_path_to_file = data_folder + '/' + json_file_name
with open(pickle_path_to_file, 'w') as f:
pickle.dump(data, f)
#Create json daat
json_data = {}
print 'env fit', env_fitness
print 'env order', env_order
#store json data
json_data['env_fitness'] = env_fitness
json_data['type'] = name
json_data['threshold'] = fitness_threshold
json_data['dimensions'] = dimensions
json_data['num_trained_in'] = len(envs_to_train_in)
json_data['env_order'] = env_order
#Write json
with open(json_path_to_file, 'w') as f:
json.dump(json_data, f)
sim.Send_Proprioceptive_Sensor(sensorID=2, jointID=0)
# sensor that returns current angle of joint in rads
#sim.Send_Ray_Sensor(sensorID=3, objectID=1, x=0, y=1.1, z=1.1, r1=0, r2=1, r3=0)
sim.Send_Ray_Sensor(sensorID=3,
objectID=1,
x=0,
y=.55,
z=1.1,
r1=0,
r2=0,
r3=-1)
# sensor that sends ray outwards and returns length of that ray
# xyz is where it resides (at the tip in this case)
# r's define where to point
sim.Start()
sim.Wait_To_Finish()
sensorData = sim.Get_Sensor_Data(sensorID=3)
print sensorData
f = plt.figure()
pn = f.add_subplot(111)
plt.plot(sensorData)
pn.set_ylim(-1, +11)
plt.show()
class INDIVIDUAL:
def __init__(self, i):
self.ID = i
self.genome = MatrixCreate(4, 8)
self.genome = MatrixRandomize(self.genome, 1, -1)
self.fitness = 0
def Evaluate(self, hideSim=True, startPaused=False):
sim = PYROSIM(playPaused=startPaused,
playBlind=hideSim,
evalTime=c.evaluationTime)
robot = ROBOT(sim, self.genome)
sim.Start()
sim.Wait_To_Finish()
x = sim.Get_Sensor_Data(sensorID=4, s=0)
y = sim.Get_Sensor_Data(sensorID=4, s=1)
z = sim.Get_Sensor_Data(sensorID=4, s=2)
# self.sensorData_0 = sim.Get_Sensor_Data(sensorID=0)
# self.sensorData_1 = sim.Get_Sensor_Data(sensorID=1)
# self.sensorData_2 = sim.Get_Sensor_Data(sensorID=2)
# self.sensorData_3 = sim.Get_Sensor_Data(sensorID=3)
# self.sensorData_4 = sim.Get_Sensor_Data(sensorID=4)
# print(sim.Get_Sensor_Data(sensorID=4))
self.fitness = y[-1]
del sim
def Mutate(self):
# This will choose a random gene to mutate. but this is based on a Gauss distribution. This has been edited to
# accept 2 dimensional genes
x = random.randint(0, len(self.genome) - 1)
y = random.randint(0, len(self.genome[0]) - 1)
self.genome[x, y] = random.gauss(self.genome[x, y],
math.fabs(self.genome[x, y]))
# # This will mutate ALL genes
# for i in range(0, len(self.genome)):
# self.genome[i] = random.gauss(self.genome[i], math.fabs(self.genome[i]))
def Print(self):
print('[', self.ID, self.fitness, ']', end=" ")
#print(self.fitness, end=" "),
#print(self.genome)
def Start_Evaluation(self, hideSim=True, startPaused=False):
self.sim = PYROSIM(playPaused=startPaused,
playBlind=hideSim,
evalTime=c.evaluationTime)
robot = ROBOT(self.sim, self.genome)
self.sim.Start()
def Compute_Fitness(self):
self.sim.Wait_To_Finish()
x = self.sim.Get_Sensor_Data(sensorID=4, s=0)
y = self.sim.Get_Sensor_Data(sensorID=4, s=1)
z = self.sim.Get_Sensor_Data(sensorID=4, s=2)
# self.sensorData_0 = sim.Get_Sensor_Data(sensorID=0)
# self.sensorData_1 = sim.Get_Sensor_Data(sensorID=1)
# self.sensorData_2 = sim.Get_Sensor_Data(sensorID=2)
# self.sensorData_3 = sim.Get_Sensor_Data(sensorID=3)
# self.sensorData_4 = sim.Get_Sensor_Data(sensorID=4)
self.fitness = y[-1]
del self.sim
