सख्त

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

लिनक्स पर केरस सेट करें

चरण 01: सिस्टम अपडेट करें

पायथन के 'केरस' पुस्तकालय के उपयोग का पूर्ण प्रदर्शन करने से पहले, हमें अपनी लिनक्स मशीन को पूरी तरह से अपडेट करना होगा ताकि इसे आगे की स्थापना के लिए आसान बनाया जा सके। इस उद्देश्य के लिए, हमें सिस्टम के अंतर्निहित अनुप्रयोगों से 'कंसोल' एप्लिकेशन को जल्दी से खोलना होगा। विशेष क्वेरी क्षेत्र के भीतर, हमने लिनक्स की 'अपडेट' क्वेरी को 'उपयुक्त' उपयोगिता और 'सुडो' विशेषाधिकार के साथ जोड़ा है ताकि हमारे पास मौजूद सिस्टम को जल्दी से अपडेट किया जा सके। इस प्रक्रिया को जारी रखने के लिए हमारे उपयोगकर्ता पासवर्ड की आवश्यकता है ताकि हमारे सिस्टम को ठीक से अपडेट किया जा सके।

चरण 02: पायथन और पिप स्थापित करें

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

दूसरी ओर, यदि आपके सिस्टम में पाइथन स्थापित करने के लिए 'पाइप' उपयोगिता का पुराना संस्करण है, तो आपको आगे बढ़ने से पहले इसे अपडेट करना चाहिए।

पायथन के सफल कॉन्फ़िगरेशन और इसकी 'पाइप' उपयोगिता के बाद, निकट भविष्य में किसी भी समस्या से बचने के लिए पायथन के लिए सेटअपटूल को अपग्रेड करने का समय आ गया है। इसलिए, हमने 'pip3' उपयोगिता के साथ इंस्टाल क्वेरी का प्रयास किया है और -अपग्रेड विकल्प को अपग्रेड करने के लिए Setuptools, यानी सेटअप टूल को स्थापित करने का प्रयास किया है। यह हमारे सिस्टम के लिए हमारे पास मौजूद वर्तमान पासवर्ड के लिए पूछता है, और हमने इसे जोड़ दिया है।

चरण 03: TensorFlow स्थापित करें

मशीन लर्निंग और पर्यवेक्षित तंत्रिका मॉडल के निर्माण के लिए, TensorFlow सबसे प्रसिद्ध प्रतीकात्मक गणित पैकेज है। इंस्टॉलेशन के माध्यम से जाने के बाद, हम उसी 'पाइप 3' इंस्टाल क्वेरी को निष्पादित कर रहे हैं जिसके बाद 'टेन्सरफ़्लो' पैकेज नाम आता है।

अन्य TensorFlow-संबंधित उपयोगिताओं को सिस्टम पर पूरी तरह से स्थापित करने की आवश्यकता है। उन उपयोगिताओं को TensorFlow के साथ स्थापित किया जाएगा, और इसमें 10 या अधिक मिनट लग सकते हैं।

चरण 04: आवश्यक पैकेज स्थापित करें

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

यह कदम इस स्थापना की पुष्टि करके हमारा सबसे अधिक ध्यान आकर्षित कर रहा है। 'Y' टैप करें और जारी रखें।

चरण 05: वर्चुअल वातावरण बनाएं

आवश्यक इंस्टॉलेशन के बाद, वर्चुअल वातावरण बनाने का समय आ गया है। इसलिए, हमें 'वेनव' चर के माध्यम से आभासी वातावरण 'केरासेनव' बनाने के लिए '-एम' विकल्प के साथ पायथन 3 उपयोगिता का उपयोग करना होगा। 'Ls' क्वेरी से पता चलता है कि पर्यावरण बनाया गया है।

अब, हमें केरस फ़ोल्डर के आभासी वातावरण में जाने की जरूरत है। इसलिए, हम वर्चुअल वातावरण फ़ोल्डर के नाम के साथ 'सीडी' निर्देश का उपयोग कर रहे हैं। उसके बाद, हम इस आभासी वातावरण के 'बिन' फ़ोल्डर में आगे बढ़ रहे हैं और इसके उप को सूचीबद्ध किया है। इस पायथन वातावरण को सक्रिय करने के लिए, हमने 'सक्रिय' फ़ाइल के साथ-साथ इसके क्वेरी क्षेत्र में 'स्रोत' निर्देश की कोशिश की। आभासी वातावरण 'केरासेनव' नाम से सक्रिय हो जाता है।

चरण 06: पायथन पुस्तकालय स्थापित करें

पायथन वर्चुअल वातावरण को सफलतापूर्वक स्थापित करने के बाद, आपको केरस की स्थापना से पहले सभी आवश्यक पायथन पुस्तकालयों को स्थापित करना होगा। इसलिए, हम पायथन के 'पाइप' पैकेज का उपयोग करके पहले उसी आभासी वातावरण में पांडा के पुस्तकालय को स्थापित कर रहे हैं।

सिस्टम इसे पायथन के आभासी वातावरण में कॉन्फ़िगर करना शुरू कर देगा, जैसा कि चित्र में दिखाया गया है:

पांडा के पुस्तकालय को स्थापित करने के बाद, निम्न विधि का उपयोग करके NumPy पुस्तकालय स्थापित करने का प्रयास करें:

ठीक इसी तरह से, उसी वातावरण में Python की scipy लाइब्रेरी को स्थापित करें।

अब, पर्यावरण में पायथन की matplotlib लाइब्रेरी स्थापित करें।

