def maze(width=81, height=51, complexity=.75, density =.75):
# Only odd shapes
shape = ((height//2)*2+1, (width//2)*2+1)
# Adjust complexity and density relative to maze size
complexity = int(complexity*(5*(shape[0]+shape[1])))
density = int(density*(shape[0]//2*shape[1]//2))
# Build actual maze
Z = np.zeros(shape, dtype=bool)
# Fill borders
Z[0,:] = Z[-1,:] = 1
Z[:,0] = Z[:,-1] = 1
# Make isles
for i in range(density):
x, y = rnd(0,shape[1]//2)*2, rnd(0,shape[0]//2)*2
Z[y,x] = 1
for j in range(complexity):
neighbours = []
if x > 1: neighbours.append( (y,x-2) )
if x < shape[1]-2: neighbours.append( (y,x+2) )
if y > 1: neighbours.append( (y-2,x) )
if y < shape[0]-2: neighbours.append( (y+2,x) )
if len(neighbours):
y_,x_ = neighbours[rnd(0,len(neighbours)-1)]
if Z[y_,x_] == 0:
Z[y_,x_] = 1
Z[y_+(y-y_)//2, x_+(x-x_)//2] = 1
x, y = x_, y_
return Z
def make_points_random(number, width, height):
points = []
for i in range(number):
x = rnd(1,width-1)/width
y = rnd(1,height-1)/height
points.append(Point(x,y))
return points
def maze_recurse(width, height):
# Init maze as numpy array (all walls)
Z = numpy.ones((height, width))
def carve(y, x):
Z[y, x] = 0
yield Z
# get randomized list of neighbours
neighbours = [(x + 2, y), (x - 2, y), (x, y + 2), (x, y - 2)]
random.shuffle(neighbours)
for nx,ny in neighbours:
if nx < 0 or ny < 0 or nx >= width or ny >= height:
continue
if Z[ny, nx] == 1:
Z[(y + ny) / 2,(x + nx) / 2] = 0
for m in carve(ny, nx):
yield m
# choose random internal starting point
x, y = rnd(0, width // 2 - 1) * 2 + 1, rnd(0, height // 2 - 1) * 2 + 1
for m in carve(y, x):
yield m
# carve exits
Z[1, 0] = Z[-2, -1] = 0
yield Z
def maze_non_recurse(width, height):
# Init maze as numpy array (all walls)
Z = numpy.ones((height, width))
stack = []
# choose random internal starting point
x, y = rnd(0, width // 2 - 1) * 2 + 1, rnd(0, height // 2 - 1) * 2 + 1
# get randomized list of neighbours
n = neighbours(x, y, width, height)
while True:
Z[y, x] = 0
yield Z
for nx, ny in n:
if Z[ny, nx] == 1:
Z[(y + ny) / 2, (x + nx) / 2] = 0
stack.append((n, (x, y)))
y, x = ny, nx
n = neighbours(x, y, width, height)
break
else:
try:
n, (x, y) = stack.pop()
except IndexError:
break
# carve exits
Z[1, 0] = Z[-2, -1] = 0
yield Z
def get_sample(self):
"""
Returns an array of sample points sampled in the specified region using Bridson's Poisson-disk sampling algorithm
Returns
=======
samples: list of tuples of two ints
A list containing the coordinates sampled on a 2-d region such that no two samples points have distance less than `radius`.
"""
# initialize with a seed point
self.__sample__(rnd() * self.width, rnd() * self.height)
while len(self.queue) > 0:
idx = int(rnd() * len(self.queue))
p = self.queue[idx]
new_inserted = False
for j in xrange(self.k):
theta = 2 * np.pi * rnd()
# radius <= r <= 2 * radius
r = np.sqrt(3 * rnd() * self.radius**2 + self.radius**2)
x = p[0] + r * np.cos(theta)
y = p[1] + r * np.sin(theta)
if (0 <= x < self.width) and (0 <= y < self.height) and self.__far__(x,y):
self.__sample__(x,y)
new_inserted = True
break
# remove point from active list
if not new_inserted:
self.queue = self.queue[:idx] + self.queue[idx+1:]
self.samples.append(p)
return self.samples
def maze_coords(width, height):
"""Return a generator where each iteration is the x, y coord of
the next wall (brick?) location.
"""
# Init maze as numpy array (all walls)
Z = numpy.ones((height, width))
stack = []
# choose random internal starting point
x, y = rnd(0, width // 2 - 1) * 2 + 1, rnd(0, height // 2 - 1) * 2 + 1
# get randomized list of neighbours
n = neighbours(x, y, width, height)
yield -1, -1
while True:
Z[y, x] = 0
yield (x, y)
for nx, ny in n:
if Z[ny, nx] == 1:
Z[(y + ny) / 2, (x + nx) / 2] = 0
yield ((x + nx) / 2, (y + ny) / 2)
stack.append((n, (x, y)))
y, x = ny, nx
n = neighbours(x, y, width, height)
break
else:
try:
n, (x, y) = stack.pop()
yield (-1, -1)
except IndexError:
break
# carve exits
Z[1, 0] = Z[-2, -1] = 0
def get_pos(enem):
# choose random start position
pos = array((rnd() * 500., rnd() * 500.))
# make several iterations
for i in xrange(25):
# get direction that minimize loss func
g = get_grad(pos, enem)
# do one dimentional optimization
npos = one_dir_opt(pos, g, enem)
# check stop condition
if norm(npos - pos) < 0.5:
break
# update position
pos = npos
return pos
def test_new(self):
# should raise AttributeError if no name is specified:
self.assertRaises(AttributeError,Dim,range(3))
# should raise ValueError if not 1-D:
self.assertRaises(ValueError,Dim,rnd((2,3)),name='test')
# should raise ValueError if data is not unique
self.assertRaises(ValueError,Dim,[1,2,2,3],name='test')
# should work fine with any number of dimensions as long as it
# is squeezable or expandable to 1-D:
tst = Dim(rnd((3,1,1,1,1)),name='test')
self.assertEquals(tst.name,'test')
tst = Dim(np.array(5),name='test2')
self.assertEquals(tst.name,'test2')
# custom attributes should work, too:
tst = Dim(range(2),name='test3',custom='attribute')
self.assertEquals(tst.name,'test3')
self.assertEquals(tst.custom,'attribute')
# should raise Attribute Error if name is removed:
self.assertRaises(AttributeError,tst.__setattr__,'name',None)
def sample_plot(data, caption, f_name) :
lc = int(check_output(['wc', '-l', data]).split()[0])
# print lc
sample = list(rnd(lc, lc/5, replace=False))
sample.sort()
# print sample
with open(data, 'r') as d_file :
new_data = []
n = 0
i_sample = 0
n_sample = sample[i_sample]
while True :
if n == n_sample :
line = d_file.readline()
if not line : break
print line
new_data.append(float(line))
i_sample += 1
if i_sample >= len(sample) : break
n_sample = sample[i_sample]
n += 1
d_file.close
# data = map(float, data)
# data = pd.Series(data)
# data = rnd(data, 1000000000, replace=False)
print '%d samples ommited randomly from dataset.\nConverting to float' % len(new_data)
# data = [float(i) for i in new_data if isfloat(i)]
# print len(data)
print 'plotting.....'
fig = plt.figure(1, figsize=(16,16))
plt.boxplot(new_data, showmeans=True)
ax = plt.gca()
# plt.minorticks_on()
ax.yaxis.grid(True, linestyle='-', which='major', color='grey', alpha=0.5)
ax.yaxis.grid(True, linestyle='--', which='minor', color='lightgrey', alpha=0.5)
plt.title(caption)
fig.savefig(f_name)
def main(alt=False):
for i in range(5):
for j in range(10):
t = np.linspace(0, tend*(1 + rnd()), nt) + rnd(nt)*t_noise
A0 = A0_base + A0_noise*rnd()
if alt:
def f(y, t):
r = 4*y[0]**3*y[1]*atan(1)
return [-3*r, -r, r]
y = odeint(f, [1e-3, 0.1*(i+1), 0], t)[:, 0]
else:
y = (2.4*t*atan(1)*(i+1) + A0**-2)**-0.5
y *= 1 + y_noise*(rnd(nt) - 0.5)**3
if rnd() < 0.28:
print('%d, %d: noise!' % (i+1, j+1))
y *= 1 + strong_noise * y_noise*rnd(nt)**13
else:
print('%d, %d: silence...' % (i+1, j+1))
if not os.path.exists('data/0.%d' % (i+1)):
os.mkdir('data/0.%d' % (i+1))
np.savetxt('data/0.%d/%d.dat' % (i+1, j+1), np.vstack((t, eps_l*y)).T)
scene = C.scene
def make_sphere(name, location, size, u_segs=32, v_segs=16):
# Create an empty mesh and the object.
mesh = D.meshes.new("%s Mesh" % name)
sphere = D.objects.new(name, mesh)
# Add the object into the scene.
scene.objects.link(sphere)
scene.objects.active = sphere
# Construct the bmesh cube and assign it to the blender mesh.
geometry = bmesh.new()
bmesh.ops.create_uvsphere(geometry, u_segments=u_segs, v_segments=v_segs, diameter=size)
geometry.to_mesh(mesh)
sphere.location = location
geometry.free()
for obj in bpy.data.objects:
if 'g_' in obj.name:
bpy.data.objects.remove(obj)
for i in range(10):
make_sphere("g_sphere_%d" % i, rnd(3) * 10 - 5, 1)
for sphere in [obj for obj in bpy.data.objects if 'g_' in obj.name]:
def arbiter(state):
return bool(rnd(2))
preamble=json.load(preamblef)
preamblef.close()
#
# Open the data files from a signle run (GENERIC)
#
RUN_NAME=lambda i: NAME+"_"+str(i)
input_file_name=lambda i: os.path.join(NAME, RUN_NAME(i) + ".dat")
supp_file_name=lambda i: os.path.join(NAME, RUN_NAME(i) + ".sup")
try:
NUM=int(sys.argv[2]) #second argument to this script (if any) is a run number
except:
NUM=rnd(preamble['Nruns'])
input_file=open(input_file_name(NUM),'rb')
supp_file=open(supp_file_name(NUM),'rb')
#
# Prepare data entries from a single run (GENERIC)
#
DATA={}
#- prepare entries for experiment measurables
if preamble['mids_recorded'] is []:
pass
else:
def random_walk(state):
diff = 2 * rnd(2) - 1
newpos = (state[id_pos][0] + diff) % X_BOUND
return newpos
def start_experiment(stdscr, agent_to_examine):
NODELAY = 0
# grid definitions
X_BOUND = 4 #length
def in_bounds(pos):
return (pos >= 0 and pos <= X_BOUND)
# distance function
def dist(p, q):
return abs(p - q)
# agent discount parameters
MOTION_PARAMS = tuple([1. - pow(2, -6)])
#ARBITRATION_PARAMS=tuple([1.-pow(2,-2)])
#ARBITRATION_PEAK=2
# initialize a new experiment
EX = Experiment()
id_dec = EX.nid('decision')
# register basic motion agents;
# - $True$ tag means they will be marked as dependent (on other agents)
id_rt, id_rtc = EX.register_sensor('rt', True)
id_lt, id_ltc = EX.register_sensor('lt', True)
# register motivation for motion agents
# - this one is NOT dependent on agents except through the position, so
# it carries the default False tag.
id_distM = EX.register('distM')
id_navM, cid_navM = EX.register_sensor('navM')
# register supervising agent
#id_super,id_superc=EX.register_sensor('super',True)
# agent to be visualized
id_lookat = EX.nid(agent_to_examine)
# register arbiter variable whose purpose is to synchronize the responses
# of agents 'lt' and 'rt' to the action of 'super', it does not depend on
# agent decisions, hence carries the default False tag.
id_arbiter = EX.register('ar', True)
# register the failure mode sensor
#id_fail,id_failc=EX.register_sensor('fl')
# add a counter
id_count = EX.register('count')
def ex_counter(state):
return 1 + state[id_count][0]
EX.construct_measurable(id_count, ex_counter, [0])
# introduce arbitration
def arbiter(state):
return bool(rnd(2))
EX.construct_measurable(id_arbiter, arbiter, [bool(rnd(2))], 0)
id_toRT, id_toRTc = EX.register_sensor('toR', True)
def intention_RT(state):
return id_rt in state[id_dec][0]
EX.construct_sensor(id_toRT, intention_RT)
id_toLT, id_toLTc = EX.register_sensor('toL', True)
def intention_LT(state):
return id_lt in state[id_dec][0]
EX.construct_sensor(id_toLT, intention_LT)
# failure mode for action $lt^rt$
id_toF, id_toFc = EX.register_sensor('toF', True)
def about_to_enter_failure_mode(state):
return state[id_toLT][0] and state[id_toRT][0]
EX.construct_sensor(id_toF, about_to_enter_failure_mode)
# add basic motion agents
def action_RT(state):
rt_decided = (id_rt in state[id_dec][0])
if state[id_toF][0]:
#return not(rt_decided) if state[id_arbiter][0] else rt_decided
return state[id_arbiter][0]
else:
return rt_decided
RT = EX.construct_agent(id_rt, id_distM, action_RT, MOTION_PARAMS, True)
def action_LT(state):
lt_decided = (id_lt in state[id_dec][0])
if state[id_toF][0]:
#return lt_decided if state[id_arbiter][0] else not(lt_decided)
return not (state[id_arbiter][0])
else:
return lt_decided
LT = EX.construct_agent(id_lt, id_distM, action_LT, MOTION_PARAMS, True)
# immediately introduce corresponding action sensors
#EX.assign_sensor(id_rt,True,[id_lt])
#EX.assign_sensor(id_lt,True,[id_rt])
#
### "mapping" system
#
## introduce agent's position
# select starting position
START = rnd(X_BOUND + 1)
# effect of motion on position
id_pos = EX.register('pos')
def motion(state):
triggers = {id_rt: 1, id_lt: -1}
diff = 0
for t in triggers:
diff += triggers[t] * int(state[t][0])
newpos = state[id_pos][0] + diff
if in_bounds(newpos):
return newpos
else:
return state[id_pos][0]
EX.construct_measurable(id_pos, motion, [START, START])
## introduce effect of agent (not/)feeding (finding and consuming targets):
# generate target position
TARGET = START
while dist(TARGET, START) < X_BOUND / 8:
TARGET = rnd(X_BOUND + 1)
# set up position sensors
def xsensor(m): # along x-axis
return lambda state: state[id_pos][0] < m + 1
for ind in xrange(X_BOUND):
tmp_name = 'x' + str(ind)
id_tmp, id_tmpc = EX.register_sensor(
tmp_name) #registers the sensor pairs
EX.construct_sensor(id_tmp, xsensor(
ind)) #constructs the measurables associated with the sensor
EX.assign_sensor(id_tmp, True,
[id_rt, id_lt]) #assigns the sensor to all agents
# normalized distance to playground (nav function #1)
# - $id_distM$ has already been registerd
def distM(state):
if state[id_pos][0] == TARGET and state[id_pos][1] == TARGET:
return state[id_distM][0] + 1
else:
#sharp (near-logarithmic) spike at the target
#return 1.-np.log((1.+dist(state[id_pos][0],TARGET))/(X_BOUND+2))
#linear peak at the target
return 1 + X_BOUND - dist(state[id_pos][0], TARGET)
INIT = 1 + X_BOUND - dist(START, TARGET)
EX.construct_measurable(id_distM, distM, [INIT, INIT])
def navM(state):
return state[id_distM][0] - state[id_distM][1] > 0
EX.construct_sensor(id_navM, navM)
EX.assign_sensor(id_navM, True,
[id_rt, id_lt]) #assigns the sensor to all agents
#
### Initialize agents on GPU
#
for agent_name in EX._AGENTS:
tmp = EX._AGENTS[agent_name].init()
#
### Introduce a conjunction
#
#for agent in [RT,LT]:
# agent.amper([agent.generate_signal([EX.nid('x0*'),EX.nid('x2')])])
#
### Introduce delayed position sensors for both agents
for agent in [RT, LT]:
delay_sigs = [
agent.generate_signal([EX.nid('x' + str(ind))])
for ind in xrange(X_BOUND)
]
agent.delay(delay_sigs)
# another update cycle
message = EX.update_state()
#message=EX.update_state()
## SET ARTIFICIAL TARGET ONCE AND FOR ALL
for agent in [RT, LT]:
for token in ['plus', 'minus']:
tmp_target = agent.generate_signal([id_navM]).value_all().tolist()
agent.brain._snapshots[token].setTarget(tmp_target)
#
### Run
#
# prepare windows for output
curses.curs_set(0)
stdscr.erase()
# color definitions
curses.init_color(0, 0, 0, 0) #black=0
curses.init_color(1, 1000, 0, 0) #red=1
curses.init_color(2, 0, 1000, 0) #green=2
curses.init_color(3, 1000, 1000, 0) #yellow=3
curses.init_color(4, 1000, 1000, 1000) #white=4
curses.init_color(5, 1000, 1000, 500)
curses.init_pair(1, 0, 1) #black on red
curses.init_pair(2, 0, 2) #green on black
curses.init_pair(3, 0, 3) #black on yellow
curses.init_pair(4, 4, 0) #white on black
curses.init_pair(5, 1, 0) #red on black
curses.init_pair(6, 0, 5)
REG_BG = curses.color_pair(4) | curses.A_BOLD
POS_BG = curses.color_pair(2) | curses.A_BOLD
NEG_BG = curses.color_pair(1) | curses.A_BOLD
OBS_BG = curses.color_pair(6) | curses.A_BOLD
BG = curses.color_pair(5) | curses.A_BOLD
FG = curses.color_pair(3) | curses.A_BOLD
WIN = curses.newwin(9, 2 * X_BOUND + 3, 5, 7)
WINs = curses.newwin(9, 200, 16, 7)
stdscr.nodelay(NODELAY)
WIN.bkgdset(ord('.'), REG_BG)
WIN.overlay(stdscr)
WINs.overlay(stdscr)
def print_state(text, id_agent):
stdscr.clear()
stdscr.addstr('W-E A-R-E R-U-N-N-I-N-G (press [space] to stop) ')
stdscr.addstr(2, 3, text)
stdscr.clrtoeol()
stdscr.noutrefresh()
WIN.clear()
WIN.addstr(0, 0, str(EX.this_state(id_count, 1)))
WIN.chgat(0, 0, BG)
## Unpacking the output from the tested agent (RT/LT)
#determining the start position of geographic sensors in signals
geo_start = min(ind for ind, id_tmp in enumerate(LT._SENSORS)
if id_tmp == EX.nid('x0'))
#decompose extra info from agent
agent = EX._AGENTS[id_agent]
curr = agent._CURRENT
targ = agent._TARGET
pred = agent._PREDICTED
#choose the signals to visualize (curr,targ or pred)
for ind, lookat in enumerate([curr, pred, targ]):
#convert signals to region bounds
bounds = {'plus': [0, X_BOUND], 'minus': [0, X_BOUND]}
for token in ['plus', 'minus']:
for x in xrange(0, X_BOUND):
if lookat[token].value(geo_start + 2 * x):
bounds[token][1] = x #pushing down the upper bound
break
else:
continue
for x in xrange(X_BOUND - 1, -1, -1):
if lookat[token].value(geo_start + 2 * x + 1):
bounds[token][0] = x + 1 #pushing up the lower bound
break
else:
continue
#display the results
tok_BG = {'plus': POS_BG, 'minus': NEG_BG}
tok_line = {'plus': 3 - ind, 'minus': 6 + ind}
for token in ['plus', 'minus']:
min_pos = bounds[token][0]
max_pos = bounds[token][1]
for x in xrange(0, X_BOUND):
ori = ord('<') if lookat[token].value(
geo_start + 2 * x) else (
ord('>') if lookat[token].value(geo_start + 2 * x +
1) else ord('*'))
this_BG = tok_BG[token] if (x >= min_pos
and x < max_pos) else BG
WIN.addch(tok_line[token], 2 + 2 * x, ori, this_BG)
WIN.chgat(tok_line[token], 1 + 2 * min_pos,
1 + 2 * (max_pos - min_pos), tok_BG[token])
# display targets with FG attributes
WIN.addch(5, 1 + 2 * TARGET, ord('T'), FG)
# display agent's position with FG attributes
WIN.addch(4, 1 + 2 * EX.this_state(id_pos, 1), ord('S'), FG)
## Unpacking extra information
WINs.clear()
WINs.addstr(0, 0, 'Observation:')
WINs.addstr(4, 0, 'Chosen signed signal:')
#
tok_BG = {'plus': POS_BG, 'minus': NEG_BG}
vpos = {'plus': 6, 'minus': 8}
hpos = lambda x: 0 if x == 0 else 2 + len(' '.join(namelist[:x]))
# CURRENT OBSERVATION
OBS = agent._OBSERVE
#OBS=Signal([EX.this_state(mid) for mid in agent._SENSORS])
#SIGNED SIGNAL TO WATCH:
#SIG=agent._CURRENT
sig = agent.generate_signal([EX.nid('x0')])
#sig=agent.generate_signal([EX.nid('{x0*;x2}')])
#sig=agent.generate_signal([EX.nid('#x2')])
#sig=agent.generate_signal([EX.nid('#x0*')])
SIG = agent.brain.up(sig, False)
#
namelist = [EX.din(mid) for mid in agent._SENSORS]
#
for x, mid in enumerate(agent._SENSORS):
this_BG = OBS_BG if OBS.value(x) else REG_BG
WINs.addstr(2, hpos(x), namelist[x], this_BG)
for token in ['plus', 'minus']:
this_BG = tok_BG[token] if SIG[token].value(x) else REG_BG
WINs.addstr(vpos[token], hpos(x), namelist[x], this_BG)
# refresh the window
WIN.overlay(stdscr)
WIN.noutrefresh()
WINs.noutrefresh()
curses.doupdate()
## Main loop
while stdscr.getch() != ord(' '):
# call output subroutine
print_state('RUNNING:\n' + message, id_lookat)
# make decisions, update the state
message = EX.update_state()
else:
raise Exception('Aborting at your request...\n\n')
def start_experiment(run_params):
# System parameters
test_name = run_params['test_name']
host = run_params['host']
port = run_params['port']
# initialize a new experiment
EX = Experiment(test_name, UMARestService(host, port))
id_dec = 'decision'
id_count = 'counter'
# Recording options:
record_mids = run_params['mids_to_record']
record_global = run_params['ex_dataQ']
record_agents = run_params['agent_dataQ']
#A recorder will be initialized later, at the end of the initialization phase,
#to enable collection of all available data tags
# Decision cycles:
TOTAL_CYCLES = run_params['total_cycles']
# Parameters and definitions
MODE = run_params[
'mode'] #mode by which Sniffy moves around: 'teleport'/'walk'/'lazy'
X_BOUND = run_params[
'env_length'] # no. of edges in discrete interval = no. of GPS sensors
try:
Discount = float(run_params['discount']) #discount coefficient, if any
except KeyError:
Discount = 0.875
try:
Threshold = float(
run_params['threshold']
) #implication threshold, defaulting to the square of the probability of a single position.
except KeyError:
Threshold = 1. / pow(X_BOUND + 1, 2)
# Environment description
def in_bounds(pos):
return (pos >= 0 and pos <= X_BOUND)
def dist(p, q):
return abs(p - q) #distance between two points in environment
# agent parameters according to .yml file
empirical_observer = {
'type': 'empirical',
'AutoTarg': True,
'threshold': Threshold,
}
discounted_observer = {
'type': 'discounted',
'discount': Discount,
'AutoTarg': True,
'threshold': Threshold,
}
qualitative_observer = {
'type': 'qualitative',
'AutoTarg': True,
#'threshold': 0,
}
AGENT_PARAMS = {
'_Q': qualitative_observer,
'_Eu': empirical_observer,
'_Ev': empirical_observer,
'_Du': discounted_observer,
'_Dv': discounted_observer,
}
ORDERED_TYPES = ['_Q', '_Eu', '_Ev', '_Du', '_Dv']
#Register "observer" agents:
# These agents remain inactive throghout the experiment, in order to record
# all the UNCONDITIONAL implications among the initial sensors (in their 'minus'
# snapshots).
# For this purpose, each sensor's FOOTPRINT in the state space (positions in
# the interval) is recorded, so that implications may be calculated according
# to the inclusions among footprints.
id_obs = {}
cid_obs = {}
for typ in ORDERED_TYPES:
id_obs[typ], cid_obs[typ] = EX.register_sensor('obs' + typ)
# register motivation for motion agents
# - this one is NOT dependent on agents except through the position, so
# it carries the default "decdep=False" tag.
# Value signals for different setups determined as a *function* of distance to target
id_dist = EX.register('dist')
id_sig = {}
for typ in ORDERED_TYPES:
id_sig[typ] = EX.register('sig' + typ)
# ...which function? THIS function:
RESCALING = {
'_Q': lambda r: r,
'_Eu': lambda r: 1,
'_Ev': lambda r: X_BOUND - r,
'_Du': lambda r: 1,
'_Dv': lambda r: pow(1. - Discount, r - X_BOUND),
}
# OBSERVER agents simply collect implications among the assigned sensors, always inactive
OBSERVERS = {}
OBSACCESS = {}
for typ in ORDERED_TYPES:
OBSERVERS[typ] = EX.construct_agent(id_obs[typ], id_sig[typ],
lambda state: False,
AGENT_PARAMS[typ])
OBSACCESS[typ] = UMAClientData(EX._EXPERIMENT_ID, id_obs[typ], 'minus',
EX._service)
#
### "mapping" system
#
## introduce agent's position
# select starting position
START = rnd(X_BOUND + 1)
# effect of motion on position
id_pos = EX.register('pos')
def random_walk(state):
diff = 2 * rnd(2) - 1
newpos = state[id_pos][0] + diff
if in_bounds(newpos):
return newpos
else:
return state[id_pos][0]
def lazy_random_walk(state):
diff = rnd(3) - 1
newpos = state[id_pos][0] + diff
if in_bounds(newpos):
return newpos
else:
return state[id_pos][0]
def teleport(state):
return rnd(X_BOUND + 1)
def back_and_forth(state):
last_diff = state[id_pos][0] - state[id_pos][1]
thispos = state[id_pos][0]
if last_diff != 0:
newpos = thispos + last_diff
if in_bounds(newpos):
return newpos
else:
return thispos - last_diff
else:
if thispos < X_BOUND:
return thispos + 1
else:
return thispos - 1
motions = {
'simple': back_and_forth,
'walk': random_walk,
'lazy': lazy_random_walk,
'teleport': teleport
}
EX.construct_measurable(id_pos, motions[MODE], [START, START])
# generate target position
TARGET = START
while dist(TARGET, START) == 0:
TARGET = rnd(X_BOUND + 1)
# set up position sensors
def xsensor(footprint): # along x-axis
return lambda state: bool(footprint[state[id_pos][0]])
def make_footprint():
return [rnd(2) for ind in xrange(X_BOUND + 1)]
#generate randomized position sensors and record their semantics
FOOTPRINTS = []
all_comp = lambda x: [1 - t for t in x]
for ind in xrange(X_BOUND):
tmp_name = 'x' + str(ind)
tmp_footprint = make_footprint()
FOOTPRINTS.append(tmp_footprint)
FOOTPRINTS.append(all_comp(tmp_footprint))
id_tmp, id_tmpc = EX.register_sensor(tmp_name)
EX.construct_sensor(id_tmp, xsensor(tmp_footprint))
OBS.add_sensor(id_tmp)
#Construct footprint-type estimate of target position
id_targ = {}
def look_up_target(state, typ):
return OBSACCESS[typ].getTarget()
#- construct target estimate measurable for each observer
INIT = np.zeros(X_BOUND + 1).tolist()
for typ in ORDERED_TYPES:
id_targ[typ] = EX.register('targ' + typ)
EX.construct_measurable(id_targ[typ],
partial(look_up_target, typ=typ), [INIT],
depth=0)
# distance to target
# - $id_distM$ has already been registerd
def dist_to_target(state):
return dist(state[id_pos][0], TARGET)
INIT = dist(START, TARGET)
EX.construct_measurable(id_dist, dist_to_target, [INIT, INIT])
#
### MOTIVATIONS
#
#construct the motivational signal for OBS:
def rescaling(state, typ):
return RESCALING[typ](state[id_dist][0])
for typ in ORDERED_TYPES:
INIT = RESCALING[typ](dist(START, TARGET))
EX.construct_measurable(id_sig[typ], partial(rescaling, typ=typ),
[INIT, INIT])
#record the value at each position, for each type:
VALUES = {
typ:
[RESCALING[typ](dist(pos, TARGET)) for pos in xrange(X_BOUND + 1)]
for typ in ORDERED_TYPES
}
# -------------------------------------init--------------------------------------------
for agent_name in EX._AGENTS:
EX._AGENTS[agent_name].init()
QUERY_IDS = {agent_id: {} for agent_id in EX._AGENTS}
for agent_id in EX._AGENTS:
for token in ['plus', 'minus']:
# INTRODUCE DELAYED GPS SENSORS:
#delay_sigs = [EX._AGENTS[agent_id].generate_signal(['x' + str(ind)], token) for ind in xrange(X_BOUND)]
#EX._AGENTS[agent_id].delay(delay_sigs, token)
# MAKE A LIST OF ALL SENSOR LABELS FOR EACH AGENT
QUERY_IDS[agent_id][token] = EX._AGENTS[
agent_id].make_sensor_labels(token)
# START RECORDING
default_instruction = [cid_obs[typ] for typ in ORDERED_TYPES]
EX.update_state(default_instruction)
recorder = experiment_output(EX, run_params)
recorder.addendum('footprints', FOOTPRINTS)
recorder.addendum('query_ids', QUERY_IDS)
recorder.addendum('values', VALUES)
recorder.addendum('threshold', Threshold)
# -------------------------------------RUN--------------------------------------------
## Main Loop:
while EX.this_state(id_count) <= TOTAL_CYCLES:
# update the state
EX.update_state(default_instruction)
recorder.record()
# Wrap up and collect garbage
recorder.close()
EX.remove_experiment()
def lazy_random_walk(state):
diff = rnd(3) - 1
newpos = (state[id_pos][0] + diff) % X_BOUND
return newpos
def teleport(state):
return rnd(X_BOUND + 1)
def make_footprint():
return [rnd(2) for ind in xrange(X_BOUND + 1)]
def main():
mode = None
if len(sys.argv) < 2 or sys.argv[1] in ('-h','--help','help'):
usage()
sys.exit(0)
mode = sys.argv[1]
if not mode in modes:
print('Unknown working mode: [%s].' % sys.argv[1])
sys.exit(1)
opts = parseGlobalArgs()
if mode in ['hybrid']:
opts = dict(parseHybridModeArgs(), **opts)
recorder_id = 0
neuron_id = []
sfactor = 1
offset = 1
for i in range(len(opts['N'])):
neuron_id.append(offset+np.arange(opts['N'][i]))
offset = offset + opts['N'][i]
all_neurons = [item for sublist in neuron_id for item in sublist]
# Add RealNeuron here...
if mode in ['hybrid']:
real_neuron = max(all_neurons)+1
all_neurons.append(real_neuron)
syn = []
for i,s in zip(range(len(neuron_id)),opts['syn']):
idx = [np.array([all_neurons[int(rnd(max(all_neurons)))] for i in range(s)]) for n in neuron_id[i]]
syn.append(idx)
syn_count = max(all_neurons)+1
syn_param = [] # [synapse_id,origin,target,weight,type]
for nn,ss,syn_type,type_weight in zip(neuron_id,syn,opts['synType'],opts['w']):
for n,s in zip(nn,ss):
if not opts['autapses']:
print n, s
s = s[np.where(s!=n)[0]]
weights = np.bincount(s)
targets = np.arange(len(weights))
targets = targets[np.nonzero(weights)]
weights = weights[np.nonzero(weights)]
for t,w in zip(targets,weights):
syn_param.append([syn_count,n,t,w*type_weight,syn_type])
syn_count += 2
if mode in ['hybrid']:
rn_syn_param = []
s = np.array([all_neurons[int(rnd(max(all_neurons)))] for i in range(opts['RN_syn_n'])])
print s
if not opts['autapses']:
s = s[np.where(s!=real_neuron)[0]]
weights = np.bincount(s)
targets = np.arange(len(weights))
targets = targets[np.nonzero(weights)]
weights = weights[np.nonzero(weights)]
for t,w in zip(targets,weights):
rn_syn_param.append([syn_count,real_neuron,t,w*opts['RN_syn_w'],opts['RN_syn_type']])
syn_count +=2
rn_syn_p = np.array(rn_syn_param)
syn_p = np.array(syn_param)
root = etree.Element("lcg")
e_group = etree.SubElement(root,"entities")
simulation_parameters = etree.SubElement(root,"simulation")
add_xml_elements(simulation_parameters,{'rate':opts['srate'],
'tend':opts['tend']})
id_cnt = 0
if opts['record-all'] or mode in ['hybrid']:
recorder = etree.SubElement(e_group,"entity")
add_xml_elements(recorder,{'name':'H5Recorder',
'id':recorder_id})
add_xml_parameters(recorder,{'compress':True})
id_cnt+=1
# Create RealNeuron
if mode in ['hybrid']:
nrn = etree.SubElement(e_group,"entity")
add_xml_elements(nrn,{'name':'RealNeuron',
'id':real_neuron})
add_xml_parameters(nrn,{'spikeThreshold':opts['threshold'],
'V0':-65,
'deviceFile':'/dev/comedi0',
'inputSubdevice':os.environ['AI_SUBDEVICE'],
'outputSubdevice':os.environ['AO_SUBDEVICE'],
'inputRange':os.environ['RANGE'],
'readChannel':opts['ai'],
'writeChannel':opts['ao'],
'inputConversionFactor':os.environ['AI_CONVERSION_FACTOR_CC'],
'outputConversionFactor':os.environ['AO_CONVERSION_FACTOR_CC'],
'holdLastValue':True,
'reference':os.environ['GROUND_REFERENCE']})
connections = rn_syn_p[np.where(rn_syn_p[:,1]==real_neuron)[0],0]
connections = np.append(connections,0)
add_xml_connections(nrn,connections)
for s_id,s_s,s_t,s_w,s_type in rn_syn_param:
if s_type in [1]:
# Excitatory
delay = np.random.uniform(0.1e-3,10e-3)
E = 0
tauRise = 0.03e-3
tauDecay = 5e-3
else:
# Inhibitory
delay = np.random.uniform(0.1e-3,10e-3)
E = -70
tauRise = 0.1e-3
tauDecay = 10e-3
add_exponential_synapse(e_group,s_id,s_t,delay,s_w,E,tauRise,tauDecay,[s_t])
# Create all Izhikevich neurons
for ii,nn in enumerate(neuron_id):
for n in nn:
connections = syn_p[np.where(syn_p[:,1]==n)[0],0]
if opts['record-all']:
connections = np.append(connections,0)
izh_par = {'a': np.random.uniform(opts['a'][ii][0],opts['a'][ii][1]),
'b': np.random.uniform(opts['b'][ii][0],opts['b'][ii][1]),
'c': np.random.uniform(opts['c'][ii][0],opts['c'][ii][1]),
'd': np.random.uniform(opts['d'][ii][0],opts['d'][ii][1]),
'Vspk':opts['Vspk'][ii],
'Iext': np.random.uniform(opts['Iext'][ii][0],opts['Iext'][ii][1])}
add_izhikevich_neuron(e_group,n,izh_par,connections)
# Create all synapses
for s_id,s_s,s_t,s_w,s_type in syn_param:
if s_type in [1]:
# Excitatory
delay = np.random.uniform(0.1e-3,10e-3)
E = 0
tauRise = 0.03e-3
tauDecay = 5e-3
else:
# Inhibitory
delay = np.random.uniform(0.1e-3,10e-3)
E = -70
tauRise = 0.1e-3
tauDecay = 10e-3
add_exponential_synapse(e_group,s_id,s_t,delay,s_w,E,tauRise,tauDecay,[s_t])
xml_tree = etree.ElementTree(root)
config_file = 'izhikevich_net.xml'
xml_tree.write(config_file,pretty_print=True)
# Run protocol
if opts['kernel']:
sub.call('lcg kernel -I ' + str(opts['ai']) + ' -O ' + str(opts['ao']) +
' -F ' + str(opts['srate']) + ' -a', shell=True)
sub.call(lcg.common.prog_name + ' -c ' + config_file + ' -i ' + str(opts['interval']) +
' -n ' + str(opts['nreps']), shell=True)
def start_experiment(run_params):
# set randmization seed
SEED = seed()
# System parameters
test_name = run_params['test_name']
host = run_params['host']
port = run_params['port']
# initialize a new experiment
EX = Experiment(test_name, UMARestService(host, port))
id_dec = 'decision'
id_count = 'counter'
# Recording options:
record_mids = run_params['mids_to_record']
record_global = run_params['ex_dataQ']
record_agents = run_params['agent_dataQ']
#A recorder will be initialized later, at the end of the initialization phase,
#to enable collection of all available data tags
# Decision cycles:
TOTAL_CYCLES = run_params['total_cycles']
# Parameters and definitions
MODE = run_params[
'mode'] #mode by which Sniffy moves around: 'teleport'/'walk'/'lazy'
X_BOUND = run_params[
'env_length'] # no. of edges in discrete interval = no. of GPS sensors
BEACON_WIDTH = run_params['beacon_width'] # [max] width of beacon sensor
ENV_LENGTH = X_BOUND
NSENSORS = X_BOUND
try:
Discount = float(run_params['discount']) #discount coefficient, if any
except KeyError:
Discount = 0.75
try:
Threshold = float(
run_params['threshold']
) #implication threshold, defaulting to the square of the probability of a single position.
except KeyError:
Threshold = 1. / pow(ENV_LENGTH, 2)
# Environment description
def in_bounds(pos):
return (pos >= 0 and pos < X_BOUND)
def dist(p, q):
return min(abs(p - q), X_BOUND -
abs(p - q)) #distance between two points in environment
# agent parameters according to .yml file
empirical_observer = {
'type': 'empirical',
'AutoTarg': True,
'threshold': Threshold,
}
discounted_observer = {
'type': 'discounted',
'q': Discount,
'AutoTarg': True,
'threshold': Threshold,
}
qualitative_observer = {
'type': 'qualitative',
'AutoTarg': True,
'threshold': 0,
}
AGENT_PARAMS = {
'_Q': qualitative_observer,
'_Eu': empirical_observer,
'_Ev': empirical_observer,
'_Du': discounted_observer,
'_Dv': discounted_observer,
}
ORDERED_TYPES = ['_Q', '_Eu', '_Ev', '_Du', '_Dv']
#Register "observer" agents:
# These agents remain inactive throghout the experiment, in order to record
# all the UNCONDITIONAL implications among the initial sensors (in their 'minus'
# snapshots).
# For this purpose, each sensor's FOOTPRINT in the state space (positions in
# the interval) is recorded, so that implications may be calculated according
# to the inclusions among footprints.
id_obs = {}
cid_obs = {}
for typ in ORDERED_TYPES:
id_obs[typ], cid_obs[typ] = EX.register_sensor('obs' + typ)
# register motivation for motion agents
# - this one is NOT dependent on agents except through the position, so
# it carries the default "decdep=False" tag.
# Value signals for different setups determined as a *function* of distance to target
id_dist = EX.register('dist')
id_sig = {}
for typ in ORDERED_TYPES:
id_sig[typ] = EX.register('sig' + typ)
# ...which function? THIS function:
RESCALING = {
#'_Q': lambda r: r,
'_Q': lambda r: 1 if r > 0 else 0,
'_Eu': lambda r: 1,
'_Ev': lambda r: pow((X_BOUND / 2) - r, 1),
'_Du': lambda r: 1,
'_Dv': lambda r: pow(1. - Discount, r - (X_BOUND / 2)),
}
# OBSERVER agents simply collect implications among the assigned sensors, always inactive
OBSERVERS = {}
OBSACCESS = {}
for typ in ORDERED_TYPES:
OBSERVERS[typ] = EX.construct_agent(id_obs[typ], id_sig[typ],
lambda state: False,
AGENT_PARAMS[typ])
OBSACCESS[typ] = UMAClientData(EX._EXPERIMENT_ID, id_obs[typ], 'minus',
EX._service)
#
### "mapping" system
#
## introduce agent's position
# select starting position
START = rnd(X_BOUND)
# effect of motion on position
id_pos = EX.register('pos')
def walk_through(state):
newpos = (state[id_pos][0] + 1) % X_BOUND
return newpos
def random_walk(state):
diff = 2 * rnd(2) - 1
newpos = (state[id_pos][0] + diff) % X_BOUND
return newpos
def lazy_random_walk(state):
diff = rnd(3) - 1
newpos = (state[id_pos][0] + diff) % X_BOUND
return newpos
def teleport(state):
return rnd(X_BOUND)
motions = {
'simple': walk_through,
'walk': random_walk,
'lazy': lazy_random_walk,
'teleport': teleport
}
EX.construct_measurable(id_pos, motions[MODE], [START, START])
# generate target position
TARGET = START
while dist(TARGET, START) == 0:
TARGET = rnd(ENV_LENGTH)
# set up position sensors
def xsensor(m, width): # along x-axis
return lambda state: dist(state[id_pos][0], m) <= width
# Construct initial sensors and record their semantics
FOOTPRINTS = []
all_comp = lambda x: [1 - t for t in x]
for ind in xrange(X_BOUND):
# create new beacon sensor centered at $ind$
tmp_name = 'x' + str(ind)
id_tmp, id_tmpc = EX.register_sensor(
tmp_name) # registers the sensor pairs
EX.construct_sensor(
id_tmp, xsensor(ind, BEACON_WIDTH)
) # constructs the measurables associated with the sensor
for typ in ORDERED_TYPES:
OBSERVERS[typ].add_sensor(id_tmp)
# record the sensor footprint
tmp_footprint = [(1 if dist(pos, ind) <= BEACON_WIDTH else 0)
for pos in xrange(X_BOUND)]
FOOTPRINTS.append(tmp_footprint)
FOOTPRINTS.append(all_comp(tmp_footprint))
# sensor footprints for this run
fp = lambda sensor_ind: np.array(FOOTPRINTS[sensor_ind])
#get internal data for each agent
id_internal = {}
def get_internal(state, typ):
return OBSACCESS[typ].get_all()
INIT = {}
for typ in ORDERED_TYPES:
id_internal[typ] = EX.register('internal' + typ)
EX.construct_measurable(id_internal[typ],
partial(get_internal, typ=typ), [INIT],
depth=0)
#Construct footprint-type estimate of target position
id_targ = {}
def look_up_target(state, typ):
target_fp = np.ones(ENV_LENGTH)
for ind, val in enumerate(state[id_internal[typ]][0]['target']):
target_fp = target_fp * fp(ind) if val else target_fp
return target_fp.tolist()
#- construct target estimate measurable for each observer
INIT = np.zeros(ENV_LENGTH).tolist()
for typ in ORDERED_TYPES:
id_targ[typ] = EX.register('targ' + typ)
EX.construct_measurable(id_targ[typ],
partial(look_up_target, typ=typ), [INIT],
depth=0)
# distance to target
# - $id_distM$ has already been registerd
def dist_to_target(state):
return dist(state[id_pos][0], TARGET)
INIT = dist(START, TARGET)
EX.construct_measurable(id_dist, dist_to_target, [INIT, INIT])
#
### MOTIVATIONS
#
#construct the motivational signal for OBS:
def rescaling(state, typ):
return RESCALING[typ](state[id_dist][0])
for typ in ORDERED_TYPES:
INIT = RESCALING[typ](dist(START, TARGET))
EX.construct_measurable(id_sig[typ], partial(rescaling, typ=typ),
[INIT, INIT])
#
### AUXILIARY COMPUTATIONS
#
# value of each position in the environment, needed as np.array, for each run and type
VALUES = {
typ: [RESCALING[typ](dist(pos, TARGET)) for pos in xrange(ENV_LENGTH)]
for typ in ORDERED_TYPES
}
vm = lambda typ: np.array(VALUES[typ])
# extreme (=target) value of signal for each run and type
v_extreme = lambda typ: vm(typ).min() if typ == '_Q' else vm(typ).max()
#Construct value-based ground truth target footprint
GROUND_TARG = {}
for typ in ORDERED_TYPES:
GROUND_TARG[typ] = [
int(abs(val - v_extreme(typ)) < pow(10, -12)) for val in vm(typ)
]
#Ground truth implication matrices
#
#- check for inclusions among footprint vectors:
std_imp_check = lambda x, y: all(fp(x) <= fp(y))
#- check for ground truth thresholded inclusions (footprint-based)
def lookup_val(x, y, typ):
#obtain footprints
FPx = fp(x)
FPy = fp(y)
#compute the expected ground weights
if typ == '_Q':
return -1 if not sum(FPx * FPy) else np.extract(
FPx * FPy, vm(typ)).min()
else:
#return (sum(FPx*FPy*vm(typ))+0.)/ENV_LENGTH
return (sum(FPx * FPy * vm(typ)) + 0.) / sum(vm(typ) + 0.)
#- check for [ground truth] implications (index based)
def imp_check(x, y, typ):
XY = lookup_val(x, y, typ)
X_Y = lookup_val(compi(x), y, typ)
X_Y_ = lookup_val(compi(x), compi(y), typ)
XY_ = lookup_val(x, compi(y), typ)
if typ == '_Q': #qualitative implication (zero threshold)
return int(qless(qmax(XY, X_Y_), XY_))
else: #real-valued (statistical) implication
if y == x:
#same sensor yields a True entry
return 1
elif y == compi(x):
#complementary sensors yield a False entry
return 0
else:
#otherwise, compare weights:
#return int(XY_<min(Threshold*sum(vm(typ)),XY,X_Y_,X_Y) or (XY_==0. and X_Y==0.))
return int(XY_ < min(Threshold, XY, X_Y_, X_Y)
or (XY_ == 0. and X_Y == 0.))
#- construct the ground truth matrices (flattened) for each run and type
GROUND_WEIGHTS = {typ: [] for typ in ORDERED_TYPES}
GROUND_RAW_IMPS = {typ: [] for typ in ORDERED_TYPES}
GROUND_ABS_IMPS = []
for yind in xrange(2 * NSENSORS):
for xind in xrange(yind + 1):
#weights and other expected implications, by type:
for typ in ORDERED_TYPES:
lookup = partial(lookup_val, typ=typ)
check = partial(imp_check, typ=typ)
# Weight matrix computed from known values of states
GROUND_WEIGHTS[typ].append(lookup(yind, xind))
# PCR matrix computed from known values of states; note the transpose!!
GROUND_RAW_IMPS[typ].append(check(yind, xind))
#absolute ground-truth implications:
for yind in xrange(2 * NSENSORS):
for xind in xrange(yind + 1):
GROUND_ABS_IMPS.append(std_imp_check(yind, xind))
if yind % 2 == 0:
GROUND_ABS_IMPS.append(0)
#- import weight matrices from core
id_weights = {typ: EX.register('wgt' + typ) for typ in ORDERED_TYPES}
def weights(state, typ):
#print typ+' weights:'
#print convert_weights(state[id_internal[typ]][0]['weights'])
#print '\n'
return flatten(state[id_internal[typ]][0]['weights'])
for typ in ORDERED_TYPES:
INIT = (-np.ones(NSENSORS * (2 * NSENSORS + 1)) if typ == '_Q' else
np.zeros(NSENSORS * (2 * NSENSORS + 1))).tolist()
EX.construct_measurable(id_weights[typ],
partial(weights, typ=typ), [INIT],
depth=0)
#- import raw implications from core
id_raw_imps = {typ: EX.register('raw' + typ) for typ in ORDERED_TYPES}
def raw_imps(state, typ):
#print typ+' implications:'
#print convert_raw_implications(state[id_internal[typ]][0]['dirs'])
#print '\n'
return flatten(state[id_internal[typ]][0]['dirs'])
INIT = [(1 if x == y else 0) for y in xrange(2 * NSENSORS)
for x in xrange(y + 1)
] #initialize to (lower triangle of) identity matrix
for typ in ORDERED_TYPES:
EX.construct_measurable(id_raw_imps[typ],
partial(raw_imps, typ=typ), [INIT],
depth=0)
#- import full implications from core
id_full_imps = {typ: EX.register('full' + typ) for typ in ORDERED_TYPES}
def full_imps(state, typ):
return flatten(state[id_internal[typ]][0]['npdirs'])
xr = lambda y: y + 2 if y % 2 == 0 else y + 1
INIT = [(1 if x == y else 0) for y in xrange(2 * NSENSORS)
for x in xrange(xr(y))
] #initialize to (lower 2*2 triangle of) identity matrix
for typ in ORDERED_TYPES:
EX.construct_measurable(id_full_imps[typ],
partial(full_imps, typ=typ), [INIT],
depth=0)
#- ell_infinity distance of current weights to ground truth
id_wdiffs = {typ: EX.register('wdiff' + typ) for typ in ORDERED_TYPES}
def wdiffs(state, typ):
#print state[id_weights[typ]][0]
return max(ldiff(state[id_weights[typ]][0], GROUND_WEIGHTS[typ]))
for typ in ORDERED_TYPES:
#print '\n\n'
#print EX.this_state(id_weights[typ])
#print len(EX.this_state(id_weights[typ]))
#print '\n\n'
#print GROUND_WEIGHTS[typ]
#print len(GROUND_WEIGHTS[typ])
#print '\n\n'
INIT = max(ldiff(EX.this_state(id_weights[typ]), GROUND_WEIGHTS[typ]))
EX.construct_measurable(id_wdiffs[typ],
partial(wdiffs, typ=typ), [INIT],
depth=0)
#- ell_one distance of learned PCR to expected ground truth PCR
id_rawdiffs = {typ: EX.register('rdiff' + typ) for typ in ORDERED_TYPES}
def rawdiffs(state, typ):
return sum(ldiff(state[id_raw_imps[typ]][0], GROUND_RAW_IMPS[typ]))
for typ in ORDERED_TYPES:
#print '\n\n'
#print EX.this_state(id_raw_imps[typ])
#print GROUND_RAW_IMPS[typ]
#print '\n\n'
INIT = sum(ldiff(EX.this_state(id_raw_imps[typ]),
GROUND_RAW_IMPS[typ]))
EX.construct_measurable(id_rawdiffs[typ],
partial(rawdiffs, typ=typ), [INIT],
depth=0)
#- ell_one distance of FULL implications to true ABSOLUTE implications
id_fulldiffs = {typ: EX.register('fdiff' + typ) for typ in ORDERED_TYPES}
def fulldiffs(state, typ):
return sum(ldiff(state[id_full_imps[typ]][0], GROUND_ABS_IMPS))
for typ in ORDERED_TYPES:
INIT = sum(ldiff(EX.this_state(id_full_imps[typ]), GROUND_ABS_IMPS))
EX.construct_measurable(id_fulldiffs[typ],
partial(fulldiffs, typ=typ), [INIT],
depth=0)
# -------------------------------------init--------------------------------------------
for agent_name in EX._AGENTS:
EX._AGENTS[agent_name].init()
QUERY_IDS = {agent_id: {} for agent_id in EX._AGENTS}
for agent_id in EX._AGENTS:
for token in ['plus', 'minus']:
# INTRODUCE DELAYED GPS SENSORS:
#delay_sigs = [EX._AGENTS[agent_id].generate_signal(['x' + str(ind)], token) for ind in xrange(NSENSORS)]
#EX._AGENTS[agent_id].delay(delay_sigs, token)
# MAKE A LIST OF ALL SENSOR LABELS FOR EACH AGENT
QUERY_IDS[agent_id][token] = EX._AGENTS[
agent_id].make_sensor_labels(token)
# START RECORDING
default_instruction = [cid_obs[typ] for typ in ORDERED_TYPES]
EX.update_state(default_instruction)
recorder = experiment_output(EX, run_params)
recorder.addendum('query_ids', QUERY_IDS)
recorder.addendum('threshold', Threshold)
recorder.addendum('Nsensors', NSENSORS)
recorder.addendum('env_length', ENV_LENGTH)
recorder.addendum('ground_targ', GROUND_TARG)
recorder.record()
# -------------------------------------RUN--------------------------------------------
## Main Loop:
while EX.this_state(id_count) <= TOTAL_CYCLES:
# update the state
EX.update_state(default_instruction)
recorder.record()
# Wrap up and collect garbage
recorder.close()
EX.remove_experiment()
"G5T. R/0.036458333333333925 EB5I R/0.040104166666667496 " \
"G5/0.203125 R/0.04843749999999858 C5/0.5833333333333334 RH " \
"BB5Q R/0.16666666666666607 A5T. R/0.036458333333333925 G5I " \
"R/0.040104166666667496 A5/0.203125 R/0.04843749999999858 " \
"D5/0.5833333333333334 R/0.5078125 A5/0.1234375 " \
"R/0.02083333333333215 G5/0.0484375 R/0.0442708333333357 " \
"F5/0.12083333333333333 R/0.0390625 C5/0.4817708333333333 " \
"R/0.11093749999999858 A5/0.140625 R/0.014062500000001421 " \
"G5/0.052083333333333336 R/0.04322916666666643 " \
"F5/0.11197916666666667 R/0.02708333333333357 " \
"C5/0.45208333333333334 R/0.16145833333333215"
PATTERN = PATTERN.replace("/", "-")
logging.debug("pattern: %s", PATTERN)
words = PATTERN.split()
logging.debug("words: %s", words)
pairs = yield_pairs(words)
logging.debug("pairs: %s", pairs)
field = train(pairs, words[-1])
logging.debug("field: %s", field)
chain = [rnd(words)]
for _ in range(80):
chain.append(rnd(field[chain[-1]]))
logging.debug("chain: %s", chain)
RESULT = ' '.join(chain).replace("-", "/")
logging.info("result: %s", RESULT)
