मेरा मॉडल इस तरह एक साधारण पूरी तरह से जुड़ा नेटवर्क है:

inp=Input(shape=(10,))
d=Dense(64, activation='relu')(inp)
d=Dense(128,activation='relu')(d)
d=Dense(256,activation='relu')(d)     #want to give input here, layer3
d=Dense(512,activation='relu')(d)
d=Dense(1024,activation='relu')(d)
d=Dense(128,activation='linear')(d)

इसलिए, मॉडल को सहेजने के बाद मैं परत 3 को इनपुट देना चाहता हूं। अभी मैं जो कर रहा हूं वह यह है:

model=load_model('blah.h5')    #above described network
print(temp_input.shape)        #(16,256), which is equal to what I want to give

index=3
intermediate_layer_model = Model(inputs=temp_input,
                                 outputs=model.output)

End_output = intermediate_layer_model.predict(temp_input)

लेकिन यह काम नहीं कर रहा है, यानी मुझे असंगत इनपुट जैसी त्रुटियां मिल रही हैं, इनपुट टुपल आदि होना चाहिए। त्रुटि संदेश है:

raise TypeError('`inputs` should be a list or tuple.') 
TypeError: `inputs` should be a list or tuple.

क्या कोई तरीका है जिससे मैं नेटवर्क के बीच में अपना इनपुट पास कर सकता हूं और शुरुआत में इनपुट देने और अंत से आउटपुट प्राप्त करने के बजाय आउटपुट प्राप्त कर सकता हूं? किसी भी तरह की सहायता की हम सराहना करेंगे।

9
Asim 14 अक्टूबर 2018, 09:19

4 जवाब

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

सबसे पहले आपको यह सीखना होगा कि केरस में जब आप किसी इनपुट पर एक परत लागू करते हैं, इस परत के अंदर एक नया नोड बनाया जाता है जो इनपुट और आउटपुट टेंसर को जोड़ता है। प्रत्येक परत में कई नोड हो सकते हैं जो अलग-अलग इनपुट टेंसर को उनके संबंधित आउटपुट टेंसर से जोड़ते हैं। एक मॉडल बनाने के लिए, इन नोड्स का पता लगाया जाता है और मॉडल का एक नया ग्राफ बनाया जाता है जिसमें इनपुट टेंसर से आउटपुट टेंसर तक पहुंचने के लिए आवश्यक सभी नोड्स होते हैं (यानी आप एक मॉडल बनाते समय निर्दिष्ट करते हैं: model = Model(inputs=[...], outputs=[...])

अब आप एक मॉडल की एक मध्यवर्ती परत को फीड करना चाहते हैं और मॉडल का आउटपुट प्राप्त करना चाहते हैं। चूंकि यह एक नया डेटा-प्रवाह पथ है, इसलिए हमें इस नए कम्प्यूटेशनल ग्राफ़ के अनुरूप प्रत्येक परत के लिए नए नोड बनाने की आवश्यकता है। हम इसे इस तरह कर सकते हैं:

idx = 3  # index of desired layer
input_shape = model.layers[idx].get_input_shape_at(0) # get the input shape of desired layer
layer_input = Input(shape=input_shape) # a new input tensor to be able to feed the desired layer

# create the new nodes for each layer in the path
x = layer_input
for layer in model.layers[idx:]:
    x = layer(x)

# create the model
new_model = Model(layer_input, x)

सौभाग्य से, आपके मॉडल में एक-शाखा है और हम नए मॉडल के निर्माण के लिए केवल for लूप का उपयोग कर सकते हैं। हालांकि, अधिक जटिल मॉडलों के लिए ऐसा करना आसान नहीं हो सकता है और नए मॉडल के निर्माण के लिए आपको और कोड लिखने की आवश्यकता हो सकती है।

12
today 15 अक्टूबर 2018, 10:12

समान परिणाम प्राप्त करने के लिए यहां एक और तरीका है। प्रारंभ में एक नई इनपुट परत बनाएं और फिर इसे निचली परतों (वजन के साथ) से कनेक्ट करें।

इस प्रयोजन के लिए, पहले इन परतों (समान नाम के साथ) को पुन: प्रारंभ करें और संबंधित वजन से पुनः लोड करें पैरेंट मॉडल का उपयोग कर रहे हैं

new_model.load_weights("parent_model.hdf5", by_name=True)

यह मूल मॉडल से आवश्यक भार लोड करेगा। बस सुनिश्चित करें कि आपने अपनी परतों को पहले से ठीक से नाम दिया है।

idx = 3  
input_shape = model.layers[idx].get_input_shape_at(0) layer

new_input = Input(shape=input_shape)

d=Dense(256,activation='relu', name='layer_3')(new_input)
d=Dense(512,activation='relu', name='layer_4'))(d)
d=Dense(1024,activation='relu', name='layer_5'))(d)
d=Dense(128,activation='linear', name='layer_6'))(d)

new_model = Model(new_input, d)
new_model.load_weights("parent_model.hdf5", by_name=True)

यह विधि कई इनपुट या शाखाओं वाले जटिल मॉडल के लिए काम करेगी। आपको बस आवश्यक परतों के लिए एक ही कोड को कॉपी करने, नए इनपुट को जोड़ने और अंत में संबंधित वज़न को लोड करने की आवश्यकता है।

5
anilsathyan7 26 सितंबर 2019, 06:05

आप इस उद्देश्य के लिए आसानी से keras.backend.function का उपयोग कर सकते हैं:

import numpy as np
from tensorflow.keras.layers import Input, Dense
from tensorflow.keras.models import Model
from tensorflow.keras import backend as K

inp=Input(shape=(10,))
d=Dense(64, activation='relu')(inp)
d=Dense(128,activation='relu')(d)
d=Dense(256,activation='relu')(d)     #want to give input here, layer3
d=Dense(512,activation='relu')(d)
d=Dense(1024,activation='relu')(d)
d=Dense(128,activation='linear')(d)

model = Model(inp, d)


foo1 = K.function(
    [inp],
    model.layers[2].output
)

foo2 = K.function(
    [model.layers[2].output],
    model.output
)


X = np.random.rand(1, 10)
X_intermediate = foo1([X])
print(np.allclose(foo2([X_intermediate]), model.predict(X)))

बदसूरत फ़ंक्शन नामकरण के लिए खेद है - इसे सर्वोत्तम करें)

-1
Василий Прядченко 12 अगस्त 2020, 06:28

मुझे एक ही समस्या हो रही थी और प्रस्तावित समाधान मेरे लिए काम करते थे लेकिन मैं कुछ और स्पष्ट खोज रहा था, इसलिए यहां यह भविष्य के संदर्भ के लिए है:

d1 = Dense(64, activation='relu')
d2 = Dense(128,activation='relu')
d3 = Dense(256,activation='relu')
d4 = Dense(512,activation='relu')
d5 = Dense(1024,activation='relu')
d6 = Dense(128,activation='linear')

inp = Input(shape=(10,))

x = d1(inp)
x = d2(x)
x = d3(x)
x = d4(x)
x = d5(x)
x = d6(x)

full_model = tf.keras.Model(inp, x)
full_model.summary()

intermediate_input = Input(shape=d3.get_input_shape_at(0)) # get shape at node 0
x = d3(intermediate_input)
x = d4(x)
x = d5(x)
x = d6(x)
partial_model = tf.keras.Model(intermediate_input, x)
partial_model.summary()

संदर्भ: https://keras.io/guides/functional_api/#shared-layers

0
Mo_ 22 अक्टूबर 2020, 09:12