मैट्रिक्स और मैट्रिक्स परिचालनों का उपयोग करके एमएक्सनेट में मॉडल कैसे बनाया जाए?

Question

मैं प्री-बिल्ड उच्च स्तरीय फ़ंक्शंस जैसे FullyConnected का उपयोग करके एक मॉडल बना सकता हूं। उदाहरण के लिए:

X = mx.sym.Variable('data') 
P = mx.sym.FullyConnected(data = X, name = 'fc1', num_hidden = 2) 

इस तरह मैं एक प्रतीकात्मक चर P कि प्रतीकात्मक चर X पर निर्भर है मिलता है। दूसरे शब्दों में, मेरे पास कम्प्यूटेशनल ग्राफ है जिसका उपयोग मॉडल को परिभाषित करने और fit और predict जैसे कार्यों को निष्पादित करने के लिए किया जा सकता है।

अब, मैं PX के माध्यम से एक अलग तरीके से व्यक्त करना चाहता हूं। अधिक विस्तार से, उच्च स्तरीय कार्यक्षमता (जैसे FullyConnected) का उपयोग करने के बजाय, मैं P और X "स्पष्ट रूप से" के बीच संबंधों को निर्दिष्ट करना चाहता हूं, निम्न स्तर के टेंसर ऑपरेशंस (जैसे मैट्रिक्स गुणा) और मॉडल पैरामीटर (झील) का प्रतिनिधित्व करने वाले प्रतीकात्मक चर वजन मैट्रिक्स)।

उपरोक्त उदाहरण के रूप में ही प्राप्त करने के लिए के लिए, मैं followig की कोशिश की है:

W = mx.sym.Variable('W') 
B = mx.sym.Variable('B') 
P = mx.sym.broadcast_plus(mx.sym.dot(X, W), B) 

हालांकि, P इस तरह से प्राप्त P पहले प्राप्त के बराबर नहीं है। मैं इसका इस्तेमाल उसी तरह नहीं कर सकता। विशेष रूप से, जहां तक ​​मैं समझता हूं, एमएक्सनेट शिकायत कर रहा है कि W और B के पास मूल्य नहीं हैं (जो समझ में आता है)।

w = np.array([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]]) 
b = np.array([7.0, 8.0]) 

W = mx.nd.array(w) 
B = mx.nd.array(b) 

यह रूप में अच्छी तरह से काम नहीं करता:

मैं भी किसी अन्य तरीके से W और B घोषित करने के लिए (ताकि वे मूल्यों होती हैं) की कोशिश की है। मुझे लगता है कि एमएक्सनेट शिकायत करता है क्योंकि यह प्रतीकात्मक चर की अपेक्षा करता है लेकिन इसके बजाय इसे एन-एरे मिल जाता है।

तो, मेरा सवाल यह है कि लो-लेवल टेंसर ऑपरेशंस (जैसे मैट्रिक्स गुणा) और मॉडल पैरामीटर (जैसे वजन मैट्रिस) का प्रतिनिधित्व करने वाली स्पष्ट वस्तुएं का उपयोग करके मॉडल बनाने का तरीका है।

Answer 1

आप ग्लूऑन एपीआई पर एक नज़र डालना चाहते हैं।

####################### 
# Allocate parameters for the first hidden layer 
####################### 
W1 = nd.random_normal(shape=(num_inputs, num_hidden), scale=weight_scale, ctx=model_ctx) 
b1 = nd.random_normal(shape=num_hidden, scale=weight_scale, ctx=model_ctx) 

params = [W1, b1, ...] 

उन्हें स्वचालित ढाल

for param in params: 
    param.attach_grad() 

मॉडल को परिभाषित करने के लिए अटैच किया जा रहा:

def net(X): 
    ####################### 
    # Compute the first hidden layer 
    ####################### 
    h1_linear = nd.dot(X, W1) + b1 
    ... 

और निष्पादित उदाहरण के लिए यहाँ खरोंच से MLP निर्माण, मानकों का आवंटन सहित के लिए एक गाइड है यह

epochs = 10 
learning_rate = .001 
smoothing_constant = .01 

for e in range(epochs): 
    ... 
    for i, (data, label) in enumerate(train_data): 
     data = data.as_in_context(model_ctx).reshape((-1, 784)) 
     label = label.as_in_context(model_ctx) 
     ... 
     with autograd.record(): 
      output = net(data) 
      loss = softmax_cross_entropy(output, label_one_hot) 
     loss.backward() 
     SGD(params, learning_rate) 

आप सीधे डोप में पूर्ण उदाहरण देख सकते हैं:

http://gluon.mxnet.io/chapter03_deep-neural-networks/mlp-scratch.html