def SAD(y_true, y_pred):
y_true2 = K.l2_normalize(y_true + K.epsilon(), axis=-1)
y_pred2 = K.l2_normalize(y_pred + K.epsilon(), axis=-1)
# sad = T.acos(K.mean(y_true2 * y_pred2, axis=-1))
sad = T.acos((y_true2 * y_pred2))
# sad = -K.mean(y_true2 * y_pred2, axis=-1)
return sad
def SCD(y_true, y_pred):
s_t = y_true - K.mean(y_true, axis=1, keepdims=True)
s_p = y_pred - K.mean(y_true, axis=1, keepdims=True)
return 1 - K.mean(
K.l2_normalize(s_t + K.epsilon(), axis=-1) *
K.l2_normalize(s_p + K.epsilon(), axis=-1))
def normSAD2(y_true, y_pred):
y_true2 = K.l2_normalize(y_true + K.epsilon(), axis=-1)
y_pred2 = K.l2_normalize(y_pred + K.epsilon(), axis=-1)
mse = K.mean(K.square(y_true - y_pred), axis=-1)
# sad = -K.log(1.0-K.mean(y_true2 * y_pred2/np.pi, axis=-1))
sad = K.mean(y_true2 * y_pred2, axis=-1)
# sid = SID(y_true,y_pred)
return 0.005 * mse - 0.75 * sad
def SID(y_true, y_pred):
y_true = K.switch(
K.min(y_true) < 0, y_true - K.min(y_true) + K.epsilon(),
y_true + K.epsilon())
y_pred = K.switch(
K.min(y_pred) < 0, y_pred - K.min(y_pred) + K.epsilon(),
y_pred + K.epsilon())
p_n = y_true / K.sum(y_true, axis=1, keepdims=True)
q_n = y_pred / K.sum(y_pred, axis=1, keepdims=True)
return (K.sum(p_n * K.log(p_n / q_n)) + K.sum(q_n * K.log(q_n / p_n)))
def MSE_KL(y_true, y_pred):
# y_true=y_true[:,-162:]
y_true = K.switch(
K.min(y_true) < 0, y_true - K.min(y_true) + K.epsilon(),
y_true + K.epsilon())
y_pred = K.switch(
K.min(y_pred) < 0, y_pred - K.min(y_pred) + K.epsilon(),
y_pred + K.epsilon())
p_n = y_true / K.max(y_true, axis=1, keepdims=True)
q_n = y_pred / K.max(y_pred, axis=1, keepdims=True)
return K.mean(K.square(y_true - y_pred),
axis=-1) + 0.5 * (K.sum(p_n * K.log(p_n / q_n)) + K.sum(
(1.001 - p_n) * K.log((1.01 - p_n) / (1.001 - q_n))))
def _get_coords_for_joint(joint_idx, parent_idx, child_angle_idx,
coords):
if parent_idx is None: # joint_idx should be 0
coords[joint_idx] = K.zeros(base_shape[:-2] + [3, 1])
parent_bone = K.constant(
np.concatenate([
np.ones(base_shape),
np.zeros(base_shape),
np.zeros(base_shape)
],
axis=-2))
else:
parent_bone = coords[parent_idx] - coords[joint_idx]
parent_bone_norm = K.sqrt(
K.sum(K.square(parent_bone), axis=-2, keepdims=True) +
K.epsilon())
parent_bone = parent_bone / parent_bone_norm
for child_idx in body_graph[joint_idx]:
child_bone = tf.matmul(rotmat_list[child_angle_idx],
parent_bone)
child_bone_idx = bone_idcs[(joint_idx, child_idx)]
child_bone = child_bone * K.reshape(
bone_len_list[child_bone_idx],
(child_bone.shape[0], 1, 1, 1))
coords[child_idx] = child_bone + coords[joint_idx]
child_angle_idx += 1
for child_idx in body_graph[joint_idx]:
child_angle_idx, coords = _get_coords_for_joint(
child_idx, joint_idx, child_angle_idx, coords)
return child_angle_idx, coords
def l_half(self, x, lambda1, tv, n):
patch_size = n * n
z = tf.abs(x + K.epsilon())
l1 = tf.reduce_sum(tf.norm(z, 0.5, axis=-1), axis=None)
# l1=self.l_one_min_two(x,lambda1,x)
regularization = lambda1 * l1
return 1 / patch_size * regularization
def l_one_min_two(self, x, lambda1, n):
patch_size = n * n
x = tf.abs(x + K.epsilon())
l1 = tf.reduce_sum(
tf.abs(tf.norm(x, 1, axis=-1) - tf.norm(x, 2, axis=-1)), axis=None)
regularization = lambda1 * l1
return 1 / patch_size * regularization
def _get_bone_len(arg):
bone_list = tf.unstack(arg[:, :, 0, :], axis=1)
bones = [
bone_list[j] - bone_list[i]
for i, j in zip(members_from, members_to)
]
bones = K.stack(bones, axis=1)
return K.sqrt(K.sum(K.square(bones), axis=-1) + K.epsilon())
def _get_avg_bone_len(arg):
bone_list = tf.unstack(arg[:, :, 0, :], axis=1)
bones = [
bone_list[j] - bone_list[i]
for i, j in zip(members_from, members_to)
]
bones = K.expand_dims(K.stack(bones, axis=1), axis=2)
bone_len = K.sqrt(
K.sum(K.square(bones), axis=-1, keepdims=True) + K.epsilon())
return K.mean(bone_len, axis=1, keepdims=True)
def soft_ASC(self, x, lambda1, lambda2, n):
patch_size = n * n
z = x
z = tf.abs(z + K.epsilon())
l1 = tf.reduce_sum(tf.norm(z, 0.5, axis=-1), axis=None)
x = tf.reduce_sum(x, axis=-1)
ones = tf.ones_like(x)
# flattened = tf.layers.flatten(x-ones)
regularization = tf.norm(x - ones, 2)
return 1 / patch_size * lambda1 * regularization + 1 / patch_size * l1 * lambda2
def call(self, x, mask=None):
# return K.softmax(3*x)
x *= K.cast(x >= 0., K.floatx())
# x = K.abs(x)
# x = x - K.min(K.flatten(x))
x = K.transpose(x)
x_normalized = x / (K.sum(x, axis=0) + K.epsilon())
x = K.transpose(x_normalized)
# x *= K.cast(x/K.max(x) >= 0.3, K.floatx())
# x = 4.0*x/(K.max(K.flatten(x))+K.epsilon())
# x=K.softmax(x)
return x
def normMSE(y_true, y_pred):
y_true2 = K.l2_normalize(y_true + K.epsilon(), axis=-1)
y_pred2 = K.l2_normalize(y_pred + K.epsilon(), axis=-1)
mse = K.mean(K.square(y_true - y_pred))
return mse
def edm(x, y=None):
with K.name_scope('edm'):
y = x if y is None else y
x = K.expand_dims(x, axis=1)
y = K.expand_dims(y, axis=2)
return K.sqrt(K.sum(K.square(x - y), axis=-1) + K.epsilon())
def __call__(self, p):
p = K.switch(K.min(p) < 0, p - K.min(p) + K.epsilon(), p + K.epsilon())
return p
def __call__(self, p):
p *= K.cast(p >= 0., K.floatx())
return p / (K.epsilon() +
K.sqrt(K.sum(K.square(p), axis=self.axis, keepdims=True)))
def normalized_mse_percentage_error(y_true, y_pred):
y_true = y_true / y_true.max()
y_pred = y_pred / y_pred.max()
diff = K.abs((y_true - y_pred) / K.clip(K.abs(y_true), K.epsilon(), None))
return 100. * K.mean(diff, axis=-1)
