एक निर्गम wrt नेटवर्क वजन की ढाल है कि एक और उत्पादन लगातार

Question

रखती

की मैं एक साधारण MLP

है मान लेते हैं और मैं उत्पादन परत के संबंध में जी पाने के लिए के साथ कुछ नुकसान समारोह की एक ढाल है = [0, -1] (यानी, दूसरे आउटपुट चर को बढ़ाने से हानि फ़ंक्शन कम हो जाता है)।

यदि मैं अपने नेटवर्क पैरामीटर के संबंध में जी का ढाल लेता हूं और एक ग्रेडियेंट सभ्य वजन अद्यतन लागू करता हूं तो दूसरा आउटपुट वैरिएबल बढ़ाना चाहिए, लेकिन पहले आउटपुट वैरिएबल के बारे में कुछ भी नहीं कहा जाता है, और ढाल के स्केल किए गए एप्लिकेशन लगभग निश्चित रूप से आउटपुट वैरिएबल को बदलें (चाहे इसे बढ़ाना या घटाना)

यह सुनिश्चित करने के लिए कि मेरा आउटपुट क्यों नहीं बदलता है, मैं अपने हानि फ़ंक्शन या किसी भी ढाल गणना को कैसे संशोधित कर सकता हूं?

Answer 1

अद्यतन: मैंने प्रश्न को गलत समझा। यह नया जवाब है।

इस उद्देश्य के लिए, आपको छिपी हुई परत और दूसरी आउटपुट इकाई के बीच कनेक्शन अपडेट करने की आवश्यकता है, जबकि छिपी हुई परत और पहली आउटपुट इकाई को बरकरार रखें। छिपी परत और पहली उत्पादन इकाई, आराम के लिए एक के बीच कनेक्शन के लिए एक:

पहले दृष्टिकोण चर के दो सेट शुरू करने की है। फिर आप उन्हें tf.stack का उपयोग करके संयोजित कर सकते हैं, और इसी डेरिवेटिव प्राप्त करने के लिए var_list पास कर सकते हैं। यह की तरह है (। बस चित्रण के लिए परीक्षण नहीं देखभाल के साथ उपयोग करें।):

out1 = tf.matmul(hidden, W_h_to_out1) + b_h_to_out1 
out2 = tf.matmul(hidden, W_h_to_out2) + b_h_to_out2 
out = tf.stack([out1, out2]) 
out = tf.transpose(tf.reshape(out, [2, -1])) 
loss = some_function_of(out) 
optimizer = tf.train.GradientDescentOptimizer(0.1) 
train_op_second_unit = optimizer.minimize(loss, var_list=[W_h_to_out2, b_h_to_out2]) 

एक और दृष्टिकोण एक मुखौटा का प्रयोग है। जब आप कुछ ढांचे (कहते हैं, पतला, केरा, इत्यादि) के साथ काम करते हैं तो इसे कार्यान्वित करना और अधिक लचीला करना आसान है, और मैं इस तरह से अनुशंसा करूंगा। दूसरी आउटपुट इकाई को न बदलें, जबकि हानि फ़ंक्शन में पहली आउटपुट इकाई को छिपाने का विचार। यह एक बाइनरी चर का उपयोग करके किया जा सकता है: यदि आप इसे रखना चाहते हैं तो 1 से कुछ गुणा करें, और इसे छोड़कर 0 से गुणा करें। कोड यह रहा:

import tensorflow as tf 
import numpy as np 

# let's make our tiny dataset: (x, y) pairs, where x = (x1, x2, x3), y = (y1, y2), 
# and y1 = x1+x2+x3, y2 = x1^2+x2^2+x3^2 

# n_sample data points 
n_sample = 8 
data_x = np.random.random((n_sample, 3)) 
data_y = np.zeros((n_sample, 2)) 
data_y[:, 0] += np.sum(data_x, axis=1) 
data_y[:, 1] += np.sum(data_x**2, axis=1) 
data_y += 0.01 * np.random.random((n_sample, 2)) # add some noise 


# build graph 
# suppose we have a network of shape [3, 4, 2], i.e.: one hidden layer of size 4. 

x = tf.placeholder(tf.float32, shape=[None, 3], name='x') 
y = tf.placeholder(tf.float32, shape=[None, 2], name='y') 
mask = tf.placeholder(tf.float32, shape=[None, 2], name='mask') 

W1 = tf.Variable(tf.random_normal(shape=[3, 4], stddev=0.1), name='W1') 
b1 = tf.Variable(tf.random_normal(shape=[4], stddev=0.1), name='b1') 
hidden = tf.nn.sigmoid(tf.matmul(x, W1) + b1) 
W2 = tf.Variable(tf.random_normal(shape=[4, 2], stddev=0.1), name='W2') 
b2 = tf.Variable(tf.random_normal(shape=[2], stddev=0.1), name='b2') 
out = tf.matmul(hidden, W2) + b2 
loss = tf.reduce_mean(tf.square(out - y)) 