पायथन तंत्रिका नेटवर्क मॉडल को निष्पादित करने के लिए मशीन लर्निंग में क्लस्टरिंग और रिग्रेशन एल्गोरिदम का उपयोग करता है। इसके लिए, इसमें विज्ञान-किट सीखने की लाइब्रेरी है जिसे हम 'पाइप' उपयोगिता के साथ-साथ आवश्यक पैकेजों को कॉन्फ़िगर करने के लिए '-यू' विकल्प के साथ स्थापित कर रहे हैं।

स्किकिट पुस्तकालय की स्थापना की प्रक्रिया को नीचे दिखाया गया है:

डीप लर्निंग में विज़ुअलाइज़ेशन के लिए, हमें पायथन के सीबॉर्न लाइब्रेरी को स्थापित करने की आवश्यकता है। इसलिए, हम इसे 'इंस्टॉल' क्वेरी के साथ उसी वातावरण में स्थापित कर रहे हैं।

चरण 07: केरस पुस्तकालय स्थापित करें

पायथन के सभी आवश्यक पूर्वापेक्षा पुस्तकालयों की स्थापना के बाद, हम अंततः केरस को पायथन के आभासी वातावरण में स्थापित कर सकते हैं। इस उद्देश्य के लिए 'पाइप' उपयोगिता का उपयोग हमारी 'इंस्टॉल' क्वेरी के भीतर मॉड्यूल नाम, यानी 'केरस' के साथ किया जाएगा। यदि सिस्टम दिखाता है कि इसकी आवश्यकता पहले से ही संतुष्ट है, तो इसका मतलब है कि यह पहले से ही स्थापित और कॉन्फ़िगर किया गया है।

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

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

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

चरण 08: एनाकोंडा क्लाउड स्थापित करें

पायथन में 'एनाकोंडा' नाम का एक बादल है जो पायथन में तंत्रिका नेटवर्क उदाहरण बनाने के लिए आवश्यक है। इसलिए, हमने इसकी निष्पादन फ़ाइल को अपने सिस्टम में डाउनलोड कर लिया है।

यह फ़ाइल 'ls' क्वेरी के अनुसार Linux मशीन के वर्तमान होम फोल्डर में रहती है। आपको यह सुनिश्चित करने की आवश्यकता है कि यह पहले चेकसम है, यानी, यह पूरी तरह से सही है या नहीं sha256sum क्वेरी के माध्यम से।

उसके बाद, हमें 'बैश' निर्देश और उसी कंसोल पर फ़ाइल नाम का उपयोग करके हमारे सिस्टम में एनाकोंडा की डाउनलोड की गई बैश फ़ाइल को स्थापित करने की आवश्यकता है। यह हमें स्थापना से पहले लाइसेंस समझौते की समीक्षा करने के लिए कह रहा है। इसलिए, हमने जारी रखने के लिए 'एंटर' पर टैप किया।

अपने लाइसेंस समझौते से गुजरने के बाद, यह हमें शर्तों से सहमत होने पर 'हां' पर टैप करने के लिए कहता है। आपको इसे उसी स्थान पर स्थापित करना जारी रखने के लिए एंटर दबाना होगा या उस निर्देशिका का पथ लिखना होगा जहाँ आप इसे स्थापित करना चाहते हैं। अन्यथा, स्थापना रद्द करने के लिए 'Ctrl-c' का उपयोग करें।

यह उन पैकेजों की लंबी सूची प्रदर्शित करेगा जो इस प्रक्रिया में स्थापित किए जाएंगे। कुछ लेन-देन के निष्पादन के बाद, यह संकुल को स्थापित करना शुरू कर देगा।

कुछ समय बाद, एनाकोंडा को इसके अतिरिक्त पैकेजों के साथ सफलतापूर्वक संस्थापित किया गया।

आपको रूट के रूप में 'स्रोत' क्वेरी के माध्यम से एनाकोंडा फ़ोल्डर से 'सक्रिय' फ़ाइल को चलाने की आवश्यकता है।

निम्नलिखित क्वेरी को नियोजित करते हुए एनाकोंडा नेविगेटर को लॉन्च करने का प्रयास करें।

नया कोंडा वातावरण बनाने और उस पर काम करने के लिए, नाम विकल्प के साथ 'कोंडा क्रिएट' निर्देश का प्रयास करें, उसके बाद नया पर्यावरण नाम, यानी पीईसीपीयू।

इस प्रक्रिया के लिए नए परिवेश के निर्माण पर हमारी पुष्टि की आवश्यकता है। 'वाई' टैप करें।

नए बने कोंडा वातावरण को सक्रिय करने और चलाने के लिए, अपने नए वातावरण के नाम के साथ 'कोंडा सक्रिय' क्वेरी का उपयोग करें, अर्थात, PyCPU वातावरण अब सक्रिय हो गया है।

चरण 09: स्पाइडर आईडीई स्थापित करें

इस वातावरण में पायथन प्रोग्राम के निष्पादन के लिए स्पाइडर आईडीई को स्थापित किया जाना चाहिए। इसके लिए, हमने PyCPU पर्यावरण शेल में 'स्पाइडर' कीवर्ड के साथ कोंडा इंस्टाल क्वेरी की कोशिश की है।

स्पाइडर स्थापित करना जारी रखने के लिए 'y' टैप करें।

चरण 10: पांडा और केरस पुस्तकालय स्थापित करें

स्पाइडर की स्थापना के बाद, -c विकल्प के साथ कोंडा इंस्टाल क्वेरी का उपयोग करके एनाकोंडा वातावरण में पांडा के पायथन पुस्तकालय को स्थापित करें।

फिर से, आगे बढ़ने के लिए 'y' बटन दबाएं।

पांडा के सफल कॉन्फ़िगरेशन के बाद, उसी क्वेरी के साथ केरस लाइब्रेरी स्थापित करें।

