def display_actual(actual):
print("actual world: ", actual['world'])
print("actual sm: ", actual['sm'])
print("actual wp: ", actual['wp'])
print("actual signals: ", actual['signals'])
print("actual meta matrix: ")
pprint.pprint(fwd_model.calc_meta_matrix(actual['sm'], actual['wp']))
def mh_signals(state, responses, meta, own_noise_type,
meta_noise_type, prior_wp_sm,
binary_beliefs, experts, use_meta):
log_back_fwd = 0
new = np.zeros(len(state['signals']))
#internals = [{} for k in range(len(state['signals']))]
#belief_matrix = fwd.calc_belief_matrix(state['sm'], state['wp'])
belief_matrix = None
meta_matrix = fwd.calc_meta_matrix(state['sm'], state['wp'], belief_matrix)
for k, s in enumerate(state['signals']):
pkd = (k, state, responses, meta, own_noise_type, meta_noise_type,
prior_wp_sm, binary_beliefs, experts,
belief_matrix, meta_matrix, use_meta)
pkd_sig_current = (s,) + pkd
pkd_sig_proposed = (1-s,) + pkd
#new[k], internalsj[k] = mh_acceptance()
new[k] = mh_acceptance(s, 1 - s,
mh_signals_func(pkd_sig_current),
mh_signals_func(pkd_sig_proposed),
log_back_fwd)
return new#, internals
def meta_loglike_marg(meta, world, sm, wp, noise, params,
belief_matrix=None, meta_matrix=None):
"""Gives log prob of meta given responses, latent variables
Args: meta - 2d np.ar, rows are options, cols ppl
signals - np.arr, counting from 0
signals - np.arr
sm - signal matrix; 2d np.arr, cols is world, rows are signals
wp - np.arr giving prior on different world states
noise_type - str giving noise model for meta beliefs
noise - amt of meta noise (interpretation depends on noise_type)
Returns: log prob
"""
if not params['use_meta']:
return 0
if params['prior_wp_sm'] in ["none", "signal_assumption"]:
if belief_matrix is None:
belief_matrix = fwd.calc_belief_matrix(sm, wp)
if meta_matrix is None:
meta_matrix = fwd.calc_meta_matrix(sm, wp, belief_matrix)
#see from belief matrix whether 0, 100 or meta_matrix.
num_ppl = meta.shape[1]
probs = np.empty(num_ppl)
prob_sigs = sm[:, world]
if params['prior_wp_sm'] in ["none", "signal_assumption"]:
if belief_matrix[0, 1] > .5:
bayes_s0_sig = np.ones(2)
elif belief_matrix[0, 0] < .5:
bayes_s0_sig = np.zeros(2)
else:
bayes_s0 = meta_matrix[0,:]
else:
bayes_s0_sig = meta_matrix[0,:]
for k in range(num_ppl):
given_s0 = meta[0][k]
probs_assuming_sigs = np.array([prob_noisy(given_s0, bs0,
params['noise_type'], noise[k])
for bs0 in bayes_s0_sigs])
probs[k] = np.sum(prob_sigs * probs_assuming_sigs)
loglike = np.sum(np.log(probs))
return loglike
def mh_meta_noise(current, latents, meta, params):
noise_type = params['meta_noise_type']
if params['meta_noise_hierarchy'] != "individual":
print("mh_meta_noise only set up for indiv. noise")
sys.exit()
new = np.zeros(len(current))
#internals = [{} for k in range(len(state['meta_noise']))]
#belief_mats = [fwd.calc_belief_matrix(lat['sm'], lat['wp'])
# for lat in latents]
belief_mats = [None for k in range(len(latents))]
meta_mats = [fwd.calc_meta_matrix(lat['sm'],lat['wp'])
for lat in latents]
for pos, noise in enumerate(current):
propose, log_back_fwd = propose_meta_noise(noise, noise_type)
#new[pos], internals[pos] = mh_acceptance()
pkd = (pos, meta, latents, noise_type, params['prior_wp_sm'],
belief_mats, meta_mats)
pkd_current = (noise,) + pkd
pkd_propose = (propose,) + pkd
new[pos] = mh_acceptance(noise, propose,
mh_meta_noise_func(pkd_current),
mh_meta_noise_func(pkd_propose),
log_back_fwd)
return new#, internals
def wp_expt(sm=np.array([[.7, .4], [.3, .6]]), wp=np.array([.1, .9]),
change_wp=True):
params = setup_params.init_params_demo1()
params['binary_beliefs'] = False
indiv = fwd.generate_individual(params)
grid = 100
diff = 0
res0 = np.zeros((grid-grid*diff, grid-grid*diff))
res1 = np.zeros((grid-grid*diff, grid-grid*diff))
bm0 = np.zeros((grid-grid*diff, grid-grid*diff))
bm1 = np.zeros((grid-grid*diff, grid-grid*diff))
mm0 = np.zeros((grid-grid*diff, grid-grid*diff))
mm1 = np.zeros((grid-grid*diff, grid-grid*diff))
mm0avg = np.zeros((grid-grid*diff, grid-grid*diff))
#hacky since grid needn't be nice num.:
for k, gen in enumerate(np.arange(diff * grid, grid)):
actual = {}
gen_s0 = gen / grid + .01
if change_wp:
gen_wp = np.array([gen_s0, 1 - gen_s0])
actual['wp'] = gen_wp
actual['sm'] = sm
else:
actual['wp'] = wp
gen_sm = np.array([[gen_s0, gen_s0 - diff],
[1 - gen_s0, 1 - gen_s0 + diff]])
actual['sm'] = gen_sm
actual['world'] = 0
actual['signals'] = fwd.sample_signals(actual['world'], actual['sm'],
params['num_responses'])
beliefs, meta = fwd.generate_data(actual, indiv, params)
for j, ans in enumerate(np.arange(grid*diff, grid)):
ans_s0 = ans / grid + .01
if change_wp:
ans_wp = np.array([ans_s0, 1 - ans_s0])
ans_sm = actual['sm']
else:
ans_wp = actual['wp']
ans_sm = np.array([[ans_s0, ans_s0 - diff],
[1 - ans_s0, 1 - ans_s0 + diff]])
ll = np.array([aggregation.reports_ll_marg(beliefs, meta, w,
ans_sm, ans_wp,
indiv['own_noise'],
indiv['meta_noise'],
params)
for w in [0, 1]])
ll += aggregation.log_prob_world(actual['world'], ans_wp)
bel = fwd.calc_belief_matrix(ans_sm, ans_wp)
bm0[k, j] = bel[0,0]
bm1[k, j] = bel[0,1]
met = fwd.calc_meta_matrix(ans_sm, ans_wp)
mm0[k, j] = met[0,0]
mm1[k, j] = met[0,1]
if bel[0, 0] < .5:
mm0avg[k,j] = 0
elif bel[0, 1] > .5:
mm0avg[k,j] = 1
else:
mm0avg[k,j] = met[0,0]
if bel[0, 1] > .5:
non_bij = 1
elif bel[0,0] < .5:
non_bij = -1
else:
non_bij = 0
res0[k, j] = ll[0]
res1[k, j] = ll[1]
plt.imshow(res0, cmap=cm.Greys_r)
plt.imshow(res1, cmap=cm.Greys_r)
1/0
return res
