def get_fitness(dna):
# reset position
e.solids[1].pos = [x, y]
g = gene_functions.Gaps2(x, y)
# set velocity based on input functions and weights from DNA
for i in range(2):
e.solids[1].velocity[i] = g.input0()[i] * dna[0] + \
g.input3()[i] * dna[1] + \
g.input4()[i] * dna[2]
initial_velocity = e.solids[1].velocity
# run the physics engine until either the termination condition is reached (termination function has to be put into the physics_engine.py
runtime = pe.run_physics_engine(tick_length, e, time_limit)
# if the simulation exceeds the time limit before the termination condition is reached, or way too quickly, the organism's fitness will be virtually 0
if runtime >= time_limit or runtime <= tick_length * 10:
return .00001 # can't be 0 bc that would cause division by 0 later on
# fitness function, tries to minimize velocity while maximizing time spent before crashing back down to planet, uses normalized quantities
velocity_magnitude = pe.distance(initial_velocity, [0, 0])
norm_runtime = (runtime - tick_length * 10) / (time_limit - tick_length * 10)
norm_velocity = velocity_magnitude / 5
return (norm_runtime - norm_velocity) ** 2
def get_fitness(dna):
# create unique object of gene function class for each iteration
g = gene_functions.Gatd1()
# set velocity based on input functions and weights from DNA
for i in range(2):
e.solids[0].velocity[i] = g.input0()[i] * dna[0] + \
g.input1()[i] * dna[1]
end_pos = pe.run_physics_engine(tick_length, e, time_limit)
return 1 / (pe.distance([0, 0], end_pos)**.5)
def get_fitness(organism):
# reset position, set velocity to what its DNA dictates
e.solids[1].pos = [0, 11.001]
e.solids[1].velocity = [0] + organism.dna
# run the physics engine until either the termination condition is reached (termination function has to be put into the physics_engine.py
runtime = pe.run_physics_engine(tick_length, e, time_limit)
# if the simulation exceeds the time limit before the termination condition is reached, or way too quickly, the organism's fitness will be virtually 0
if runtime >= time_limit or runtime <= tick_length * 10:
return .001
# fitness function, tries to minimize velocity while maximizing time spent before crashing back down to planet, uses normalized quantities
velocity_magnitude = pe.distance([0] + organism.dna, [0, 0])
norm_runtime = runtime / time_limit
norm_velocity = velocity_magnitude / 5
return (norm_runtime - norm_velocity)**2
def get_fitness(dna, destination):
# create unique object of gene function class for each iteration
g = gene_functions.Gasv1(e.g_strength[1], destination)
# make sure to reset pos before starting again!!!!!!!!!!
e.solids[0].pos = [-100, .001]
# set velocity based on input functions and weights from DNA
for i in range(2):
e.solids[0].velocity[i] = g.input0()[i] * dna[0] + \
g.input1()[i] * dna[1] + \
g.input2()[i] * dna[2] + \
g.input3()[i] * dna[3]
if abs(e.solids[0].velocity[i]) >= 100:
return 10 ** -10
end_pos = pe.run_physics_engine(tick_length, e, time_limit)
return 1 / (pe.distance(destination, end_pos) ** 2)
def get_fitness(start_x, dna):
start_pos = get_start_pos(start_x, top)
e.solids[1].pos = [start_pos[0], start_pos[1]]
# create unique object of gene function class for each iteration
g = gene_functions.Gaps3(e.solids[1].pos[0], e.solids[1].pos[1])
# set velocity based on input functions and weights from DNA
for i in range(2):
e.solids[1].velocity[i] = g.input0()[i] * dna[0]
# g.input1()[i] * dna[1] + \
# g.input4()[i] * dna[2]
# run the physics engine until either the termination condition is reached (termination function has to be put into the physics_engine.py
runtime = pe.run_physics_engine(tick_length, e, time_limit)
# if the simulation exceeds the time limit before the termination condition is reached, or way too quickly, the organism's fitness will be virtually 0
if runtime >= time_limit or runtime <= tick_length * 10:
return .00001 # can't be 0 bc that could cause division by 0 later on
return runtime**2
for j in range(2):
velocity[j] = g.input0()[j] * dna[0]
# g.input1()[j] * dna[1] + \
# g.input4()[j] * dna[2]
print(velocity)
# print('velocity', velocity)
e = environments.Environment(solids=[pe.Circle(static=True),
pe.Circle(radius=1, pos=i, velocity=velocity)],
g_type='nonuniform',
g_strength=10)
# run the physics engine until either the termination condition is reached (termination function has to be put into the physics_engine.py
runtime = pe.run_physics_engine(.2, e, 100)
# print('runtime', runtime)
# if the simulation exceeds the time limit before the termination condition is reached, or way too quickly, the organism's fitness will be virtually 0
if runtime >= 100 or runtime <= .2 * 10:
print('fitness', 0)
else:
# fitness function, tries to minimize velocity while maximizing time spent before crashing back down to planet, uses normalized quantities
velocity_magnitude = pe.distance(velocity, [0, 0])
norm_runtime = (runtime - .2 * 10) / (100 - .2 * 10)
norm_velocity = velocity_magnitude / 5
print('fitness', (norm_runtime - norm_velocity) ** 2)
print()
# run neural network
for i in range(10**order):
if i % ((10**order) / 100) == 0:
print(i / (10**(order - 2)))
# turn the inputs into outputs using existing weights
n.feedforward()
# setup for running physics engine
e.solids[0].velocity = [n.l2[0][0] * 100, n.l2[0][1] * 100]
e.solids[0].pos = [-100, .001]
# run physics engine and use it in the cost function to determine error for later use in backpropagation
end_pos = pe.run_physics_engine(tick_length=.2,
environ=e,
time_limit=10**3)
# modify data for optimal use by backpropagation algorithm
difference = [end_pos[0] - destination[0], end_pos[1] - destination[1]]
share_proportion = .5 - (nn.nonlin(np.random.normal()) / 2)
complement = 1 - share_proportion
shared_difference = [
(difference[0] * complement) + (difference[1] * share_proportion),
(difference[1] * complement) + (difference[0] * share_proportion)
]
l2_error = np.array(
[-tanh(shared_difference[0] / 100), -tanh(shared_difference[1] / 100)])
n.backpropagation(l2_error)
import physics_engine as pe
from environments import Environment
import gene_functions
g = gene_functions.Gatd1()
velocity = [0, 0]
dna = [1.0493179215779653, 0.26432598219944303]
for j in range(2):
velocity[j] = g.input0()[j] * dna[0] + \
g.input1()[j] * dna[1]
e = Environment(solids=[pe.Circle(pos=[-100, -100], velocity=velocity),
pe.Rect(static=True, pos=[-155, 0], height=300),
pe.Rect(static=True, pos=[155, 0], height=300),
pe.Rect(static=True, pos=[0, -155], width=300),
pe.Rect(static=True, pos=[0, 155], width=300)],
g_type='downward',
g_strength=.2)
print(e.solids[0].velocity)
# run the physics engine until the termination condition is reached (termination function has to be put into the physics_engine.py and return statement corrected)
# time_limit is set to be virtually infinite because we are not worried about this environment running indefinitely, the ball will always eventually slow down to stop
end_pos = pe.run_physics_engine(.2, e, 10 ** 10)
print('fitness', 1 / pe.distance([0, 0], end_pos))
# # switch variables every 5 iterations
# if i % 20 == 0:
# destination = destinations[int(i / 20) % 5]
# e.g_strength[1] = gravities[int(i / 20) % 5]
# turn the inputs into outputs using existing weights
n.feedforward()
# setup for running physics engine
initial_velocity = [n.l2[0][0] * 10, n.l1[0][1] * 10]
e.solids[1].velocity = initial_velocity
e.solids[1].pos = [0, 11.001]
# run physics engine and use it in the cost function to determine error for later use in backpropagation
final_velocity = pe.run_physics_engine(tick_length=.2,
environ=e,
time_limit=50)
# modify data for optimal use by backpropagation algorithm
difference = [
initial_velocity[0] - final_velocity[0],
initial_velocity[1] - final_velocity[1]
]
share_proportion = .5 - (nn.nonlin(np.random.normal()) / 2)
complement = 1 - share_proportion
shared_difference = [
(difference[0] * complement) + (difference[1] * share_proportion),
(difference[1] * complement) + (difference[0] * share_proportion)
]
l2_error = np.array(
temp = tweak(time_limit)
if temp > 0:
time_limit = temp
n.inputs[0][3] = temp
# turn the inputs into outputs using existing weights
n.feedforward()
# setup for running physics engine
initial_velocity = [n.l2[0][0] * 10, n.l2[0][1] * 10]
e.solids[1].velocity = initial_velocity
e.solids[1].pos = [n.inputs[0][0], n.inputs[0][1]]
# run physics engine and use it in the cost function to determine error for later use in backpropagation
runtime = pe.run_physics_engine(tick_length=.2,
environ=e,
time_limit=time_limit,
e_type='PS_1')
# modify data for optimal use by backpropagation algorithm
difference = [runtime, runtime]
if i == (10**magnitude) - 1:
print('PS_1', difference)
n.backpropagation(get_l2_error(difference))
# start things off again
e = PS_2
time_limit = 50
n.inputs = np.array(