'Y' बटन पर क्लिक करने के बाद आगे बढ़ें।

आप एनाकोंडा वर्तमान परिवेश कंसोल के भीतर स्पाइडर आईडीई को निम्नानुसार लॉन्च कर सकते हैं:

स्पाइडर आईडीई लॉन्च करने की तैयारी कर रहा है।

छिपा हुआ फ़ोल्डर '.keras' होम निर्देशिका में स्थित है। इसे अनहाइड करें और इसमें निम्नलिखित कॉन्फ़िगरेशन जोड़ने के लिए इसकी 'keras.json' फ़ाइल खोलें।

Windows पर Keras और TensorFlow सेट करें

Windows वातावरण में Keras और TensorFlow को स्थापित करने के लिए, आपको यह सुनिश्चित करने की आवश्यकता है कि Python भाषा के साथ-साथ इसकी 'पाइप' लाइब्रेरी और एनाकोंडा नेविगेटर पहले से ही इस पर स्थापित है। इसे सेट करने के बाद, आपको इसे अपने खोज क्षेत्र से खोलना चाहिए और 'वातावरण' टैब के भीतर जाना चाहिए। इस टैब में, आपको उस परिवेश का नाम मिलेगा जिसमें आप वर्तमान में काम कर रहे हैं, यानी आधार। नीचे के क्षेत्र में, आपको निम्न टैब मिलेगा। 'बनाएँ' विकल्प पर टैप करें।

यहां, आपको एक नया एनवायरनमेंट नाम 'टेन्सरफ्लो' बनाना होगा, यानी, वर्तमान में बेस एनवायरनमेंट के अंदर हैं। उपयोग करने के लिए पायथन के नवीनतम संस्करण का चयन करें और आगे बढ़ने के लिए 'बनाएँ' बटन पर टैप करें।

आप देखेंगे कि पर्यावरण लोड होना शुरू हो गया है।

कुछ समय बाद, TensorFlow वातावरण पूरी तरह से स्थापित हो जाता है।

इसके सबसे बाएं क्षेत्र से, आप पायथन के लिए सभी स्थापित और उपलब्ध पुस्तकालय और मॉड्यूल देख सकते हैं, जैसा कि नीचे प्रस्तुत किया गया है:

अब, हमें इस क्षेत्र का उपयोग करके पायथन के TensorFlow बैकएंड लाइब्रेरी को स्थापित करने की आवश्यकता है। खोज बार में, 'TensorFlow' लिखें और इसे स्थापित करने के लिए दिखाई गई सूची से उसी केस पैकेज को चिह्नित करें। 'केरस' जैसे उप-मॉड्यूल के साथ TensorFlow की स्थापना के साथ आगे बढ़ने के लिए 'लागू करें' बटन पर टैप करें।

इसने हमारे एनाकोंडा वातावरण पर TensorFlow को काम करना और कॉन्फ़िगर करना शुरू कर दिया है।

संस्थापन के समय यह उप-पैकेजों की सूची प्रदर्शित करेगा जो एनाकोंडा वातावरण पर संस्थापित होने जा रहे हैं। 'लागू करें' बटन को थपथपाएं और समाप्त होने तक थोड़ी देर प्रतीक्षा करें।

थोड़ी देर के बाद, आप एक ही मॉड्यूल क्षेत्र में सभी स्थापित पैकेज पाएंगे। आप देख सकते हैं कि केरस पुस्तकालय अन्य पैकेजों के साथ स्थापित किया गया है और हमें इसे अभी स्थापित करने की आवश्यकता नहीं है।

विंडोज सर्च बार से, 'जुपिटर' कीवर्ड खोजें। 'जुपिटर नोटबुक (टेन्सरफ्लो)' नाम के एप्लिकेशन को अन्य के साथ दिखाया जाएगा। बैकएंड TensorFlow सक्षम के साथ ज्यूपिटर नोटबुक लॉन्च करने के लिए उस पर टैप करें। एक नई पायथन फाइल बनाएं और काम करना शुरू करें।

हार्ड के माध्यम से डीप लर्निंग

डीप लर्निंग में इनटेक का परत-दर-परत विश्लेषण शामिल है, प्रत्येक परत धीरे-धीरे इनपुट से उन्नत-स्तरीय विवरण निकालती है। किसी भी प्रकार के तंत्रिका नेटवर्क को बनाने के लिए केरस द्वारा एक पूर्ण ढांचा प्रदान किया जाता है। दोनों रचनात्मक और समझने में अविश्वसनीय रूप से सरल, केरस। यह सबसे भोले से लेकर सबसे बड़े और सर्वोच्च परिसर तक के तंत्रिका नेटवर्क मॉडल को सक्षम बनाता है।

कृत्रिम तंत्रिका नेटवर्क (एएनएन)

'कृत्रिम तंत्रिका नेटवर्क' (एएनएन) पद्धति गहन शिक्षण की सबसे व्यापक रूप से उपयोग की जाने वाली और मौलिक विधि प्रतीत होती है। वे मानव मन से अपने संकेत निकालते हैं, हमारे शरीर का प्राकृतिक सबसे जटिल घटक, जो उनके मॉडल के रूप में कार्य करता है। 'न्यूरॉन्स' नामक 90 बिलियन से अधिक सूक्ष्म कोशिकाएं एक व्यक्ति के मस्तिष्क का निर्माण करती हैं। अक्षतंतु और डेंड्राइट तंत्रिका तंतुओं के प्रकार होते हैं जो न्यूरॉन्स को एक साथ जोड़ते हैं। एक अक्षतंतु का प्राथमिक कार्य एक जुड़े हुए न्यूरॉन से दूसरे में डेटा भेजना है। अधिक जानकारी के लिए कृपया गूगल सर्च इंजन से सर्च करें।