# multiply out by mask, thus out[0] is "invisible" to loss, and its gradient will not be propagated 
masked_out = mask * out 
loss2 = tf.reduce_mean(tf.square(masked_out - y)) 

optimizer = tf.train.GradientDescentOptimizer(0.1) 
train_op_all = optimizer.minimize(loss) # update all variables in the network 
train_op12 = optimizer.minimize(loss, var_list=[W2, b2]) # update hidden -> output layer 
train_op2 = optimizer.minimize(loss2, var_list=[W2, b2]) # update hidden -> second output unit 


sess = tf.InteractiveSession() 
sess.run(tf.global_variables_initializer()) 
mask_out1 = np.zeros((n_sample, 2)) 
mask_out1[:, 1] += 1.0 
# print(mask_out1) 
print(sess.run([hidden, out, loss, loss2], feed_dict={x: data_x, y: data_y, mask: mask_out1})) 

# In this case, only out2 is updated. You see the loss and loss2 decreases. 
sess.run(train_op2, feed_dict={x: data_x, y:data_y, mask: mask_out1}) 
print(sess.run([hidden, out, loss, loss2], feed_dict={x: data_x, y:data_y, mask: mask_out1})) 

# In this case, both out1 and out2 is updated. You see the loss and loss2 decreases. 
sess.run(train_op12, feed_dict={x: data_x, y:data_y, mask: mask_out1}) 
print(sess.run([hidden, out, loss, loss2], feed_dict={x: data_x, y:data_y, mask: mask_out1})) 

# In this case, everything is updated. You see the loss and loss2 decreases. 
sess.run(train_op_all, feed_dict={x: data_x, y:data_y, mask: mask_out1}) 
print(sess.run([hidden, out, loss, loss2], feed_dict={x: data_x, y:data_y, mask: mask_out1})) 
sess.close() 

======================= नीचे पुराने जवाब है ========== ====================

डेरिवेटिव wrt प्राप्त करने के लिए विभिन्न चर, आप यह निर्धारित करने के लिए कि कौन से चर अद्यतन करने के लिए var_list पास कर सकते हैं। यहाँ एक उदाहरण है:

import tensorflow as tf 
import numpy as np 

# let's make our tiny dataset: (x, y) pairs, where x = (x1, x2, x3), y = (y1, y2), 
# and y1 = x1+x2+x3, y2 = x1^2+x2^2+x3^2 

# n_sample data points 
n_sample = 8 
data_x = np.random.random((n_sample, 3)) 
data_y = np.zeros((n_sample, 2)) 
data_y[:, 0] += np.sum(data_x, axis=1) 
data_y[:, 1] += np.sum(data_x**2, axis=1) 
data_y += 0.01 * np.random.random((n_sample, 2)) # add some noise 


# build graph 
# suppose we have a network of shape [3, 4, 2], i.e.: one hidden layer of size 4. 

x = tf.placeholder(tf.float32, shape=[None, 3], name='x') 
y = tf.placeholder(tf.float32, shape=[None, 2], name='y') 

W1 = tf.Variable(tf.random_normal(shape=[3, 4], stddev=0.1), name='W1') 
b1 = tf.Variable(tf.random_normal(shape=[4], stddev=0.1), name='b1') 
hidden = tf.nn.sigmoid(tf.matmul(x, W1) + b1) 
W2 = tf.Variable(tf.random_normal(shape=[4, 2], stddev=0.1), name='W2') 
b2 = tf.Variable(tf.random_normal(shape=[2], stddev=0.1), name='b2') 
out = tf.matmul(hidden, W2) + b2 

loss = tf.reduce_mean(tf.square(out - y)) 
optimizer = tf.train.GradientDescentOptimizer(0.1) 
# You can pass a variable list to decide which variable(s) to minimize. 
train_op_second_layer = optimizer.minimize(loss, var_list=[W2, b2]) 
# If there is no var_list, all variables will be updated. 
train_op_all = optimizer.minimize(loss) 

sess = tf.InteractiveSession() 
sess.run(tf.global_variables_initializer()) 
print(sess.run([W1, b1, W2, b2, loss], feed_dict={x: data_x, y:data_y})) 

# In this case, only W2 and b2 are updated. You see the loss decreases. 
sess.run(train_op_second_layer, feed_dict={x: data_x, y:data_y}) 
print(sess.run([W1, b1, W2, b2, loss], feed_dict={x: data_x, y:data_y})) 

# In this case, all variables are updated. You see the loss decreases. 
sess.run(train_op_all, feed_dict={x: data_x, y:data_y}) 
print(sess.run([W1, b1, W2, b2, loss], feed_dict={x: data_x, y:data_y})) 
sess.close()