Caffe2 - अपना खुद का नेटवर्क बनाना

इस पाठ में, आप एक परिभाषित करना सीखेंगे single layer neural network (NN)Caffe2 में और इसे बेतरतीब ढंग से उत्पन्न डेटासेट पर चलाएं। हम नेटवर्क आर्किटेक्चर, प्रिंट इनपुट, आउटपुट, वेट्स और पूर्वाग्रह मानों को रेखांकन करने के लिए कोड लिखेंगे। इस पाठ को समझने के लिए, आपको परिचित होना चाहिएneural network architectures, आईटी इस terms तथा mathematics उन में इस्तेमाल किया।

नेटवर्क आर्किटेक्चर

आइए विचार करें कि हम एक एकल NN का निर्माण करना चाहते हैं जैसा कि नीचे दिए गए चित्र में दिखाया गया है -

गणितीय रूप से, इस नेटवर्क को निम्नलिखित पायथन कोड द्वारा दर्शाया गया है -

Y = X * W^T + b

कहाँ पे X, W, b दसियों और हैं Yआउटपुट है। हम सभी तीन टेनर्स को कुछ यादृच्छिक डेटा से भर देंगे, नेटवर्क चलाएंगे और जांच करेंगेYउत्पादन। नेटवर्क और टेंसर्स को परिभाषित करने के लिए, Caffe2 कई प्रदान करता हैOperator कार्य करता है।

Caffe2 संचालक

Caffe2 में, Operatorगणना की मूल इकाई है। कफ २Operator इस प्रकार दर्शाया गया है।

Caffe2 ऑपरेटरों की एक विस्तृत सूची प्रदान करता है। वर्तमान में हम जो नेटवर्क डिजाइन कर रहे हैं, उसके लिए हम FC नामक ऑपरेटर का उपयोग करेंगे, जो इनपुट वेक्टर पास करने के परिणाम की गणना करता हैX एक दो आयामी वजन मैट्रिक्स के साथ एक पूरी तरह से जुड़े नेटवर्क में W और एक एकल-आयामी पूर्वाग्रह वेक्टर b। दूसरे शब्दों में, यह निम्नलिखित गणितीय समीकरण की गणना करता है

Y = X * W^T + b

कहाँ पे X आयाम हैं (M x k), W आयाम हैं (n x k) तथा b है (1 x n)। उत्पादनY आयाम का होगा (M x n), कहाँ पे M बैच का आकार है।

वैक्टर के लिए X तथा W, हम उपयोग करेंगे GaussianFillऑपरेटर कुछ यादृच्छिक डेटा बनाने के लिए। पूर्वाग्रह मान उत्पन्न करने के लिएb, हम इस्तेमाल करेंगे ConstantFill ऑपरेटर।

अब हम अपने नेटवर्क को परिभाषित करने के लिए आगे बढ़ेंगे।

नेटवर्क बनाना

सबसे पहले, आवश्यक पैकेज आयात करें -

from caffe2.python import core, workspace

अगला, कॉल करके नेटवर्क को परिभाषित करें core.Net निम्नानुसार है -

net = core.Net("SingleLayerFC")

नेटवर्क का नाम इस प्रकार है SingleLayerFC। इस बिंदु पर, नेट नामक नेटवर्क ऑब्जेक्ट बनाया जाता है। इसमें अब तक कोई परत नहीं है।

सेंसर बनाना

अब हम अपने नेटवर्क द्वारा आवश्यक तीन वैक्टर बनाएंगे। सबसे पहले, हम कॉल करके X टेनसर बनाएंगेGaussianFill ऑपरेटर निम्नानुसार है -

X = net.GaussianFill([], ["X"], mean=0.0, std=1.0, shape=[2, 3], run_once=0)

X वेक्टर के आयाम हैं 2 x 3 0,0 के माध्य डेटा मान और मानक विचलन के साथ 1.0।

इसी तरह, हम बनाते हैं W टेंसर निम्नानुसार है -

W = net.GaussianFill([], ["W"], mean=0.0, std=1.0, shape=[5, 3], run_once=0)

W वेक्टर आकार का है 5 x 3।

अंत में, हम पूर्वाग्रह पैदा करते हैं b आकार 5 का मैट्रिक्स।

b = net.ConstantFill([], ["b"], shape=[5,], value=1.0, run_once=0)

अब, कोड का सबसे महत्वपूर्ण हिस्सा आता है और यह नेटवर्क को परिभाषित कर रहा है।

परिभाषित करने वाला नेटवर्क

हम निम्नलिखित पायथन कथन में नेटवर्क को परिभाषित करते हैं -

Y = X.FC([W, b], ["Y"])

हम फोन करते हैं FC इनपुट डेटा पर ऑपरेटर X। वज़न में निर्दिष्ट हैंWऔर पूर्वाग्रह में बी। आउटपुट हैY। वैकल्पिक रूप से, आप निम्नलिखित पायथन कथन का उपयोग करके नेटवर्क बना सकते हैं, जो अधिक क्रिया है।

Y = net.FC([X, W, b], ["Y"])

इस बिंदु पर, नेटवर्क बस बनाया जाता है। जब तक हम कम से कम एक बार नेटवर्क चलाते हैं, तब तक इसमें कोई डेटा नहीं होगा। नेटवर्क चलाने से पहले, हम इसकी वास्तुकला की जांच करेंगे।

मुद्रण नेटवर्क वास्तुकला

Caffe2 एक JSON फ़ाइल में नेटवर्क आर्किटेक्चर को परिभाषित करता है, जिसे बनाए गए प्रोटो विधि को कॉल करके जांच की जा सकती है net वस्तु।

print (net.Proto())

यह निम्नलिखित उत्पादन का उत्पादन करता है -