केरस वास्तुकला

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

• नमूना
• परत
• अंतर्भाग मापदंड

कठिन मॉडल

केरस मॉडल में ठीक दो प्रकार होते हैं, अर्थात् अनुक्रमिक और कार्यात्मक एपीआई।

अनुक्रमिक मॉडल

मूल रूप से, अनुक्रमिक मॉडल केरस परतों का कालानुक्रमिक संकलन है। सरल, सरल अनुक्रमिक मॉडल लगभग सभी तंत्रिका नेटवर्क का वर्णन कर सकता है जो वर्तमान में उपयोग में हैं। मॉडल वर्ग का उपयोग करके एक अनुकूलित मॉडल बनाया जा सकता है जो अनुक्रमिक मॉडल प्रकट करता है। उप-वर्गीकरण दृष्टिकोण का उपयोग हमारे अपने स्वयं के एक परिष्कृत मॉडल के निर्माण के लिए किया जा सकता है। अनुक्रमिक मॉडल का प्रदर्शन नीचे प्रस्तुत किया गया है।

परतें जोड़ें

स्क्रिप्ट को keras.models के माध्यम से अनुक्रमिक मोड के आयात से शुरू किया गया है और दूसरी पंक्ति अनुक्रमिक मॉडल बना रही है। उसके बाद, सघन परत का आयात एक इनपुट परत बनाता है और एक मॉडल में एक इनपुट परत जोड़ता है। हिडन डेंस लेयर को मॉडल में बनाया और जोड़ा गया है और आउटपुट डेंस लेयर के लिए भी यही किया गया है।

मॉडल तक पहुंचें

आप अपने मॉडल लेयर्स, इसके द्वारा उपयोग किए जा रहे इनपुट डेटा और इसके आउटपुट डेटा के बारे में जानकारी प्राप्त कर सकते हैं। model.layers फ़ंक्शन आपको सभी परतों तक पहुंचने की अनुमति देता है। Model.inputs इनपुट टेंसर दिखा रहा होगा, और model.output आउटपुट टेंसर प्रदर्शित करेगा।

मॉडल को क्रमबद्ध करें

स्क्रिप्ट में उपयोग किए गए मॉडल को ऑब्जेक्ट या JSON के रूप में वापस करना आसान है। उदाहरण के लिए, get_config() फ़ंक्शन मॉडल को एक इकाई/ऑब्जेक्ट के रूप में उत्पन्न करता है। From_config () फ़ंक्शन एक पैरामीट्रिक मान के रूप में ऑब्जेक्ट का उपयोग करके एक नया मॉडल बनाता है।

आप to_json() फ़ंक्शन का उपयोग करके अपने मॉडल को JSON में भी बदल सकते हैं।

मॉडल सारांश

कुछ अतिरिक्त जानकारी के साथ मॉडल के भीतर उपयोग की जाने वाली परतों के बारे में संपूर्ण सारांश प्राप्त करने के लिए, सारांश () फ़ंक्शन को कॉल करें।

मॉडल को प्रशिक्षित करें और भविष्यवाणी करें

प्रशिक्षित करने और भविष्यवाणी करने के लिए, हमें इस संबंध में कंपाइल फंक्शन, फिट फंक्शन, फंक्शन का मूल्यांकन और प्रेडिक्ट फंक्शन का उपयोग करना चाहिए।

कठोर परतें

तंत्रिका नेटवर्क के सुझाए गए मॉडल में प्रत्येक इनपुट, छुपा और उपज परत वास्तविक मॉडल में एक अलग केरस परत से मेल खाती है। किसी भी परिष्कृत तंत्रिका नेटवर्क को केरस पुस्तकालय की पूर्व-निर्मित परतों का उपयोग करके जल्दी से विकसित किया जा सकता है। हमारे पास अलग-अलग केरस परतें हैं, अर्थात, कोर परतें, पूलिंग परतें, आवर्तक परतें, और दृढ़ परतें। आप वेब पर खोज कर उनका अध्ययन कर सकते हैं। पहली दो पंक्तियाँ अनुक्रमिक मोड, सघन, सक्रियण और ड्रॉपआउट परत का आयात कर रही हैं।

हम ड्रॉपआउट अनुक्रमिक मॉडल बनाने के लिए अनुक्रमिक () एपीआई की कोशिश कर रहे हैं। सक्रियण मॉडल 'रिलु' को बंद करके हम 'घने' एपीआई के माध्यम से एक घनी परत बना रहे हैं। घनी परत की अधिक-फिटिंग को पूरा करने के लिए, हम ड्रॉपआउट () एपीआई, यानी ड्रॉपआउट () फ़ंक्शन के माध्यम से ड्रॉपआउट लेयरिंग का उपयोग कर रहे हैं। इसके बाद, हम यहां 'रेलू' सक्रियण मॉडल के साथ अधिक सघन परत का उपयोग कर रहे हैं। ओवर-फिटिंग से घनी परतों को संभालने के लिए, हमें ड्रॉपआउट परतों का उपयोग करना होगा। अंत में, हम 'सॉफ्टमैक्स' प्रकार के सक्रियण मॉडल का उपयोग करके अपनी अंतिम सघन परतों को हटा रहे हैं।

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

• इनपुट डेटा आकार
• एक परत में कुल न्यूरॉन्स/इकाइयाँ
• initializers
• नियमितकर्ता
• प्रतिबंध
• सक्रियता

इनपुट डेटा आकार

