def calculate_protein(self, fbar, k_fbar, Δ): # Calculate p_i vector
τ = self.data.τ
f_i = inverse_positivity(fbar)
δ_i = tf.reshape(logit(k_fbar), (-1, 1))
if self.options.delays:
# Add delay
Δ = tf.cast(Δ, 'int32')
for r in range(self.num_replicates):
f_ir = rotate(f_i[r], -Δ)
mask = ~tf.sequence_mask(Δ, f_i.shape[2])
f_ir = tf.where(mask, f_ir, 0)
mask = np.zeros((self.num_replicates, 1, 1), dtype='float64')
mask[r] = 1
f_i = (1 - mask) * f_i + mask * f_ir
# Approximate integral (trapezoid rule)
resolution = τ[1] - τ[0]
sum_term = tfm.multiply(tfm.exp(δ_i * τ), f_i)
cumsum = 0.5 * resolution * tfm.cumsum(
sum_term[:, :, :-1] + sum_term[:, :, 1:], axis=2)
integrals = tf.concat([
tf.zeros((self.num_replicates, self.num_tfs, 1), dtype='float64'),
cumsum
],
axis=2)
exp_δt = tfm.exp(-δ_i * τ)
p_i = exp_δt * integrals
return p_i
def h_(self, X, k, j, primefirst=True):
Dj = tf.reshape(self.D, (1, -1))
Dj = broadcast_tile(Dj, 1, 7)
Dj = tf.tile(Dj, [35, 1])
Dk = tf.reshape(self.D, (-1, 1))
Dk = broadcast_tile(Dk, 7, 1)
Dk = tf.tile(Dk, [1, 35])
gk = tf.transpose(
broadcast_tile(tf.reshape(self.gamma(), (-1, 1)), 7, 1))
gk = tf.tile(gk, [35, 1])
if not primefirst:
Dk, Dj = Dj, Dk
gk = tf.transpose(
broadcast_tile(tf.reshape(self.gamma(), (1, -1)), 1, 7))
gk = tf.tile(gk, [1, 35])
l = self.lengthscale
t_x = tf.reshape(X[:self.block_size], (-1, ))
t_prime, t, t_dist = self.get_distance_matrix(primefirst=primefirst,
t_x=t_x)
t_prime = tf.tile(t_prime, [5, 5])
t = tf.tile(t, [5, 5])
t_dist = tf.tile(t_dist, [5, 5])
multiplier = tfm.exp(gk**2) / (Dj + Dk)
first_erf_term = tfm.erf(t_dist / l - gk) + tfm.erf(t / l + gk)
second_erf_term = tfm.erf(t_prime / l - gk) + tfm.erf(gk)
return multiplier * (tf.multiply(tfm.exp(-Dk*t_dist) , first_erf_term) - \
tf.multiply(tfm.exp(-Dk*t_prime-Dj*t) , second_erf_term))
def energy_4_log_pdf(z):
z2 = z[:, 1]
x1 = -0.5 * ((z2 - w1(z)) / 0.4)**2
x2 = -0.5 * ((z2 - w1(z) + w3(z)) / 0.35)**2
a = math.maximum(x1, x2)
exp1 = math.exp(x1 - a)
exp2 = math.exp(x2 - a)
return a + math.log(exp1 + exp2)
def energy_1_log_pdf(z):
z1, z2 = z[:, 0], z[:, 1]
norm = (z1**2 + z2**2)**0.5
exp1 = math.exp(-0.5 * ((z1 - 2) / 0.6)**2)
exp2 = math.exp(-0.5 * ((z1 + 2) / 0.6)**2)
u = 0.5 * ((norm - 2) / 0.4)**2 - math.log(exp1 + exp2)
return -u
def circle_log_pdf(z):
z1, z2 = z[:, 0], z[:, 1]
norm = (z1**2 + z2**2)**0.5
exp1 = math.exp(-0.2 * ((z1 - 2) / 0.8)**2)
exp2 = math.exp(-0.2 * ((z1 + 2) / 0.8)**2)
u = 0.5 * ((norm - 4) / 0.4)**2 - math.log(exp1 + exp2)
return -u
def k_xf(self, j, X, X2):
t_prime, t_, t_dist = self.get_distance_matrix(
t_x=tf.reshape(X[:self.block_size], (-1, )),
t_y=tf.reshape(X2, (-1, )))
l = self.lengthscale
erf_term = tfm.erf(t_dist / l - self.gamma(j)) + tfm.erf(t_ / l +
self.gamma(j))
return self.S[j] * l * 0.5 * tfm.sqrt(PI) * tfm.exp(
self.gamma(j)**2) * tfm.exp(-self.D[j] * t_dist) * erf_term
def pdf_1D(z, density_name=''):
assert density_name in AVAILABLE_1D_DISTRIBUTIONS, "Incorrect density name."
if density_name == '':
return 1
elif density_name == 'two_hills':
y = 0.5
sigma2 = 0.1
likelihood = (1 / math.sqrt(2 * pi * sigma2)) * math.exp(-(
(y - (z**2))**2) / (2 * sigma2))
prior = (1 / math.sqrt(2 * pi))**math.exp(-(z**2) / 2)
return likelihood * prior
def PST(I, LPF, Phase_strength, Warp_strength, Threshold_min, Threshold_max):
#inverting Threshold_min to simplyfy optimization porcess, so we can clip all variable between 0 and 1
LPF = ops.convert_to_tensor_v2(LPF)
Phase_strength = ops.convert_to_tensor_v2(Phase_strength)
Warp_strength = ops.convert_to_tensor_v2(Warp_strength)
I = ops.convert_to_tensor_v2(I)
Threshold_min = ops.convert_to_tensor_v2(Threshold_min)
Threshold_max = ops.convert_to_tensor_v2(Threshold_max)
Threshold_min = -Threshold_min
L = 0.5
x = tf.linspace(-L, L, I.shape[0])
y = tf.linspace(-L, L, I.shape[1])
[X1, Y1] = (tf.meshgrid(x, y))
X = tf.transpose(X1)
Y = tf.transpose(Y1)
[THETA, RHO] = cart2pol(X, Y)
# Apply localization kernel to the original image to reduce noise
Image_orig_f = sig.fft2d(tf.dtypes.cast(I, tf.complex64))
tmp6 = (LPF**2.0) / tfm.log(2.0)
tmp5 = tfm.sqrt(tmp6)
tmp4 = (tfm.divide(RHO, tmp5))
tmp3 = -tfm.pow(tmp4, 2)
tmp2 = tfm.exp(tmp3)
expo = fftshift(tmp2)
Image_orig_filtered = tfm.real(
sig.ifft2d((tfm.multiply(tf.dtypes.cast(Image_orig_f, tf.complex64),
tf.dtypes.cast(expo, tf.complex64)))))
# Constructing the PST Kernel
tp1 = tfm.multiply(RHO, Warp_strength)
PST_Kernel_1 = tfm.multiply(
tp1, tfm.atan(tfm.multiply(RHO, Warp_strength))
) - 0.5 * tfm.log(1.0 + tfm.pow(tf.multiply(RHO, Warp_strength), 2.0))
PST_Kernel = PST_Kernel_1 / tfm.reduce_max(PST_Kernel_1) * Phase_strength
# Apply the PST Kernel
temp = tfm.multiply(
fftshift(
tfm.exp(
tfm.multiply(tf.dtypes.complex(0.0, -1.0),
tf.dtypes.cast(PST_Kernel,
tf.dtypes.complex64)))),
sig.fft2d(tf.dtypes.cast(Image_orig_filtered, tf.dtypes.complex64)))
Image_orig_filtered_PST = sig.ifft2d(temp)
# Calculate phase of the transformed image
PHI_features = tfm.angle(Image_orig_filtered_PST)
out = PHI_features
out = (out / tfm.reduce_max(out)) * 3
return out
def h(self, X, k, j, t_y=None, primefirst=True):
l = self.lengthscale
# print(l, self.D[k], self.D[j])
t_x = tf.reshape(X[:self.block_size], (-1, ))
t_prime, t, t_dist = self.get_distance_matrix(primefirst=primefirst,
t_x=t_x,
t_y=t_y)
multiplier = tfm.exp(self.gamma(k)**2) / (self.D[j] + self.D[k])
first_erf_term = tfm.erf(t_dist / l -
self.gamma(k)) + tfm.erf(t / l +
self.gamma(k))
second_erf_term = tfm.erf(t_prime / l - self.gamma(k)) + tfm.erf(
self.gamma(k))
return multiplier * (tf.multiply(tfm.exp(-self.D[k]*t_dist) , first_erf_term) - \
tf.multiply(tfm.exp(-self.D[k]*t_prime-self.D[j]*t) , second_erf_term))
def __init__(self, num_input):
num_output = 2 # Based on two genders given (K)
in_ = keras.layers.Input(shape=(num_input, ))
fc1 = keras.layers.Dense(num_input // 2,
activation="relu",
name="fully_connected1")(
in_) # They use different activation tanh
fc2 = keras.layers.Dense(num_input // 4,
activation="relu",
name="fully_connected2")(fc1)
fc3 = keras.layers.Dense(num_input // 8, activation="relu")(fc2)
# Mixture Density Outputs
mu_output = keras.layers.Dense((num_input * num_output),
activation=None,
name="mean_layer")(fc3)
variance_layer = keras.layers.Dense(num_output,
activation=None,
name="variance_layer")(fc3)
var_output = keras.layers.Lambda(lambda x: exp(x),
output_shape=(num_output, ),
name="exp_var_layer")(variance_layer)
pi_output = keras.layers.Dense(num_output,
acitvation="softmax",
name="pi_layer")(fc3)
model = keras.models.Model(in_, [mu_output, var_output, pi_output],
name="MDN")
adam = keras.optimizers.Adam()
# TODO: Can I compile the model here? Is loss the custom loss function? Similar to CAN
model.compile(optimizer="adam")
self.model = model
def K_ff(self, X):
print('k_diag')
"""I've used the fact that we call this method for K_ff when finding the covariance as a hack so
I know if I should return K_ff or K_xx. In this case we're returning K_ff!!
$K_{ff}^{post} = K_{ff} - K_{fx} K_{xx}^{-1} K_{xf}$"""
_, _, t_dist = self.get_distance_matrix(t_x=tf.reshape(X, (-1, )))
K_ff = self.kervar**2 * tfm.exp(-(t_dist**2) / (self.lengthscale**2))
return (K_ff)
def rbf(self, v, l2):
if self.options.kernel_exponential:
v = tf.exp(v)
l2 = tf.exp(l2)
sq_dist = tf.divide(tfm.square(self.t_dist),
tf.reshape(2 * l2, (-1, 1, 1)))
K = tf.reshape(v, (-1, 1, 1)) * tfm.exp(-sq_dist)
m = tf.zeros((self.N_p), dtype='float64')
return m, K
def compute_gaussian_kl(z_log_var, z_mean):
""" Compute the KL divergence between a Gaussian and a Normal distribution. Based on Locatello et al.
implementation (https://github.com/google-research/disentanglement_lib)
:param z_log_var: the log variance of the Gaussian
:param z_mean: the mean of the Gaussian
:return: the KL divergence
"""
kl_loss = tfm.square(z_mean) + tfm.exp(z_log_var) - z_log_var - 1
return 0.5 * tfm.reduce_sum(kl_loss, [1])
def compute_gaussian_log_pdf(z, z_mean, z_log_var):
""" Compute the log probability density of a Gaussian distribution. Based on Locatello et al. implementation
(https://github.com/google-research/disentanglement_lib)
:param z: the sampled values
:param z_mean: the mean of the Gaussian
:param z_log_var: the log variance of the Gaussian
:return: the log probability density
"""
log2pi = tfm.log(2. * tf.constant(pi))
return -0.5 * (tfm.square(z - z_mean) * tfm.exp(-z_log_var) + z_log_var + log2pi)
def predict_m(self, kbar, k_fbar, wbar, fbar, w_0bar, Δ):
# Take relevant parameters out of log-space
if self.options.kinetic_exponential:
kin = (tf.reshape(tf.exp(logit(kbar[:, i])), (-1, 1))
for i in range(kbar.shape[1]))
else:
kin = (tf.reshape(logit(kbar[:, i]), (-1, 1))
for i in range(kbar.shape[1]))
if self.options.initial_conditions:
a_j, b_j, d_j, s_j = kin
else:
b_j, d_j, s_j = kin
w = (wbar)
w_0 = tf.reshape((w_0bar), (-1, 1))
τ = self.data.τ
N_p = self.data.τ.shape[0]
p_i = inverse_positivity(fbar)
if self.options.translation:
p_i = self.calculate_protein(fbar, k_fbar, Δ)
# Calculate m_pred
resolution = τ[1] - τ[0]
interactions = tf.matmul(w, tfm.log(p_i + 1e-100)) + w_0
G = tfm.sigmoid(interactions) # TF Activation Function (sigmoid)
sum_term = G * tfm.exp(d_j * τ)
integrals = tf.concat(
[
tf.zeros((self.num_replicates, self.num_genes, 1),
dtype='float64'), # Trapezoid rule
0.5 * resolution *
tfm.cumsum(sum_term[:, :, :-1] + sum_term[:, :, 1:], axis=2)
],
axis=2)
exp_dt = tfm.exp(-d_j * τ)
integrals = tfm.multiply(exp_dt, integrals)
m_pred = b_j / d_j + s_j * integrals
if self.options.initial_conditions:
m_pred += tfm.multiply((a_j - b_j / d_j), exp_dt)
return m_pred
def call(self, alpha_true, logits_pred):
epsilon = self.epsilon
alpha_pred = exp(logits_pred)
KL = lgamma(tf.math.reduce_sum(alpha_pred)) - tf.math.reduce_sum(
lgamma(alpha_pred + epsilon)) - lgamma(
tf.math.reduce_sum(alpha_true)) + tf.math.reduce_sum(
lgamma(alpha_true + epsilon)) + tf.math.reduce_sum(
(alpha_pred - alpha_true) *
(digamma(alpha_pred + epsilon) -
digamma(tf.math.reduce_sum(alpha_pred))))
return KL
def _convert_to_pxyz(self, x):
from numpy import cos, sin, sinh, exp, clip, stack
pt = exp(clip(x[:, 0], -7., 7.)) - 0.1
pt *= self._pt_scale
eta = x[:, 1]
phi = x[:, 2]
px = pt * cos(phi)
py = pt * sin(phi)
pz = pt * sinh(clip(eta, -5, 5))
return stack([px, py, pz], axis=1)
def _convert_to_pxyz(self, x):
from tensorflow.math import cos, sin, sinh, exp
from tensorflow import clip_by_value, stack
pt = exp(clip_by_value(x[:, 0], -7., 7.)) - 0.1
pt *= self._pt_scale
eta = x[:, 1]
phi = x[:, 2]
px = pt * cos(phi)
py = pt * sin(phi)
pz = pt * sinh(clip_by_value(eta, -5, 5))
return stack([px, py, pz], axis=1)
def gaussian_log_likelihood(x, mu_x, log_sig_sq_x, SMALL_CONSTANT=1e-5):
'''
Element-wise Gaussian log likelihood
INPUTS:
x = points
mu_x - means of Gaussians
log_sig_sq_x - log variance of Gaussian
OPTIONAL INPUTS:
SMALL_CONSTANT - small constant to avoid taking the log of 0 or dividing by 0
OUTPUTS:
log_lik - element-wise log likelihood
'''
# -E_q(z|x) log(p(x|z))
normalising_factor = -0.5 * tfm.log(
SMALL_CONSTANT + tfm.exp(log_sig_sq_x)) - 0.5 * np.log(2.0 * np.pi)
square_diff_between_mu_and_x = tfm.square(mu_x - x)
inside_exp = -0.5 * tfm.divide(square_diff_between_mu_and_x,
SMALL_CONSTANT + tfm.exp(log_sig_sq_x))
log_lik = normalising_factor + inside_exp
return log_lik
def kl_normal(mu_1, log_sig_sq_1, mu_2, log_sig_sq_2):
'''
Element-wise KL divergence between two normal distributions
INPUTS:
mu_1 - mean of firat distribution
log_sig_sq_1 - log variance of first diatribution
mu_2 - mean of second distribution
log_sig_sq_2 - log variance of second diatribution
OUTPUTS:
KL - element-wise KL divergence
'''
v_mean = mu_2 #2
aux_mean = mu_1 #1
v_log_sig_sq = log_sig_sq_2 #2
aux_log_sig_sq = log_sig_sq_1 #1
v_log_sig = tfm.log(tfm.sqrt(tfm.exp(v_log_sig_sq))) #2
aux_log_sig = tfm.log(tfm.sqrt(tfm.exp(aux_log_sig_sq))) #1
KL = v_log_sig - aux_log_sig + tf.divide(
tfm.exp(aux_log_sig_sq) + tfm.square(aux_mean - v_mean),
2.0 * tfm.exp(v_log_sig_sq)) - 0.5
return KL
def reparameterisation_trick(mu, log_sig_sq):
'''
Sample from Gaussian such that it stays differentiable
INPUTS:
mu - mean of distribution
log_sig_sq - log variance of diatribution
OUTPUTS:
samp - sample from distribution
'''
eps = tf.random.normal([tf.shape(mu)[0], tf.shape(mu)[1]],
0,
1.,
dtype=tf.float32)
samp = tfm.add(mu, tfm.multiply(tfm.sqrt(tfm.exp(log_sig_sq)), eps))
return samp
def proceed():
num_tfs = current_state.shape[0]
new_state = current_state
Δrange = np.arange(self.lower, self.upper + 1, dtype='float64')
Δrange_tf = tf.range(self.lower, self.upper + 1, dtype='float64')
for i in range(num_tfs):
# Generate normalised cumulative distribution
probs = list()
mask = np.zeros((num_tfs, ), dtype='float64')
mask[i] = 1
for Δ in Δrange:
test_state = (1 - mask) * new_state + mask * Δ
# if j == 0:
# cumsum.append(tf.reduce_sum(self.likelihood.genes(
# all_states=all_states,
# state_indices=self.state_indices,
# Δ=test_state,
# )) + tf.reduce_sum(self.prior.log_prob(Δ)))
# else:
probs.append(
tf.reduce_sum(
self.likelihood.genes(
all_states=all_states,
state_indices=self.state_indices,
Δ=test_state,
)) + tf.reduce_sum(self.prior.log_prob(Δ)))
# curri = tf.cast(current_state[i], 'int64')
# start_index = tf.reduce_max([self.lower, curri-2])
# probs = tf.gather(probs, tf.range(start_index,
# tf.reduce_min([self.upper+1, curri+3])))
probs = tf.stack(probs) - tfm.reduce_max(probs)
probs = tfm.exp(probs)
probs = probs / tfm.reduce_sum(probs)
cumsum = tfm.cumsum(probs)
u = tf.random.uniform([], dtype='float64')
index = tf.where(
cumsum == tf.reduce_min(cumsum[(cumsum - u) > 0]))
chosen = Δrange_tf[index[0][0]]
new_state = (1 - mask) * new_state + mask * chosen
return new_state
def train(epoch, model):
# LEARNING_RATE = lr / tf.math((1 + 10 * (epoch - 1) / epochs), 0.75)
# print('learning rate{: .4f}'.format(LEARNING_RATE))
optimizer = tf.train.AdamOptimizer(0.01,
beta1=0.9,
beta2=0.9,
epsilon=l2_decay)
iter_source = iter(source_loader)
iter_target = iter(target_train_loader)
num_iter = len_source_loader
for i in range(1, num_iter):
data_source, label_source = iter_source.get_next()
data_target, _ = iter_target.get_next()
if i % len_target_loader == 0:
iter_target = iter(target_train_loader)
if cuda:
data_source, label_source = data_source.cuda(), label_source.cuda(
) # tf.matmul(data_source)
data_target = data_target.cuda() # tf.matmul(data_target)
data_source, label_source = tf.Variable(data_source), tf.Variable(
label_source)
data_target = tf.Variable(data_target)
label_source_pred, loss_mmd = model(data_source, data_target)
loss_cls = tf.losses.sparse_softmax_cross_entropy(
label_source_pred, label_source)
gamma = 2 / (1 + math.exp(-10 * (epoch) / epochs)) - 1
loss = loss_cls + gamma * loss_mmd
if i % log_interval == 0:
print(
'Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}\tsoft_Loss: {:.6f}\tmmd_Loss: {:.6f}'
.format(epoch, i * len(data_source), len_source_dataset,
100. * i / len_source_loader, loss.data[0],
loss_cls.data[0], loss_mmd.data[0]))
train_op = optimizer.minimize(loss)
with tf.Session() as sess:
for i in range(num_batches):
_, loss_val = sess.run([train_op, loss])
def call(self, ensemble_logits, logits):
'''
ensemble_logits are the outputs from our ensemble (batch x ensembles x classes)
logits are the predicted outputs from our model (batch x classes)
'''
logits = tf.cast(logits, dtype=tf.float64)
ensemble_logits = tf.cast(ensemble_logits, dtype=tf.float64)
alphas = exp(logits / self.temp)
precision = reduce_sum(alphas, axis=1) #sum over classes
ensemble_probs = softmax(ensemble_logits / self.temp,
axis=2) #softmax over classes
# Smooth for num. stability:
probs_mean = 1 / (tf.shape(ensemble_probs)[2]
) #divide by nr of classes
# Subtract mean, scale down, add mean back)
ensemble_probs = self.tp_scaling * (ensemble_probs -
probs_mean) + probs_mean
log_ensemble_probs_geo_mean = reduce_mean(log(ensemble_probs +
self.smooth_val),
axis=1) #mean over ensembles
target_independent_term = reduce_sum(
lgamma(alphas + self.smooth_val), axis=1) - lgamma(
precision + self.smooth_val
) #sum over lgammma of classes - lgamma(precision)
target_dependent_term = -reduce_sum(
(alphas - 1.) * log_ensemble_probs_geo_mean,
axis=1) # -sum over classes
cost = target_dependent_term + target_independent_term
# tf.print(self.temp)
return reduce_mean(cost) * (self.temp**2) #mean of all batches
def eight_schools_log_pdf(z, centered=EIGHT_SCHOOL_CENTERED):
prior_mu = tfd.Normal(loc=0, scale=5)
prior_tau = tfd.HalfCauchy(loc=0, scale=5)
mu, log_tau = z[:, -2], z[:, -1]
# Adapt size of mu an tau.
mu = tf.transpose(eight_schools_replicate * mu)
log_tau = tf.transpose(eight_schools_replicate * log_tau)
if centered:
# shapes, thetas=(8,N), mu=(N,), tau=(N,)
thetas = z[:, 0:eight_schools_K]
likelihood = tfd.Normal(loc=thetas,
scale=eight_schools_sigma[0:eight_schools_K])
prior_theta = tfd.Normal(loc=mu, scale=math.exp(log_tau))
log_det_jac = math.log(math.exp(
log_tau)) # kept log(exp()) for mathematical understanding.
return likelihood.log_prob(
eight_schools_y[0:eight_schools_K]) + prior_theta.log_prob(
thetas) + prior_mu.log_prob(mu) + prior_tau.log_prob(
math.exp(log_tau)) + log_det_jac
else:
# shapes, thetas=(8,N), mu=(N,), tau=(N,)
thetas_tilde = z[:, 0:eight_schools_K]
zeros = tf.zeros(mu.shape)
ones = tf.ones(log_tau.shape)
thetas = mu + thetas_tilde * math.exp(log_tau)
likelihood = tfd.Normal(loc=thetas,
scale=eight_schools_sigma[0:eight_schools_K])
prior_theta = tfd.Normal(loc=zeros, scale=ones)
log_det_jac = math.log(math.exp(
log_tau)) # kept log(exp()) for mathematical understanding.
return likelihood.log_prob(
eight_schools_y[0:eight_schools_K]) + prior_theta.log_prob(
thetas_tilde) + prior_mu.log_prob(mu) + prior_tau.log_prob(
math.exp(log_tau)) + log_det_jac
def pdf_2D(z, density_name=''):
assert density_name in AVAILABLE_2D_DISTRIBUTIONS, "Incorrect density name."
if density_name == '':
return 1
elif density_name == 'banana':
z1, z2 = z[:, 0], z[:, 1]
mu = np.array([0.5, 0.5], dtype='float32')
cov = np.array([[0.06, 0.055], [0.055, 0.06]], dtype='float32')
scale = tf.linalg.cholesky(cov)
p = tfd.MultivariateNormalTriL(loc=mu, scale_tril=scale)
z2 = z1**2 + z2
z1, z2 = tf.expand_dims(z1, 1), tf.expand_dims(z2, 1)
z = tf.concat([z1, z2], axis=1)
return p.prob(z)
elif density_name == 'circle':
z1, z2 = z[:, 0], z[:, 1]
norm = (z1**2 + z2**2)**0.5
exp1 = math.exp(-0.2 * ((z1 - 2) / 0.8)**2)
exp2 = math.exp(-0.2 * ((z1 + 2) / 0.8)**2)
u = 0.5 * ((norm - 4) / 0.4)**2 - math.log(exp1 + exp2)
return math.exp(-u)
elif density_name == 'eight_schools':
y_i = 0
sigma_i = 10
thetas, mu, log_tau = z[:, 0], z[:, 1], z[:, 2]
likelihood = tfd.Normal(loc=thetas, scale=sigma_i)
prior_theta = tfd.Normal(loc=mu, scale=math.exp(log_tau))
prior_mu = tfd.Normal(loc=0, scale=5)
prior_tau = tfd.HalfCauchy(loc=0, scale=5)
return likelihood.prob(y_i) * prior_theta.prob(thetas) * prior_mu.prob(
mu) * prior_tau.prob(math.exp(log_tau)) * math.exp(log_tau)
elif density_name == 'figure_eight':
mu1 = 1 * np.array([-1, -1], dtype='float32')
mu2 = 1 * np.array([1, 1], dtype='float32')
scale = 0.45 * np.array([1, 1], dtype='float32')
pi = 0.5
comp1 = tfd.MultivariateNormalDiag(loc=mu1, scale_diag=scale)
comp2 = tfd.MultivariateNormalDiag(loc=mu2, scale_diag=scale)
return (1 - pi) * comp1.prob(z) + pi * comp2.prob(z)
if not shared:
# weight loss
a_list = []
b_list = []
with tf.variable_scope('weight_regulizer'):
for i in range(nb_cnn+2):
a_list.append(tf.Variable(1.0, name='a_{}'.format(i)))
b_list.append(tf.Variable(0.0, name='b_{}'.format(i)))
# source kernel and target kernel
source_kernels = [v for v in tf.trainable_variables('source') if 'kernel' in v.name]
target_kernels = [v for v in tf.trainable_variables('target') if 'kernel' in v.name]
source_bias = [v for v in tf.trainable_variables('source') if 'bias' in v.name]
target_bias = [v for v in tf.trainable_variables('target') if 'bias' in v.name]
layer_loss_list = []
for a, b, sk, tk, sb, tb in list(zip(a_list[:-1], b_list[:-1], source_kernels[:-1], target_kernels[:-1], source_bias[:-1], target_bias[:-1])):
layer_loss_list.append(tm.exp(tf.nn.l2_loss(tm.scalar_mul(a, sk) + b - tk)) -1)
layer_loss_list.append(tm.exp(tf.nn.l2_loss(tm.scalar_mul(a, sb) + b - tb)) -1)
# layer_loss_list.append(tm.exp(tf.nn.l2_loss(tm.subtract(tm.add(tm.scalar_mul(a, sb), b), tb)))-1)
# source bais and target bais
w_loss = tf.add_n(layer_loss_list)
total_loss = total_loss + w_loss
gen_step = tf.train.AdamOptimizer(lr).minimize(total_loss, var_list = target_vars_list + source_vars_list + tf.trainable_variables('weight_regulizer'))
else:
gen_step = tf.train.AdamOptimizer(lr).minimize(total_loss, var_list = target_vars_list)
D_loss_list = []
sC_loss_list = []
tC_loss_list = []
test_auc_list = []
val_auc_list = []
train_auc_list = []
def calculate_score_loss(score, y_k):
x = tf.gather(tf.gather(score, 0), 0)
return log(1 + exp(-y_k * x))
def positivity(f_i):
return tfm.log(tfm.exp(f_i) - 1)
def calculate_segment_loss(segment, true_mask):
prod = tf.multiply(segment, true_mask)
unit_val = log(1 + exp(-prod))
return tf.reduce_sum(unit_val)
