2016-05-05 18 views
6

मुझे पता है कि इस सवाल को विभिन्न रूपों में पूछा गया है, लेकिन मुझे वास्तव में कोई जवाब नहीं मिल रहा है जिसे मैं समझ सकता हूं और उपयोग कर सकता हूं। तो, मुझे माफ कर दो अगर यह एक बुनियादी सवाल यह है कि क्योंकि मैं इन उपकरणों (थेनो/keras) के लिए एक नौसिखिया हूँथेनो/केरास में टेंसर मूल्यों की निगरानी कैसे करें?

समस्या तंत्रिका नेटवर्क में

मॉनिटर चर का समाधान करने के लिए (उदाहरण के लिए इनपुट/भूलना/LSTM में उत्पादन गेट मान)

क्या मैं वर्तमान में हो रही है

कोई फर्क नहीं पड़ता जो मंच मैं उन मूल्यों में हो रही है, मैं की तरह कुछ हो रही है:

Elemwise{mul,no_inplace}.0 
Elemwise{mul,no_inplace}.0 
[for{cpu,scan_fn}.2, Subtensor{int64::}.0, Subtensor{int64::}.0] 
[for{cpu,scan_fn}.2, Subtensor{int64::}.0, Subtensor{int64::}.0] 
Subtensor{int64}.0 
Subtensor{int64}.0 

क्या कोई तरीका है जिस पर मैं निगरानी नहीं कर सकता (उदा। stdout पर प्रिंट करें, एक फाइल को लिखें, आदि) उन्हें?

संभव समाधान

Keras में कॉलबैक काम कर सकते हैं की तरह लगता है, लेकिन यह या तो मेरे लिए काम नहीं करता। मैं

ऊपर मेरा अनुमान है के रूप में एक ही बात हो रही है

लगता है जैसे मैं बहुत ही सरल गलतियों रहा हूँ।

अग्रिम में बहुत पहले धन्यवाद।


जोड़ा विशेष रूप से, मैं इनपुट की निगरानी/LSTM में भूल जाते हैं/आउटपुट gating मूल्यों के लिए कोशिश कर रहा हूँ। मैंने पाया कि LSTM.step() उन मूल्यों की गणना के लिए है:

def step(self, x, states): 
    h_tm1 = states[0] # hidden state of the previous time step 
    c_tm1 = states[1] # cell state from the previous time step 
    B_U = states[2]  # dropout matrices for recurrent units? 
    B_W = states[3]  # dropout matrices for input units? 

    if self.consume_less == 'cpu':        # just cut x into 4 pieces in columns 
     x_i = x[:, :self.output_dim] 
     x_f = x[:, self.output_dim: 2 * self.output_dim] 
     x_c = x[:, 2 * self.output_dim: 3 * self.output_dim] 
     x_o = x[:, 3 * self.output_dim:] 
    else: 
     x_i = K.dot(x * B_W[0], self.W_i) + self.b_i 
     x_f = K.dot(x * B_W[1], self.W_f) + self.b_f 
     x_c = K.dot(x * B_W[2], self.W_c) + self.b_c 
     x_o = K.dot(x * B_W[3], self.W_o) + self.b_o 

    i = self.inner_activation(x_i + K.dot(h_tm1 * B_U[0], self.U_i)) 
    f = self.inner_activation(x_f + K.dot(h_tm1 * B_U[1], self.U_f)) 
    c = f * c_tm1 + i * self.activation(x_c + K.dot(h_tm1 * B_U[2], self.U_c)) 
    o = self.inner_activation(x_o + K.dot(h_tm1 * B_U[3], self.U_o)) 

    with open("test_visualization.txt", "a") as myfile: 
     myfile.write(str(i)+"\n") 

    h = o * self.activation(c) 
    return h, [h, c] 

और के रूप में यह उपरोक्त कोड में है, मैं एक फ़ाइल में मैं के मूल्य में लिखने का प्रयास किया, लेकिन यह केवल मेरे जैसे बहुत महत्व दिया:

Elemwise{mul,no_inplace}.0 
[for{cpu,scan_fn}.2, Subtensor{int64::}.0, Subtensor{int64::}.0] 
Subtensor{int64}.0 

तो मैं i.eval() या i.get_value() की कोशिश की, लेकिन दोनों मुझे मान देने के लिए विफल रहा है।

theano.gof.fg.MissingInputError: An input of the graph, used to compute Subtensor{::, :int64:}(<TensorType(float32, matrix)>, Constant{10}), was not provided and not given a value.Use the Theano flag exception_verbosity='high',for more information on this error. 