name: "SingleLayerFC"
op {
   output: "X"
   name: ""
   type: "GaussianFill"
   arg {
      name: "mean"
      f: 0.0
   }
   arg {
      name: "std"
      f: 1.0
   }
   arg {
      name: "shape"
      ints: 2
      ints: 3
   }
   arg {
      name: "run_once"
      i: 0
   }
}
op {
   output: "W"
   name: ""
   type: "GaussianFill"
   arg {
      name: "mean"
      f: 0.0
   }
   arg {
      name: "std"
      f: 1.0
   }
   arg {
      name: "shape"
      ints: 5
      ints: 3
   }
   arg {
      name: "run_once"
      i: 0
   }
}
op {
   output: "b"
   name: ""
   type: "ConstantFill"
   arg {
      name: "shape"
      ints: 5
   }
   arg {
      name: "value"
      f: 1.0
   }
   arg {
      name: "run_once"
      i: 0
   }
}
op {
   input: "X"
   input: "W"
   input: "b"
   output: "Y"
   name: ""
   type: "FC"
}

जैसा कि आप उपरोक्त सूची में देख सकते हैं, यह पहले ऑपरेटरों को परिभाषित करता है X, W तथा b। आइए हम इसकी परिभाषा की जाँच करेंWउदाहरण के तौर पे। के जैसाW के रूप में निर्दिष्ट किया गया है GausianFill। mean फ्लोट के रूप में परिभाषित किया गया है 0.0मानक विचलन को फ्लोट के रूप में परिभाषित किया गया है 1.0, और यह shape है 5 x 3।

op {
   output: "W"
   name: "" type: "GaussianFill"
   arg {
      name: "mean" 
	   f: 0.0
   }
   arg { 
      name: "std" 
      f: 1.0
   }
   arg { 
      name: "shape" 
      ints: 5 
      ints: 3
   }
   ...
}

की परिभाषाओं का परीक्षण करें X तथा bअपनी समझ के लिए। अंत में, हम अपने सिंगल लेयर नेटवर्क की परिभाषा को देखते हैं, जिसे यहाँ पुन: प्रस्तुत किया गया है

op {
   input: "X"
   input: "W"
   input: "b"
   output: "Y"
   name: ""
   type: "FC"
}

यहां, नेटवर्क प्रकार है FC (पूरी तरह से जुड़ा हुआ) X, W, b आदानों के रूप में और Yआउटपुट है। यह नेटवर्क परिभाषा बहुत क्रियात्मक है और बड़े नेटवर्क के लिए, इसकी सामग्री की जांच करना कठिन हो जाएगा। सौभाग्य से, Caffe2 निर्मित नेटवर्क के लिए एक चित्रमय प्रतिनिधित्व प्रदान करता है।

नेटवर्क ग्राफिकल प्रतिनिधित्व

नेटवर्क के चित्रमय प्रतिनिधित्व को प्राप्त करने के लिए, निम्न कोड स्निपेट चलाएँ, जो अनिवार्य रूप से पायथन कोड की केवल दो पंक्तियाँ हैं।

from caffe2.python import net_drawer
from IPython import display
graph = net_drawer.GetPydotGraph(net, rankdir="LR")
display.Image(graph.create_png(), width=800)

जब आप कोड चलाते हैं, तो आपको निम्न आउटपुट दिखाई देंगे -

बड़े नेटवर्क के लिए, ग्राफिकल प्रतिनिधित्व नेटवर्क परिभाषा त्रुटियों को दर्शाने और डीबग करने में बेहद उपयोगी हो जाता है।

अंत में, अब नेटवर्क चलाने का समय आ गया है।

रनिंग नेटवर्क

आप कॉल करके नेटवर्क चलाते हैं RunNetOnce पर विधि workspace वस्तु -

workspace.RunNetOnce(net)

नेटवर्क के एक बार चलने के बाद, यादृच्छिक रूप से उत्पन्न हमारा सारा डेटा नेटवर्क में फीड हो जाएगा और आउटपुट बन जाएगा। नेटवर्क चलाने के बाद जो टेनर्स बनाए जाते हैं उन्हें कहा जाता हैblobsCaffe2 में। कार्यक्षेत्र के होते हैंblobsआप स्मृति में बनाते हैं और संग्रहीत करते हैं। यह मतलूब से काफी मिलता-जुलता है।

नेटवर्क चलाने के बाद, आप जांच कर सकते हैं blobs कार्यक्षेत्र में निम्नलिखित का उपयोग होता है print आदेश

print("Blobs in the workspace: {}".format(workspace.Blobs()))

आप निम्न आउटपुट देखेंगे -

Blobs in the workspace: ['W', 'X', 'Y', 'b']

ध्यान दें कि कार्यक्षेत्र में तीन इनपुट ब्लब्स शामिल हैं - X, W तथा b। इसमें आउटपुट ब्लॉब भी कहा जाता हैY। आइए अब हम इन ब्लब्स की सामग्री की जांच करते हैं।

for name in workspace.Blobs():
   print("{}:\n{}".format(name, workspace.FetchBlob(name)))

आप निम्न आउटपुट देखेंगे -

W:
[[ 1.0426593 0.15479846 0.25635982]
[-2.2461145 1.4581774 0.16827184]
[-0.12009818 0.30771437 0.00791338]
[ 1.2274994 -0.903331 -0.68799865]
[ 0.30834186 -0.53060573 0.88776857]]
X:
[[ 1.6588869e+00 1.5279824e+00 1.1889904e+00]
[ 6.7048723e-01 -9.7490678e-04 2.5114202e-01]]
Y:
[[ 3.2709925 -0.297907 1.2803618 0.837985 1.7562964]
[ 1.7633215 -0.4651525 0.9211631 1.6511179 1.4302125]]
b:
[1. 1. 1. 1. 1.]

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