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)