def sqr_vonMises23D_angle(y_reco, y_true, re=False):
#energy
loss_energy = reduce_mean(
tf.math.squared_difference(y_reco[:, 0], y_true[:, 0])) #mae again
polar_k = abs(y_reco[:, 3]) + eps
zenth_k = abs(y_reco[:, 4]) + eps
cos_azi = cos(subtract(y_true[:, 2], y_reco[:, 2]))
cos_zenth = cos(subtract(y_true[:, 1], y_reco[:, 1]))
lnI0_azi = polar_k + tf.math.log(
1 + tf.math.exp(-2 * polar_k)
) - 0.25 * tf.math.log(1 + 0.25 * tf.square(polar_k)) + tf.math.log(
1 + 0.24273 * tf.square(polar_k)) - tf.math.log(1 + 0.43023 *
tf.square(polar_k))
lnI0_zenth = zenth_k + tf.math.log(
1 + tf.math.exp(-2 * zenth_k)
) - 0.25 * tf.math.log(1 + 0.25 * tf.square(zenth_k)) + tf.math.log(
1 + 0.24273 * tf.square(zenth_k)) - tf.math.log(1 + 0.43023 *
tf.square(zenth_k))
llh_azi = polar_k * cos_azi - lnI0_azi
llh_zenith = zenth_k * cos_zenth - lnI0_zenth
loss_azi = reduce_mean(-llh_azi)
loss_zenith = reduce_mean(-llh_zenith)
kappa = tf.math.abs(y_reco[:, 5]) + eps
cos_alpha = cos_angle(y_reco, y_true)
# tf.debugging.assert_less_equal(tf.math.abs(cos_alpha), 1, message='cos_alpha problem', summarize=None, name=None)
tf.debugging.assert_all_finite(tf.math.abs(cos_alpha),
message='cos_alpha problem infinite/nan',
name=None)
nlogC = -tf.math.log(kappa) + kappa + tf.math.log(1 -
tf.math.exp(-2 * kappa))
tf.debugging.assert_all_finite(nlogC, 'log kappa problem', name=None)
loss_angle = tf.reduce_mean(-kappa * cos_alpha + nlogC)
if not re:
return loss_azi + loss_zenith + loss_energy + loss_angle
if re:
return float(loss_azi + loss_zenith + loss_energy + loss_angle), [
float(loss_energy),
float(loss_zenith),
float(loss_azi),
float(loss_angle)
]
def trainModel(self, infos):
with self.graph.as_default():
states = tf.constant([i["state"].tolist() for i in infos],
shape=[infos.size, 24])
rewards = tf.constant([i["reward"] for i in infos],
dtype=tf.float32,
shape=[infos.size, 1])
# next_states = tf.constant([i["next_state"].tolist() for i in infos], shape=[infos.size, 24])
actions = tf.constant([i["action"] for i in infos],
dtype=tf.float32,
shape=[infos.size, 12])
# Qtargets = tf.constant(self.model.predict(next_states, steps=1), shape=[infos.size, 12])
# Recupere l'etat actuel
targets = tf.constant(self.model.predict(states, steps=1),
shape=[infos.size, 12])
# Calcure le mask negatif
mask = tf.ones([infos.size, 12], dtype=tf.float32)
mask = tfm.subtract(mask, actions)
# Applique le mask négatif
targets = tfm.multiply(targets, mask)
# Calcure le mask positif
mask = tfm.multiply(rewards, actions)
# Applique le mask positif
targets = tfm.add(targets, mask)
self.model.fit(states, targets, steps_per_epoch=200) # 1000
def loss(y_pred, y_true):
#y_true = print_tensor(y_true, message='y_true = ')
#y_pred = print_tensor(y_pred, message='y_pred = ')
absPred = y_pred[:, :1]
absTrue = y_true[:, :1]
#absPred = print_tensor(absPred, message='absPred = ')
#absTrue = print_tensor(absTrue, message='absTrue = ')
#prvPred = y_pred[1:]
prvTrue = y_true[:, 1:]
#prvTrue = print_tensor(prvTrue, message='prvTrue = ')
anglePred = tanh(subtract(absPred, prvTrue))
angleTrue = tanh(subtract(absTrue, prvTrue))
grd = gradientMass * (mse(anglePred, angleTrue))
abs = absoluteMass * (mse(absPred, absTrue))
#return mse(anglePred,angleTrue)
return grd + abs
def abs_negcos_angle(y_reco, y_true, re=False):
# Energy loss
loss_energy = reduce_mean(abs(subtract(y_reco[:,0], y_true[:,0]))) #this works well but could maybe be improved
# Angle loss
loss_angle = reduce_mean(1-cos_angle(y_reco, y_true))
if not re:
return loss_energy+loss_angle
else:
return float(loss_energy+loss_angle), [float(loss_energy), float(loss_angle)]
def abs_vM2D_KDE_weak(y_reco, y_true, kdet, re=False):
#energy
loss_energy = reduce_mean(abs(subtract(y_reco[:, 0],
y_true[:, 0]))) #mae again
polar_k = abs(y_reco[:, 3]) + eps
zenth_k = abs(y_reco[:, 4]) + eps
cos_azi = cos(subtract(y_true[:, 2], y_reco[:, 2]))
cos_zenth = cos(subtract(y_true[:, 1], y_reco[:, 1]))
lnI0_azi = polar_k + tf.math.log(
1 + tf.math.exp(-2 * polar_k)
) - 0.25 * tf.math.log(1 + 0.25 * tf.square(polar_k)) + tf.math.log(
1 + 0.24273 * tf.square(polar_k)) - tf.math.log(1 + 0.43023 *
tf.square(polar_k))
lnI0_zenth = zenth_k + tf.math.log(
1 + tf.math.exp(-2 * zenth_k)
) - 0.25 * tf.math.log(1 + 0.25 * tf.square(zenth_k)) + tf.math.log(
1 + 0.24273 * tf.square(zenth_k)) - tf.math.log(1 + 0.43023 *
tf.square(zenth_k))
llh_azi = polar_k * cos_azi - lnI0_azi
llh_zenith = zenth_k * cos_zenth - lnI0_zenth
loss_azi = reduce_mean(-llh_azi)
loss_zenith = reduce_mean(-llh_zenith)
kder = kde(tf.cast(y_reco[:, 1], tf.float32))
kdeloss = tf.reduce_mean(
tf.math.abs(kdet.log_prob(xkde) - kder.log_prob(xkde))) / 10
if not re:
return loss_azi + loss_zenith + loss_energy + tf.cast(
kdeloss, tf.float32)
if re:
return float(loss_azi + loss_zenith + loss_energy + kdeloss), [
float(loss_energy),
float(loss_zenith),
float(loss_azi),
float(kdeloss)
]
def compute_covariance(x):
""" Compute the covariance cov(x) = E[x*x^T] - E[x]E[x]^T. Based on Locatello et al. implementation
(https://github.com/google-research/disentanglement_lib)
:param x: a matrix of size N*M
:return: the covariance of x, a matrix of size M*M
"""
e_x = tfm.reduce_mean(x, axis=0)
e_x_e_xt = tf.expand_dims(e_x, 1) * tf.expand_dims(e_x, 0)
e_xxt = tfm.reduce_mean(tf.expand_dims(x, 2) * tf.expand_dims(x, 1), axis=0)
return tfm.subtract(e_xxt, e_x_e_xt)
def call(self, inputs):
mean = reduce_mean(inputs, axis=0)
std = reduce_std(inputs, axis=0) + 1e-6
InputBatchNormalization.temp += 1
InputBatchNormalization.mean += mean
InputBatchNormalization.std += std
inputs = divide(subtract(inputs, mean), std)
return inputs.squeeze(0)
def sqr_vonMises2D_angle(y_reco, y_true, re=False):
#energy
loss_energy = reduce_mean(
tf.math.squared_difference(y_reco[:, 0], y_true[:, 0])) #mae again
polar_k = abs(y_reco[:, 3]) + eps
zenth_k = abs(y_reco[:, 4]) + eps
cos_azi = cos(subtract(y_true[:, 2], y_reco[:, 2]))
cos_zenth = cos(subtract(y_true[:, 1], y_reco[:, 1]))
lnI0_azi = polar_k + tf.math.log(
1 + tf.math.exp(-2 * polar_k)
) - 0.25 * tf.math.log(1 + 0.25 * tf.square(polar_k)) + tf.math.log(
1 + 0.24273 * tf.square(polar_k)) - tf.math.log(1 + 0.43023 *
tf.square(polar_k))
lnI0_zenth = zenth_k + tf.math.log(
1 + tf.math.exp(-2 * zenth_k)
) - 0.25 * tf.math.log(1 + 0.25 * tf.square(zenth_k)) + tf.math.log(
1 + 0.24273 * tf.square(zenth_k)) - tf.math.log(1 + 0.43023 *
tf.square(zenth_k))
llh_azi = polar_k * cos_azi - lnI0_azi
llh_zenith = zenth_k * cos_zenth - lnI0_zenth
loss_azi = reduce_mean(-llh_azi)
loss_zenith = reduce_mean(-llh_zenith)
if not re:
return loss_azi + loss_zenith + loss_energy
if re:
return float(loss_azi + loss_zenith + loss_energy), [
float(loss_energy),
float(loss_zenith),
float(loss_azi)
]
def abs_linear_unit(y_reco, y_true, re=False):
''
from tensorflow.math import sin, cos, acos, abs, reduce_mean, subtract
#energy loss
loss_energy = reduce_mean(abs(subtract(y_reco[:,0], y_true[:,0])))
#angle loss
cos_alpha = cos_unit(y_reco,y_true)
loss_angle = reduce_mean(tf.math.acos(cos_alpha))
if not re:
return loss_energy+loss_angle
else:
return float(loss_energy+loss_angle), [float(loss_energy), float(loss_angle)]
def loss_funcxpos2(y_reco, y_true, re=False):
from tensorflow.math import sin, cos, acos, abs, reduce_mean, subtract, square
# Energy loss
loss_energy = reduce_mean(abs(subtract(y_reco[:,0], y_true[:,0]))) #this works well but could maybe be improved
zeni = [cos(y_true[:,1]) - y_reco[:,1] ,
sin(y_true[:,1]) - y_reco[:,2]]
azi = [cos(y_true[:,2]) - y_reco[:,3] ,
sin(y_true[:,2]) - y_reco[:,4]]
loss_angle = reduce_mean(square(azi[0]))+reduce_mean(square(azi[1]))+reduce_mean(square(zeni[0]))+reduce_mean(square(zeni[1]))
if not re:
return loss_energy+loss_angle
else:
return float(loss_energy+loss_angle), [float(loss_energy), float(loss_angle)]
def psnr(y_label, y_pred):
"""
PSNR is Peek Signal to Noise Ratio, which is similar to mean squared error.
It can be calculated as
PSNR = 20 * log10(MAXp) - 10 * log10(MSE)
When providing an unscaled input, MAXp = 255. Therefore 20 * log10(255)== 48.1308036087.
However, since we are scaling our input, MAXp = 1. Therefore 20 * log10(1) = 0.
Thus we remove that component completely and only compute the remaining MSE component.
"""
_result = subtract(y_label, y_pred)
_result = square(_result)
_result = tf_mean(_result)
_result = multiply(-10., log(_result, 10.))
return _result
def update_state(self, y_true, y_pred, sample_weight=None):
y_true = tf.cast(y_true, tf.float32)
y_pred = tf.cast(y_pred, tf.float32)
error = 100 * math.abs(math.subtract(y_true, y_pred)) / y_true
return super(MAPE, self).update_state(error,
sample_weight=sample_weight)
def f2():
val1 = tfm.divide(
tfm.multiply(tfm.subtract(k, k_1), tfm.subtract(k, k_1)), 2)
val2 = tfm.multiply(tfm.subtract(k, k_1), tfm.subtract(x, k))
val = tfm.add(val1, val2)
return val
def f1():
return tfm.add(
tfm.subtract(tfm.divide(tfm.multiply(x, x), 2),
tfm.multiply(k_1, x)),
tfm.divide(tfm.multiply(k_1, k_1), 2))
def DSSIM(y_true, y_pred):
return tfmath.divide(
tfmath.subtract(1.0, tfimage.ssim(y_true, y_pred, max_val=1.0)), 2.0)
def tf_ssim(x, y, is_normalized=False):
"""
k1 = 0.01
k2 = 0.03
L = 1.0 if is_normalized else 255.0
c1 = np.power(k1 * L, 2)
c2 = np.power(k2 * L, 2)
c3 = c2 / 2
"""
k1 = 0.01
k2 = 0.03
L = 1.0 if is_normalized else 255.0
c1 = tf_pow(multiply(k1, L), 2.0)
c2 = tf_pow(multiply(k2, L), 2.0)
c3 = divide(c2, 2.0)
# if type(x) is np.ndarray:
# x = tf.convert_to_tensor(x, dtype=tf.float32)
# if type(y) is np.ndarray:
# y = tf.convert_to_tensor(y, dtype=tf.float32)
"""
ux = x.mean()
uy = y.mean()
"""
ux = tf_mean(x)
uy = tf_mean(y)
"""
std_x = x.std()
std_y = y.std()
"""
std_x = tf_std(x)
std_y = tf_std(y)
"""
xy = (x - ux) * (y - uy)
std_xy = xy.mean()
"""
xy = multiply(subtract(x, ux), subtract(y, uy))
std_xy = tf_mean(xy)
"""
l_xy = (2 * ux * uy + c1) / (np.power(ux, 2) + np.power(uy, 2) + c1)
"""
l_son = add(multiOperation(multiply, 2.0, ux, uy), c1)
l_mom = multiOperation(add, tf_pow(ux, 2.0), tf_pow(uy, 2.0), c1)
l_xy = divide(l_son, l_mom)
"""
c_xy = (2 * std_x * std_y + c2) / (np.power(std_x, 2) + np.power(std_y, 2) + c2)
"""
c_son = add(multiOperation(multiply, 2.0, std_x, std_y), c2)
c_mom = multiOperation(add, tf_pow(std_x, 2.0), tf_pow(std_y, 2.0), c2)
c_xy = divide(c_son, c_mom)
"""
s_xy = (std_xy + c3) / (std_x * std_y + c3)
"""
s_son = add(std_xy, c3)
s_mom = add(multiply(std_x, std_y), c3)
s_xy = divide(s_son, s_mom)
one = tf.constant(1.0)
_ssim = multiOperation(multiply, l_xy, c_xy, s_xy)
_result = tf.cond(greater(_ssim, one), lambda: one, lambda: _ssim)
return _result