और .get_value() मुझे यह दिया:

.eval() मुझे यह दिया

AttributeError: 'TensorVariable' object has no attribute 'get_value' 

तो मैं उन जंजीरों पीछे हट गए हैं (जो लाइन कॉल जो कार्यों ..) और मैंने पाया हर कदम पर मूल्य प्राप्त करने की कोशिश की लेकिन व्यर्थ में।

ऐसा लगता है कि मैं कुछ बुनियादी नुकसान में हूं।

http://keras.io/getting-started/faq/#how-can-i-visualize-the-output-of-an-intermediate-layer

विस्तार में:

from keras import backend as K 

intermediate_tensor_function = K.function([model.layers[0].input],[model.layers[layer_of_interest].output]) 
intermediate_tensor = intermediate_tensor_function([thisInput])[0] 

पैदावार:

+0

बनाने के लिए उपयोगी है आप मूल्य कैसे प्राप्त कर रहे हैं? अपना कोड शामिल करें, ऐसा लगता है कि आप प्रतीकात्मक चर प्रिंट कर रहे हैं, न कि उनके मूल्य। –

+0

आपके त्वरित उत्तर @MatiasValdenegro के लिए बहुत बहुत धन्यवाद। मैंने कोड और त्रुटि संदेशों के साथ ऊपर अपना प्रश्न अपडेट किया। – totuta

उत्तर

1

मैं समाधान Keras पूछे जाने वाले प्रश्न में वर्णित का उपयोग

array([[ 3., 17.]], dtype=float32) 

हालांकि मैं उपयोग करना चाहते हैं कार्यात्मक एपीआई लेकिन मुझे वास्तविक टेंसर, केवल प्रतीकात्मक प्रतिनिधित्व नहीं मिल रहा है आयन।

model.layers[1].output 

पैदावार: उदाहरण के लिए:

<tf.Tensor 'add:0' shape=(?, 2) dtype=float32> 

मैं Keras और Tensorflow की बातचीत के बारे में यहाँ कुछ याद कर रहा हूँ, लेकिन मुझे यकीन है कि क्या नहीं कर रहा हूँ। किसी भी अंतर्दृष्टि की सराहना की।

1

एक समाधान आपके नेटवर्क का एक संस्करण बनाना है जिसे एलएसटीएम परत पर छोटा कर दिया गया है, जिसमें आप गेट मानों की निगरानी करना चाहते हैं, और उसके बाद मूल परत को एक कस्टम परत के साथ प्रतिस्थापित करें जिसमें चरणबद्धता को वापस करने के लिए संशोधित नहीं किया गया है केवल छिपे हुए परत मान, बल्कि गेट मान भी।

उदाहरण के लिए, आप एक जीआरयू के गेट वैल्यू तक पहुंच का उपयोग करना चाहते हैं। एक कस्टम परत GRU2 बनाएं जो जीआरयू कक्षा से सबकुछ प्राप्त करता है, लेकिन चरण फ़ंक्शन को अनुकूलित करता है जैसे कि यह उन राज्यों का एक संयोजन देता है जिन्हें आप मॉनिटर करना चाहते हैं, और फिर अगली सक्रियताओं की गणना करते समय केवल पिछली छिपी हुई परत सक्रियण वाले भाग को लेते हैं। आईई:

def step(self, x, states): 

    # get prev hidden layer from input that is concatenation of 
    # prev hidden layer + reset gate + update gate 
    x = x[:self.output_dim, :] 


    ############################################### 
    # This is the original code from the GRU layer 
    # 

    h_tm1 = states[0] # previous memory 
    B_U = states[1] # dropout matrices for recurrent units 
    B_W = states[2] 

    if self.consume_less == 'gpu': 

     matrix_x = K.dot(x * B_W[0], self.W) + self.b 
     matrix_inner = K.dot(h_tm1 * B_U[0], self.U[:, :2 * self.output_dim]) 

     x_z = matrix_x[:, :self.output_dim] 
     x_r = matrix_x[:, self.output_dim: 2 * self.output_dim] 
     inner_z = matrix_inner[:, :self.output_dim] 
     inner_r = matrix_inner[:, self.output_dim: 2 * self.output_dim] 

     z = self.inner_activation(x_z + inner_z) 
     r = self.inner_activation(x_r + inner_r) 

     x_h = matrix_x[:, 2 * self.output_dim:] 
     inner_h = K.dot(r * h_tm1 * B_U[0], self.U[:, 2 * self.output_dim:]) 
     hh = self.activation(x_h + inner_h) 
    else: 
     if self.consume_less == 'cpu': 
      x_z = x[:, :self.output_dim] 
      x_r = x[:, self.output_dim: 2 * self.output_dim] 
      x_h = x[:, 2 * self.output_dim:] 
     elif self.consume_less == 'mem': 
      x_z = K.dot(x * B_W[0], self.W_z) + self.b_z 
      x_r = K.dot(x * B_W[1], self.W_r) + self.b_r 
      x_h = K.dot(x * B_W[2], self.W_h) + self.b_h 
     else: 
      raise Exception('Unknown `consume_less` mode.') 
     z = self.inner_activation(x_z + K.dot(h_tm1 * B_U[0], self.U_z)) 
     r = self.inner_activation(x_r + K.dot(h_tm1 * B_U[1], self.U_r)) 

     hh = self.activation(x_h + K.dot(r * h_tm1 * B_U[2], self.U_h)) 
    h = z * h_tm1 + (1 - z) * hh 

    # 
    # End of original code 
    ########################################################### 


    # concatenate states you want to monitor, in this case the 
    # hidden layer activations and gates z and r 
    all = K.concatenate([h, z, r]) 

    # return everything 
    return all, [h] 

