tensorflow
TensorFlow Graph Collection का उपयोग कैसे करें?

टिप्पणियों

tf.GraphKeys.VARIABLES
tf.GraphKeys.TRAINABLE_VARIABLES
tf.GraphKeys.SUMMARIES

अपना स्वयं का संग्रह बनाएं और अपने सभी नुकसानों को इकट्ठा करने के लिए इसका उपयोग करें।

यहां हम न्यूरल नेटवर्क के कम्प्यूटेशनल ग्राफ के नुकसान के लिए संग्रह बनाएंगे।

पहले एक कम्प्यूटेशनल ग्राफ बनाएं जैसे:

with tf.variable_scope("Layer"):
    W = tf.get_variable("weights", [m, k],
        initializer=tf.zeros_initializer([m, k], dtype=tf.float32))
    b1 = tf.get_variable("bias", [k],
        initializer = tf.zeros_initializer([k], dtype=tf.float32))
    z = tf.sigmoid((tf.matmul(input, W) + b1))
    
    with tf.variable_scope("Softmax"):
        U = tf.get_variable("weights", [k, r],
            initializer=tf.zeros_initializer([k,r], dtype=tf.float32))
        b2 = tf.get_variable("bias", [r],
            initializer=tf.zeros_initializer([r], dtype=tf.float32))
    out = tf.matmul(z, U) + b2
cross_entropy = tf.reduce_mean(
    tf.nn.sparse_softmax_cross_entropy_with_logits(out, labels))

एक नया संग्रह बनाने के लिए, आप बस tf.add_to_collection() कॉल करना शुरू कर सकते हैं - पहला कॉल संग्रह बनाएगा।

tf.add_to_collection("my_losses", 
    self.config.l2 * (tf.add_n([tf.reduce_sum(U ** 2), tf.reduce_sum(W ** 2)])))
tf.add_to_collection("my_losses", cross_entropy)

और अंत में आप अपने संग्रह से दसियों प्राप्त कर सकते हैं:

loss = sum(tf.get_collection("my_losses"))

ध्यान दें कि यदि संग्रह मौजूद नहीं है तो tf.get_collection() संग्रह की एक प्रति या एक खाली सूची लौटाता है। इसके अलावा, अगर यह मौजूद नहीं है तो यह संग्रह नहीं बनाता है। ऐसा करने के लिए, आप tf.get_collection_ref() उपयोग कर सकते हैं जो संग्रह का एक संदर्भ देता है और वास्तव में एक खाली बनाता है यदि यह अभी तक मौजूद नहीं है।

नेस्टेड scopes से चर ले लीजिए

नीचे एकल छिपी हुई परत बहुपरत पर्सेप्ट्रॉन (MLP) है जिसका उपयोग चर के नेस्टेड स्कूपिंग के लिए किया जाता है।

def weight_variable(shape):
    return tf.get_variable(name="weights", shape=shape,
                           initializer=tf.zeros_initializer(dtype=tf.float32))

def bias_variable(shape):
    return tf.get_variable(name="biases", shape=shape,
                           initializer=tf.zeros_initializer(dtype=tf.float32))

def fc_layer(input, in_dim, out_dim, layer_name):
    with tf.variable_scope(layer_name):
        W = weight_variable([in_dim, out_dim])
        b = bias_variable([out_dim])
        linear = tf.matmul(input, W) + b
        output = tf.sigmoid(linear)

with tf.variable_scope("MLP"):
    x = tf.placeholder(dtype=tf.float32, shape=[None, 1], name="x")
    y = tf.placeholder(dtype=tf.float32, shape=[None, 1], name="y")
    fc1 = fc_layer(x, 1, 8, "fc1")
    fc2 = fc_layer(fc1, 8, 1, "fc2")

mse_loss = tf.reduce_mean(tf.reduce_sum(tf.square(fc2 - y), axis=1))

MLP शीर्ष स्तर गुंजाइश नाम का उपयोग करता MLP और यह अपने-अपने दायरे नाम के साथ दो परतों है fc1 और fc2 । प्रत्येक परत का अपना weights और biases चर भी होता है।

चर को इस तरह एकत्रित किया जा सकता है:

trainable_var_key = tf.GraphKeys.TRAINABLE_VARIABLES
all_vars = tf.get_collection(key=trainable_var_key, scope="MLP")
fc1_vars = tf.get_collection(key=trainable_var_key, scope="MLP/fc1")
fc2_vars = tf.get_collection(key=trainable_var_key, scope="MLP/fc2")
fc1_weight_vars = tf.get_collection(key=trainable_var_key, scope="MLP/fc1/weights")
fc1_bias_vars = tf.get_collection(key=trainable_var_key, scope="MLP/fc1/biases")

चर के मानों को sess.run() कमांड का उपयोग करके एकत्र किया जा सकता है। उदाहरण के लिए अगर हम प्रशिक्षण के बाद fc1_weight_vars के मूल्यों को इकट्ठा करना चाहते हैं, तो हम निम्नलिखित कर सकते हैं:

sess = tf.Session()
# add code to initialize variables
# add code to train the network
# add code to create test data x_test and y_test

fc1_weight_vals = sess.run(fc1, feed_dict={x: x_test, y: y_test})
print(fc1_weight_vals)  # This should be an ndarray with ndim=2 and shape=[1, 8]