पायथन भाषा के भीतर, हर प्रकार के इनपुट को पूर्णांकों की एक सरणी में बदल दिया गया है और फिर एल्गोरिथम मॉडल में जोड़ा गया है। पायथन के भीतर, हमें अपनी आवश्यकता के अनुसार आउटपुट प्राप्त करने के लिए इनपुट आकार निर्दिष्ट करने की आवश्यकता है। निम्नलिखित उदाहरणों में, हमने इनपुट आकार (3,3), यानी 3 पंक्तियों और 3 स्तंभों को निर्दिष्ट किया है। आउटपुट मैट्रिक्स प्रदर्शित कर रहा है।

initializers

केरस लेयर्स का इनिशियलाइज़र मॉड्यूल हमें इनपुट डेटा के लिए एक विशिष्ट वजन निर्दिष्ट करने के लिए कई फ़ंक्शन प्रदान करता है। उदाहरण के लिए, शून्य () फ़ंक्शन सभी के लिए 0 निर्दिष्ट करता है, वाले () सभी के लिए निर्दिष्ट करेगा, और स्थिर () फ़ंक्शन एक निर्दिष्ट स्थिर मान निर्दिष्ट करेगा जो उपयोगकर्ता द्वारा सभी और अधिक के लिए जोड़ा गया है। एक बेहतर समझ के लिए, हमने पहचान मैट्रिक्स उत्पन्न करने के लिए पहचान () फ़ंक्शन का उपयोग किया है। बाकी फंक्शन सर्च इंजन से भी सर्च किए जा सकते हैं।

प्रतिबंध

परत के 'वजन' पैरामीटर पर बाधाओं को लागू करने के लिए विभिन्न बाधा कार्य उपलब्ध हैं, अर्थात, गैर-नकारात्मक, इकाई मानदंड, अधिकतम मानदंड, न्यूनतम मानदंड, और बहुत कुछ। निम्नलिखित दृष्टांत में, हमने वजन से कम या उसके बराबर बाधा मानदंड लागू किया है। 'Max_value' पैरामीटर लागू होने वाली बाधा की ऊपरी सीमा है और अक्ष वह आयाम है जिस पर बाधा लागू की जाएगी, यानी आयाम 1।

नियमितकर्ता

अनुकूलन के दौरान, यह परत संपत्ति पर विभिन्न शुल्क लगाता है। यह ऐसा करने के लिए कुछ कार्यों के साथ भी आया, जैसे, L1 रेगुलराइज़र, L2 रेगुलराइज़र, और 'LI और L2' रेगुलराइज़र। यहाँ L1 रेगुलराइज़र फ़ंक्शन का सबसे सरल उदाहरण दिया गया है:

सक्रियता

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

कठिन मॉड्यूल

जैसा कि हम जानते हैं कि प्रोग्रामिंग मॉड्यूल में आमतौर पर विभिन्न और विशिष्ट उद्देश्यों के लिए उपयोग किए जाने वाले फ़ंक्शन, कक्षाएं और चर होते हैं। ठीक उसी तरह, पायथन की केरस लाइब्रेरी में कई मॉड्यूल हैं। आप वेब से केरस मॉड्यूल के बारे में सभी आवश्यक जानकारी प्राप्त कर सकते हैं।

बैकएंड

इसके सबसे प्रसिद्ध और उपयोग किए जाने वाले मॉड्यूल में से एक 'बैकएंड' मॉड्यूल है जिसे टेंसरफ्लो और थीनो जैसे पायथन के बैकएंड पुस्तकालयों का उपयोग करने के लिए डिज़ाइन किया गया है। बैकएंड मॉड्यूल का उपयोग करके, हम TensorFlow और Theano लाइब्रेरी से अधिक से अधिक बैकएंड फ़ंक्शंस का उपयोग कर सकते हैं। बैकएंड लाइब्रेरी मॉड्यूल का उपयोग करने के लिए, हमें कॉन्फ़िगरेशन फ़ाइल 'keras.json' में उपयोग किए जाने वाले बैकएंड लाइब्रेरी को निर्दिष्ट करने की आवश्यकता है, जिसे हमने छिपे हुए .keras फ़ोल्डर में बनाया है। डिफ़ॉल्ट रूप से, बैकएंड को 'टेन्सरफ्लो' के रूप में निर्दिष्ट किया गया है, लेकिन आप इसे किसी अन्य, यानी थीनो, या सीएनटीके में भी बदल सकते हैं।

हमारे उदाहरण में, हम बैकएंड के रूप में TensorFlow लाइब्रेरी का उपयोग करेंगे। रूट 'keras' फ़ोल्डर की keras.json फ़ाइल से बैकएंड के कॉन्फ़िगरेशन को लोड करने के लिए, उपयोग करें:

• केरस आयात बैकएंड से k . के रूप में

keras.json फ़ाइल से बैकएंड को सफलतापूर्वक आयात करने के बाद, वेरिएबल के साथ वेरिएबल 'k' का उपयोग करके बैकएंड जानकारी प्राप्त करने का समय आ गया है। सबसे पहले, हम एक बैकएंड का नाम ला रहे हैं जिसका हम उपयोग कर रहे हैं और पहले से ही 'बैकएंड ()' फ़ंक्शन का उपयोग करके आयात किया गया है। यह 'टेंसरफ़्लो' को इसके बैकएंड मान के रूप में लौटाता है। बैकएंड का फ्लोट वैल्यू प्राप्त करने के लिए, हम केरस के 'के' वेरिएबल ऑब्जेक्ट के माध्यम से फ्लोटएक्स () फ़ंक्शन को कॉल कर रहे हैं। यह दिखा रहा है कि हम फ्लोट 32 मान का उपयोग कर रहे हैं।

