code: def arcface_loss(
      embedding,
      labels,
      out_num,
      weights=None,
      s=64.0,
      m=0.5,
      limit_to_pi=True,
  ):
      """
      https://github.com/auroua/InsightFace_TF/blob/master/losses/face_losses.py
      :param embedding: the input embedding vectors
      :param labels:  the input labels, the shape should be eg: (batch_size, 1)
      :param s: scalar value default is 64
      :param out_num: output class num
      :param weights: a tf.variable with shape (embedding.shape[-1], out_num)
                      or None to make a new one internally. default = None
      :param m: the margin value, default is 0.5
      :return: the final cacualted output, this output is send into the tf.nn.softmax directly
      """
      cos_m = math.cos(m)
      sin_m = math.sin(m)
      mm = sin_m * m  # issue 1
      threshold = math.cos(math.pi - m)
      with tf.variable_scope("arcface_loss"):
          # inputs and weights norm
          embedding_norm = tf.norm(embedding, axis=1, keep_dims=True)
          embedding = tf.div(
              embedding, embedding_norm, name="norm_embedding"
          )
          if weights is None:
              weights = tf.get_variable(
                  name="weights",
                  shape=[embedding.shape[-1].value, out_num],
                  initializer=tf.initializer.glorot_unifrom(),
              )
          weights_norm = tf.norm(weights, axis=0, keep_dims=True)
          weights = tf.div(weights, weights_norm, name="norm_weights")
          # cos(theta+m)
          cos_t = tf.matmul(embedding, weights, name="cos_t")
          cos_t2 = tf.square(cos_t, name="cos_2")
          sin_t2 = tf.subtract(1.0, cos_t2, name="sin_2")
          sin_t = tf.sqrt(sin_t2, name="sin_t")
          cos_mt = s * tf.subtract(
              tf.multiply(cos_t, cos_m),
              tf.multiply(sin_t, sin_m),
              name="cos_mt",
          )
  
          if limit_to_pi:
              # this condition controls the theta+m should in range [0, pi]
              #      0<=theta+m<=pi
              #     -m<=theta<=pi-m
              cond_v = cos_t - threshold
              cond = tf.cast(
                  tf.nn.relu(cond_v, name="if_else"), dtype=tf.bool
              )
  
              keep_val = s * (cos_t - mm)
              cos_mt_temp = tf.where(cond, cos_mt, keep_val)
          else:
              cos_mt_temp = cos_mt
  
          mask = tf.one_hot(labels, depth=out_num, name="one_hot_mask")
          # mask = tf.squeeze(mask, 1)
          inv_mask = tf.subtract(1.0, mask, name="inverse_mask")
  
          s_cos_t = tf.multiply(s, cos_t, name="scalar_cos_t")
  
          output = tf.add(
              tf.multiply(s_cos_t, inv_mask),
              tf.multiply(cos_mt_temp, mask),
              name="arcface_loss_output",
          )
      return output
  
file_path: delta/delta/utils/loss/loss_utils.py
imports: import math
  import delta.compat
  import tensorflow_addons
  from delta import utils
  from delta.utils import ctc_utils
label_desc: Use image node_id 6 for calling a global function with example usage: arcface_loss(embedding, labels, out_num, weights, s, m, limit_to_pi) and returns: output