def encode_x_y_distribution(self, x, test=False, softmax=True):
x = self.to_variable(x)
mean, ln_var = self.q_a_x(x, test=test)
a = F.gaussian(mean, ln_var)
y = self.q_y_ax(a, x, test=test)
if softmax:
return F.softmax(y)
return y
python类gaussian()的实例源码
def sample_x_y_gumbel(self, x, temperature=10, test=False):
x = self.to_variable(x)
mean, ln_var = self.q_a_x(x, test=test)
a = F.gaussian(mean, ln_var)
return self.sample_ax_y_gumbel(a, x, temperature=temperature, test=test)
def sample_x_label(self, x, argmax=True, test=False):
x = self.to_variable(x)
mean, ln_var = self.q_a_x(x, test=test)
a = F.gaussian(mean, ln_var)
return self.sample_ax_label(a, x, argmax=argmax, test=test)
def decode_xyz_a(self, x, y, z, test=False):
x = self.to_variable(x)
y = self.to_variable(y)
z = self.to_variable(z)
mean, ln_var = self.p_a_xyz(x, y, z, test=test)
return F.gaussian(mean, ln_var)
def decode_yz_a(self, y, z, test=False):
y = self.to_variable(y)
z = self.to_variable(z)
mean, ln_var = self.p_a_yz(y, z, test=test)
return F.gaussian(mean, ln_var)
def __init__(self):
self.image_width = 28
self.image_height = 28
self.ndim_x = 28 * 28
self.ndim_y = 10
self.ndim_z = 50
# True : y = f(BN(Wx + b))
# False: y = f(W*BN(x) + b)
self.batchnorm_before_activation = True
# gaussianmarg | gaussian
self.type_pz = "gaussianmarg"
self.type_qz = "gaussianmarg"
self.encoder_xy_z_hidden_units = [500]
self.encoder_xy_z_activation_function = "softplus"
self.encoder_xy_z_apply_dropout = False
self.encoder_xy_z_apply_batchnorm = True
self.encoder_xy_z_apply_batchnorm_to_input = True
self.encoder_x_y_hidden_units = [500]
self.encoder_x_y_activation_function = "softplus"
self.encoder_x_y_apply_dropout = False
self.encoder_x_y_apply_batchnorm = True
self.encoder_x_y_apply_batchnorm_to_input = True
self.decoder_hidden_units = [500]
self.decoder_activation_function = "softplus"
self.decoder_apply_dropout = False
self.decoder_apply_batchnorm = True
self.decoder_apply_batchnorm_to_input = True
self.gpu_enabled = True
self.learning_rate = 0.0003
self.gradient_momentum = 0.9
self.gradient_clipping = 5.0
def log_pz(self, z, mean, ln_var, test=False):
if self.type_pz == "gaussianmarg":
# \int q(z)logp(z)dz = -(J/2)*log2pi - (1/2)*sum_{j=1}^{J} (mu^2 + var)
# See Appendix B [Auto-Encoding Variational Bayes](http://arxiv.org/abs/1312.6114)
log_pz = -0.5 * (math.log(2.0 * math.pi) + mean * mean + F.exp(ln_var))
elif self.type_pz == "gaussian":
log_pz = -0.5 * math.log(2.0 * math.pi) - 0.5 * z ** 2
return F.sum(log_pz, axis=1)
# this will not be used
def log_qz_xy(self, z, mean, ln_var, test=False):
if self.type_qz == "gaussianmarg":
# \int q(z)logq(z)dz = -(J/2)*log2pi - (1/2)*sum_{j=1}^{J} (1 + logvar)
# See Appendix B [Auto-Encoding Variational Bayes](http://arxiv.org/abs/1312.6114)
log_qz_xy = -0.5 * F.sum((math.log(2.0 * math.pi) + 1 + ln_var), axis=1)
elif self.type_qz == "gaussian":
log_qz_xy = -self.gaussian_nll_keepbatch(z, mean, ln_var)
return log_qz_xy
def __call__(self, x, y, test=False, apply_f=True):
mean, ln_var = self.forward_one_step(x, y, test=test, apply_f=apply_f)
if apply_f:
return F.gaussian(mean, ln_var)
return mean, ln_var
# Network structure is same as the GaussianEncoder
def __call__(self, z, y, test=False, apply_f=False):
mean, ln_var = self.forward_one_step(z, y, test=test, apply_f=False)
if apply_f:
return F.gaussian(mean, ln_var)
return mean, ln_var
def log_pz(self, z, mean, ln_var):
if self.type_pz == "gaussianmarg":
# \int q(z)logp(z)dz = -(J/2)*log2pi - (1/2)*sum_{j=1}^{J} (mu^2 + var)
# See Appendix B [Auto-Encoding Variational Bayes](http://arxiv.org/abs/1312.6114)
# See https://github.com/dpkingma/nips14-ssl/blob/master/anglepy/models/VAE_YZ_X.py line 106
log_pz = -0.5 * (math.log(2.0 * math.pi) + mean * mean + F.exp(ln_var))
elif self.type_pz == "gaussian":
log_pz = -0.5 * math.log(2.0 * math.pi) - 0.5 * z ** 2
return F.sum(log_pz, axis=1)
# this will not be used for bernoulli decoder
def log_qz_x(self, z, mean, ln_var):
if self.type_qz == "gaussianmarg":
# \int q(z)logq(z)dz = -(J/2)*log2pi - (1/2)*sum_{j=1}^{J} (1 + logvar)
# See Appendix B [Auto-Encoding Variational Bayes](http://arxiv.org/abs/1312.6114)
# See https://github.com/dpkingma/nips14-ssl/blob/master/anglepy/models/VAE_YZ_X.py line 118
log_qz_x = -0.5 * F.sum((math.log(2.0 * math.pi) + 1 + ln_var), axis=1)
elif self.type_qz == "gaussian":
log_qz_x = -self.gaussian_nll_keepbatch(z, mean, ln_var)
return log_qz_x
def __call__(self, x, test=False, apply_f=True):
mean, ln_var = self.forward_one_step(x, test=test, apply_f=apply_f)
if apply_f:
return F.gaussian(mean, ln_var)
return mean, ln_var
# Network structure is same as the Encoder
def __call__(self, x):
# Obtain parameters for q(z|x)
encoding_time = time.time()
self.encode(x)
encoding_time = float(time.time() - encoding_time)
decoding_time_average = 0.
xp = cuda.cupy
self.importance_weights = 0
self.w_holder = []
self.kl = 0
self.logp = 0
for j in xrange(self.num_zsamples):
# Sample z ~ q(z|x)
z = F.gaussian(self.qmu, self.qln_var)
# Compute log q(z|x)
encoder_log = gaussian_logp(z, self.qmu, self.qln_var)
# Obtain parameters for p(x|z)
decoding_time = time.time()
self.decode(z)
decoding_time = time.time() - decoding_time
decoding_time_average += decoding_time
# Compute log p(x|z)
decoder_log = bernoulli_logp(x, self.p_ber_prob_logit)
# Compute log p(z).
prior_log = gaussian_logp0(z)
# Store the latest log weight'
current_temperature = min(self.temperature['value'],1.0)
self.w_holder.append(decoder_log + current_temperature*(prior_log - encoder_log))
# Store the KL and Logp equivalents. They are not used for computation but for recording and reporting.
self.kl += (encoder_log-prior_log)
self.logp += (decoder_log)
self.temperature['value'] += self.temperature['increment']
# Compute w' for this sample (batch)
logps = F.stack(self.w_holder)
self.obj_batch = F.logsumexp(logps, axis=0) - np.log(self.num_zsamples)
self.kl /= self.num_zsamples
self.logp /= self.num_zsamples
decoding_time_average /= self.num_zsamples
batch_size = self.obj_batch.shape[0]
self.obj = -F.sum(self.obj_batch)/batch_size
self.timing_info = np.array([encoding_time,decoding_time_average])
return self.obj
def __call__(self, x):
# Obtain parameters for q(z|x)
encoding_time = time.time()
qmu, qln_var, qh_vec_0 = self.encode(x)
encoding_time = float(time.time() - encoding_time)
decoding_time_average = 0.
self.kl = 0
self.logp = 0
for j in xrange(self.num_zsamples):
# z_0 ~ q(z|x)
z_0 = F.gaussian(qmu, qln_var)
# Perform Householder flow transformation, Equation (8)
decoding_time = time.time()
z_T = self.house_transform(z_0)
# Obtain parameters for p(x|z_T)
pmu, pln_var = self.decode(z_T)
decoding_time = time.time() - decoding_time
decoding_time_average += decoding_time
# Compute objective
self.logp += gaussian_logp(x, self.pmu, self.pln_var)
self.kl += gaussian_kl_divergence(z_0, qmu, qln_var, z_T)
decoding_time_average /= self.num_zsamples
self.logp /= self.num_zsamples
self.kl /= self.num_zsamples
current_temperature = min(self.temperature['value'],1.0)
self.obj_batch = self.logp - (current_temperature*self.kl)
self.temperature['value'] += self.temperature['increment']
self.timing_info = np.array([encoding_time,decoding_time_average])
batch_size = self.obj_batch.shape[0]
self.obj = -F.sum(self.obj_batch)/batch_size
return self.obj
def __call__(self, x):
# Compute q(z|x)
# pdb.set_trace()
encoding_time = time.time()
self.encode(x)
encoding_time = float(time.time() - encoding_time)
decoding_time_average = 0.
self.kl = 0
self.logp = 0
for j in xrange(self.num_zsamples):
# z ~ q(z|x)
z = F.gaussian(self.qmu, self.qln_var)
# pdb.set_trace()
# Compute log q(z|x)
encoder_log = gaussian_logp(z, self.qmu, self.qln_var)
# Compute p(x|z)
decoding_time = time.time()
self.decode(z)
decoding_time = time.time() - decoding_time
decoding_time_average += decoding_time
# Computer p(z)
prior_log = gaussian_logp0(z)
# Compute objective
self.kl += (encoder_log-prior_log)
self.logp += bernoulli_logp(x, self.p_ber_prob_logit)
# pdb.set_trace()
current_temperature = min(self.temperature['value'],1.0)
self.temperature['value'] += self.temperature['increment']
decoding_time_average /= self.num_zsamples
self.logp /= self.num_zsamples
self.kl /= self.num_zsamples
# pdb.set_trace()
self.obj_batch = self.logp - (current_temperature*self.kl)
self.timing_info = np.array([encoding_time,decoding_time_average])
batch_size = self.obj_batch.shape[0]
self.obj = -F.sum(self.obj_batch)/batch_size
# pdb.set_trace()
return self.obj
def __call__(self, x):
# Obtain parameters for q(z|x)
encoding_time = time.time()
self.encode(x)
encoding_time = float(time.time() - encoding_time)
decoding_time_average = 0.
xp = cuda.cupy
self.importance_weights = 0
self.w_holder = []
self.kl = 0
self.logp = 0
for j in xrange(self.num_zsamples):
# Sample z ~ q(z|x)
z = F.gaussian(self.qmu, self.qln_var)
# Compute log q(z|x)
encoder_log = gaussian_logp(z, self.qmu, self.qln_var)
# Obtain parameters for p(x|z)
decoding_time = time.time()
self.decode(z)
decoding_time = time.time() - decoding_time
decoding_time_average += decoding_time
# Compute log p(x|z)
decoder_log = gaussian_logp(x, self.pmu, self.pln_var)
# Compute log p(z). The odd notation being used is to supply a mean of 0 and covariance of 1
prior_log = gaussian_logp(z, self.qmu*0, self.qln_var/self.qln_var)
# Store the latest log weight'
current_temperature = min(self.temperature['value'],1.0)
self.w_holder.append(decoder_log + current_temperature*(prior_log - encoder_log))
# Store the KL and Logp equivalents. They are not used for computation but for recording and reporting.
self.kl += (encoder_log-prior_log)
self.logp += (decoder_log)
self.temperature['value'] += self.temperature['increment']
# Compute w' for this sample (batch)
logps = F.stack(self.w_holder)
self.obj_batch = F.logsumexp(logps, axis=0) - np.log(self.num_zsamples)
self.kl /= self.num_zsamples
self.logp /= self.num_zsamples
decoding_time_average /= self.num_zsamples
batch_size = self.obj_batch.shape[0]
self.obj = -F.sum(self.obj_batch)/batch_size
self.timing_info = np.array([encoding_time,decoding_time_average])
return self.obj
def __call__(self, x):
# Compute q(z|x)
# pdb.set_trace()
encoding_time = time.time()
self.encode(x)
encoding_time = float(time.time() - encoding_time)
decoding_time_average = 0.
self.kl = 0
self.logp = 0
for j in xrange(self.num_zsamples):
# z ~ q(z|x)
z = F.gaussian(self.qmu, self.qln_var)
# pdb.set_trace()
# Compute log q(z|x)
encoder_log = gaussian_logp(z, self.qmu, self.qln_var)
# Compute p(x|z)
decoding_time = time.time()
self.decode(z)
decoding_time = time.time() - decoding_time
decoding_time_average += decoding_time
# Computer p(z)
prior_log = gaussian_logp0(z)
# Compute objective
self.kl += (encoder_log-prior_log)
self.logp += bernoulli_logp(x, self.p_ber_prob_logit)
# pdb.set_trace()
current_temperature = min(self.temperature['value'],1.0)
self.temperature['value'] += self.temperature['increment']
decoding_time_average /= self.num_zsamples
self.logp /= self.num_zsamples
self.kl /= self.num_zsamples
# pdb.set_trace()
self.obj_batch = self.logp - (current_temperature*self.kl)
self.timing_info = np.array([encoding_time,decoding_time_average])
batch_size = self.obj_batch.shape[0]
self.obj = -F.sum(self.obj_batch)/batch_size
# pdb.set_trace()
return self.obj
def __call__(self, x):
# Obtain parameters for q(z|x)
encoding_time = time.time()
qmu, qln_var, qh_vec_0 = self.encode(x)
encoding_time = float(time.time() - encoding_time)
decoding_time_average = 0.
self.kl = 0
self.logp = 0
for j in xrange(self.num_zsamples):
# z_0 ~ q(z|x)
z_0 = F.gaussian(qmu, qln_var)
# Perform Householder flow transformation, Equation (8)
decoding_time = time.time()
z_T = self.house_transform(z_0)
# Obtain parameters for p(x|z_T)
p_ber_prob_logit = self.decode(z_T)
decoding_time = time.time() - decoding_time
decoding_time_average += decoding_time
# Compute objective
self.logp += bernoulli_logp(x, self.p_ber_prob_logit)
self.kl += gaussian_kl_divergence(z_0, qmu, qln_var, z_T)
decoding_time_average /= self.num_zsamples
self.logp /= self.num_zsamples
self.kl /= self.num_zsamples
current_temperature = min(self.temperature['value'],1.0)
self.obj_batch = self.logp - (current_temperature*self.kl)
self.temperature['value'] += self.temperature['increment']
self.timing_info = np.array([encoding_time,decoding_time_average])
batch_size = self.obj_batch.shape[0]
self.obj = -F.sum(self.obj_batch)/batch_size
return self.obj
def __call__(self, x):
# Obtain parameters for q(z|x)
encoding_time = time.time()
qmu, qln_var, qh_vec_0 = self.encode(x)
encoding_time = float(time.time() - encoding_time)
decoding_time_average = 0.
self.kl = 0
self.logp = 0
for j in xrange(self.num_zsamples):
# z_0 ~ q(z|x)
z_0 = F.gaussian(qmu, qln_var)
# Perform Householder flow transformation, Equation (8)
decoding_time = time.time()
z_T = self.house_transform(z_0)
# Obtain parameters for p(x|z_T)
p_ber_prob_logit = self.decode(z_T)
decoding_time = time.time() - decoding_time
decoding_time_average += decoding_time
# Compute objective
self.logp += bernoulli_logp(x, self.p_ber_prob_logit)
self.kl += gaussian_kl_divergence(z_0, qmu, qln_var, z_T)
decoding_time_average /= self.num_zsamples
self.logp /= self.num_zsamples
self.kl /= self.num_zsamples
current_temperature = min(self.temperature['value'],1.0)
self.obj_batch = self.logp - (current_temperature*self.kl)
self.temperature['value'] += self.temperature['increment']
self.timing_info = np.array([encoding_time,decoding_time_average])
batch_size = self.obj_batch.shape[0]
self.obj = -F.sum(self.obj_batch)/batch_size
return self.obj
