class INDIVIDUAL:
def __init__(self, i):
self.ID = i
self.genome = numpy.random.random([4, 8]) * 2 - 1
self.fitness = 0
def Start_Evaluation(self, pp, pb):
self.sim = PYROSIM(playPaused=pp, playBlind=pb, evalTime=500)
robot = ROBOT(self.sim, self.genome)
self.sim.Start()
def Compute_Fitness(self):
self.sim.Wait_To_Finish()
sensorData = self.sim.Get_Sensor_Data(sensorID=4, s=1)
self.fitness = sensorData[499]
if (self.fitness > 10.0):
self.fitness = 10.0
del self.sim
def Mutate(self):
s = random.randint(0, 3)
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 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
from pyrosim import PYROSIM import matplotlib.pyplot as plt sim = PYROSIM(playPaused=True , evalTime=100) sim.Send_Cylinder( objectID=0, x=0 , y=0 , z=.6 , length=1.0 , radius=0.1 ) sim.Send_Cylinder( objectID=1 , x=0 , y=.5 , z=1.1 , r1=0 , r2=1, r3=0 , length=1.0 , radius=0.1 , r=1, g=0, b=0) sim.Send_Joint( jointID = 0 , firstObjectID = 0 , secondObjectID = 1, x=0 , y=0 , z=1.1, n1 = -1 , n2 = 0 , n3 = 0, lo=-3.14159/2 , hi=3.14159/2 ) sim.Send_Touch_Sensor( sensorID = 0 , objectID = 0 ) sim.Send_Touch_Sensor( sensorID = 1 , objectID = 1 ) sim.Start() sim.Wait_To_Finish() sensorData = sim.Get_Sensor_Data(sensorID = 1) print sensorData #f = plt.figure() #pn = f.add_subplot(111) #plt.plot(sensorData) #plt.show()
import matplotlib.pyplot as plt
from pyrosim import PYROSIM
from robot import ROBOT
import random
for i in range(0, 3):
########################################################################################################################
# Pyrosim setup
########################################################################################################################
sim = PYROSIM(playPaused=False, evalTime=300)
robot = ROBOT(sim, random.random() * 2 - 1)
sim.Start()
sim.Wait_To_Finish()
sensorData_0 = sim.Get_Sensor_Data(sensorID=0)
sensorData_1 = sim.Get_Sensor_Data(sensorID=1)
sensorData_2 = sim.Get_Sensor_Data(sensorID=2)
sensorData_3 = sim.Get_Sensor_Data(sensorID=3)
sensorData_4 = sim.Get_Sensor_Data(sensorID=4)
sensorData_5 = sim.Get_Sensor_Data(sensorID=5)
# x = sim.Get_Sensor_Data(sensorID=5, s=0)
# y = sim.Get_Sensor_Data(sensorID=5, s=1)
# z = sim.Get_Sensor_Data(sensorID=5, s=2)
#
# print (x[-1])
# print(y[-1])
# print(z[-1])
########################################################################################################################
sim = PYROSIM(playPaused=False, playBlind=False, evalTime=T)
objID = 0
jointID = 0
sensorID = 0
neuronID = 0
pos_sensor_list = []
N = 4
for i in range(
N): #Create N potatoes, each with a different random network
color = np.random.rand(3)
objID, jointID, sensorID, neuronID = Send_Quadruped_Body_And_Brain(
sim,
x=i * 1.5 - N / 2.,
objID=objID,
jointID=jointID,
sensorID=sensorID,
neuronID=neuronID,
color=color)
pos_sensor_list.append(sensorID - 1)
sim.Start()
sim.Wait_To_Finish()
print pos_sensor_list
for i in range(N):
for j in range(3):
print sim.Get_Sensor_Data(pos_sensor_list[i], j, T - 1)
print '--------'
#sim.Get_Sensor_Data(pos_sensor_list[0],0,0)
#print Create_Layered_Network(back_connections=1,hidden_recurrence=0,motor_recurrence=0)
# sim.Collect_Sensor_Data()
n2=0,
n3=0,
lo=-3.14159 / 2,
hi=3.14159 / 2)
sim.Send_Touch_Sensor(sensorID=0, objectID=0)
sim.Send_Touch_Sensor(sensorID=1, objectID=1)
sim.Send_Proprioceptive_Sensor(sensorID=2, jointID=0)
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 = 0.55 , z = 1.1 , r1 = 0 , r2 = 0 , r3 = -1)
sim.Start()
sim.Wait_To_Finish()
sensorData0 = sim.Get_Sensor_Data(sensorID=0)
sensorData1 = sim.Get_Sensor_Data(sensorID=1)
sensorData2 = sim.Get_Sensor_Data(sensorID=2)
sensorData3 = sim.Get_Sensor_Data(sensorID=3)
f = plt.figure()
pn = f.add_subplot(111)
plt.plot(sensorData0)
plt.plot(sensorData1)
plt.plot(sensorData2)
plt.plot(sensorData3)
pn.set_ylim(-2, +11)
plt.show()
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 '] ',
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