छवि डेटा का प्रारूप प्राप्त करने के लिए, 'k' चर के साथ image_Data_format() फ़ंक्शन का उपयोग करें। इसका उपयोग करने पर, यह दर्शाता है कि हमारा बैकएंड 'चैनल_लास्ट' छवि डेटा प्रारूप का उपयोग कर रहा है। बैकएंड के लिए एक्सपोनेंट पावर प्राप्त करने के लिए, ईपीएसलॉन () फ़ंक्शन को वेरिएबल 'के' के साथ कॉल करें। यह लौटाता है कि बैकएंड '07' की घातीय शक्ति का उपयोग करेगा। यह सब बैकएंड जानकारी प्राप्त करने के बारे में है।

Get_uid () फ़ंक्शन

इसकी कार्यक्षमता को समझने के लिए TensorFlow के कुछ बैकएंड कार्यों पर एक नज़र डालने का समय आ गया है। इसके सबसे अधिक उपयोग किए जाने वाले बैकएंड फ़ंक्शंस में से एक 'get_uid () फ़ंक्शन है जिसका उपयोग हमारे द्वारा उपयोग किए जा रहे डिफ़ॉल्ट ग्राफ़ की पहचान करने के लिए किया जाता है। उपसर्ग = '' पैरामीटर के साथ इसका उपयोग करने से '1', यानी उपयोग के अनुसार वापस आ जाएगा। दोबारा, इसका उपयोग करने से '2' वापस आ जाएगा क्योंकि हम इसे फिर से कॉल कर रहे हैं और ग्राफ़ का मान बढ़ा दिया गया है। 'reset_uids' फ़ंक्शन का उपयोग करने के बाद, ग्राफ़ उपयोगकर्ता आईडी मान 0 पर रीसेट हो जाएगा। इसलिए, get_uid () फ़ंक्शन का एक बार फिर से उपयोग करने से यह 1 से बढ़ जाएगा।

प्लेसहोल्डर () फ़ंक्शन

टेंसर प्लेसहोल्डर () फ़ंक्शन का उपयोग इसमें विभिन्न आयामी आकृतियों को रखने के लिए कर रहा है। उदाहरण के लिए, निम्नलिखित उदाहरण के भीतर, हम इसे केरस चर 'के' के माध्यम से 3-डी छवि को टेंसर में रखने के लिए उपयोग कर रहे हैं और इसे दूसरे चर 'डी' में सहेजते हैं। चर 'डी' का आउटपुट प्लेसहोल्डर के भीतर उपयोग की जाने वाली आकृति के गुणों को दिखा रहा है।

प्लेसहोल्डर 'डी' में सहेजे गए मान के आकार को प्रदर्शित करने के लिए 'int_shape ()' फ़ंक्शन का उपयोग किया जाता है।

डॉट () फ़ंक्शन

क्या आपने कभी दो सदिशों को गुणा किया है? यदि ऐसा है, तो आपके लिए दो टेंसरों को गुणा करना चुनौतीपूर्ण नहीं होगा। इसके लिए बैकएंड लाइब्रेरी 'डॉट' फंक्शन के साथ आई। सबसे पहले, दो अलग-अलग आकृतियों को धारण करने के लिए, हम दो धारकों 'x' और 'y' बनाने के लिए पहली 2 पंक्तियों में प्लेसहोल्डर () फ़ंक्शन में आकार मानों का उपयोग कर रहे हैं। डॉट () फ़ंक्शन दोनों टेंसरों को गुणा करने के लिए 'x' और 'y' धारकों को ले रहा है और परिणाम को दूसरे चर 'z' में सहेज रहा है। मुद्रण के लिए 'z' टेंसर का उपयोग करने पर, यह स्क्रीन पर गुणा परिणामी टेंसर आकार (1, 5) प्रदर्शित करता है।

वाले () समारोह

बैकएंड मॉड्यूल के one() फ़ंक्शन को किसी विशेष आकार के सभी मानों को 1 में प्रारंभ करने के लिए जाना जाता है। उदाहरण के लिए, हम टेंसर आकार (3,3) पर one() फ़ंक्शन का उपयोग कर रहे हैं और परिणाम को सहेज रहे हैं चर 'वी'। एक चर 'v' के मूल्य का मूल्यांकन करने और पायथन वातावरण में प्रदर्शित करने के लिए eval () फ़ंक्शन को यहां बंद कर दिया गया है। बदले में, इसने आकार (3,3) को फ्लोट32 डेटा प्रकार वाले सभी के एक सरणी मैट्रिक्स में बदल दिया है।

बैच_डॉट () फ़ंक्शन

टेंसर बैच मॉडल को अपडेट करने से पहले सॉर्ट करने के लिए कुल नमूने निर्दिष्ट करेगा। TensorFlow बैकएंड के बैच_डॉट () फ़ंक्शन का उपयोग मुख्य रूप से दो अलग-अलग बैच डेटा के गुणन परिणाम का पता लगाने के लिए किया जाता है। इसलिए, हमने दो टेंसर वैरिएबल v1 और v2 बनाए हैं और इनपुट के रूप में उन्हें v1 और v2 में सहेजने के लिए इनपुट () फ़ंक्शन का उपयोग किया है। उसके बाद, हम दोनों टेंसर चर, v1 और v2 पर बैच_डॉट () फ़ंक्शन का प्रयास कर रहे हैं, और परिणामी मान दूसरे चर 'v3' में सहेजा जाएगा। वेरिएबल v3 को प्रिंट करने पर हमें बदले में परिणामी आकार (2,2) मिला।

चर समारोह

