Keras后端和Tensorflow之间梯度计算的变化

Question

Note: keras.backend() returns tensorflow. Python 3.5 used.

I have encountered a bug in the computation of gradient. I have replicated the bug in a simple Keras model and Tensorflow model shown below.

from keras.layers import Dense, Input
from keras.models import Model
from keras.optimizers import Adam
import keras

import keras.backend as K
import numpy as np
import tensorflow as tf

class KerasModel(object):
    def __init__(self, seed, dim_size, optimizer, loss_func):


        self.sess=tf.Session()

        I = Input(
                shape=[dim_size], 
                name='i'
                 )

        O = Dense(
                1,
                activation='relu',
                kernel_initializer=keras.initializers.glorot_uniform(seed=seed),
                name='o'
                 )(I)


        self.model = Model(inputs=I,outputs=O)
        self.model.compile(loss=loss_func, optimizer=optimizer)


        self.action_grads = tf.gradients(self.model.output, self.model.input)  
        self.grad_func= K.function(self.model.inputs, self.action_grads)

        self.sess.run(tf.global_variables_initializer())

    def tf_grad(self, X):
        return self.sess.run(self.action_grads, feed_dict={self.model.input: X,})[0]


    def keras_grad(self, X):        
        return self.grad_func(X)[0]



class TFModel(object):
    def __init__(self, seed, dim_size, optimizer, loss_func):

        self.graph= tf.Graph()

        with self.graph.as_default():
            glorot_uniform= tf.glorot_uniform_initializer(seed=seed)

            O= {
                    'weights': tf.Variable(glorot_uniform([dim_size, 1])),
                    'bias': tf.Variable( tf.zeros(1) )
                }


            w_list= [ 
                O['weights'], O['bias']
                    ] 

            w_list_placeholder= []
            w_list_update= []
            for i in range(0, len(w_list)):
                w_list_placeholder.append( tf.placeholder(tf.float32) )
                w_list_update.append( w_list[i].assign( w_list_placeholder[i] ) )


            I= tf.placeholder(tf.float32, shape= (None, dim_size))

            output= tf.nn.relu( tf.add( tf.matmul( I, O['weights']), O['bias'] ) )

            gradient= tf.gradients(output, I)

            y= tf.placeholder(tf.float32)

            loss= tf.reduce_mean( loss_func(y, output) )

            train = optimizer.minimize(loss)

            self.tensors= {
                'output': output, 'I': I, 'y': y, 'grad':gradient,
                'loss': loss, 'train-op': train, 'w': w_list,
                'w-placeholder': w_list_placeholder, 'w-update': w_list_update
                          }

            self.sess= tf.Session(graph=self.graph)

            self.sess.run( tf.variables_initializer( self.graph.get_collection('variables') ) )


    def train_on_batch(self, X, y):
        _, l=self.sess.run( 
            [self.tensors['train-op'], self.tensors['loss']],
            feed_dict={ 
                self.tensors['I']: X,
                self.tensors['y']: y
                       }
                           )
        return l

    def predict(self, X):
        return self.sess.run(self.tensors['output'], feed_dict={self.tensors['I']: X})

    def get_weights(self):
        return self.sess.run(self.tensors['w'])

    def set_weights(self, new_weights):
        self.sess.run( 
            self.tensors['w-update'], 
            feed_dict={ x:y for x,y in zip(self.tensors['w-placeholder'], new_weights) } 
                     )

    def grad(self, X):
        return self.sess.run(self.tensors['grad'], feed_dict={self.tensors['I']:X})[0]

The two models are identical in layers, initialization, optimizer, loss function, weights, etc.

I use the two models to compute gradient from the same set of inputs. For the Tensorflow model, this is done with the grad() function:

def grad(self, X):
    return self.sess.run(self.tensors['grad'], feed_dict={self.tensors['I']:X})[0]

For the Keras model, this is done with keras_grad() and tf_grad() .

self.action_grads = tf.gradients(self.model.output, self.model.input)
self.grad_func= K.function(self.model.inputs, self.action_grads)

def tf_grad(self, X):
    return self.sess.run(self.action_grads, feed_dict={self.model.input: X,})[0]


def keras_grad(self, X):        
    return self.grad_func(X)[0]

keras_grad() utilizes keras.backend.function() to do so, while tf_grad() utilizes tf.Session() .

They are then trained with a different set of identical inputs. Again, this is shown below:

seed=1
dim_size=3
learning_rate=0.01
e=1e-8


k_adam= KerasModel(
    seed, dim_size, tf.train.AdamOptimizer(learning_rate=learning_rate,epsilon= e),
    keras.losses.mean_squared_error
                  )

tf_model= TFModel(
    seed, dim_size, tf.train.AdamOptimizer(learning_rate=learning_rate,epsilon= e),
    keras.losses.mean_squared_error
                  )


X=np.array([[0.25175066, 0.53507285, 0.3210762 ]])
#X= np.random.random([1,dim_size])
y= np.random.random([1])

print(k_adam.keras_grad([X]))
print(k_adam.tf_grad(X))
print(tf_model.grad(X))

print()
X= np.array([[0.47194079, 0.85071664, 0.25451934]])
#X= np.random.random([1,dim_size])
y= np.random.random([1])
k_adam.model.train_on_batch(X,y)
tf_model.train_on_batch(X,y)

print(k_adam.keras_grad([X]))
print(k_adam.tf_grad(X))
print(tf_model.grad(X))

print()
X= np.random.random([1,dim_size])
y= np.random.random([1])
k_adam.model.train_on_batch(X,y)
tf_model.train_on_batch(X,y)

print(k_adam.keras_grad([X]))
print(k_adam.tf_grad(X))
print(tf_model.grad(X))

Running the code should give you the following output:

[[-0.63922524  1.0297645  -1.1010152 ]]
[[-0.63922524  1.0297645  -1.1010152 ]]
[[-0.63922524  1.0297645  -1.1010152 ]]

[[-0.62922525  1.0397645  -1.0910152 ]]
[[-0.63922524  1.0297645  -1.1010152 ]]
[[-0.62922525  1.0397645  -1.0910152 ]]

[[ ... ]]
....

And some other results.

For the first block of output, I expected the array of gradients computed to be the same among the two models, since they are the same model. And this is true.

For the second block of output, I have trained the two models with a different set of identical inputs. So the array of gradients should differ from the first block of output, but they should be the same among themselves (the second block of output). This is true to a degree. The array of gradients from the Tensorflow model and keras_grad() is the same between themselves but different from the first block.

However, the output of tf_grad() did not change from the first block of output.

From my own testing, I found that the output from tf_grad() varies between either 0 or the same set of numbers after initialization. This behavior repeats even when training with different batches.

As mentioned already, the only difference in tf_grad() and keras_grad() , which are both from the Keras model, is that one ( tf_grad ) is ran with tf.session() while the other ( keras_grad ) is ran with keras.backend.function() .

Why is it that one is able to update accordingly and the other cannot do so?

Answer 1

You need to set the session to the keras TF backend

K.set_session(self.sess)

Like this:

class KerasModel(object):
def __init__(self, seed, dim_size, optimizer, loss_func):
    self.sess=tf.Session()

    K.set_session(self.sess)