Tensorflow: Cách thay thế hoặc sửa đổi độ dốc?

Question

Tôi muốn thay thế hoặc sửa đổi độ dốc của một op hoặc một phần của biểu đồ trong chuỗi lưu lượng. Nó sẽ là lý tưởng nếu tôi có thể sử dụng gradient hiện có trong tính toán.

Trong một số cách, điều này ngược lại với những gì tf.stop_gradient() thực hiện: thay vì thêm phép tính bị bỏ qua khi tính toán độ dốc, tôi muốn tính toán chỉ được sử dụng khi tính toán độ dốc.

Một ví dụ đơn giản sẽ là một cái gì đó mà chỉ đơn giản là quy mô gradients bằng cách nhân chúng với một hằng số (nhưng không nhân tính toán chuyển tiếp bởi một hằng số). Một ví dụ khác sẽ là một cái gì đó mà clip gradient đến một phạm vi nhất định.

Answer 1

Đầu tiên xác định độ dốc tùy chỉnh của bạn:

@tf.RegisterGradient("CustomGrad") 
def _const_mul_grad(unused_op, grad): 
    return 5.0 * grad 

Vì bạn muốn gì xảy ra trong đường chuyền về phía trước, ghi đè gradient của một hoạt động bản sắc với độ dốc mới của bạn:

g = tf.get_default_graph() 
with g.gradient_override_map({"Identity": "CustomGrad"}): 
    output = tf.identity(input, name="Identity") 

Dưới đây là một ví dụ làm việc với một lớp mà clip gradient trong ngược vượt qua và không có gì trong những tiền đạo vượt qua, bằng cách sử dụng phương pháp tương tự:

import tensorflow as tf 

@tf.RegisterGradient("CustomClipGrad") 
def _clip_grad(unused_op, grad): 
    return tf.clip_by_value(grad, -0.1, 0.1) 

input = tf.Variable([3.0], dtype=tf.float32) 

g = tf.get_default_graph() 
with g.gradient_override_map({"Identity": "CustomClipGrad"}): 
    output_clip = tf.identity(input, name="Identity") 
grad_clip = tf.gradients(output_clip, input) 

# output without gradient clipping in the backwards pass for comparison: 
output = tf.identity(input) 
grad = tf.gradients(output, input) 

with tf.Session() as sess: 
    sess.run(tf.global_variables_initializer()) 
    print("with clipping:", sess.run(grad_clip)[0]) 
    print("without clipping:", sess.run(grad)[0]) 

Answer 2

sử dụng optimizer.compute_gradients hoặc tf.gradient để có được gradient gốc
sau đó làm bất cứ điều gì bạn muốn
cuối cùng, sử dụng optimizer.apply_gradients

Tôi tìm thấy một example từ github

Answer 3

Cách chung nhất để làm điều đó là bằng cách sử dụng https://www.tensorflow.org/api_docs/python/tf/RegisterGradient

Dưới đây, tôi đã triển khai thực hiện trích xuất dốc ngược, có thể sử dụng với matmul, như thể hiện ở đây, hoặc bất kỳ op khác:

import tensorflow as tf 
import numpy as np 

# from https://gist.github.com/harpone/3453185b41d8d985356cbe5e57d67342 
def py_func(func, inp, Tout, stateful=True, name=None, grad=None): 

    # Need to generate a unique name to avoid duplicates: 
    rnd_name = 'PyFuncGrad' + str(np.random.randint(0, 1E+8)) 

    tf.RegisterGradient(rnd_name)(grad) 
    g = tf.get_default_graph() 
    with g.gradient_override_map({"PyFunc": rnd_name}): 
     return tf.py_func(func, inp, Tout, stateful=stateful, name=name) 

def clip_grad(x, clip_value, name=None): 
    """" 
    scales backpropagated gradient so that 
    its L2 norm is no more than `clip_value` 
    """ 
    with tf.name_scope(name, "ClipGrad", [x]) as name: 
     return py_func(lambda x : x, 
         [x], 
         [tf.float32], 
         name=name, 
         grad=lambda op, g : tf.clip_by_norm(g, clip_value))[0] 

---

Ví dụ sử dụng:

with tf.Session() as sess: 
    x = tf.constant([[1., 2.], [3., 4.]]) 
    y = tf.constant([[1., 2.], [3., 4.]]) 

    print('without clipping') 
    z = tf.matmul(x, y) 
    print(tf.gradients(tf.reduce_sum(z), x)[0].eval()) 

    print('with clipping') 
    z = tf.matmul(clip_grad(x, 1.0), clip_grad(y, 0.5)) 
    print(tf.gradients(tf.reduce_sum(z), x)[0].eval()) 

    print('with clipping between matmuls') 
    z = tf.matmul(clip_grad(tf.matmul(x, y), 1.0), y) 
    print(tf.gradients(tf.reduce_sum(z), x)[0].eval()) 

---

Output:

without clipping 
[[ 3. 7.] 
[ 3. 7.]] 
with clipping 
[[ 0.278543 0.6499337] 
[ 0.278543 0.6499337]] 
with clipping between matmuls 
[[ 1.57841039 3.43536377] 
[ 1.57841039 3.43536377]] 

Answer 4

Giả sử các tính toán về phía trước được

y = f(x) 

Và bạn muốn nó backpropagate như

y = b(x) 

Một hack đơn giản sẽ là:

y = b(x) + tf.stop_gradient(f(x) - b(x))