यदि आपने कभी किसी अन्य भाषा पर काम किया है, तो हो सकता है कि आपने 'var' कीवर्ड के साथ या इसके बिना कई वेरिएबल्स को इनिशियलाइज़ किया हो। कई बार, आपने वेरिएबल को उनके डेटा प्रकारों जैसे पूर्णांक, स्ट्रिंग या वर्ण के साथ प्रारंभ किया होगा। पायथन केरस पुस्तकालय के भीतर, हम नमूने के रूप में कुछ टेंसर डेटा पर चर () फ़ंक्शन का उपयोग करके कोई भी चर बना सकते हैं।

निम्नलिखित छवि के भीतर, हमने केरस ऑब्जेक्ट 'के' के साथ एक चर () फ़ंक्शन में नमूना दो सूची डेटा जोड़कर एक चर 'डी' बनाया है। इस वेरिएबल को जोड़ने के बाद, हम इस वेरिएबल 'डी' पर ट्रांसपोज़ () फ़ंक्शन को कॉल कर रहे हैं ताकि केरस ऑब्जेक्ट 'के' के माध्यम से इसके भीतर एक नमूना डेटा के स्थानान्तरण का पता लगाया जा सके। परिणामी स्थानांतरण को एक चर 'वैल' में सहेजा जाएगा। 'वैल' परिणामी चर के मूल्य को मुद्रित करने के लिए यहां पायथन भाषा के प्रिंट स्टेटमेंट का उपयोग किया गया है। प्रिंट स्टेटमेंट फ़ंक्शन की पसंद को प्रदर्शित कर रहा है जिसे हमने वेरिएबल 'डी' पर लागू किया है और प्रत्येक सूची में तत्वों की कुल संख्या।

इसके बाद, हमने 'वैल' वेरिएबल पर 'eval' फंक्शन की कोशिश की ताकि वेरिएबल 'd' में जोड़े गए नमूनों का ट्रांसपोज़र प्राप्त हो सके और प्रिंट फंक्शन इसे प्रदर्शित कर रहा था। आप आउटपुट में दो सूचियों का स्थानांतरण देख सकते हैं।

पिछला कोड चित्रण किसी विशेष पायथन पुस्तकालय को आयात किए बिना सरल पायथन कार्यों के उपयोग द्वारा प्राप्त किया गया था। दो डेटा सेटों का 'स्थानांतरण' NumPy सरणियों का उपयोग करके पाया जा सकता है। इसके लिए, हमें शुरुआत में NumPy लाइब्रेरी को 'n' के रूप में आयात करना होगा। मूल प्रारूप समान है, लेकिन हमें 'चर' कीवर्ड का उपयोग करने के बजाय 'सरणी' कीवर्ड के साथ आकार डेटा सेट को प्रारंभ करने की आवश्यकता है। नमूना NumPy सरणी को चर 'd' पर वापस रखा जाना चाहिए। उसी NumPy ऑब्जेक्ट 'n' का उपयोग 'd' वैरिएबल पर ट्रांसपोज़ () फ़ंक्शन को कॉल करने और इसके परिणाम को वेरिएबल 'वैल' में सहेजने के लिए किया जाता है।

प्रिंट स्टेटमेंट अपने ट्रांसपोज़र टेंसर को प्रदर्शित करने के लिए इसमें 'वैल' वेरिएबल को कॉल कर रहा है। आप देख सकते हैं, 'वैल' चर के परिणामी स्थानांतरित मूल्य को प्रदर्शित करने के लिए, हमें यहां 'eval' फ़ंक्शन की आवश्यकता नहीं है। अब, हमने 'd' तर्क के साथ चर फ़ंक्शन का उपयोग किया है और परिणाम को चर 'z' में सहेजा है। इसमें तर्क मान 'z' जोड़कर प्रिंट स्टेटमेंट की कोशिश करने के बाद, यह उसी पिछले प्रारूप में आउटपुट प्रदर्शित करता है जिसे हमने उपरोक्त चर उदाहरण में आजमाया है।

Is_sparse () फ़ंक्शन

टेंसर में 'स्पैस' शब्द का प्रयोग स्पैस टेंसर के लिए किया जाता है जिसमें ज्यादातर शून्य वाली प्रविष्टियां होती हैं। इस उदाहरण में, हम यह जांचने के लिए बैकएंड मॉड्यूल के is_sparse () फ़ंक्शन का उपयोग करेंगे कि टेंसर में अधिकांश शून्य हैं या नहीं।

सबसे पहले, हम प्लेसहोल्डर () फ़ंक्शन को टेंसर आकार (3,3) रखने के लिए तर्क के साथ स्पैस को सही पर सेट कर रहे हैं। यह प्लेसहोल्डर मान परिवर्तनशील 'x' पर रखा जाएगा और प्रदर्शित किया जाएगा। आउटपुट प्लेसहोल्डर वेरिएबल 'x' के बारे में जानकारी प्रदर्शित कर रहा है।

उदाहरण के लिए, इसका डेटा प्रकार, आकार और कार्य इस पर लागू होते हैं। इसके बाद, हमने एक बार फिर प्रिंट स्टेटमेंट में is_Sparse () फ़ंक्शन को कॉल करने का प्रयास किया। यह फ़ंक्शन चर 'x' को अपने तर्क के रूप में प्रदर्शित करता है कि 'x' टेंसर विरल है या नहीं। आउटपुट 'सच' प्रदर्शित करता है।

To_dense () फ़ंक्शन

घने टेंसर को वह कहा जाता है जो स्मृति के कालानुक्रमिक ब्लॉक का उपयोग सूचना को आसन्न तरीके से संग्रहीत करने के लिए करता है और साथ ही सूचना के मूल्यों का प्रतिनिधित्व करता है। बैकएंड मॉड्यूल का 'to_dense ()' फ़ंक्शन हमें विरल टेंसर को घने टेंसर में बदलने देता है। इसलिए, हम टेंसर को चर 'x' में जोड़ने के लिए एक ही प्लेसहोल्डर फ़ंक्शन ले रहे हैं और इस टेंसर को 'स्पैस' पर सेट किया गया है।

