def evaluate_combination(self, target, feasible_set, t, r, logging=False): """ return expected information gain of target combination (target) for a specific degree-order pair """ if logging: print "\n### Evaluating combination: ", target collected_responses = [] if self.codelength == 2: n_responses = self.codelength**2 + 1 else: n_responses = self.codelength**2 prob_of_response = np.zeros(n_responses) ''' compute feedback for each combination in the feasible set ''' for combination in feasible_set: response = self.response(target, combination) probability = self.get_probability(combination) if response not in collected_responses: #add to responses collected_responses.append(response) idx = np.where(np.array(collected_responses)==response)[0] prob_of_response[idx] += probability prob_of_response = np.array((prob_of_response[:len(collected_responses)] / np.sum(prob_of_response))) collected_responses = np.array(collected_responses) ''' compute prior entropy (before guess) ''' self.getCurrentFS() fs, fs_prob, _ = self.currentFS prior_entropy = sharma_mittal.sm_entropy(fs_prob, t=t, r=r) ''' compute hypothetical feasible sets for all possible responses ''' entropy_of_sets = [] for response in collected_responses: f_rc = [] #construct hypothetical feasible set if logging: print "\n -> when response is: ", response for combination, c_prob in zip(fs, fs_prob): if (self.response(combination, target) == response): f_rc.append(c_prob) f_rc /= np.sum(f_rc) if logging: print tmf_rcp entropy_of_sets.append(sharma_mittal.sm_entropy(f_rc, t=t, r=r)) entropy_of_sets = np.array(entropy_of_sets) exp_post_entropy = np.sum(np.multiply(entropy_of_sets, prob_of_response)) return prior_entropy - exp_post_entropy
def evaluate_combination(self, target, feasible_set, t, r, logging=False): """ return expected information gain of target combination (target) for a specific degree-order pair """ if logging: print "\n### Evaluating combination: ", target collected_responses = [] if self.codelength == 2: n_responses = self.codelength**2 + 1 else: n_responses = self.codelength**2 prob_of_response = np.zeros(n_responses) ''' compute feedback for each combination in the feasible set ''' for combination in feasible_set: response = self.response(target, combination) probability = self.get_probability(combination) if response not in collected_responses: #add to responses collected_responses.append(response) idx = np.where(np.array(collected_responses)==response)[0] prob_of_response[idx] += probability prob_of_response = np.array((prob_of_response[:len(collected_responses)] / np.sum(prob_of_response))) collected_responses = np.array(collected_responses) ''' compute prior entropy (before guess) ''' self.getCurrentFS() fs, fs_prob, _ = self.currentFS prior_entropy = sharma_mittal.sm_entropy(fs_prob, t=t, r=r) ''' compute hypothetical feasible sets for all possible responses ''' entropy_of_sets = [] for response in collected_responses: f_rc = [] #construct hypothetical feasible set if logging: print "\n -> when response is: ", response for combination, c_prob in zip(fs, fs_prob): if (self.response(combination, target) == response): f_rc.append(c_prob) f_rc /= np.sum(f_rc) if logging: print tmf_rcp entropy_of_sets.append(sharma_mittal.sm_entropy(f_rc, t=t, r=r)) entropy_of_sets = np.array(entropy_of_sets) exp_post_entropy = np.sum(np.multiply(entropy_of_sets, prob_of_response)) return prior_entropy - exp_post_entropy
def sm_usefulness(self, d, degree, order, normalize=True):
prior_entropy = sharma_mittal.sm_entropy(d.prior, degree, order)
posterior_entropy = [
np.sum([
d.marginal[i][j] * sharma_mittal.sm_entropy(dd, degree, order)
for j, dd in enumerate(posterior)
]) for i, posterior in enumerate(d.posterior)
]
sm_relevance = prior_entropy - np.array(posterior_entropy)
if not normalize: return sm_relevance
oidx = np.where(self.orderSpace == order)[0][0]
didx = np.where(self.degreeSpace == degree)[0][0]
upperBound = self.bounds[0][oidx][didx]
lowerBound = self.bounds[1][oidx][didx]
if upperBound == lowerBound: return [0, 0]
for i, uu in enumerate(
sm_relevance): #PREVENT u from being out of bounds!
sm_relevance[i] = min(upperBound, sm_relevance[i])
sm_relevance[i] = max(lowerBound, sm_relevance[i])
return (sm_relevance - lowerBound) / (upperBound - lowerBound)
def global_utility(self, d, pure_ig=False):
likelihood = np.empty((self.N, self.N, self.N_beta, self.n_trials + 1))
posterior = np.empty((self.n_trials + 1, self.N, self.N, self.N_beta))
for (t, r, b), p in np.ndenumerate(self.prior):
likelihood[t][r][b] = self.model_likelihood(
d, self.degreeSpace[t], self.orderSpace[r], self.betaSpace[b])
for y in np.arange(self.n_trials + 1):
posterior[y][t][r][b] = p * likelihood[t][r][b][y]
unnorm_post = np.copy(posterior)
for y in np.arange(self.n_trials + 1): #normalize posteriors
posterior[y] /= np.sum(posterior[y])
self.prior_ent = sharma_mittal.sm_entropy(self.prior, r=1.0, t=1.0)
margpost = [
np.sum(unnorm_post[y]) for y in np.arange(self.n_trials + 1)
]
post_ent = [
sharma_mittal.sm_entropy(unnorm_post[y], r=1.0, t=1.0)
for y in np.arange(self.n_trials + 1)
]
exp_post_ent = np.dot(margpost, post_ent)
global_utility = self.prior_ent - exp_post_ent
# global_utility = 0
# for (t,r,b), p in np.ndenumerate(self.prior):
# for y in np.arange(self.n_trials+1):
# global_utility += p * likelihood[t][r][b][y] * self.local_utility(
# t,r,b,y,posterior[y][t][r][b])
# print(global_utility)
if pure_ig: return global_utility
if self.l_flag: return global_utility * self.learnability(d)
else: return global_utility
def viz_triplet(self, old_prior, d):
f, axarr = plt.subplots(1, 3, figsize=(16, 5))
prior_ent = sharma_mittal.sm_entropy(old_prior, r=1.0, t=1.0)
post_ent = sharma_mittal.sm_entropy(self.prior, r=1.0, t=1.0)
axarr[0] = self.viz_prior(
old_prior,
ax=axarr[0],
title=r'Prior $\quad P(\Theta) \qquad ent^{SM_{(1,1)}}(P)=%.2f$' %
prior_ent,
annotate=self.step)
axarr[1] = self.viz_prior(
ax=axarr[1],
title=
r'Posterior $\quad P(\Theta|d=d^{*},y=%d) \qquad ent^{SM_{(1,1)}}(P)=%.2f$'
% (self.results.responses[-1], post_ent),
annotate=self.step + 1)
# axarr[2] = ternary_plot.plot(d,
# t=self.degreeSpace[int(self.guess_degree)],
# r=self.orderSpace[int(self.guess_order)],
# ax=axarr[2], title=r'Design $d^{*}$')
axarr[2] = ternary_plot.plot(d,
t=self.degreeSpace[int(self.true_degree)],
r=self.orderSpace[int(self.true_order)],
ax=axarr[2],
title=r'"Optimal" Design $d^{*}$')
y1, y2 = axarr[2].get_ylim()
axarr[2].set_ylim([y1, y2 * 1.1])
f.subplots_adjust(left=0.05,
bottom=0.10,
right=0.95,
top=0.90,
wspace=0.0,
hspace=0.0)
return f
def learnability(self, d, split=False, noH=False):
"""
Function to compute learnability of a given environment d.
Description:
------------
Learnability has two components: the posterior and the joint
distribution. The posterior is scored according to how dissimilar
its two largest values are. The joint component penalizes joint
feature combinations that are very small (and non-zero).
Arguments:
----------
d (design object): the environment to be evaluated
Returns:
--------
learnability: posterior and joint score (between 0 and 1)
"""
def transformPosterior(x, c=15, n=2):
return 1 if x == 0 else (2 / (1 + np.exp(-c * abs(x - n))) - 1)
def transformJoint(x, e=0.01, c=30):
if x == 0: return 1
return 0 if x <= e else (2 / (1 + np.exp(-c * (x - e))) - 1)
postScore = []
altProbabilities = np.zeros(self.N_categories)
for idx, featureComb in enumerate(d.postComb):
altProbabilities[np.argmax(featureComb)] += d.margComb[idx]
n = np.max(featureComb)
postScore.append([
transformPosterior(f, n=n) for f in np.sort(featureComb)[:-1]
])
postScore = np.prod(postScore)
jointScore = np.prod([transformJoint(x) for x in d.margComb.flatten()])
maxEnt = np.log(np.count_nonzero(altProbabilities))
ent = sharma_mittal.sm_entropy(altProbabilities, 1.0, 1.0)
hetScore = 0 if maxEnt == 0 else ent / maxEnt
if noH: return postScore * jointScore
if split: return [postScore, jointScore, hetScore]
else: return postScore * jointScore * hetScore
def compute_console_statistics(self): """ Funciton to compute (position/color/feasible set) statistics used by the MMind_App. The statistics are displayed in the statistics widget """ self.getCurrentFS() #------ compute position statistics position_statistics = np.zeros(shape=(self.Ncolors, self.codelength)) for p in np.arange(self.codelength): position_vector = self.currentFS[0][:,p] for c in np.arange(self.Ncolors): idx = np.where(position_vector==(c+1)) position_statistics[c][p] += np.sum(self.currentFS[1][idx]) #------ compute color statistics color_statistics = np.zeros(shape=(self.Ncolors, self.codelength+1)) for code, p in zip(self.currentFS[0], self.currentFS[1]): count = np.bincount(code)[1:] count = np.pad(count, (0, self.Ncolors-len(count)), mode='constant', constant_values=0) for color, number in np.ndenumerate(count): color_statistics[color][number] += p #------ compute fs statistics fs_size = len(self.currentFS[0]) fs_entropy = sharma_mittal.sm_entropy( self.currentFS[1], t=1.0, r=1.0) n = 5 topIDX = [np.argsort(self.currentFS[1])][0][-n:] topC = self.currentFS[0][topIDX][::-1] topP = self.currentFS[1][topIDX][::-1] fs_stats = [fs_size, fs_entropy, topC, topP] return [position_statistics, color_statistics, fs_stats]
def compute_console_statistics(self): """ Funciton to compute (position/color/feasible set) statistics used by the MMind_App. The statistics are displayed in the statistics widget """ self.getCurrentFS() #------ compute position statistics position_statistics = np.zeros(shape=(self.Ncolors, self.codelength)) for p in np.arange(self.codelength): position_vector = self.currentFS[0][:,p] for c in np.arange(self.Ncolors): idx = np.where(position_vector==(c+1)) position_statistics[c][p] += np.sum(self.currentFS[1][idx]) #------ compute color statistics color_statistics = np.zeros(shape=(self.Ncolors, self.codelength+1)) for code, p in zip(self.currentFS[0], self.currentFS[1]): count = np.bincount(code)[1:] count = np.pad(count, (0, self.Ncolors-len(count)), mode='constant', constant_values=0) for color, number in np.ndenumerate(count): color_statistics[color][number] += p #------ compute fs statistics fs_size = len(self.currentFS[0]) fs_entropy = sharma_mittal.sm_entropy( self.currentFS[1], t=1.0, r=1.0) n = 5 topIDX = [np.argsort(self.currentFS[1])][0][-n:] topC = self.currentFS[0][topIDX][::-1] topP = self.currentFS[1][topIDX][::-1] fs_stats = [fs_size, fs_entropy, topC, topP] return [position_statistics, color_statistics, fs_stats]
def fs_entropy(self, fs, t, r): """ returns Sharma-Mittal entropy of feasible """ probs = self.fs_probability(fs) return sharma_mittal.sm_entropy(probs, t=t, r=r)
def entropy(p):
return sharma_mittal.sm_entropy(p, t, r)
def fs_entropy(self, fs, t, r): """ returns Sharma-Mittal entropy of feasible """ probs = self.fs_probability(fs) return sharma_mittal.sm_entropy(probs, t=t, r=r)
def run(self, func):
"""
Recursive function that is at the heart of ADO.
"""
#stopping criterion
if self.step >= self.max_steps: return True
else: self.step += 1
#specify filename for save file
if self.save_results:
if not self.filename:
fileName = 'hado_' + str(datetime.datetime.now().strftime(
"%Y-%m-%d_%H-%M-%S")) + '_id_' + str(
self.fileID) + '_step_' + str(self.step)
else:
fileName = self.filename
fileName = 'data/' + fileName
#start iteration
self.tic()
self.log("\n### STEP %s ###" % self.step)
#using pre-specified design
if self.method == 'pre':
self.log("\t### using pre-specified design ... ###")
d, u = self.step_design, self.global_utility(self.step_design)
self.toc()
#design optimization step
else:
self.log("\t### executing optimization method ... ###")
d, u = func.optimize(self, **self.m_args)
self.log("\t### ... done! ###")
self.toc()
self.log("\t### time per design eval = %.12f" %
(self.trial_time / (self.m_args['n_designs'] * 1.0)))
#save results
self.results.lscores.append(self.learnability(d))
self.results.dobject.append(d)
self.results.designs.append(d.oneLine())
self.results.utilities.append(u)
self.results.pure_utilities.append(self.global_utility(d,
pure_ig=True))
self.log("\t### U(d) = %2.4f ###" %
self.global_utility(d, pure_ig=True))
lj, jp, lh = self.learnability(d, split=True)
self.log("\t### L(d) = %2.8f (post), %2.8f (joint) ###" % (lj, jp))
self.log("\t### Heterogeneity (0-1) = %1.5f ###" % lh)
self.log("\t### U(.)*L(.) = %2.4f ###" % u)
#factor learnability into beta
if self.l_flag:
beta_star = self.betaSpace[self.true_beta] * self.learnability(
d, noH=True)
else:
beta_star = self.betaSpace[self.true_beta]
self.log("\t### effective beta = %.5f" % beta_star)
if self.set_response != -1:
response = self.set_response
self.log("\t### pre-specified response: %s" % response)
else:
#simulate experiment
response_distribution = self.model_likelihood(
d, self.degreeSpace[self.true_degree],
self.orderSpace[self.true_order], beta_star)
# response = sp.choice(self.n_trials+1, p=response_distribution)[0] #hack for numpy v. < 1.6
response = np.random.choice(self.n_trials + 1,
p=response_distribution)
self.log("\t### simulated response: %s" % response)
self.results.responses.append(response)
self.marginals = self.marginal_response_probability(
d) #probability of response under model(s)
#update posterior
old_prior = np.copy(self.prior)
posterior_response_0 = np.copy(self.prior)
posterior_response_1 = np.copy(self.prior)
def update_prior(prior, response):
for (t, r, b), p in np.ndenumerate(prior):
prior[t][r][b] = self.model_likelihood(
d, self.degreeSpace[t], self.orderSpace[r],
self.betaSpace[b])[response] * p
prior /= np.sum(prior)
return prior
posterior_response_0 = update_prior(posterior_response_0, 0)
posterior_response_1 = update_prior(posterior_response_1, 1)
#actual experiment:
self.prior = update_prior(self.prior, response)
self.prior_ent = sharma_mittal.sm_entropy(self.prior, r=1.0, t=1.0)
#compute and store results
self.results.time_array.append(self.trial_time)
self.compute_results()
self.log("\t### execution time (s): %s ###" % self.trial_time)
# def pround(a, decimals=4):
# a = np.round_(a, decimals=decimals)
# midx = np.argmax(a)
# e = 1 - np.sum(a)
# a[midx] += e
# return a
if self.plotting or self.save_results:
f = self.viz_full(d, old_prior)
if self.save_results:
fileName += '_stage_' + str(self.step).zfill(3)
f.savefig(fileName + '_figures.pdf',
dpi=150,
bbox_inches='tight')
with open(fileName + '_design.txt', 'w') as text_file:
strtofile = 'Prior\n' + \
np.array_str(self.results.dobject[-1].prior) + \
'\n\nLikelihoods\n' + \
np.array_str(self.results.dobject[-1].marginal) + \
'\n\nFeature marginals\n' + \
np.array_str(self.results.dobject[-1].likelihoods) + \
'\n\nFeature Posteriors\n' + \
np.array_str(self.results.dobject[-1].posterior) + \
'\n\nMarginals (combined)\n' + \
np.array_str(self.results.dobject[-1].margComb) + \
'\n\nPosteriors (combined)\n' + \
np.array_str(self.results.dobject[-1].postComb) + \
'\n\nJoint probabilities\n' + \
np.array_str(self.results.dobject[-1].joint) + \
'\n\n!!! Use flattened joint probabilities array (from top left to bottom right) for experience-based learning experiment !!!'
self.log("\n\nResults successfully SAVED as %s!!" %
fileName)
strtofile = strtofile + '\n\n' + self.log_string
text_file.write("Environment:\n%s" % strtofile)
# save design
np.save(fileName + '_design.npy',
d.asNumpy(),
allow_pickle=False)
# save prior
np.save(fileName + '_prior.npy', old_prior, allow_pickle=False)
# save posterior(s)
np.save(fileName + '_posterior_0.npy',
posterior_response_1,
allow_pickle=False)
np.save(fileName + '_posterior_1.npy',
posterior_response_0,
allow_pickle=False)
'''
if self.plotting or self.save_results:
f = self.viz_triplet(old_prior, d)
self.viz_like(d, annotate=True, ax=None)
# if self.plotting: plt.show()
if self.save_results: f.savefig(
'plots/'+datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S")+'.pdf',
dpi=150, bbox_inches='tight')
'''
return self.run(func)
def compute_results(self):
"""
USE THIS FUNCTION TO SAVE RESULTS TO ADO.results AFTER EACH ITERATION
"""
#Mean Squared Error
dist_prior = np.add.reduce(self.prior, axis=2)
dist_prior /= np.sum(dist_prior) #normalized prior
#VARIANCE
order_variance = 0
degree_variance = 0
beta_variance = 0
for (t, r, b), p in np.ndenumerate(self.prior):
degree_distance = abs(self.true_degree - t)**2
degree_variance += degree_distance * p
order_distance = abs(self.true_order - r)**2
order_variance += order_distance * p
beta_distance = abs(self.true_beta - b)**2
beta_variance += beta_distance * p
# all_distance = degree_distance + order_distance + beta_distance
# all_variance += all_distance * p
self.results.order_variance_array.append(np.sqrt(order_variance))
self.results.degree_variance_array.append(np.sqrt(degree_variance))
self.results.beta_variance_array.append(np.sqrt(beta_variance))
self.results.total_variance_array.append(
np.sqrt(order_variance) + np.sqrt(degree_variance) +
np.sqrt(beta_variance))
self.guess_order = np.sum([
p * r
for p, r in zip((np.sum(dist_prior, axis=0) /
np.sum(dist_prior)).flatten(), np.arange(self.N))
])
self.results.order_guesses.append(self.guess_order)
self.results.ent_order_array.append(
sharma_mittal.sm_entropy(
(np.sum(dist_prior, axis=0) / np.sum(dist_prior)).flatten(),
r=1.0,
t=1.0))
self.guess_degree = np.sum([
p * t
for p, t in zip((np.sum(dist_prior, axis=1) /
np.sum(dist_prior)).flatten(), np.arange(self.N))
])
self.results.degree_guesses.append(self.guess_degree)
self.results.ent_degree_array.append(
sharma_mittal.sm_entropy(
(np.sum(dist_prior, axis=1) / np.sum(dist_prior)).flatten(),
r=1.0,
t=1.0))
dist_beta = [
np.sum(self.prior[:, :, i]) for i in np.arange(self.N_beta)
]
dist_beta /= np.sum(dist_beta)
self.guess_beta = np.sum(
[p * b for p, b in zip(dist_beta, np.arange(self.N_beta))])
self.results.beta_guesses.append(self.guess_beta)
self.results.ent_beta_array.append(
sharma_mittal.sm_entropy(dist_beta, r=1.0, t=1.0))
self.mse_order = np.sqrt((self.true_order - self.guess_order)**2)
self.mse_degree = np.sqrt((self.true_degree - self.guess_degree)**2)
self.mse_beta = np.sqrt((self.true_beta - self.guess_beta)**2)
#Shannon Entropy
self.results.post_entropy_array.append(
sharma_mittal.sm_entropy(self.prior, r=1.0, t=1.0))
self.results.mse_order_array.append(self.mse_order)
self.results.mse_degree_array.append(self.mse_degree)
self.results.mse_beta_array.append(self.mse_beta)
def viz_full(self, d, old_prior):
f, axarr = plt.subplots(2, 4, figsize=(13, 7))
prior_ent = sharma_mittal.sm_entropy(old_prior, r=1.0, t=1.0)
cmap = sns.cubehelix_palette(12,
start=0,
rot=0.5,
light=1,
as_cmap=True,
reverse=True,
hue=0.0,
dark=0.05)
axarr[0,
0] = self.viz_prior(old_prior,
ax=axarr[0, 0],
title=r'P(model), ent(P)=%.2f' % prior_ent,
annotate=self.step)
axarr[1, 0] = ternary_plot.plot_small(
d,
t=self.degreeSpace[int(self.true_degree)],
r=self.orderSpace[int(self.true_order)],
ax=axarr[1, 0],
title=r'"Optimal" Design $d^{*}$')
y1, y2 = axarr[1, 0].get_ylim()
axarr[1, 0].set_ylim([y1, y2 * 1.1])
#labeling
vspac = 0.05
ypos = 0.95
xpos = -0.1
fsize = 9
axarr[1,
0].text(xpos,
ypos,
r'info gain (d)=%.2f' % self.results.pure_utilities[-1],
fontsize=fsize,
ha='left',
va='center',
color='k',
transform=axarr[1, 0].transAxes)
axarr[1, 0].text(xpos,
ypos - vspac,
r'learnability=%.2f' % self.results.lscores[-1],
fontsize=fsize,
ha='left',
va='center',
color='k',
transform=axarr[1, 0].transAxes)
axarr[1, 0].text(xpos,
ypos - 2 * vspac,
r'goodness=%.2f' % self.results.utilities[-1],
fontsize=fsize,
ha='left',
va='center',
color='k',
transform=axarr[1, 0].transAxes)
axarr[1, 0].text(xpos,
ypos - 3 * vspac,
r'choice=$Q_%d$' % (2 - self.results.responses[-1]),
fontsize=fsize,
ha='left',
va='center',
color='k',
transform=axarr[1, 0].transAxes)
axarr[0, 1] = self.viz_relevance(
d,
q=0,
annotate=False,
ax=axarr[0, 1],
title=r'info gain of $Q_1$ | model (norm.)',
cmap=cmap)
axarr[1, 1] = self.viz_relevance(
d,
q=1,
annotate=False,
ax=axarr[1, 1],
title=r'info gain of $Q_2$ | model (norm.)',
cmap=cmap)
axarr[0, 2] = self.viz_choice_prob(
d,
ax=axarr[0, 2],
title=r'P(choice = $Q_1$ | model), P($Q_1$)=%.2f' %
self.marginals[1],
annotate=self.step)
axarr[1, 2] = self.viz_choice_prob(
d,
inv=True,
ax=axarr[1, 2],
title=r'P(choice = $Q_2$ | model), P($Q_2$)=%.2f' %
self.marginals[0],
annotate=self.step)
#update posterior
post_q1 = np.copy(old_prior)
post_q2 = np.copy(old_prior)
for (t, r, b), p in np.ndenumerate(old_prior):
post_q1[t][r][b] = self.model_likelihood(d, self.degreeSpace[t],
self.orderSpace[r],
self.betaSpace[b])[1] * p
post_q2[t][r][b] = self.model_likelihood(d, self.degreeSpace[t],
self.orderSpace[r],
self.betaSpace[b])[0] * p
post_q1 /= np.sum(post_q1)
post_q2 /= np.sum(post_q2)
post_ent_q1 = sharma_mittal.sm_entropy(post_q1, r=1.0, t=1.0)
post_ent_q2 = sharma_mittal.sm_entropy(post_q2, r=1.0, t=1.0)
axarr[0, 3] = self.viz_prior(
post_q1,
ax=axarr[0, 3],
title=r'P(model | choice=$Q_1$), ent(P)=%.2f' % post_ent_q1,
annotate=self.step)
axarr[1, 3] = self.viz_prior(
post_q2,
ax=axarr[1, 3],
title=r'P(model | choice=$Q_2$), ent(P)=%.2f' % post_ent_q2,
annotate=self.step)
# TODO: rotate tick labels !!!
for ax in axarr.flatten():
_ = [
tick.label.set_fontsize(7)
for tick in ax.xaxis.get_major_ticks()
]
_ = [
tick.label.set_fontsize(7)
for tick in ax.yaxis.get_major_ticks()
]
f.suptitle('Results after ADO step %d' % self.step,
x=0.5,
y=0.95,
fontsize=14,
ha='center',
va='center')
f.subplots_adjust(left=0.05,
bottom=0.10,
right=0.98,
top=0.90,
wspace=0.1,
hspace=0.3)
return f
def __init__(self, max_steps, n_trials, orderSpace, degreeSpace, betaSpace,
true_order, true_degree, true_beta, N_categories, N_features,
prior, g, method, m_args, logging, plotting, save_results,
l_flag, filename):
self.logging = logging
self.plotting = plotting
self.save_results = save_results
self.method = method
self.m_args = m_args
self.priorName = prior
self.l_flag = l_flag
self.log_string = ''
self.fileID = np.random.randint(100000, 999999)
self.max_steps = max_steps
self.orderSpace = orderSpace
self.degreeSpace = degreeSpace
self.betaSpace = betaSpace
# self.labels = [('%s' % Fraction(f)) for f in degreeSpace] #as fractions
self.labels = ['%.1f' % f for f in degreeSpace]
self.step = 0
self.stepwise = False
self.set_response = -1
self.simulation = True
self.filename = filename
self.N = len(orderSpace)
self.N_beta = len(betaSpace)
self.N_categories = N_categories
self.N_features = N_features
self.n_trials = n_trials
self.g = g
self.bounds = np.array([
np.fliplr(
np.rot90(
np.loadtxt("hado/extrema/katVals%s_%s_numOpt_1e4-%s.csv" %
(N_categories, i, str(self.g)),
delimiter=',',
dtype=float),
k=3)) for i in ['best', 'worst']
])
if prior == 'exp':
self.prior = np.ones((self.N, self.N, self.N_beta))
p_tmp = np.flipud(
np.array(
np.loadtxt("hado/priors/hadoPriorsExperienceData-%s.csv" %
str(self.g),
delimiter=',',
dtype=float)))
for i in np.arange(self.N_beta):
self.prior[:, :, i] = p_tmp
elif prior == 'rand':
self.prior = np.random.rand(self.N, self.N, self.N_beta)
else:
self.prior = np.ones((self.N, self.N, self.N_beta)) #uniform
self.prior = self.prior / self.prior.sum()
prior_margin = np.add.reduce(
self.prior, axis=2) #marginal prior (sum across betas)
prior_margin /= np.sum(prior_margin)
if true_order == None: #sample from prior if not defined
order_sample = np.sum(prior_margin, axis=0) / np.sum(
np.sum(prior_margin, axis=0))
self.true_order = np.random.choice(self.N,
1,
replace=True,
p=order_sample)[0]
else:
self.true_order = true_order
if true_degree == None: #sample from prior if not defined
degree_sample = np.sum(prior_margin, axis=1) / np.sum(
np.sum(prior_margin, axis=1))
self.true_degree = np.random.choice(self.N,
1,
replace=True,
p=degree_sample)[0]
else:
self.true_degree = true_degree
if true_beta == None: #sample from prior if not defined
beta_sample = [
np.sum(self.prior[:, :, i]) for i in np.arange(self.N_beta)
]
self.true_beta = np.random.choice(self.N_beta,
1,
replace=True,
p=beta_sample)[0]
else:
self.true_beta = true_beta
self.marginals = np.zeros(self.n_trials + 1)
self.expinfogain = 0
self.prior_ent = sharma_mittal.sm_entropy(self.prior, r=1.0, t=1.0)
#create separate 'results' object
self.results = self.Results(self)
self.results.post_entropy_array.append( #initial entropy of prior beliefs
sharma_mittal.sm_entropy(self.prior, r=1.0, t=1.0))
