En TensorFlow, ce qui est tf.identité utilisée pour?

tf.identity est utile quand vous voulez explicitement transporter tenseur entre les appareils (comme, de GPU à un CPU). L'op ajoute send/recv les nœuds du graphe, qui rendent une copie lorsque les périphériques d'entrée et de sortie sont différents.

un comportement par défaut est que les noeuds send/recv sont ajoutés implicitement lorsque l'opération se produit sur un périphérique différent mais vous pouvez imaginer certaines situations (en particulier dans un paramétrage multi-threadé/distribué) où il pourrait être utile de récupérer la valeur de la variable plusieurs fois dans une seule exécution de l' session.run. tf.identity permet plus de contrôle en ce qui concerne le moment où la valeur doit être lue à partir du périphérique source. Éventuellement un nom plus approprié pour cette op serait read.

veuillez également noter que dans la mise en œuvre de tf.Variablelien, l'option identity est ajoutée dans le constructeur, ce qui permet de s'assurer que tous les accès à la variable copient les données de la source une seule fois. Plusieurs copies peuvent être coûteuses dans les cas où la variable vit sur un GPU, mais elle est lue par plusieurs CPU ops (ou l'inverse). Les utilisateurs peuvent modifier le comportement avec plusieurs appels à tf.identity lorsque vous le souhaitez.

modifier: réponse mise à jour après la modification de la question.

en outre,tf.identity peut être utilisé comme noeud fictif pour mettre à jour une référence au tenseur. Ceci est utile pour diverses opérations d'écoulement de contrôle. Dans le cas de la CIFAR, nous voulons faire respecter le ExponentialMovingAverageOp mettra à jour les variables pertinentes avant de récupérer la valeur de la perte. Cela peut être mis en œuvre comme:

with tf.control_dependencies([loss_averages_op]):
  total_loss = tf.identity(total_loss)

Ici tf.identity ne fait rien d'utile à part marquer le total_loss tenseur d'être couru après l'évaluation de loss_averages_op.

en plus de ce qui précède, je l'utilise simplement quand j'ai besoin d'assigner un nom à ops qui n'ont pas d'argument nom, tout comme lors de l'initialisation d'un État dans RN's:

rnn_cell = tf.contrib.rnn.MultiRNNCell([cells])
# no name arg
initial_state = rnn_cell.zero_state(batch_size,tf.float32)
# give it a name with tf.identity()
initial_state = tf.identity(input=initial_state,name="initial_state")

je suis tombé sur un autre cas d'utilisation qui n'est pas couvert par les autres réponses.

def conv_layer(input_tensor, kernel_shape, output_dim, layer_name, decay=None, act=tf.nn.relu):
    """Reusable code for making a simple convolutional layer.
    """
    # Adding a name scope ensures logical grouping of the layers in the graph.
    with tf.name_scope(layer_name):
        # This Variable will hold the state of the weights for the layer
        with tf.name_scope('weights'):
            weights = weight_variable(kernel_shape, decay)
            variable_summaries(weights, layer_name + '/weights')
        with tf.name_scope('biases'):
            biases = bias_variable([output_dim])
            variable_summaries(biases, layer_name + '/biases')
        with tf.name_scope('convolution'):
            preactivate = tf.nn.conv2d(input_tensor, weights, strides=[1, 1, 1, 1], padding='SAME')
            biased = tf.nn.bias_add(preactivate, biases)
            tf.histogram_summary(layer_name + '/pre_activations', biased)
        activations = act(biased, 'activation')
        tf.histogram_summary(layer_name + '/activations', activations)
        return activations

la plupart du temps lors de la construction d'une couche de convolution, vous voulez juste que les activations soient retournées pour que vous puissiez les insérer dans la couche suivante. Parfois, cependant - par exemple lors de la construction d'un encodeur automatique-vous voulez les valeurs de pré - activation.

dans cette situation une solution élégante est de passer tf.identity comme la fonction d'activation, n'activant pas effectivement couche.

j'ai trouvé une autre application de tf.identité en Tensorboard. Si vous utilisez tf.shuffle_batch, il renvoie plusieurs tenseurs à la fois, donc vous voyez une image désordonnée lors de la visualisation du Graphe, vous ne pouvez pas diviser le pipeline de création de tenseurs à partir des tenseurs d'entrée actiual: malpropre

mais avec tf.d'identité, vous pouvez créer des copies de nœuds, qui n'affectent pas le calcul du flux: nice

lorsque nos données d'entrée sont sérialisées en octets, et nous voulons extraire des fonctionnalités de cet ensemble de données. Nous pouvons le faire dans le format clé-valeur et ensuite obtenir un placeholder pour elle. Ses avantages sont plus réalisé lorsqu'il y a plusieurs caractéristiques et chaque fonctionnalité doit être lu en format différent.

  #read the entire file in this placeholder      
  serialized_tf_example = tf.placeholder(tf.string, name='tf_example')

  #Create a pattern in which data is to be extracted from input files
  feature_configs = {'image': tf.FixedLenFeature(shape=[256], dtype=tf.float32),/
                     'text': tf.FixedLenFeature(shape=[128], dtype=tf.string),/
                     'label': tf.FixedLenFeature(shape=[128], dtype=tf.string),}

  #parse the example in key: tensor dictionary
  tf_example = tf.parse_example(serialized_tf_example, feature_configs)

  #Create seperate placeholders operation and tensor for each feature
  image = tf.identity(tf_example['image'], name='image')
  text  = tf.identity(tf_example['text'], name='text')
  label = tf.identity(tf_example['text'], name='label')

dans la formation de distribution, nous devrions utiliser tf.l'identité ou les travailleurs vais accrocher à l'attente pour l'initialisation du chef du travailleur:

vec = tf.identity(tf.nn.embedding_lookup(embedding_tbl, id)) * mask
with tf.variable_scope("BiRNN", reuse=None):
    out, _ = tf.nn.bidirectional_dynamic_rnn(fw, bw, vec, sequence_length=id_sz, dtype=tf.float32)

pour plus de détails, sans identité, le chef traiterait certaines variables comme des variables locales de façon inappropriée et les autres travailleurs attendent une opération d'initialisation qui ne peut pas se terminer