Optimizing a vector using eager execution

Question

I would like to use TensorFlow's eager execution functionality to optimize the components of a vector. In all the documented examples, each trainable variable is just a scalar, with collections represented by lists of these. However, the loss function I have in mind involves performing vector manipulations on those components, and so this is inconvenient.

For example, let us use the Adam optimizer to normalize a 3-component vector:

 import tensorflow as tf
 import tensorflow.contrib.eager as tfe
 import numpy as np
 tf.enable_eager_execution()                                                                         
 def normalize(din=[2.0,1.0,0.0], lr=0.001, 
                nsteps=100):

     d = tfe.Variable(din)
     def loss(dvec):
            return tf.sqrt((1.0 - tf.tensordot(dvec, dvec, 1))**2)                                          
     def grad(dvec):
           with tf.GradientTape() as tape:
                 loss_val = loss(dvec)
           return tape.gradient(loss_val, dvec)

     optimizer = tf.train.AdamOptimizer(learning_rate=lr)
     for i in range(nsteps):
        grads = grad(d)
        optimizer.apply_gradients(zip(grads, d))  #Throws error                                                         
     return d

This code correctly computes the required gradients. However, the "optimizer.apply_gradients" line throws some kind of error, seemingly no matter what I do, essentially because tfe.Variable is not an iterable.

In this specific example the error is "AttributeError: Tensor.name is meaningless when eager execution is enabled". We could also try, for example,

  zip(grads, [d[i] for i in range(3)])

instead of d, but then the interpreter complains that d is not iterable.

What is the correct way to pair grads with d?

Answer 1

Optimizer.apply_gradients requires its first argument to be a list of (gradient, variable) pairs.

In the code above, neither grads nor d is a list (try print(type(grads)) for example), so the error is from the call to zip. I think what you want instead is:

optimizer.apply_gradients(zip([grads], [d]))

Or, more simply:

optimizer.apply_gradients([(grads, d)])

Also, FYI, as eager execution is stabilizing more things are moving out of the experimental "contrib" namespace, so you don't need the tfe module for your example (tf.Variable will work just fine) if you're using a recent version of TensorFlow (1.11, 1.12 etc.). Making your whole program look like:

import tensorflow as tf
import numpy as np
tf.enable_eager_execution()                                                                         
def normalize(din=[2.0,1.0,0.0], lr=0.001, 
              nsteps=100):

    d = tf.Variable(din)
    def loss(dvec):
           return tf.sqrt((1.0 - tf.tensordot(dvec, dvec, 1))**2)                                          
    def grad(dvec):
          with tf.GradientTape() as tape:
                loss_val = loss(dvec)
          return tape.gradient(loss_val, dvec)

    optimizer = tf.train.AdamOptimizer(learning_rate=lr)
    for i in range(nsteps):
       dd = grad(d)
       optimizer.apply_gradients([(dd, d)])                                                       
    return d

Hope that helps!