def _observe(self, action):
mean_old = self._state[action].mu
sigma_old = self._state[action].sigma
tau_old = 1 / (sigma_old**2)
obs_dist = Normal(self.ground_truth[action], 1 / math.sqrt(self.tau))
obs = obs_dist.sample()
self.obs_list[action].append(obs)
tau_new = tau_old + len(self.obs_list[action]) * self.tau
mean_new = ((mean_old * tau_old) +
self.tau * sum(self.obs_list[action])) / tau_new
sigma_new = 1 / math.sqrt(tau_new)
s = list(self._state)
s[action] = Normal(mean_new, sigma_new)
return tuple(s)
def actor(self, states, name='actor', reuse=False, trainable=True):
with tf.variable_scope(name, reuse=reuse):
features = self.actor_net(states,
self.drop_rate,
trainable=trainable)
if isinstance(self.act_space, gym.spaces.Discrete):
logits = Dense(self.act_space.n,
None,
trainable=trainable,
name="layer_logits")(features)
distribution = Categorical(logits)
else:
mean = Dense(self.act_space.shape[0],
None,
trainable=trainable,
name='mean')(features)
logstd = tf.get_variable(
'logstd',
initializer=-0.5 *
np.ones(self.act_space.shape[0], dtype=np.float32))
# logstd = Dense(self.act_space.shape[0], None, trainable=trainable, name='logstd')(features)
distribution = Normal(mean=mean, logstd=logstd)
return distribution
def get_conjugate(likelihood, prior, parameter: str, observations: list):
conjugate = CONJUGATE_TABLE[(likelihood.name, prior.name, parameter)]
n = len(observations)
if conjugate == "normal_normal_mean":
new_mean = (1/(1/prior.sigma2 + n/likelihood.sigma2))*\
(prior.mu/prior.sigma2+sum(observations)/likelihood.sigma2)
new_var = 1/(1/prior.sigma2+n/likelihood.sigma2)
posterior = Normal(new_mean, new_var)
elif conjugate == "normal_gamma_precision":
new_alpha = prior.alpha + n/2
new_beta = prior.beta + sum([(observations[i]-likelihood.mu)**2
for i in range(n)])/2
posterior = Gamma(new_alpha, new_beta)
elif conjugate == "normal_inv_gamma_variance":
posterior = Inv_Gamma(prior.alpha + n/2, prior.beta +
sum([(observations[i]-likelihood.mu)**2
for i in range(n)])/2)
elif conjugate == "exponential_gamma_rate":
posterior = Gamma(prior.alpha+n, prior.beta+sum(observations))
elif conjugate == "gamma_gamma_rate":
posterior = Gamma(prior.alpha+n*likelihood.alpha, prior.beta+sum(observations))
elif conjugate == "poisson_gamma_rate":
posterior = Gamma(prior.alpha+sum(observations), prior.beta+n)
return posterior
def sample(self, num_samples, t):
scale_ind = 0
z0_size = [num_samples] + self.z0_size
dist = Normal(mu=torch.zeros(z0_size).cuda(), log_sigma=torch.zeros(z0_size).cuda(), temp=t)
z, _ = dist.sample()
idx_dec = 0
s = self.prior_ftr0.unsqueeze(0)
batch_size = z.size(0)
s = s.expand(batch_size, -1, -1, -1)
for cell in self.dec_tower:
if cell.cell_type == 'combiner_dec':
if idx_dec > 0:
# form prior
param = self.dec_sampler[idx_dec - 1](s)
mu, log_sigma = torch.chunk(param, 2, dim=1)
dist = Normal(mu, log_sigma, t)
z, _ = dist.sample()
# 'combiner_dec'
s = cell(s, z)
idx_dec += 1
else:
s = cell(s)
if cell.cell_type == 'up_dec':
scale_ind += 1
if self.vanilla_vae:
s = self.stem_decoder(z)
for cell in self.post_process:
s = cell(s)
logits = self.image_conditional(s)
return logits
def reward(i):
global node_types
sigma_val = {
'V1': 5,
'V2': 10,
'V3': 20,
'V4': 40,
'G1': 100,
'G2': 120,
'G3': 140,
'G4': 160,
'G5': 180
}
return Normal(mu=0, sigma=sigma_val[node_types[i]])
def forward(self, x):
s = self.stem(2 * x - 1.0)
# perform pre-processing
for cell in self.pre_process:
s = cell(s)
# run the main encoder tower
combiner_cells_enc = []
combiner_cells_s = []
for cell in self.enc_tower:
if cell.cell_type == 'combiner_enc':
combiner_cells_enc.append(cell)
combiner_cells_s.append(s)
else:
s = cell(s)
# reverse combiner cells and their input for decoder
combiner_cells_enc.reverse()
combiner_cells_s.reverse()
idx_dec = 0
ftr = self.enc0(s) # this reduces the channel dimension
param0 = self.enc_sampler[idx_dec](ftr)
mu_q, log_sig_q = torch.chunk(param0, 2, dim=1)
dist = Normal(mu_q, log_sig_q) # for the first approx. posterior
z, _ = dist.sample()
log_q_conv = dist.log_p(z)
# apply normalizing flows
nf_offset = 0
for n in range(self.num_flows):
z, log_det = self.nf_cells[n](z, ftr)
log_q_conv -= log_det
nf_offset += self.num_flows
all_q = [dist]
all_log_q = [log_q_conv]
# To make sure we do not pass any deterministic features from x to decoder.
s = 0
# prior for z0
dist = Normal(mu=torch.zeros_like(z), log_sigma=torch.zeros_like(z))
log_p_conv = dist.log_p(z)
all_p = [dist]
all_log_p = [log_p_conv]
idx_dec = 0
s = self.prior_ftr0.unsqueeze(0)
batch_size = z.size(0)
s = s.expand(batch_size, -1, -1, -1)
for cell in self.dec_tower:
if cell.cell_type == 'combiner_dec':
if idx_dec > 0:
# form prior
param = self.dec_sampler[idx_dec - 1](s)
mu_p, log_sig_p = torch.chunk(param, 2, dim=1)
# form encoder
ftr = combiner_cells_enc[idx_dec - 1](
combiner_cells_s[idx_dec - 1], s)
param = self.enc_sampler[idx_dec](ftr)
mu_q, log_sig_q = torch.chunk(param, 2, dim=1)
dist = Normal(mu_p + mu_q, log_sig_p +
log_sig_q) if self.res_dist else Normal(
mu_q, log_sig_q)
z, _ = dist.sample()
log_q_conv = dist.log_p(z)
# apply NF
for n in range(self.num_flows):
z, log_det = self.nf_cells[nf_offset + n](z, ftr)
log_q_conv -= log_det
nf_offset += self.num_flows
all_log_q.append(log_q_conv)
all_q.append(dist)
# evaluate log_p(z)
dist = Normal(mu_p, log_sig_p)
log_p_conv = dist.log_p(z)
all_p.append(dist)
all_log_p.append(log_p_conv)
# 'combiner_dec'
s = cell(s, z)
idx_dec += 1
else:
s = cell(s)
if self.vanilla_vae:
s = self.stem_decoder(z)
for cell in self.post_process:
s = cell(s)
logits = self.image_conditional(s)
# compute kl
kl_all = []
kl_diag = []
log_p, log_q = 0., 0.
for q, p, log_q_conv, log_p_conv in zip(all_q, all_p, all_log_q,
all_log_p):
if self.with_nf:
kl_per_var = log_q_conv - log_p_conv
else:
kl_per_var = q.kl(p)
kl_diag.append(torch.mean(torch.sum(kl_per_var, dim=[2, 3]),
dim=0))
kl_all.append(torch.sum(kl_per_var, dim=[1, 2, 3]))
log_q += torch.sum(log_q_conv, dim=[1, 2, 3])
log_p += torch.sum(log_p_conv, dim=[1, 2, 3])
return logits, log_q, log_p, kl_all, kl_diag
def make_env(cost=1.25, ground_truth=None):
reward = Normal(0, 10).to_discrete(6)
return MouselabEnv.new_symmetric([4, 1, 2],
reward,
cost=cost,
ground_truth=None)
from conjugates import get_conjugate, CONJUGATES_INV
from distributions import Normal, Gamma
# Our base model is a normal distribution, with the likelihood
likelihood = Normal(1,
[]) # with mean 1 and unknown precision tau = 1/variance
# We observe the values for X to be [1,2,1,0.5]
observations = [1, 2, 1, 0.5, 2, 4, -1, -5, 2, 4, 5]
# We want to find out what conjugate priors there are for a Normal distribution
# and its precision tau
print(CONJUGATES_INV[("Normal", "tau")])
# The answer is a Gamma distribution. Let's set the prior to Gamma:
prior = Gamma(3, 1) # This is not an uninformative prior
# Combining these to the posterior:
posterior = get_conjugate(likelihood, prior, "precision", observations)
print(posterior.describe())
print(posterior.mean())
print(posterior.equitailed_cs(95))
posterior.plot_pdf(0, 2)
def main():
run_data = {}
run_id = 0
scale = 0.5
emissions_normal = { 1: Normal(0, 2.0 * scale),
2: Normal(3.5, 3.0 * scale),
3: Normal(6.5, 1.0 * scale) }
emissions_laplace = { 1: Laplace(0, 2.0 * scale),
2: Laplace(3.5, 3.0 * scale),
3: Laplace(6.5, 1.0 * scale) }
emission_spec = emissions_normal
dists = [Normal(max_sigma = 6.0) for n in range(3)]
num_state_reps = 50
num_emission_reps = 4
num_gamma_init_reps = 4
num_blocks = [1, 2, 5, 10, 20, 50]
verbose = False
graphics_on = False
total_work = (num_state_reps * num_emission_reps *
2 * num_gamma_init_reps * len(num_blocks))
work = 0
for state_rep in range(num_state_reps):
print 'State repetition %d' % state_rep
# Generate HMM states
while True:
model = HMM([('Start', (1,), (1.0,)),
(1, (1,2,3), (0.98, 0.02, 0.0)),
(2, (1,2,3), (0.02, 0.95, 0.03)),
(3, (1,2,3,'End'), (0.03, 0.03, 0.93, 0.01))],
emission_spec)
model.simulate()
num_data = len(model.state_vec)
if num_data < 5000 and num_data > 100: break
counts = {}
for state in model.state_vec:
if not state in counts:
counts[state] = 0
counts[state] += 1
if verbose: print 'Counts: %s' % str(counts)
# Generate shuffled indices for repeatable shuffling
shuffling = np.arange(num_data)
np.random.shuffle(shuffling)
for emission_rep in range(num_emission_reps):
if verbose: print 'Emission repetition %d' % emission_rep
model.emit()
for shuffled in [False, True]:
if verbose: print 'Shuffling HMM run: %s' % str(shuffled)
states = np.array(model.state_vec)
emissions = np.array(model.emission_vec)
if shuffled:
states = states[shuffling]
emissions = emissions[shuffling]
for num_block in num_blocks:
if verbose: print 'Blocks: %d' % num_block
blocks = np.array_split(np.arange(num_data), num_block)
for gamma_rep in range(num_gamma_init_reps):
if verbose: print 'Initial gamma seed: %d' % gamma_rep
init_gamma = np.array(states) - 1
run_id += 1
this_run = {}
this_run['num data'] = num_data
this_run['state rep'] = state_rep
this_run['emission rep'] = emission_rep
this_run['shuffled'] = shuffled
this_run['blocks'] = num_block
this_run['gamma init rep'] = gamma_rep
start_time = time.clock()
results = em(emissions,
dists,
blocks = blocks,
gamma_seed = gamma_rep,
init_gamma = init_gamma,
count_restart = 0.0)
pi = results['pi']
dists = results['dists']
reps = results['reps']
conv = results['converged']
run_time = time.clock() - start_time
this_run['run time'] = run_time
this_run['reps'] = reps
conv_status = conv and 'converged' or 'not converged'
this_run['convergence'] = conv_status
print 'Reps: %d (%s)' % (reps, conv_status)
print 'Time elapsed: %.2f' % run_time
if verbose: print_mixture(pi, dists)
if graphics_on:
display_densities(emissions, dists)
display_hist(emissions, dists)
act = emission_spec.values()
this_run['err mean max'] = max_error_mean(dists, act)
this_run['err mean mean'] = mean_error_mean(dists, act)
like = np.zeros(num_data)
pi_overall = np.mean(pi, 0)
for p, dist in zip(pi_overall, dists):
like += p * dist.density(states)
this_run['log likelihood'] = np.sum(np.log(like))
like = np.zeros(num_data)
for i, block in enumerate(blocks):
for p, dist in zip(pi[i], dists):
comp = p * dist.density(states[block])
like[block] += comp
this_run['log likelihood local'] = np.sum(np.log(like))
run_data[run_id] = this_run
work += 1
print 'Finished run %d/%d' % (work, total_work)
# Output data to CSV
cols = set()
for id in run_data:
for k in run_data[id]:
cols.add(k)
with open('outfile.csv', 'wb') as f:
writer = csv.writer(f)
writer.writerow(list(cols))
writer.writerows([[run_data[id][c] for c in cols] for id in run_data])
from numpy import mod, exp
import matplotlib.pyplot as plt
import random
from em import kmeans, em
from distributions import Normal
from visualization import display_densities, display_hist
# Parameters
reps = 100
mus = np.linspace(0.0, 5.0, 40)
dim = 50
theta = [0.0, 1.0]
temp = 2.269 # T_c = 2.269?
gibbs_sweeps = 30
model = [Normal() for n in range(2)]
pi_max = True
count_restart = 0.0
init = 'kmeans' # Choices: random, kmeans, true
block_strategies = [
'none', 'mean_4n', 'all_4n', 'mean_8n', 'all_8n', 'perfect'
]
graphics = False
show_each = False
# Set random seeds for reproducible runs
random.seed(163)
np.random.seed(137)
# Precalculate neighbors
neighbors_4 = {}
def forward(self, x, global_step, args):
if args.fp16:
x = x.half()
metrics = {}
alpha_i = utils.kl_balancer_coeff(
num_scales=self.num_latent_scales,
groups_per_scale=self.groups_per_scale,
fun='square')
x_in = self.preprocess(x)
if args.fp16:
x_in = x_in.half()
s = self.stem(x_in)
# perform pre-processing
for cell in self.pre_process:
s = cell(s)
# run the main encoder tower
combiner_cells_enc = []
combiner_cells_s = []
for cell in self.enc_tower:
if cell.cell_type == 'combiner_enc':
combiner_cells_enc.append(cell)
combiner_cells_s.append(s)
else:
s = cell(s)
# reverse combiner cells and their input for decoder
combiner_cells_enc.reverse()
combiner_cells_s.reverse()
idx_dec = 0
ftr = self.enc0(s) # this reduces the channel dimension
param0 = self.enc_sampler[idx_dec](ftr)
mu_q, log_sig_q = torch.chunk(param0, 2, dim=1)
dist = Normal(mu_q, log_sig_q) # for the first approx. posterior
z, _ = dist.sample()
log_q_conv = dist.log_p(z)
# apply normalizing flows
nf_offset = 0
for n in range(self.num_flows):
z, log_det = self.nf_cells[n](z, ftr)
log_q_conv -= log_det
nf_offset += self.num_flows
all_q = [dist]
all_log_q = [log_q_conv]
# To make sure we do not pass any deterministic features from x to decoder.
s = 0
# prior for z0
dist = Normal(mu=torch.zeros_like(z), log_sigma=torch.zeros_like(z))
log_p_conv = dist.log_p(z)
all_p = [dist]
all_log_p = [log_p_conv]
idx_dec = 0
s = self.prior_ftr0.unsqueeze(0)
batch_size = z.size(0)
s = s.expand(batch_size, -1, -1)
for cell in self.dec_tower:
if cell.cell_type == 'combiner_dec':
if idx_dec > 0:
# form prior
param = self.dec_sampler[idx_dec - 1](s)
mu_p, log_sig_p = torch.chunk(param, 2, dim=1)
# form encoder
ftr = combiner_cells_enc[idx_dec - 1](
combiner_cells_s[idx_dec - 1], s)
param = self.enc_sampler[idx_dec](ftr)
mu_q, log_sig_q = torch.chunk(param, 2, dim=1)
dist = Normal(mu_p + mu_q, log_sig_p +
log_sig_q) if self.res_dist else Normal(
mu_q, log_sig_q)
z, _ = dist.sample()
log_q_conv = dist.log_p(z)
# apply NF
for n in range(self.num_flows):
z, log_det = self.nf_cells[nf_offset + n](z, ftr)
log_q_conv -= log_det
nf_offset += self.num_flows
all_log_q.append(log_q_conv)
all_q.append(dist)
# evaluate log_p(z)
dist = Normal(mu_p, log_sig_p)
log_p_conv = dist.log_p(z)
all_p.append(dist)
all_log_p.append(log_p_conv)
# 'combiner_dec'
s = cell(s, z)
idx_dec += 1
else:
s = cell(s)
if self.vanilla_vae:
s = self.stem_decoder(z)
for cell in self.post_process:
s = cell(s)
logits = self.image_conditional(s)
# compute kl
kl_all = []
kl_diag = []
log_p, log_q = 0., 0.
for q, p, log_q_conv, log_p_conv in zip(all_q, all_p, all_log_q,
all_log_p):
if self.with_nf:
kl_per_var = log_q_conv - log_p_conv
else:
kl_per_var = q.kl(p)
kl_diag.append(torch.mean(torch.sum(kl_per_var, dim=2), dim=0))
kl_all.append(torch.sum(kl_per_var, dim=[1, 2]))
log_q += torch.sum(log_q_conv, dim=[1, 2])
log_p += torch.sum(log_p_conv, dim=[1, 2])
output = self.decoder_output(logits)
"""
def _spectral_loss(x_target, x_out, args):
if hps.use_nonrelative_specloss:
sl = spectral_loss(x_target, x_out, args) / args.bandwidth['spec']
else:
sl = spectral_convergence(x_target, x_out, args)
sl = t.mean(sl)
return sl
def _multispectral_loss(x_target, x_out, args):
sl = multispectral_loss(x_target, x_out, args) / args.bandwidth['spec']
sl = t.mean(sl)
return sl
"""
kl_coeff = utils.kl_coeff(global_step,
args.kl_anneal_portion * args.num_total_iter,
args.kl_const_portion * args.num_total_iter,
args.kl_const_coeff)
recon_loss = utils.reconstruction_loss(output,
x,
crop=self.crop_output)
balanced_kl, kl_coeffs, kl_vals = utils.kl_balancer(kl_all,
kl_coeff,
kl_balance=True,
alpha_i=alpha_i)
nelbo_batch = recon_loss + balanced_kl
loss = torch.mean(nelbo_batch)
bn_loss = self.batchnorm_loss()
norm_loss = self.spectral_norm_parallel()
#x_target = audio_postprocess(x.float(), args)
#x_out = audio_postprocess(output.sample(), args)
#spec_loss = _spectral_loss(x_target, x_out, args)
#multispec_loss = _multispectral_loss(x_target, x_out, args)
if args.weight_decay_norm_anneal:
assert args.weight_decay_norm_init > 0 and args.weight_decay_norm > 0, 'init and final wdn should be positive.'
wdn_coeff = (1. - kl_coeff) * np.log(
args.weight_decay_norm_init) + kl_coeff * np.log(
args.weight_decay_norm)
wdn_coeff = np.exp(wdn_coeff)
else:
wdn_coeff = args.weight_decay_norm
loss += bn_loss * wdn_coeff + norm_loss * wdn_coeff
metrics.update(
dict(recon_loss=recon_loss,
bn_loss=bn_loss,
norm_loss=norm_loss,
wdn_coeff=wdn_coeff,
kl_all=torch.mean(sum(kl_all)),
kl_coeff=kl_coeff))
for key, val in metrics.items():
metrics[key] = val.detach()
return output, loss, metrics
def __init__(self, policy_function: ParametricFunction,
dt: float, c_entropy: float) -> None:
OnlineActor.__init__(self, policy_function, dt, c_entropy)
self._distr_generator = lambda t: Independent(Normal(*t), 1)
def reward(depth):
if depth > 0:
return Normal(0, sigmas[depth]).to_discrete(6)
return 0.