def __init__(self,
init_pos=np.zeros(3),
init_rot=np.zeros(3),
condition=Hybrid(),
live_sky=True,
fov=None,
rgb=False,
visualiser=None,
name=None):
"""
:param init_pos: the initial position
:type init_pos: np.ndarray
:param init_rot: the initial orientation (yaw, pitch, roll)
:type init_rot: np.ndarray
:param condition:
:type condition: Hybrid
:param live_sky: flag to update the sky with respect to the time
:type live_sky: bool
:param fov: vertical field of view of the agent (the widest: -pi/2 to pi/2)
:type fov: tuple, list, np.ndarray
:param rgb: flag to set as input to the network all the channels (otherwise use only green)
:type rgb: bool
:param visualiser:
:type visualiser: Visualiser
:param name: a name for the agent
:type name: string
"""
if fov is None:
fov = Agent.FOV
self.pos = init_pos
self.rot = init_rot
self.nest = np.zeros(2)
self.feeder = np.zeros(2)
self.live_sky = live_sky
self.rgb = rgb
self.visualiser = visualiser
self.homing_routes = []
self.world = None # type: World
self.__is_foraging = False
self.__is_homing = False
self.dx = 0. # type: float
self.condition = condition
self.__per_ground = np.abs(fov[0]) / (np.pi / 2) # type: float
self.__per_sky = np.abs(fov[1]) / (np.pi / 2) # type: float
self.log = Logger()
Agent.__latest_agent_id__ += 1
self.id = Agent.__latest_agent_id__
if name is None:
self.name = "agent_%02d" % Agent.__latest_agent_id__
else:
self.name = name
def create_ephem_paths():
# sensor design
n = 60
omega = 56
theta, phi, fit = angles_distribution(n, float(omega))
theta_t, phi_t = 0., 0.
# ant-world
noise = 0.0
ttau = .06
dx = 1e-02 # meters
dt = 2. / 60. # min
delta = timedelta(minutes=dt)
routes = load_routes()
flow = dx * np.ones(2) / np.sqrt(2)
max_theta = 0.
def encode(theta, phi, Y, P, A, theta_t=0., phi_t=0., d_phi=0., nb_tcl=8, sigma=np.deg2rad(13),
shift=np.deg2rad(40)):
alpha = (phi + np.pi / 2) % (2 * np.pi) - np.pi
phi_tcl = np.linspace(0., 2 * np.pi, nb_tcl, endpoint=False) # TB1 preference angles
phi_tcl = (phi_tcl + d_phi) % (2 * np.pi)
# Input (POL) layer -- Photo-receptors
s_1 = Y * (np.square(np.sin(A - alpha)) + np.square(np.cos(A - alpha)) * np.square(1. - P))
s_2 = Y * (np.square(np.cos(A - alpha)) + np.square(np.sin(A - alpha)) * np.square(1. - P))
r_1, r_2 = np.sqrt(s_1), np.sqrt(s_2)
r_pol = (r_1 - r_2) / (r_1 + r_2 + eps)
# Tilting (CL1) layer
d_cl1 = (np.sin(shift - theta) * np.cos(theta_t) +
np.cos(shift - theta) * np.sin(theta_t) *
np.cos(phi - phi_t))
gate = np.power(np.exp(-np.square(d_cl1) / (2. * np.square(sigma))), 1)
w = -float(nb_tcl) / (2. * float(n)) * np.sin(phi_tcl[np.newaxis] - alpha[:, np.newaxis]) * gate[:, np.newaxis]
r_tcl = r_pol.dot(w)
R = r_tcl.dot(np.exp(-np.arange(nb_tcl) * (0. + 1.j) * 2. * np.pi / float(nb_tcl)))
res = np.clip(3.5 * (np.absolute(R) - .53), 0, 2) # certainty of prediction
ele_pred = 26 * (1 - 2 * np.arcsin(1 - res) / np.pi) + 15
d_phi += np.deg2rad(9 + np.exp(.1 * (54 - ele_pred))) / (60. / float(dt))
return r_tcl, d_phi
stats = {
"max_alt": [],
"noise": [],
"opath": [],
"ipath": [],
"d_x": [],
"d_c": [],
"tau": []
}
avg_time = timedelta(0.)
terrain = z_terrain.copy()
for enable_ephemeris in [False, True]:
if enable_ephemeris:
print "Foraging with the time compensation mechanism."
else:
print "Foraging without the time compensation mechanism."
# stats
d_x = [] # logarithmic distance
d_c = []
tau = [] # tortuosity
ri = 0
print "Routes: ",
for route in routes[::2]:
net = CX(noise=0., pontin=False)
net.update = True
# sun position
cur = datetime(2018, 6, 21, 10, 0, 0)
seville_obs.date = cur
sun.compute(seville_obs)
theta_s = np.array([np.pi / 2 - sun.alt])
phi_s = np.array([(sun.az + np.pi) % (2 * np.pi) - np.pi])
sun_azi = []
sun_ele = []
time = []
# outward route
route.condition = Hybrid(tau_x=dx)
oroute = route.reverse()
x, y, yaw = [(x0, y0, yaw0) for x0, y0, _, yaw0 in oroute][0]
opath = [[x, y, yaw]]
v = np.zeros(2)
tb1 = []
d_phi = 0.
for _, _, _, yaw in oroute:
theta_n, phi_n = tilt(theta_t, phi_t, theta, phi + yaw)
sun_ele.append(theta_s[0])
sun_azi.append(phi_s[0])
time.append(cur)
sky.theta_s, sky.phi_s = theta_s, phi_s
Y, P, A = sky(theta_n, phi_n, noise=noise)
if enable_ephemeris:
r_tb1, d_phi = encode(theta, phi, Y, P, A, d_phi=d_phi)
else:
r_tb1, d_phi = encode(theta, phi, Y, P, A, d_phi=0.)
yaw0 = yaw
_, yaw = np.pi - decode_sph(r_tb1) + phi_s
net(yaw, flow)
yaw = (yaw + np.pi) % (2 * np.pi) - np.pi
v = np.array([np.sin(yaw), np.cos(yaw)]) * route.dx
opath.append([opath[-1][0] + v[0], opath[-1][1] + v[1], yaw])
tb1.append(net.tb1)
cur += delta
seville_obs.date = cur
sun.compute(seville_obs)
theta_s = np.array([np.pi / 2 - sun.alt])
phi_s = np.array([(sun.az + np.pi) % (2 * np.pi) - np.pi])
opath = np.array(opath)
yaw -= phi_s
# inward route
ipath = [[opath[-1][0], opath[-1][1], opath[-1][2]]]
L = 0. # straight distance to the nest
C = 0. # distance towards the nest that the agent has covered
SL = 0.
TC = 0.
tb1 = []
tau.append([])
d_x.append([])
d_c.append([])
while C < 15:
theta_n, phi_n = tilt(theta_t, phi_t, theta, phi + yaw)
sun_ele.append(theta_s[0])
sun_azi.append(phi_s[0])
time.append(cur)
sky.theta_s, sky.phi_s = theta_s, phi_s
Y, P, A = sky(theta_n, phi_n, noise=noise)
if enable_ephemeris:
r_tb1, d_phi = encode(theta, phi, Y, P, A, d_phi=d_phi)
else:
r_tb1, d_phi = encode(theta, phi, Y, P, A, d_phi=0.)
_, yaw = np.pi - decode_sph(r_tb1) + phi_s
motor = net(yaw, flow)
yaw = (ipath[-1][2] + motor + np.pi) % (2 * np.pi) - np.pi
v = np.array([np.sin(yaw), np.cos(yaw)]) * route.dx
ipath.append([ipath[-1][0] + v[0], ipath[-1][1] + v[1], yaw])
tb1.append(net.tb1)
L = np.sqrt(np.square(opath[0][0] - ipath[-1][0]) + np.square(opath[0][1] - ipath[-1][1]))
C += route.dx
d_x[-1].append(L)
d_c[-1].append(C)
tau[-1].append(L / C)
if C <= route.dx:
SL = L
if TC == 0. and len(d_x[-1]) > 50 and d_x[-1][-1] > d_x[-1][-2]:
TC = C
cur += delta
seville_obs.date = cur
sun.compute(seville_obs)
theta_s = np.array([np.pi / 2 - sun.alt])
phi_s = np.array([(sun.az + np.pi) % (2 * np.pi) - np.pi])
ipath = np.array(ipath)
d_x[-1] = np.array(d_x[-1]) / SL * 100
d_c[-1] = np.array(d_c[-1]) / TC * 100
tau[-1] = np.array(tau[-1])
ri += 1
avg_time += cur - datetime(2018, 6, 21, 10, 0, 0)
stats["max_alt"].append(0.)
stats["noise"].append(noise)
stats["opath"].append(opath)
stats["ipath"].append(ipath)
stats["d_x"].append(d_x[-1])
stats["d_c"].append(d_c[-1])
stats["tau"].append(tau[-1])
print ".",
print ""
print "average time:", avg_time / ri # 1:16:40
np.savez_compressed("data/pi-stats-ephem.npz", **stats)
def create_paths(noise_type="uniform"):
global seville_obs, sun, dx
# sensor design
n = 60
omega = 56
theta, phi, fit = angles_distribution(n, float(omega))
theta_t, phi_t = 0., 0.
# sun position
seville_obs.date = datetime(2018, 6, 21, 9, 0, 0)
sun.compute(seville_obs)
theta_s = np.array([np.pi / 2 - sun.alt])
phi_s = np.array([(sun.az + np.pi) % (2 * np.pi) - np.pi])
# ant-world
noise = 0.0
ttau = .06
dx = 1e-02
routes = load_routes()
flow = dx * np.ones(2) / np.sqrt(2)
max_theta = 0.
stats = {
"max_alt": [],
"noise": [],
"opath": [],
"ipath": [],
"d_x": [],
"d_c": [],
"tau": []
}
for max_altitude in [.0, .1, .2, .3, .4, .5]:
for ni, noise in enumerate([0.0, 0.2, 0.4, 0.6, 0.8, .97]):
# stats
d_x = [] # logarithmic distance
d_c = []
tau = [] # tortuosity
ri = 0
for route in routes[::2]:
dx = route.dx
net = CX(noise=0., pontin=False)
net.update = True
# outward route
route.condition = Hybrid(tau_x=dx)
oroute = route.reverse()
x, y, yaw = [(x0, y0, yaw0) for x0, y0, _, yaw0 in oroute][0]
opath = [[x, y, yaw]]
v = np.zeros(2)
tb1 = []
for _, _, _, yaw in oroute:
theta_t, phi_t = get_3d_direction(opath[-1][0], opath[-1][1], yaw, tau=ttau)
max_theta = max_theta if max_theta > np.absolute(theta_t) else np.absolute(theta_t)
theta_n, phi_n = tilt(theta_t, phi_t, theta, phi + yaw)
sky.theta_s, sky.phi_s = theta_s, phi_s
Y, P, A = sky(theta_n, phi_n, noise=get_noise(theta_n, phi_n, noise, mode=noise_type))
r_tb1 = encode(theta, phi, Y, P, A)
yaw0 = yaw
_, yaw = np.pi - decode_sph(r_tb1) + phi_s
net(yaw, flow)
yaw = (yaw + np.pi) % (2 * np.pi) - np.pi
v = np.array([np.sin(yaw), np.cos(yaw)]) * route.dx
opath.append([opath[-1][0] + v[0], opath[-1][1] + v[1], yaw])
tb1.append(net.tb1)
opath = np.array(opath)
yaw -= phi_s
# inward route
ipath = [[opath[-1][0], opath[-1][1], opath[-1][2]]]
L = 0. # straight distance to the nest
C = 0. # distance towards the nest that the agent has covered
SL = 0.
TC = 0.
tb1 = []
tau.append([])
d_x.append([])
d_c.append([])
while C < 15:
theta_t, phi_t = get_3d_direction(ipath[-1][0], ipath[-1][1], yaw, tau=ttau)
theta_n, phi_n = tilt(theta_t, phi_t, theta, phi + yaw)
sky.theta_s, sky.phi_s = theta_s, phi_s
Y, P, A = sky(theta_n, phi_n, noise=noise)
r_tb1 = encode(theta, phi, Y, P, A)
_, yaw = np.pi - decode_sph(r_tb1) + phi_s
motor = net(yaw, flow)
yaw = (ipath[-1][2] + motor + np.pi) % (2 * np.pi) - np.pi
v = np.array([np.sin(yaw), np.cos(yaw)]) * route.dx
ipath.append([ipath[-1][0] + v[0], ipath[-1][1] + v[1], yaw])
tb1.append(net.tb1)
L = np.sqrt(np.square(opath[0][0] - ipath[-1][0]) + np.square(opath[0][1] - ipath[-1][1]))
C += route.dx
d_x[-1].append(L)
d_c[-1].append(C)
tau[-1].append(L / C)
if C <= route.dx:
SL = L
if TC == 0. and len(d_x[-1]) > 50 and d_x[-1][-1] > d_x[-1][-2]:
TC = C
ipath = np.array(ipath)
d_x[-1] = np.array(d_x[-1]) / SL * 100
d_c[-1] = np.array(d_c[-1]) / TC * 100
tau[-1] = np.array(tau[-1])
ri += 1
stats["max_alt"].append(max_altitude)
stats["noise"].append(noise)
stats["opath"].append(opath)
stats["ipath"].append(ipath)
stats["d_x"].append(d_x[-1])
stats["d_c"].append(d_c[-1])
stats["tau"].append(tau[-1])
np.savez_compressed("../data/pi-stats-%s.npz" % noise_type, **stats)
show = True
i = 0
for update_sky, uniform_sky, rgb, rng in exps:
date = datetime(2018, 6, 21, 12, 0, 0) # shifted_datetime()
if rng is None:
rng = np.random.RandomState(2018)
RND = rng
fov = (-np.pi / 2, np.pi / 2)
# fov = (-np.pi/6, np.pi/2)
sky_type = "uniform" if uniform_sky else "live" if update_sky else "fixed"
if rgb:
sky_type += "-rgb"
step = .01 # 1 cm
tau_phi = np.pi # 180 deg
condition = Hybrid(tau_x=step, tau_phi=tau_phi)
agent_name = create_agent_name(date, sky_type, step, fov[0], fov[1])
print agent_name
world = load_world()
world.enable_pol_filters(enable_pol)
world.uniform_sky = uniform_sky
routes = load_routes()
route = routes[i]
route.agent_no = 1
route.route_no = 2
world.add_route(route)
i += 1
agent = CXAgent(
condition=condition,
ri = 0
print "Noise:", noise
sky.theta_s, sky.phi_s = np.pi / 6, np.pi
eta = get_noise(theta_sky, phi_sky, noise, noise_type)
Y, P, A = sky(theta_sky, phi_sky, noise=eta)
plt.figure("Sky-%d-%s" % (noise * 10, noise_type), figsize=(7.5, 2.5))
plot_sky(phi_sky, theta_sky, Y, P, A)
# for route in routes[::2]:
for route in [routes[0]]:
net = CX(noise=0., pontin=False)
net.update = True
# outward route
route.condition = Hybrid(tau_x=dx)
oroute = route.reverse()
x, y, yaw = [(x0, y0, yaw0) for x0, y0, _, yaw0 in oroute][0]
opath = [[x, y, yaw]]
v = np.zeros(2)
tb1 = []
# print np.rad2deg(phi_s)
# plt.figure("yaws")
for _, _, _, yaw in oroute:
if mode == "uneven":
theta_t, phi_t = get_3d_direction(opath[-1][0],
opath[-1][1],
yaw,
tau=ttau)
if best_pn2kc is None or dispersion[trial] < dispersion[:trial].min():
best_pn2kc = pn2kc
# if non of the samples have dispersion lower than the baseline,
# return the less dispersed one
return best_pn2kc
if __name__ == "__main__":
from world import load_world, load_routes
from agent import Visualiser
from world import Hybrid
world = load_world()
routes = load_routes()
routes[0].condition = Hybrid(tau_x=.1, tau_phi=np.pi)
world.add_route(routes[0])
nn = WillshawNet(nb_channels=3)
nn.update = True
vis = Visualiser(mode="panorama")
vis.reset()
x, y, z = np.zeros(3)
phi = 0.
def world_snapshot(width=None, height=None):
global x, y, z, phi
return world.draw_panoramic_view(x,
y,
z,