'to_dense ()' फ़ंक्शन घने टेंसर वैरिएबल 'x' पर लागू होता है, यानी इसे घने टेंसर में बदलने के लिए और इसे दूसरे वेरिएबल 'रेस' में सेव करने के लिए। अब, 'रेस' एक सघन टेंसर ही है। 'रेस' वेरिएबल को प्रिंट करने के लिए प्रिंट स्टेटमेंट को हटा दिया गया है। 'रेस' वेरिएबल के लिए प्रिंट स्टेटमेंट के उपयोग ने 'रेस' कन्वर्टेड वेरिएबल के बारे में जानकारी प्रदर्शित की, यानी सफलतापूर्वक विरल को डेंस में बदल दिया और बहुत कुछ।

फिर, एक अन्य प्रिंट फ़ंक्शन को is_sparse () फ़ंक्शन का उपयोग करके यह जांचने के लिए कहा जाता है कि चर 'रेस' विरल है या नहीं। आउटपुट दिखा रहा है कि चर 'रेस' विरल नहीं है, अर्थात, जैसा कि हमने इसे पहले से ही 'घने' टेंसर में बदल दिया है।

Random_uniform_variable () फ़ंक्शन

केरस बैकएंड मॉड्यूल में random_uniform_variable () फ़ंक्शन विशेष रूप से समान वितरण के माध्यम से एक टेंसर के आरंभीकरण के लिए डिज़ाइन किया गया है। इसमें कुल तीन तर्क लगते हैं। टुपल रूप में आकृति की पंक्तियों और स्तंभों को परिभाषित करने के लिए सबसे पहले तर्क 'आकृति' का उपयोग किया जाता है। यदि आपने गणित किया है, तो आपने माध्य और मानक विचलन की अवधारणा सीखी होगी।

random_uniform_variable() विधि में, अगले दो तर्क एक समान वितरण से माध्य और विशिष्ट विचलन हैं। इस उदाहरण के भीतर, हमने random_uniform_variable() फ़ंक्शन के माध्यम से मानक समान वितरण का उपयोग करते हुए दो टेंसर 'x' और 'y' को इनिशियलाइज़ किया है। दोनों टेंसर में अलग-अलग आकार के प्रारूप होते हैं, यानी, समान माध्य और मानक विचलन वाली पंक्तियाँ और स्तंभ, यानी, निम्न = 0, और उच्च = 1।

इसके बाद, हम गुणन के लिए इसमें 'x' और 'y' टेंसर लेकर 'डॉट' फ़ंक्शन को बंद कर रहे हैं। इस गुणन का परिणाम चर 'z' में सहेजा जाएगा। अंत में, परिणामी टेंसर 'z' के आकार को प्रदर्शित करने के लिए int_shape() का उपयोग करना आवश्यक है। आउटपुट टेंसर (2,2) दिखा रहा है।

Utils

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

To_श्रेणीबद्ध () फ़ंक्शन

यह फ़ंक्शन आपको एक वर्ग वेक्टर को एक मैट्रिक्स, यानी बाइनरी क्लास मैट्रिक्स में संशोधित करने की अनुमति देता है। मान लीजिए, हमने utils मॉड्यूल से to_categorical () फ़ंक्शन को आयात किया है और एक वेक्टर 'A' को इनिशियलाइज़ किया है। वेक्टर 'ए' को to_categorical() फ़ंक्शन में पास कर दिया गया है। इस वर्ग वेक्टर 'ए' के लिए बाइनरी मैट्रिक्स प्रदर्शित किया गया है।

Print_summary () फ़ंक्शन

एक मॉडल के सारांश को प्रिंट करने के लिए जिसे हम अपने परिवेश में बंद कर रहे हैं, print_summary फ़ंक्शन का उपयोग किया गया था।

प्लॉट_मॉडल () फ़ंक्शन

प्लॉट_मॉडल () फ़ंक्शन मॉडल को डॉट प्रारूप में दर्शाता है और आपको इसे एक दस्तावेज़ में सहेजने देता है।

निष्कर्ष

संक्षेप में, हम कह सकते हैं कि पायथन भाषा आज के युग के लिए एक आवश्यक भाषा है क्योंकि सब कुछ तेजी से हो रहा है और तकनीक इतनी तेजी से विकसित हो रही है। इस पूरे लर्निंग गाइडलाइन के दौरान, हम डीप लर्निंग और आर्टिफिशियल न्यूरल नेटवर्क्स में पायथन की केरस लाइब्रेरी का इस्तेमाल करते रहे हैं। इसके लिए, हमने स्पष्ट समझ प्राप्त करने के लिए इसकी बैकएंड लाइब्रेरी 'टेन्सरफ्लो' के महत्व और उपयोग को भी देखा है। इसके अतिरिक्त, हमने उबंटू 20.04 लिनक्स ऑपरेटिंग सिस्टम के भीतर पायथन में केरस और एनाकोंडा वातावरण स्थापित करने के लिए आवश्यक प्रत्येक कॉन्फ़िगरेशन पर चर्चा और व्याख्या की है। इसके बाद, हमने केरस मॉडल्स, लेयर्स और मॉड्यूल्स पर एक-एक करके उनके सबसे अधिक उपयोग किए जाने वाले फंक्शन्स के बारे में विस्तार से चर्चा की है। फंक्शन एपीआई मॉडल के प्रदर्शन के लिए, कृपया आधिकारिक दस्तावेज देखें।