En TensorFlow, qué es tf.¿identidad usada para?

tf.identity es útil cuando desea transportar explícitamente tensor entre dispositivos (como, de GPU a una CPU). El op agrega nodos send / recv al gráfico, que hacen una copia cuando los dispositivos de la entrada y la salida son diferentes.

Un comportamiento predeterminado es que los nodos send/recv se agregan implícitamente cuando la operación ocurre en un dispositivo diferente, pero puede imaginar algunas situaciones (especialmente en una configuración multi-threaded/distributed) en las que podría ser útil obtener el valor de la variable varias veces dentro de una sola ejecución del session.run. tf.identity permite un mayor control con respecto a cuándo se debe leer el valor desde el dispositivo de origen. Posiblemente un nombre más apropiado para este op sería read.

También, tenga en cuenta que en la implementación de tf.Variable link , la op de identidad se añade en el constructor, que se asegura de que todos los accesos a la variable copien los datos de la fuente solo una vez. Múltiples copias pueden ser costosas en los casos cuando la variable vive en una GPU pero es leída por múltiples operaciones de CPU (o al revés). Los usuarios pueden cambiar el comportamiento con múltiples llamadas a tf.identity cuando lo deseen.

EDITAR: Respuesta actualizada después de que la pregunta fue editada.

Además, tf.identity se puede usar como un nodo ficticio para actualizar una referencia al tensor. Esto es útil con varias operaciones de flujo de control. En el caso CIFAR queremos exigir que el ExponentialMovingAverageOp actualice las variables relevantes antes de recuperar el valor de la pérdida. Esto se puede implementar como:

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

Aquí, el tf.identity no hace nada útil aparte de marcar el tensor total_loss a ejecutar después de evaluar loss_averages_op.

Además de lo anterior, simplemente lo uso cuando necesito asignar un nombre a ops que no tienen un argumento de nombre, al igual que cuando inicializo un estado en RNN:

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")

Me encontré con otro caso de uso que no está completamente cubierto por las otras respuestas.

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 mayor parte del tiempo al construir una capa convolucional, solo desea que se devuelvan las activaciones para que pueda alimentarlas en la siguiente capa. Sin embargo, a veces, por ejemplo, al construir un codificador automático, desea los valores de preactivación.

En esta situación una solución elegante es pasar tf.identity como la función de activación, no activando efectivamente la capa.

Encontré otra aplicación de tf.identidad en Tensorboard. Si usa tf.shuffle_batch, devuelve varios tensores a la vez, por lo que puede ver una imagen desordenada al visualizar el gráfico, no puede dividir la canalización de creación de tensores desde tensores de entrada actiual: messy

Pero con tf.identidad puede crear nodos duplicados, que no afectan el flujo de cómputo: nice

Cuando nuestros datos de entrada se serializan en bytes, y queremos extraer entidades de este conjunto de datos. Podemos hacerlo en formato clave-valor y luego obtener un marcador de posición para ello. Sus beneficios se realizan más cuando hay múltiples características y cada característica tiene que leerse en un formato diferente.

  #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')

En el entrenamiento de distribución, debemos usar tf.identidad o los trabajadores colgarán a la espera de la inicialización del trabajador jefe:

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)

Para detalles, sin identidad, el trabajador jefe trataría algunas variables como variables locales de manera inapropiada y los otros trabajadores esperarían una operación de inicialización que no pueda terminar