(embeddings, num_classes, cosine_classifier,
                      cosine_logits_multiplier, use_weight_norm, weight_decay)
return logits
Forward pass through a linear classifier, or possibly a cosine classifier.

  Args:
    embeddings: A Tensor of size [batch size, embedding dim].
    num_classes: An integer; the dimension of the classification.
    cosine_classifier: A bool. If true, a cosine classifier is used, which does
      not require a bias.
    cosine_logits_multiplier: A float. Only used if cosine_classifier is True,
      and multiplies the resulting logits.
    use_weight_norm: A bool. Whether weight norm was used. If so, then if using
      cosine classifier, normalize only the embeddings but not the weights.
    weight_decay: A float; the scalar multiple on the L2 regularization of the
      weight matrix.

  Returns:
    logits: A Tensor of size [batch size, num outputs].
Forward pass through a linear classifier, or possibly a cosine classifier.
Forward pass through a linear classifier or possibly a cosine classifier .
def linear_classifier(embeddings, num_classes, cosine_classifier,
                      cosine_logits_multiplier, use_weight_norm, weight_decay):
  """Forward pass through a linear classifier, or possibly a cosine classifier.

  Args:
    embeddings: A Tensor of size [batch size, embedding dim].
    num_classes: An integer; the dimension of the classification.
    cosine_classifier: A bool. If true, a cosine classifier is used, which does
      not require a bias.
    cosine_logits_multiplier: A float. Only used if cosine_classifier is True,
      and multiplies the resulting logits.
    use_weight_norm: A bool. Whether weight norm was used. If so, then if using
      cosine classifier, normalize only the embeddings but not the weights.
    weight_decay: A float; the scalar multiple on the L2 regularization of the
      weight matrix.

  Returns:
    logits: A Tensor of size [batch size, num outputs].
  """

  embedding_dims = embeddings.get_shape().as_list()[-1]

  if use_weight_norm:
    # A variable to keep track of whether the initialization has already
    # happened.
    data_dependent_init_done = tf.get_variable(
        'data_dependent_init_done',
        initializer=0,
        dtype=tf.int32,
        trainable=False)

    w_fc = tf.get_variable(
        'w_fc', [embedding_dims, num_classes],
        initializer=tf.random_normal_initializer(0, 0.05),
        trainable=True)
    # This init is temporary as it needs to be done in a data-dependent way.
    # It will be overwritten during the first forward pass through this layer.
    g = tf.get_variable(
        'g',
        dtype=tf.float32,
        initializer=tf.ones([num_classes]),
        trainable=True)
    b_fc = None
    if not cosine_classifier:
      # Also initialize a bias.
      b_fc = tf.get_variable(
          'b_fc', initializer=tf.zeros([num_classes]), trainable=True)

    def _do_data_dependent_init():
      """Returns ops for the data-dependent init of g and maybe b_fc."""
      w_fc_normalized = tf.nn.l2_normalize(w_fc.read_value(), [0])
      output_init = tf.matmul(embeddings, w_fc_normalized)
      mean_init, var_init = tf.nn.moments(output_init, [0])
      # Data-dependent init values.
      g_init_value = 1. / tf.sqrt(var_init + 1e-10)
      ops = [tf.assign(g, g_init_value)]
      if not cosine_classifier:
        # Also initialize a bias in a data-dependent way.
        b_fc_init_value = -mean_init * g_init_value
        ops.append(tf.assign(b_fc, b_fc_init_value))
      # Mark that the data-dependent initialization is done to prevent it from
      # happening again in the future.
      ops.append(tf.assign(data_dependent_init_done, 1))
      return tf.group(*ops)

    # Possibly perform data-dependent init (if it hasn't been done already).
    init_op = tf.cond(
        tf.equal(data_dependent_init_done, 0), _do_data_dependent_init,
        tf.no_op)

    with tf.control_dependencies([init_op]):
      # Apply weight normalization.
      w_fc *= g / tf.sqrt(tf.reduce_sum(tf.square(w_fc), [0]))
      # Forward pass through the layer defined by w_fc and b_fc.
      logits = linear_classifier_forward_pass(embeddings, w_fc, b_fc,
                                              cosine_classifier,
                                              cosine_logits_multiplier, True)

  else:
    # No weight norm.
    w_fc = functional_backbones.weight_variable([embedding_dims, num_classes],
                                                weight_decay=weight_decay)
    b_fc = None
    if not cosine_classifier:
      # Also initialize a bias.
      b_fc = functional_backbones.bias_variable([num_classes])
    # Forward pass through the layer defined by w_fc and b_fc.
    logits = linear_classifier_forward_pass(embeddings, w_fc, b_fc,
                                            cosine_classifier,
                                            cosine_logits_multiplier, False)
  return logits