(ध्यान दें कि मैंने जो लाइनें जोड़ी हैं वह फ़ंक्शन की शुरुआत और अंत में हैं)।

यदि आप जीआरयू 2 के बजाय जीआरयू 2 के साथ अपने नेटवर्क को जीआरयू के बजाय अंतिम परत के रूप में चलाते हैं (return_sequences = GRU2 परत के लिए सही है), तो आप बस अपने नेटवर्क पर भविष्यवाणी कर सकते हैं, इससे आपको सभी छिपी हुई परत और गेट मान मिलेंगे।

वही बात एलएसटीएम के लिए काम करनी चाहिए, हालांकि आपको एक वेक्टर में इच्छित सभी आउटपुट को स्टोर करने के तरीके को समझने के लिए थोड़ा सा पहेली करना पड़ सकता है और बाद में उन्हें पुनः प्राप्त कर सकते हैं।

आशा है कि मदद करता है!

0

आप (और नहीं परिभाषा के दौरान जो आप क्या कर रहे हैं और कारण है कि आप मान नहीं मिल रहे हैं है, लेकिन उनकी सार परिभाषा) निष्पादन दौरान मुद्रण के लिए थेनो के printing मॉड्यूल का उपयोग कर सकते हैं।

प्रिंट

बस Print समारोह का उपयोग करें। अपने ग्राफ को जारी रखने के लिए Print के आउटपुट का उपयोग करना न भूलें, अन्यथा आउटपुट डिस्कनेक्ट हो जाएगा और प्रिंटिंग को ऑप्टिमाइज़ेशन के दौरान हटा दिया जाएगा। और आप कुछ भी नहीं देखेंगे।

from keras import backend as K 
from theano.printing import Print 

def someLossFunction(x, ref): 
    loss = K.square(x - ref) 
    loss = Print('Loss tensor (before sum)')(loss) 
    loss = K.sum(loss) 
    loss = Print('Loss scalar (after sum)')(loss) 
    return loss 

प्लॉट

एक छोटी सी बोनस आप आनंद सकता है।

प्रिंट क्लास में global_fn पैरामीटर है, प्रिंट करने के लिए डिफ़ॉल्ट कॉलबैक ओवरराइड करने के लिए। उदाहरण के लिए साजिश बनाने के लिए आप अपने स्वयं के फ़ंक्शन और सीधे डेटा तक पहुंच सकते हैं।

from keras import backend as K 
from theano.printing import Print 
import matplotlib.pyplot as plt 

curve = [] 

# the callback function 
def myPlottingFn(printObj, data): 
    global curve 
    # Store scalar data 
    curve.append(data) 

    # Plot it 
    fig, ax = plt.subplots() 
    ax.plot(curve, label=printObj.message) 
    ax.legend(loc='best') 
    plt.show() 

def someLossFunction(x, ref): 
    loss = K.sum(K.square(x - ref)) 
    # Callback is defined line below 
    loss = Print('Loss scalar (after sum)', global_fn=myplottingFn)(loss) 
    return loss 

BTW स्ट्रिंग आप प्रिंट करने के लिए पारित किया ('...') संपत्ति नाम message के तहत प्रिंट वस्तु में संग्रहीत है (समारोह myPlottingFn देखें)। यह मल्टी-वक्र प्लॉट स्वचालित रूप से

संबंधित मुद्दे