def stock_loss(y_true, y_pred):
alpha = 100.
loss = K.switch(K.less(y_true * y_pred, 0), \
alpha*y_pred**2 - K.sign(y_true)*y_pred + K.abs(y_true), \
K.abs(y_true - y_pred)
)
return K.mean(loss, axis=-1)
def weighted_bce_dice_loss(y_true, y_pred):
y_true = K.cast(y_true, 'float32')
y_pred = K.cast(y_pred, 'float32')
# if we want to get same size of output, kernel size must be odd number
averaged_mask = K.pool2d(
y_true, pool_size=(11, 11), strides=(1, 1), padding='same', pool_mode='avg')
border = K.cast(K.greater(averaged_mask, 0.005), 'float32') * K.cast(K.less(averaged_mask, 0.995), 'float32')
weight = K.ones_like(averaged_mask)
w0 = K.sum(weight)
weight += border * 2
w1 = K.sum(weight)
weight *= (w0 / w1)
loss = weighted_bce_loss(y_true, y_pred, weight) + \
weighted_dice_loss(y_true, y_pred, weight)
return loss
def output_sampling(self, output, rand_matrix):
# Generates a sampled selection based on raw output state vector
# Creates a cdf vector and compares against a randomly generated vector
# Requires a pre-generated rand_matrix (i.e. generated outside step function)
sampled_output = output / K.sum(output, axis=-1, keepdims=True) # (batch_size, self.units)
mod_sampled_output = sampled_output / K.exp(self.temperature)
norm_exp_sampled_output = mod_sampled_output / K.sum(mod_sampled_output, axis=-1, keepdims=True)
cdf_vector = K.cumsum(norm_exp_sampled_output, axis=-1)
cdf_minus_vector = cdf_vector - norm_exp_sampled_output
rand_matrix = K.stack([rand_matrix], axis=0)
rand_matrix = K.stack([rand_matrix], axis=2)
compared_greater_output = K.cast(K.greater(cdf_vector, rand_matrix), dtype='float32')
compared_lesser_output = K.cast(K.less(cdf_minus_vector, rand_matrix), dtype='float32')
final_output = compared_greater_output * compared_lesser_output
return final_output
def _loop_over_nodes_condition(node_idx, h, c):
return K.less(node_idx, num_nodes)
def is_iterate_neurons_n(idx_p, idx_l, idx_m, idx_n):
return k.less(idx_n, shape[3])
def is_iterate_powers(act_value, idx_p, idx_l, idx_m, idx_n):
return k.less(idx_p, num_bits)
def custom_accuracy(y_true, y_pred, thresh):
y_true_t = y_true[y_true > thresh + 0.1]
y_pred_t = y_pred[y_true > thresh + 0.1]
eval = K.mean(K.less(K.abs(y_true_t - y_pred_t), 0.05))
return eval
def FP(y_true, y_pred):
y_true = K.argmax(y_true, axis=-1)
y_pred = K.argmax(y_pred, axis=-1)
return K.sum(K.cast(K.less(y_true, y_pred), K.floatx()))
def false_positive(y_true, y_pred):
return K.sum(K.cast(K.less(y_true, y_pred), K.floatx()))
def max_sim_acc(y_true, y_pred):
centroids = K.constant(embedding.T)
sim = K.dot(y_pred, centroids)
true_sim = K.sum(y_pred * y_true, axis = -1)
return K.cast(K.less(K.abs(K.max(sim, axis = -1) - true_sim), 1e-6), K.floatx())
def limit(x):
y = tf.where(K.greater(x, 100000), 1000000. * K.ones_like(x), x)
z = tf.where(K.less(y, -100000), -1000000. * K.ones_like(x), y)
return z
def PredictClass(y_pred,thresholdLow=0.5,thresholdHigh=1):
return K.tf.cast((K.greater(y_pred,thresholdLow) & K.less(y_pred,thresholdHigh)),tf.int8)
def tmp(v):
r = K.arange(size, dtype=K.floatx())
mask = K.less(r, trunc)
return K.cast(mask, K.floatx())
def func(tensors):
return K.cast(K.less(tensors[0], tensors[1]), dtype='float32')
def eucAcc(y_true, y_pred):
thresh = 0.5
return K.mean(K.equal(y_true, tf.to_float(K.less(thresh, y_pred))), axis=-1)
def get_loss(self):
def cal_df_gp():
def cal_gp(gradients):
gradients_sqr = K.square(gradients[0])
gradients_sqr_sum = K.sum(gradients_sqr,
axis=np.arange(
1, len(gradients_sqr.shape)))
gradient_l2_norm = K.sqrt(gradients_sqr_sum)
gradient_penalty = K.mean(K.square(1 - gradient_l2_norm))
return gradient_penalty
alpha = K.random_uniform_variable(shape=(1, ), low=0, high=1)
mix_tar = alpha * self.img_a + (1 - alpha) * self.img_a2b
mix_outputs_a2b = self.d_model(
[self.img_a, mix_tar, self.vec_ab_pos])
mix_outputs_a2ab = self.d_model(
[self.img_a, self.img_a2ab, self.vec_ab_pos])
gradients_a2b = K.gradients([mix_outputs_a2b[0]], [mix_tar])
gradients_a2ab = K.gradients([mix_outputs_a2ab[2]],
[self.img_a2ab])
df_gp = cal_gp(gradients_a2b) + cal_gp(gradients_a2ab)
return df_gp
def lsgan(xs, ts):
real = 0
fake = 0
for i in range(len(xs)):
if ts[i] == 1:
real += K.mean(K.square(K.ones_like(xs[i]) - xs[i]),
axis=[-1])
else:
fake += K.mean(K.square(K.zeros_like(xs[i]) - xs[i]),
axis=[-1])
return real + fake
self.img_a = Input(shape=self.img_shape)
self.img_b = Input(shape=self.img_shape)
self.img_c = Input(shape=self.img_shape)
self.vec_ab_pos = Input(shape=self.vec_shape)
self.vec_ac_pos = Input(shape=self.vec_shape)
self.vec_cb_pos = Input(shape=self.vec_shape)
self.img_a2b, self.enc_a2b = self.g_model(
[self.img_a, self.vec_ab_pos])
self.img_a2a, self.enc_a2a = self.g_model(
[self.img_a, K.zeros_like(self.vec_ab_pos)])
self.img_a2b2a, _ = self.g_model([self.img_a2b, -self.vec_ab_pos])
inter_seed = K.random_uniform_variable(shape=([
self.batch,
]),
low=0,
high=1)
inter_seed = K.reshape(inter_seed, [self.batch, 1])
self.img_a2ab, self.enc_a2ab = self.g_model(
[self.img_a, inter_seed * self.vec_ab_pos])
input_real = [self.img_a, self.img_b, self.vec_ab_pos]
input_fake = [self.img_a, self.img_a2b, self.vec_ab_pos]
input_w_ori = [self.img_c, self.img_b, self.vec_ab_pos]
input_w_tar = [self.img_a, self.img_c, self.vec_ab_pos]
input_w_vec1 = [self.img_a, self.img_b, self.vec_ac_pos]
input_w_vec2 = [self.img_a, self.img_b, self.vec_cb_pos]
input_inter = [self.img_a, self.img_a2ab, inter_seed * self.vec_ab_pos]
input_zero = [self.img_a, self.img_a2a, K.zeros_like(self.vec_ab_pos)]
d_real, dc_real, _ = self.d_model(input_real)
d_fake, dc_fake, di_fake = self.d_model(input_fake)
d_w_ori, dc_w_ori, _ = self.d_model(input_w_ori)
d_w_tar, dc_w_tar, _ = self.d_model(input_w_tar)
d_w_vec1, dc_w_vec1, _ = self.d_model(input_w_vec1)
d_w_vec2, dc_w_vec2, _ = self.d_model(input_w_vec2)
_, _, di_inter = self.d_model(input_inter)
_, _, di_zero = self.d_model(input_zero)
self.df_loss = lsgan([d_real, d_fake], [1, 0])
self.dc_loss = lsgan(
[dc_real, dc_fake, dc_w_ori, dc_w_tar, dc_w_vec1, dc_w_vec2],
[1, 0, 0, 0, 0, 0])
inter_seed_rep = K.flatten(inter_seed)
di_temp = K.switch(
K.less(inter_seed_rep, 0.5 * K.ones_like(inter_seed_rep)), di_zero,
di_fake)
self.di_loss = K.square(
K.minimum(inter_seed_rep,
K.ones_like(inter_seed_rep) - inter_seed_rep) *
K.ones_like(di_inter) - di_inter) + K.square(di_temp)
print('self.df_loss', K.int_shape(self.df_loss))
print('self.dc_loss', K.int_shape(self.dc_loss))
print('self.di_loss', K.int_shape(self.di_loss))
self.df_gp = cal_df_gp()
self.d_loss = self.df_loss + self.dc_loss + self.gp_l * self.df_gp + self.lambda5 * self.di_loss
self.gf_loss = lsgan([d_real, d_fake], [0, 1])
self.gc_loss = lsgan([dc_real, dc_fake], [0, 1])
self.gi_loss = K.square(di_inter)
dist_a2b = self.enc_a2b - self.enc_a2a
dist_a2ab = self.enc_a2ab - self.enc_a2a
inter_seed = K.reshape(inter_seed, [self.batch, 1, 1, 1])
self.g_inter_loss = K.mean(K.abs(inter_seed * dist_a2b - dist_a2ab))
g_loss_rec1 = K.mean(K.abs(self.img_a - self.img_a2b2a))
g_loss_rec2 = K.mean(K.abs(self.img_a - self.img_a2a))
print('self.gf_loss', K.int_shape(self.gf_loss))
print('self.gc_loss', K.int_shape(self.gc_loss))
print('self.gi_loss', K.int_shape(self.gi_loss))
print('self.g_loss_rec1', K.int_shape(g_loss_rec1))
print('self.g_loss_rec2', K.int_shape(g_loss_rec2))
self.gr_loss = self.lambda1 * g_loss_rec1 + self.lambda2 * g_loss_rec2
self.g_loss = self.gf_loss + self.gc_loss + self.gr_loss + self.lambda5 * self.gi_loss
def matching_loss(y_true, y_pred):
# # the indexes of a1, a2, b1, b2
# args = self.regression_model.predict_on_batch(correlation)
# a and b are the original inputs
# inverse a or b ??
sess = tf.InteractiveSession()
main_log.debug(a.shape)
main_log.debug(y_pred.eval()[0, 1])
main_log.debug(y_pred.eval()[0, 1].shape)
aa = a[:, :, y_pred.eval()[0] - 1, :]
main_log.debug(aa)
a1 = tf.squeeze(a[:, :, y_pred.eval()[0], :])
a2 = tf.squeeze(a[:, :, y_pred.eval()[1], :])
b1 = tf.squeeze(b[:, :, y_pred.eval()[2], :])
b2 = tf.squeeze(b[:, :, y_pred.eval()[3], :])
d = subtract([b1, a1])
dx = d[0]
dy = d[1]
translated_a2 = add([a2, d])
cos = tf.squeeze(
dot([translated_a2 - b1, b2, b1], axes=0, normalize=True))
sin = tf.sqrt(subtract([1, cos * cos]))
# rotation_m = np.array([
# [cos, -sin],
# [sin, cos]
# ])
# tf_rotation_m = tf.constant(rotation_m, dtype=tf.float32)
# translation_m = np.array([
# [dx],
# [dy]
# ])
# tf_translation_m = tf.constant(translation_m, dtype=tf.float32)
affine = np.array([[cos, -sin, dx], [sin, cos, dy], [0, 0, 1]])
tf_affine = tf.constant(affine, dtype=tf.float32)
h**o = np.ones((1, tf.shape(a).eval()[1]))
tf_homo = tf.constant(h**o, dtype=tf.float32)
homo_a = concatenate([a, tf_homo], axis=0)
homo_b = concatenate([b, tf_homo], axis=0)
new_a_homo = tf.matmul(tf_affine, homo_a)
new_a = new_a_homo[:, 0:2, :, :]
new_a1 = tf.squeeze(new_a[:, :, y_pred[0], :])
new_a2 = tf.squeeze(new_a[:, :, y_pred[1], :])
pi = tf.constant(3.14159265, dtype=tf.float32)
# convexity matching cost
def convexity_cue(contour, i):
# boundary??
v1 = tf.squeeze(contour[:, :, i, :])
v0 = tf.squeeze(contour[:, :, i - 1, :])
v2 = tf.squeeze(contour[:, :, i + 1, :])
v01 = subtract([v1, v0])
v21 = subtract([v2, v1])
zero = tf.constant([[0]], dtype=tf.float32)
v01 = tf.reshape(tf.concat([v01, zero], axis=0), [3])
v21 = tf.reshape(tf.concat([v21, zero], axis=0), [3])
sign = tf.sign(tf.cross(v01, v21)[2])
theta = tf.acos(cos)
convexity = multiply([sign, subtract(pi, theta)])
return convexity
convexity_loss = tf.Variable(1.0, dtype=tf.float32)
fc_loss = tf.Variable(0, dtype=tf.float32)
# sess = tf.InteractiveSession()
sess.run(tf.global_variables_initializer())
# how to define the bijective function??
i = tf.constant(y_pred[0], dtype=tf.int32)
i_last = tf.constant(add(y_pred[1], 1), dtype=tf.int32)
j = tf.constant(y_pred[2], dtype=tf.int32)
j_last = tf.constant(add(y_pred[3], 1), dtype=tf.int32)
while_condition = lambda i, i_last, j, j_last, fc_loss: K.less(
i, i_last)
def while_body(i, i_last, j, j_last, fc_loss):
main_log.debug('while_body')
alpha_a = convexity_cue(new_a, i)
alpha_b = convexity_cue(b, j)
fc_loss = add(
fc_loss,
multiply(tf.sign(multiply(alpha_a, alpha_b)),
tf.sqrt(tf.abs(multiply(alpha_a, alpha_b)))))
return [add(i, 1), i_last, add(j, 1), j_last, fc_loss]
results = tf.while_loop(while_condition, while_body,
[i, i_last, j, j_last, fc_loss])
fc_loss = results[4]
convexity_loss = add(convexity_loss,
tf.divide(fc_loss, subtract(i_last, i)))
sess.close()
return convexity_loss
def call(self, x, mask=None):
return K.less(K.abs(x), 1)
def calc_accuracy(labels, predictions):
'''accuracy function for compilation'''
return K.mean(K.equal(labels, K.cast(K.less(predictions, 0.5), "float32")))
def step(self, x, states):
ytm, stm, t = states
# repeat the hidden state to the length of the sequence
_stm = K.repeat(stm, self.timesteps)
# now multiplty the weight matrix with the repeated hidden state
_Wxstm = K.dot(_stm, self.W_a)
# calculate the attention probabilities
# this relates how much other timesteps contributed to this one.
et = K.dot(activations.tanh(_Wxstm + self._uxpb),
K.expand_dims(self.V_a))
if self.causal and not self.use_attention_horizon:
is_future = K.greater(self._input_t, t)
mask = K.cast(is_future, 'float32') * -10e9
et = et + K.expand_dims(K.expand_dims(mask, -1), 0)
elif self.causal and self.use_attention_horizon:
is_future = K.greater(self._input_t, t)
is_beyond_horizon = K.less(self._input_t, t - self.attn_horizon)
mask_future = K.cast(is_future, 'float32') * -10e9
mask_past = K.cast(is_beyond_horizon, 'float32') * -10e9
mask = mask_future + mask_past
et = et + K.expand_dims(K.expand_dims(mask, -1), 0)
at = K.softmax(et, axis=1)
# calculate the context vector
context = K.squeeze(K.batch_dot(at, self.x_seq, axes=1), axis=1)
# ~~~> calculate new hidden state
# first calculate the "r" gate:
rt = activations.sigmoid(
K.dot(ytm, self.W_r) + K.dot(stm, self.U_r) +
K.dot(context, self.C_r) + self.b_r)
# now calculate the "z" gate
zt = activations.sigmoid(
K.dot(ytm, self.W_z) + K.dot(stm, self.U_z) +
K.dot(context, self.C_z) + self.b_z)
# calculate the proposal hidden state:
s_tp = activations.tanh(
K.dot(ytm, self.W_p) + K.dot((rt * stm), self.U_p) +
K.dot(context, self.C_p) + self.b_p)
# new hidden state:
st = (1 - zt) * stm + zt * s_tp
yt = self.activation(
K.dot(ytm, self.W_o) + K.dot(stm, self.U_o) +
K.dot(context, self.C_o) + self.b_o)
t += 1
if self.return_probabilities:
return at, [yt, st, t]
else:
return yt, [yt, st, t]
def get_lr_decay_schedule(args):
number_of_iters_generator = 1000. * args.number_of_epochs
number_of_iters_discriminator = 1000. * args.number_of_epochs * args.training_ratio
if args.lr_decay_schedule is None:
lr_decay_schedule_generator = lambda iter: 1.
lr_decay_schedule_discriminator = lambda iter: 1.
elif args.lr_decay_schedule == 'linear':
lr_decay_schedule_generator = lambda iter: K.maximum(
0., 1. - K.cast(iter, 'float32') / number_of_iters_generator)
lr_decay_schedule_discriminator = lambda iter: K.maximum(
0., 1. - K.cast(iter, 'float32') / number_of_iters_discriminator)
elif args.lr_decay_schedule == 'half-linear':
lr_decay_schedule_generator = lambda iter: ktf.where(
K.less(iter, K.cast(number_of_iters_generator / 2, 'int64')),
ktf.maximum(
0., 1. -
(K.cast(iter, 'float32') / number_of_iters_generator)), 0.5)
lr_decay_schedule_discriminator = lambda iter: ktf.where(
K.less(iter, K.cast(number_of_iters_discriminator / 2, 'int64')),
ktf.maximum(
0., 1. - (K.cast(iter, 'float32') /
number_of_iters_discriminator)), 0.5)
elif args.lr_decay_schedule == 'linear-end':
decay_at = 0.828
number_of_iters_until_decay_generator = number_of_iters_generator * decay_at
number_of_iters_until_decay_discriminator = number_of_iters_discriminator * decay_at
number_of_iters_after_decay_generator = number_of_iters_generator * (
1 - decay_at)
number_of_iters_after_decay_discriminator = number_of_iters_discriminator * (
1 - decay_at)
lr_decay_schedule_generator = lambda iter: ktf.where(
K.greater(iter,
K.cast(number_of_iters_until_decay_generator, 'int64')),
ktf.maximum(
0., 1. - (K.cast(iter, 'float32') -
number_of_iters_until_decay_generator) /
number_of_iters_after_decay_generator), 1)
lr_decay_schedule_discriminator = lambda iter: ktf.where(
K.greater(
iter, K.cast(number_of_iters_until_decay_discriminator, 'int64'
)),
ktf.maximum(
0., 1. - (K.cast(iter, 'float32') -
number_of_iters_until_decay_discriminator) /
number_of_iters_after_decay_discriminator), 1)
elif args.lr_decay_schedule.startswith("dropat"):
drop_at = int(args.lr_decay_schedule.replace('dropat', ''))
drop_at_generator = drop_at * 1000
drop_at_discriminator = drop_at * 1000 * args.training_ratio
print("Drop at generator %s" % drop_at_generator)
lr_decay_schedule_generator = lambda iter: (ktf.where(
K.less(iter, drop_at_generator), 1., 0.1) * K.maximum(
0., 1. - K.cast(iter, 'float32') / number_of_iters_generator))
lr_decay_schedule_discriminator = lambda iter: (ktf.where(
K.less(iter, drop_at_discriminator), 1., 0.1) * K.maximum(
0., 1. - K.cast(iter, 'float32') /
number_of_iters_discriminator))
else:
assert False
return lr_decay_schedule_generator, lr_decay_schedule_discriminator
def contrastive_accuracy(y_true, y_pred):
margin = 1.0
return K.mean(K.equal(y_true,
K.cast(K.less(y_pred, margin / 2), 'float32')),
axis=-1)
def triplet_acc(self, y_true, y_pred):
return K.mean(K.less(y_pred, 0))
def my_critic_acc(y_true, y_pred): sign = K.less(K.zeros(1), y_true*y_pred) return K.mean(sign)
def call(self, x):
a, b = x
return K.less(a, b)
def GRU_merge(self, self_act, a, b, act):
lower_a, upper_a = a.get_lu()
lower_b, upper_b = b.get_lu()
fa_lower, fa_upper = lower_a, upper_a
fb_lower, fb_upper = act(lower_b), act(upper_b)
lower_x, upper_x = self.get_lu()
fx_lower, fx_upper = self_act(lower_x), self_act(upper_x)
partial_fx_lower = tf.gradients(fx_lower, lower_x)[0]
partial_fx_upper = tf.gradients(fx_upper, upper_x)[0]
def lower_a_greater_zero():
uz_x_Phi = K.minimum(partial_fx_upper * fa_upper,
(fx_upper - fx_lower) * fa_upper /
(upper_x - lower_x))
ax_right_upper = fx_upper * fa_upper
ax_left_upper = uz_x_Phi * (lower_x - upper_x) + ax_right_upper
lz_x_Phi = K.minimum(partial_fx_lower * fa_lower,
(fx_lower - fx_upper) * fa_lower /
(lower_x - upper_x))
ax_left_lower = fx_lower * fa_lower
ax_right_lower = lz_x_Phi * (upper_x - lower_x) + ax_left_lower
return [
ax_left_lower, ax_left_upper, ax_right_lower, ax_right_upper
]
def lower_b_greater_zero():
uz_x_Phi = K.maximum(-partial_fx_lower * fb_upper,
(-fx_upper + fx_lower) * fb_upper /
(upper_x - lower_x))
bx_left_upper = (1 - fx_lower) * fb_upper
bx_right_upper = uz_x_Phi * (upper_x - lower_x) + bx_left_upper
lz_x_Phi = K.maximum(-partial_fx_upper * fb_lower,
(-fx_lower + fx_upper) * fb_lower /
(lower_x - upper_x))
bx_right_lower = (1 - fx_upper) * fb_lower
bx_left_lower = lz_x_Phi * (lower_x - upper_x) + bx_right_lower
return [
bx_left_lower, bx_left_upper, bx_right_lower, bx_right_upper
]
def upper_a_less_zero():
uz_x_Phi = K.maximum(partial_fx_lower * fa_upper,
(fx_lower - fx_upper) * fa_upper /
(lower_x - upper_x))
ax_left_upper = fx_lower * fa_upper
ax_right_upper = uz_x_Phi * (upper_x - lower_x) + ax_left_upper
lz_x_Phi = K.maximum(partial_fx_upper * fa_lower,
(fx_upper - fx_lower) * fa_lower /
(upper_x - lower_x))
ax_right_lower = fx_upper * fa_lower
ax_left_lower = lz_x_Phi * (lower_x - upper_x) + ax_right_lower
return [
ax_left_lower, ax_left_upper, ax_right_lower, ax_right_upper
]
def upper_b_less_zero():
uz_x_Phi = K.minimum(-partial_fx_upper * fb_upper,
(-fx_upper + fx_lower) * fb_upper /
(upper_x - lower_x))
bx_right_upper = (1 - fx_upper) * fb_upper
bx_left_upper = uz_x_Phi * (lower_x - upper_x) + bx_right_upper
lz_x_Phi = K.minimum(-partial_fx_lower * fb_lower,
(-fx_lower + fx_upper) * fb_lower /
(lower_x - upper_x))
bx_left_lower = (1 - fx_lower) * fb_lower
bx_right_lower = lz_x_Phi * (upper_x - lower_x) + bx_left_lower
return [
bx_left_lower, bx_left_upper, bx_right_lower, bx_right_upper
]
def otherwise_a():
uz_x_Phi = K.minimum(partial_fx_upper * fa_upper,
(fx_upper - fx_lower) * fa_upper /
(upper_x - lower_x))
ax_right_upper = fx_upper * fa_upper
ax_left_upper = uz_x_Phi * (lower_x - upper_x) + ax_right_upper
lz_x_Phi = K.maximum(partial_fx_upper * fa_lower,
(fx_upper - fx_lower) * fa_lower /
(upper_x - lower_x))
ax_right_lower = fx_upper * fa_lower
ax_left_lower = lz_x_Phi * (lower_x - upper_x) + ax_right_lower
return [
ax_left_lower, ax_left_upper, ax_right_lower, ax_right_upper
]
def otherwise_b():
uz_x_Phi = K.maximum(-partial_fx_lower * fb_upper,
(-fx_upper + fx_lower) * fb_upper /
(upper_x - lower_x))
bx_left_upper = (1 - fx_lower) * fb_upper
bx_right_upper = uz_x_Phi * (upper_x - lower_x) + bx_left_upper
lz_x_Phi = K.minimum(-partial_fx_lower * fb_lower,
(-fx_lower + fx_upper) * fb_lower /
(lower_x - upper_x))
bx_left_lower = (1 - fx_lower) * fb_lower
bx_right_lower = lz_x_Phi * (upper_x - lower_x) + bx_left_lower
return [
bx_left_lower, bx_left_upper, bx_right_lower, bx_right_upper
]
a_anchors = otherwise_a()
anchors_lower_a_greater_zero = lower_a_greater_zero()
anchors_upper_a_less_zero = upper_a_less_zero()
for i in range(4):
a_anchors[i] = K.switch(K.greater(lower_a, K.zeros_like(lower_a)),
anchors_lower_a_greater_zero[i],
a_anchors[i])
a_anchors[i] = K.switch(K.less(upper_a, K.zeros_like(upper_a)),
anchors_upper_a_less_zero[i], a_anchors[i])
b_anchors = otherwise_b()
anchors_lower_b_greater_zero = lower_b_greater_zero()
anchors_upper_b_less_zero = upper_b_less_zero()
for i in range(4):
b_anchors[i] = K.switch(K.greater(lower_b, K.zeros_like(lower_b)),
anchors_lower_b_greater_zero[i],
b_anchors[i])
b_anchors[i] = K.switch(K.less(upper_b, K.zeros_like(upper_b)),
anchors_upper_b_less_zero[i], b_anchors[i])
for i in range(4):
a_anchors[i] += b_anchors[i]
lower_z = K.minimum(a_anchors[0], a_anchors[2])
upper_z = K.maximum(a_anchors[1], a_anchors[3])
return AI((lower_z + upper_z) / 2, (upper_z - lower_z) / 2, None, True)
def call(self, x):
return K.less(x, K.constant(0))
def Max(x):
zeros = K.zeros_like(x)
return K.switch(K.less(x, 0.9), zeros, x)
def customized_loss(y_true, y_pred):
self.tensor_ = y_true
loss = K.switch(K.less(y_pred, y_true), cu * (y_true - y_pred), co * (y_pred - y_true))
return K.sum(loss)
def is_iterate_neurons_m(idx_p, idx_l, idx_m, idx_n):
return k.less(idx_m, shape[2])
def RecoProb_forVAE(x, par1, par2, par3):
N = 0
nll_loss = 0
#Log-Normal distributed variables
mu = par1[:, :Nf_lognorm]
sigma = par2[:, :Nf_lognorm]
fraction = par3[:, :Nf_lognorm]
x_clipped = K.clip(x[:, :Nf_lognorm], clip_x_to0, 1e8)
single_NLL = K.tf.where(
K.less(x[:, :Nf_lognorm], clip_x_to0), -K.log(fraction),
-K.log(1 - fraction) + K.log(sigma) + K.log(x_clipped) +
0.5 * K.square(K.tf.divide(K.log(x_clipped) - mu, sigma)))
nll_loss += K.sum(single_NLL, axis=-1)
N += Nf_lognorm
# Gaussian distributed variables
mu = par1[:, N:N + Nf_gauss]
sigma = par2[:, N:N + Nf_gauss]
norm_x = K.tf.divide(x[:, N:N + Nf_gauss] - mu, sigma)
single_NLL = K.log(sigma) + 0.5 * K.square(norm_x)
nll_loss += K.sum(single_NLL, axis=-1)
N += Nf_gauss
# Positive Gaussian distributed variables
mu = par1[:, N:N + Nf_Pgauss]
sigma = par2[:, N:N + Nf_Pgauss]
norm_x = K.tf.divide(x[:, N:N + Nf_Pgauss] - mu, sigma)
sqrt2 = 1.4142135624
aNorm = 1 + 0.5 * (1 + K.tf.erf(K.tf.divide(-mu, sigma) / sqrt2))
single_NLL = K.log(sigma) + 0.5 * K.square(norm_x) - K.log(aNorm)
nll_loss += K.sum(single_NLL, axis=-1)
N += Nf_Pgauss
# Positive Discrete Gaussian distributed variables
mu = par1[:, N:N + Nf_PDgauss]
sigma = par2[:, N:N + Nf_PDgauss]
norm_xp = K.tf.divide(x[:, N:N + Nf_PDgauss] + 0.5 - mu, sigma)
norm_xm = K.tf.divide(x[:, N:N + Nf_PDgauss] - 0.5 - mu, sigma)
sqrt2 = 1.4142135624
single_LL = 0.5 * (K.tf.erf(norm_xp / sqrt2) - K.tf.erf(norm_xm / sqrt2))
norm_0 = K.tf.divide(-0.5 - mu, sigma)
aNorm = 1 + 0.5 * (1 + K.tf.erf(norm_0 / sqrt2))
single_NLL = -K.log(K.clip(single_LL, 1e-10, 1e40)) - K.log(aNorm)
nll_loss += K.sum(single_NLL, axis=-1)
N += Nf_PDgauss
#Binomial distributed variables
p = 0.5 * (1 + 0.98 * K.tanh(par1[:, N:N + Nf_binomial]))
single_NLL = -K.tf.where(K.equal(x[:, N:N + Nf_binomial], 1), K.log(p),
K.log(1 - p))
nll_loss += K.sum(single_NLL, axis=-1)
N += Nf_binomial
#Poisson distributed variables
aux = par1[:, N:]
mu = 1 + K.tf.where(K.tf.greater(aux, 0), aux,
K.tf.divide(aux, K.sqrt(1 + K.square(aux))))
single_NLL = K.tf.lgamma(x[:, N:] + 1) - x[:, N:] * K.log(mu) + mu
nll_loss += K.sum(single_NLL, axis=-1)
return nll_loss
def is_iterate_neurons_l(idx_p, idx_l):
return k.less(idx_l, shape[1])
def IOU_metric(y_true, y_pred):
"""
Compute the intersection over the union of the true and
the predicted bounding boxes. Output in range 0-1;
1 being the best match of bounding boxes (perfect alignment),
0 being worst (no intersection at all).
@param y_true - BATCH_SIZEx4 Tensor object (float), the ground
truth labels for the bounding boxes around the
tumor in the corresponding images. Value order:
(x_top_left, y_top_left, x_bot_right, y_bot_right)
@param y_pred - BATCH_SIZEx4 Tensor object (float), the model's
prediction for the bounding boxes around the
tumor in the corresponding images. Value order:
(x_top_left, y_top_left, x_bot_right, y_bot_right)
@return iou - 1x1 Tensor object (float), value being the mean
IOU for all image in the batch, and is within the
range of 0-1 (inclusive).
"""
# extract points from tensors
x_LT = tf.math.minimum(y_true[:, 0], y_true[:, 2])
y_UT = tf.math.minimum(y_true[:, 1], y_true[:, 3])
x_RT = tf.math.maximum(y_true[:, 0], y_true[:, 2])
y_LT = tf.math.maximum(y_true[:, 1], y_true[:, 3])
x_LP = tf.math.minimum(y_pred[:, 0], y_pred[:, 2])
y_UP = tf.math.minimum(y_pred[:, 1], y_pred[:, 3])
x_RP = tf.math.maximum(y_pred[:, 0], y_pred[:, 2])
y_LP = tf.math.maximum(y_pred[:, 1], y_pred[:, 3])
# to perform the IOU math correctly, the points that are left-most,
# upper-most, right-most, and lower-most must be found
xL_pairwise_gt = K.greater(x_LT, x_LP)
yU_pairwise_gt = K.greater(y_UT, y_UP)
xW1_pairwise_int = K.less(x_LT, x_RP)
xW1 = K.cast(xW1_pairwise_int, K.floatx())
xW2_pairwise_int = K.less(x_LP, x_RT)
xW2 = K.cast(xW2_pairwise_int, K.floatx())
yH1_pairwise_int = K.less(y_UT, y_LP)
yH1 = K.cast(yH1_pairwise_int, K.floatx())
yH2_pairwise_int = K.less(y_UP, y_LT)
yH2 = K.cast(yH2_pairwise_int, K.floatx())
x_bin = K.cast(xL_pairwise_gt, K.floatx())
y_bin = K.cast(yU_pairwise_gt, K.floatx())
# find the amount by which the bboxes intersect
x_does_intersect = tf.math.add(
tf.math.multiply(x_bin, xW1),
tf.math.multiply(tf.math.subtract(1.0, x_bin), xW2))
y_does_intersect = tf.math.add(
tf.math.multiply(y_bin, yH1),
tf.math.multiply(tf.math.subtract(1.0, y_bin), yH2))
box_does_intersect = tf.math.multiply(x_does_intersect, y_does_intersect)
a = tf.math.minimum(tf.math.subtract(x_RP, x_LT),
tf.math.subtract(x_RP, x_LP))
b = tf.math.minimum(tf.math.subtract(x_RT, x_LP),
tf.math.subtract(x_RT, x_LT))
c = tf.math.minimum(tf.math.subtract(y_LP, y_UT),
tf.math.subtract(y_LP, y_UP))
d = tf.math.minimum(tf.math.subtract(y_LT, y_UP),
tf.math.subtract(y_LT, y_UT))
# calculate intersection area
intersection_width = tf.math.add(
tf.math.multiply(x_bin, a),
tf.math.multiply(tf.math.subtract(1.0, x_bin), b))
intersection_height = tf.math.add(
tf.math.multiply(y_bin, c),
tf.math.multiply(tf.math.subtract(1.0, y_bin), d))
intersection = tf.math.multiply(
tf.math.multiply(intersection_width, intersection_height),
box_does_intersect)
# calculate union area
union_double = tf.math.add(
tf.math.multiply(tf.math.subtract(x_RP, x_LP),
tf.math.subtract(y_LP, y_UP)),
tf.math.multiply(tf.math.subtract(x_RT, x_LT),
tf.math.subtract(y_LT, y_UT)))
union = tf.math.subtract(union_double, intersection)
# take the mean in order to compress BATCH_SIZEx1 Tensor
# into a 1x1 Tensor
iou = K.mean(tf.math.divide(intersection, union))
return iou