def linear_classifier ( embeddings , num_classes , cosine_classifier , cosine_logits_multiplier , use_weight_norm , weight_decay ) : embedding_dims = embeddings . get_shape ( ) . as_list ( ) [ - 1 ] if use_weight_norm : # A variable to keep track of whether the initialization has already # happened. data_dependent_init_done = tf . get_variable ( 'data_dependent_init_done' , initializer = 0 , dtype = tf . int32 , trainable = False ) w_fc = tf . get_variable ( 'w_fc' , [ embedding_dims , num_classes ] , initializer = tf . random_normal_initializer ( 0 , 0.05 ) , trainable = True ) # This init is temporary as it needs to be done in a data-dependent way. # It will be overwritten during the first forward pass through this layer. g = tf . get_variable ( 'g' , dtype = tf . float32 , initializer = tf . ones ( [ num_classes ] ) , trainable = True ) b_fc = None if not cosine_classifier : # Also initialize a bias. b_fc = tf . get_variable ( 'b_fc' , initializer = tf . zeros ( [ num_classes ] ) , trainable = True ) def _do_data_dependent_init ( ) : """Returns ops for the data-dependent init of g and maybe b_fc.""" w_fc_normalized = tf . nn . l2_normalize ( w_fc . read_value ( ) , [ 0 ] ) output_init = tf . matmul ( embeddings , w_fc_normalized ) mean_init , var_init = tf . nn . moments ( output_init , [ 0 ] ) # Data-dependent init values. g_init_value = 1. / tf . sqrt ( var_init + 1e-10 ) ops = [ tf . assign ( g , g_init_value ) ] if not cosine_classifier : # Also initialize a bias in a data-dependent way. b_fc_init_value = - mean_init * g_init_value ops . append ( tf . assign ( b_fc , b_fc_init_value ) ) # Mark that the data-dependent initialization is done to prevent it from # happening again in the future. ops . append ( tf . assign ( data_dependent_init_done , 1 ) ) return tf . group ( * ops ) # Possibly perform data-dependent init (if it hasn't been done already). init_op = tf . cond ( tf . equal ( data_dependent_init_done , 0 ) , _do_data_dependent_init , tf . no_op ) with tf . control_dependencies ( [ init_op ] ) : # Apply weight normalization. w_fc *= g / tf . sqrt ( tf . reduce_sum ( tf . square ( w_fc ) , [ 0 ] ) ) # Forward pass through the layer defined by w_fc and b_fc. logits = linear_classifier_forward_pass ( embeddings , w_fc , b_fc , cosine_classifier , cosine_logits_multiplier , True ) else : # No weight norm. w_fc = functional_backbones . weight_variable ( [ embedding_dims , num_classes ] , weight_decay = weight_decay ) b_fc = None if not cosine_classifier : # Also initialize a bias. b_fc = functional_backbones . bias_variable ( [ num_classes ] ) # Forward pass through the layer defined by w_fc and b_fc. logits = linear_classifier_forward_pass ( embeddings , w_fc , b_fc , cosine_classifier , cosine_logits_multiplier , False ) return logits