ग्रेडिएंट टेप का उपयोग करते समय आप उपयोग करने के बाद ग्रेडिएंट की गणना कर सकते हैं:

with tf.GradientTape() as tape:
        out = model(x, training=True)
        out = tf.reshape(out, (num_img, 1, 10)) # Resizing 
        loss = tf.keras.losses.categorical_crossentropy(y, out) 
        gradient = tape.gradient(loss, model.trainable_variables)

हालाँकि, यह cifar10 इनपुट के मामले में, इनपुट इमेज के ग्रेडिएंट्स को लौटाता है। क्या मध्यवर्ती चरण के ग्रेडियेंट तक पहुंचने का कोई तरीका है, जैसे कि वे "कुछ" प्रशिक्षण के माध्यम से रहे हैं?

0
user13906837 9 फरवरी 2021, 16:58
यदि आप मॉडल से मध्यवर्ती चर का उपयोग कर सकते हैं, उदा। पूरे मॉडल की बजाय केवल पहली परत को कॉल करके, आप वहां ग्रेडियेंट की गणना कर सकते हैं। GradientTape सामान्य तौर पर, अधिकांश Tensorflow गणनाओं पर लागू किया जा सकता है, आपको बस चरों तक पहुँचने की आवश्यकता है।
 – 
PythonF
9 फरवरी 2021, 17:34
1
बस मॉडल को प्रशिक्षित करें और इन पंक्तियों को चलाएं?
 – 
Nicolas Gervais
9 फरवरी 2021, 17:37
मैं उचित आउटपुट लेबल के बिना नुकसान की गणना कैसे कर सकता हूं? बस मान लें कि आउटपुट मूल कोड के समान ही लेबल होना चाहिए? यदि हां, तो उनका आकार समान नहीं होगा, है ना?
 – 
user13906837
9 फरवरी 2021, 17:59

1 उत्तर

सबसे बढ़िया उत्तर

संपादित करें: आपकी टिप्पणी के लिए धन्यवाद मुझे आपकी समस्या की बेहतर समझ है। निम्नलिखित कोड आदर्श से बहुत दूर है और बैच प्रशिक्षण आदि को ध्यान में नहीं रखता है, लेकिन यह आपको एक अच्छा प्रारंभिक बिंदु दे सकता है। मैंने एक कस्टम प्रशिक्षण चरण लिखा है जो मूल रूप से model.fit विधि को प्रतिस्थापित करता है। ऐसा करने के लिए बेहतर तरीके हो सकते हैं, लेकिन इससे आपको ग्रेडिएंट की त्वरित तुलना मिलनी चाहिए।

def custom_training(model, data):
    x, y = data
    # Training 
    with tf.GradientTape() as tape:
        y_pred = model(x, training=True)  # Forward pass
        # Compute the loss value
        # (the loss function is configured in `compile()`)
        loss = tf.keras.losses.mse(y, y_pred)
        
    trainable_vars = model.trainable_variables
    gradients = tape.gradient(loss, trainable_vars)
    tf.keras.optimizers.Adam().apply_gradients(zip(gradients, trainable_vars))
    # computing the gradient without optimizing it!
    with tf.GradientTape() as tape:
        y_pred = model(x, training=False)  # Forward pass
        # Compute the loss value
        # (the loss function is configured in `compile()`)
        loss = tf.keras.losses.mse(y, y_pred)
    trainable_vars = model.trainable_variables
    gradients_plus = tape.gradient(loss, trainable_vars)
    
    return gradients, gradients_plus

आइए हम एक बहुत ही सरल मॉडल मान लें:

import tensorflow as tf

train_data = tf.random.normal((1000, 32))
train_features = tf.random.normal((1000,))

inputs = tf.keras.layers.Input(shape=(32))
hidden_1 = tf.keras.layers.Dense(32)(inputs)
hidden_2 = tf.keras.layers.Dense(32)(hidden_1)
outputs = tf.keras.layers.Dense(1)(hidden_2)

model = tf.keras.Model(inputs, outputs)

और आप इनपुट के संबंध में सभी परतों के ग्रेडियेंट की गणना करना चाहते हैं। आप निम्न का उपयोग कर सकते हैं:

with tf.GradientTape(persistent=True) as tape:
    tape.watch(inputs)
    out_intermediate = []
    inputs = train_data
    cargo = model.layers[0](inputs)
    for layer in model.layers[1:]:
        cargo = layer(cargo)
        out_intermediate.append(cargo)
        
for x in out_intermediate:
    print(tape.gradient(x, inputs))

अगर आप एक कस्टम नुकसान की गणना करना चाहते हैं, तो मैं मॉडल.फिट में जो होता है उसे अनुकूलित करने का सुझाव देता हूं

0
PythonF 10 फरवरी 2021, 12:03
ऐसा प्रतीत होता है कि मोड के साथ कार्गो का उपयोग करना। ट्रेन करने योग्य पैरामीटर कोई भी मान नहीं देता है, जहां मूल कोड नहीं है। कोई नहीं लौटाते समय एक अलग अनुकूलक का उपयोग करते समय ग्रेडियेंट की तुलना करना संभव नहीं है। क्या ऑप्टिमाइज़र के एक चरण के माध्यम से चलने के बाद ग्रेडिएंट को हल करने का कोई और तरीका है?
 – 
user13906837
9 फरवरी 2021, 21:43
आपको tape.watch(model.trainable_variables) या टेप के समान कुछ जोड़ना पड़ सकता है। मूल रूप से आपको यह सुनिश्चित करना होगा, कि सब कुछ जिस पर आप ग्रेडिएंट की गणना करना चाहते हैं, वह ग्रैडिएंटटेप के अंदर चल रहा है, लेकिन मुझे पूरी तरह से यकीन नहीं है, अगर मैं आपकी समस्या को ठीक से समझता हूं।
 – 
PythonF
10 फरवरी 2021, 00:12
मैं विभिन्न अनुकूलकों के बीच, कम से कम एक अद्यतन के बाद, ग्रेडियेंट की तुलना करना चाहता हूं। मूल रूप से मैं एक्सटी + 1 ग्रेडियेंट चाहता हूं, जहां मेरा कोड एक्सटी ग्रेडियेंट लौटाता है।
 – 
user13906837
10 फरवरी 2021, 00:20
अतिरिक्त सूचना के लिए आपका धन्यवाद। मैं जो सोच रहा हूं उसकी पुष्टि करने के लिए, पहला फ़ंक्शन कॉल Xt ग्रेडिएंट लौटाता है और दूसरा Xt+1 ग्रेडिएंट है? मुझे विश्वास है इसलिए मैं दूसरी कॉल के ऊपर की टिप्पणी से भ्रमित था।
 – 
user13906837
10 फरवरी 2021, 16:30
साथ ही, क्या मॉडल दूसरे ग्रेडिएंट टेप कॉल से पहले खड़े "मूल" पर वापस नहीं आएगा?
 – 
user13906837
10 फरवरी 2021, 18:41