TensorFlow複数のバッチにわたる平均勾配

Question

これはTensorflow: How to get gradients per instance in a batch?の可能な複製です。私はとにかくそれに満足している答えがなかったので、私はそれを尋ねます、そして、ここの目標は少し異なります。

私は私が私のGPUに収まることができる非常に大きなネットワークを持っていますが、私は養うことができ、最大バッチサイズはそれよりも大きい32何がGPUがメモリを使い果たしてしまうことになります。グラデーションのより正確な近似を得るために、より大きなバッチを使用したいと思います。

具体的には、サイズが96の大きなバッチの勾配を、3つのバッチを順番に並べて勾配を計算したいとします。私が知っている最良の方法はOptimizer.compute_gradients()とOptimizer.apply_gradients()です。ここでは、それは

import tensorflow as tf 
import numpy as np 

learn_rate = 0.1 

W_init = np.array([ [1,2,3], [4,5,6], [7,8,9] ], dtype=np.float32) 
x_init = np.array([ [11,12,13], [14,15,16], [17,18,19] ], dtype=np.float32) 

X = tf.placeholder(dtype=np.float32, name="x") 
W = tf.Variable(W_init, dtype=np.float32, name="w") 
y = tf.matmul(X, W, name="y") 
loss = tf.reduce_mean(y, name="loss") 

opt = tf.train.GradientDescentOptimizer(learn_rate) 
grad_vars_op = opt.compute_gradients(loss) 

sess = tf.Session() 
sess.run(tf.global_variables_initializer()) 

# Compute the gradients for each batch 
grads_vars1 = sess.run(grad_vars_op, feed_dict = {X: x_init[None,0]}) 
grads_vars2 = sess.run(grad_vars_op, feed_dict = {X: x_init[None,1]}) 
grads_vars3 = sess.run(grad_vars_op, feed_dict = {X: x_init[None,2]}) 

# Separate the gradients from the variables 
grads1 = [ grad for grad, var in grads_vars1 ] 
grads2 = [ grad for grad, var in grads_vars2 ] 
grads3 = [ grad for grad, var in grads_vars3 ] 
varl = [ var for grad, var in grads_vars1 ] 

# Average the gradients 
grads = [ (g1 + g2 + g3)/3 for g1, g2, g3 in zip(grads1, grads2, grads3)] 

sess.run(opt.apply_gradients(zip(grads,varl))) 

print("Weights after 1 gradient") 
print(sess.run(W)) 

を作業することができますどのように小さな例では、往路がGPU上で実行されているので、勾配を平均化し、それらをGPU上で起こる適用CPU上で発生している間今、これはすべての非常に醜いと非効率的です再び。

gradsがnp.array秒のリストであり、それを動作させるために、1つが、すべてのグラデーションのtf.placeholderを作成する必要があるためまた、このコードは例外をスローします。

これを行うにはより効率的な方法が必要でしょうか？助言がありますか？

Answer 1

trainable_variablesのコピーを作成し、バッチグラデーションを蓄積することができます。ここには簡単な手順がいくつかあります。

... 
opt = tf.train.GradientDescentOptimizer(learn_rate) 
# get all trainable variables 
t_vars = tf.trainable_variables() 
# create a copy of all trainable variables with `0` as initial values 
accum_tvars = [tf.Variable(tf.zeros_like(tv.initialized_value()),trainable=False) for t_var in t_vars]           
# create a op to initialize all accums vars 
zero_ops = [tv.assign(tf.zeros_like(tv)) for tv in accum_tvars] 

# compute gradients for a batch 
batch_grads_vars = opt.compute_gradients(loss, t_vars) 
# collect the batch gradient into accumulated vars 
accum_ops = [accum_tvars[i].assign_add(batch_grad_var[0]) for i, batch_grad_var in enumerate(batch_grads_vars)] 

# apply accums gradients 
train_step = opt.apply_gradients([(accum_tvars[i], batch_grad_var[1]) for i, batch_grad_var in enumerate(batch_grads_vars)]) 
# train_step = opt.apply_gradients(zip(accum_tvars, zip(*batch_grads_vars)[1]) 

while True: 
    # initialize the accumulated gards 
    sess.run(zero_ops) 

    # number of batches for gradient accumulation 
    n_batches = 3 
    for i in xrange(n_batches): 
     sess.run(accum_ops, feed_dict={X: x_init[:, i]}) 

    sess.run(train_step)