मॉडल और परतें

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

TensorFlow.js में मशीन लर्निंग मॉडल बनाने के दो तरीके हैं:

1. लेयर्स एपीआई का उपयोग करके जहां आप लेयर्स का उपयोग करके एक मॉडल बनाते हैं।
2. निचले स्तर के ऑप्स जैसे tf.matMul() , tf.add() , आदि के साथ कोर एपीआई का उपयोग करना।

सबसे पहले, हम लेयर्स एपीआई को देखेंगे, जो मॉडल बनाने के लिए एक उच्च-स्तरीय एपीआई है। फिर, हम दिखाएंगे कि कोर एपीआई का उपयोग करके समान मॉडल कैसे बनाया जाए।

लेयर्स एपीआई के साथ मॉडल बनाना

लेयर्स एपीआई का उपयोग करके मॉडल बनाने के दो तरीके हैं: एक अनुक्रमिक मॉडल, और एक कार्यात्मक मॉडल। अगले दो अनुभाग प्रत्येक प्रकार पर अधिक बारीकी से नज़र डालते हैं।

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

मॉडल का सबसे आम प्रकार Sequential मॉडल है, जो परतों का एक रैखिक ढेर है। आप sequential() फ़ंक्शन में परतों की एक सूची पास करके एक Sequential मॉडल बना सकते हैं:

const model = tf.sequential({
 layers: [
   tf.layers.dense({inputShape: [784], units: 32, activation: 'relu'}),
   tf.layers.dense({units: 10, activation: 'softmax'}),
 ]
});

या add() विधि के माध्यम से:

const model = tf.sequential();
model.add(tf.layers.dense({inputShape: [784], units: 32, activation: 'relu'}));
model.add(tf.layers.dense({units: 10, activation: 'softmax'}));

महत्वपूर्ण: मॉडल में पहली परत को inputShape आवश्यकता होती है। सुनिश्चित करें कि आप inputShape प्रदान करते समय बैच आकार को बाहर कर दें। उदाहरण के लिए, यदि आप आकार के मॉडल टेंसरों को खिलाने की योजना बना रहे हैं [B, 784] , जहां B किसी भी बैच का आकार हो सकता है, तो मॉडल बनाते समय inputShape [784] के रूप में निर्दिष्ट करें।

आप मॉडल की परतों तक model.layers और विशेष रूप से model.inputLayers और model.outputLayers के माध्यम से पहुंच सकते हैं।

कार्यात्मक मॉडल

LayersModel बनाने का दूसरा तरीका tf.model() फ़ंक्शन के माध्यम से है। tf.model() और tf.sequential() के बीच मुख्य अंतर यह है कि tf.model() आपको परतों का एक मनमाना ग्राफ़ बनाने की अनुमति देता है, जब तक कि उनमें चक्र न हों।

यहां एक कोड स्निपेट है जो tf.model() API का उपयोग करके ऊपर दिए गए समान मॉडल को परिभाषित करता है:

// Create an arbitrary graph of layers, by connecting them
// via the apply() method.
const input = tf.input({shape: [784]});
const dense1 = tf.layers.dense({units: 32, activation: 'relu'}).apply(input);
const dense2 = tf.layers.dense({units: 10, activation: 'softmax'}).apply(dense1);
const model = tf.model({inputs: input, outputs: dense2});

हम इसे किसी अन्य परत के आउटपुट से जोड़ने के लिए प्रत्येक परत पर apply() कहते हैं। इस मामले में apply() का परिणाम एक SymbolicTensor है, जो Tensor की तरह कार्य करता है लेकिन बिना किसी ठोस मान के।

ध्यान दें कि अनुक्रमिक मॉडल के विपरीत, हम पहली परत को inputShape प्रदान करने के बजाय tf.input() के माध्यम से एक SymbolicTensor बनाते हैं।

apply() आपको एक ठोस Tensor भी दे सकता है, यदि आप इसमें एक ठोस Tensor पास करते हैं:

const t = tf.tensor([-2, 1, 0, 5]);
const o = tf.layers.activation({activation: 'relu'}).apply(t);
o.print(); // [0, 1, 0, 5]

परतों का अलगाव में परीक्षण करते समय और उनका आउटपुट देखते समय यह उपयोगी हो सकता है।

अनुक्रमिक मॉडल की तरह, आप मॉडल की परतों को model.layers और विशेष रूप से model.inputLayers और model.outputLayers माध्यम से एक्सेस कर सकते हैं।

मान्यकरण

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

मॉडल सारांश

मॉडल का उपयोगी सारांश मुद्रित करने के लिए model.summary() पर कॉल करें, जिसमें शामिल हैं:

• मॉडल में सभी परतों का नाम और प्रकार।
• प्रत्येक परत के लिए आउटपुट आकार.
• प्रत्येक परत के वजन मापदंडों की संख्या।
• यदि मॉडल में सामान्य टोपोलॉजी है (नीचे चर्चा की गई है), तो प्रत्येक परत को इनपुट प्राप्त होता है
• मॉडल के प्रशिक्षण योग्य और गैर-प्रशिक्षित मापदंडों की कुल संख्या।

जिस मॉडल को हमने ऊपर परिभाषित किया है, उसके लिए हमें कंसोल पर निम्नलिखित आउटपुट मिलता है:

परतों के आउटपुट आकार में null मानों पर ध्यान दें: एक अनुस्मारक कि मॉडल इनपुट से सबसे बाहरी आयाम के रूप में बैच आकार की अपेक्षा करता है, जो इस मामले में null मान के कारण लचीला हो सकता है।

क्रमबद्धता

निचले स्तर के एपीआई पर LayersModel का उपयोग करने का एक प्रमुख लाभ मॉडल को सहेजने और लोड करने की क्षमता है। एक LayersModel इसके बारे में जानता है:

• मॉडल की वास्तुकला, आपको मॉडल को फिर से बनाने की अनुमति देती है।
• मॉडल का वजन
• प्रशिक्षण विन्यास (नुकसान, अनुकूलक, मेट्रिक्स)।
• अनुकूलक की स्थिति, जो आपको प्रशिक्षण फिर से शुरू करने की अनुमति देती है।

किसी मॉडल को सहेजने या लोड करने के लिए कोड की केवल 1 पंक्ति है:

const saveResult = await model.save('localstorage://my-model-1');
const model = await tf.loadLayersModel('localstorage://my-model-1');

उपरोक्त उदाहरण मॉडल को ब्राउज़र में स्थानीय संग्रहण में सहेजता है। विभिन्न माध्यमों (उदाहरण के लिए फ़ाइल स्टोरेज, IndexedDB , ब्राउज़र डाउनलोड को ट्रिगर करना आदि) में सेव करने के तरीके के लिए model.save() documentation और सेव और लोड गाइड देखें।

कस्टम परतें

परतें एक मॉडल के निर्माण खंड हैं। यदि आपका मॉडल एक कस्टम गणना कर रहा है, तो आप एक कस्टम परत को परिभाषित कर सकते हैं, जो बाकी परतों के साथ अच्छी तरह से इंटरैक्ट करती है। नीचे हम एक कस्टम परत परिभाषित करते हैं जो वर्गों के योग की गणना करती है:

class SquaredSumLayer extends tf.layers.Layer {
 constructor() {
   super({});
 }
 // In this case, the output is a scalar.
 computeOutputShape(inputShape) { return []; }

 // call() is where we do the computation.
 call(input, kwargs) { return input.square().sum();}

 // Every layer needs a unique name.
 getClassName() { return 'SquaredSum'; }
}

इसका परीक्षण करने के लिए, हम कंक्रीट टेंसर के साथ apply() विधि को कॉल कर सकते हैं:

const t = tf.tensor([-2, 1, 0, 5]);
const o = new SquaredSumLayer().apply(t);
o.print(); // prints 30

महत्वपूर्ण: यदि आप एक कस्टम परत जोड़ते हैं, तो आप किसी मॉडल को क्रमबद्ध करने की क्षमता खो देते हैं।

कोर एपीआई के साथ मॉडल बनाना

इस गाइड की शुरुआत में, हमने बताया कि TensorFlow.js में मशीन लर्निंग मॉडल बनाने के दो तरीके हैं।

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

आप जब भी कोर एपीआई का उपयोग करना चाहेंगे:

• आपको अधिकतम लचीलेपन या नियंत्रण की आवश्यकता है।
• आपको क्रमांकन की आवश्यकता नहीं है, या आप अपना स्वयं का क्रमांकन तर्क लागू कर सकते हैं।

कोर एपीआई में मॉडल केवल ऐसे फ़ंक्शन हैं जो एक या अधिक Tensors लेते हैं और एक Tensor लौटाते हैं। कोर एपीआई का उपयोग करके ऊपर लिखा गया वही मॉडल इस तरह दिखता है:

// The weights and biases for the two dense layers.
const w1 = tf.variable(tf.randomNormal([784, 32]));
const b1 = tf.variable(tf.randomNormal([32]));
const w2 = tf.variable(tf.randomNormal([32, 10]));
const b2 = tf.variable(tf.randomNormal([10]));

function model(x) {
  return x.matMul(w1).add(b1).relu().matMul(w2).add(b2).softmax();
}

ध्यान दें कि कोर एपीआई में हम मॉडल का वजन बनाने और आरंभ करने के लिए जिम्मेदार हैं। प्रत्येक वज़न एक Variable द्वारा समर्थित होता है जो TensorFlow.js को संकेत देता है कि ये टेंसर सीखने योग्य हैं। आप tf.variable() का उपयोग करके और मौजूदा Tensor को पास करके एक Variable बना सकते हैं।

इस गाइड में आपने लेयर्स और कोर एपीआई का उपयोग करके मॉडल बनाने के विभिन्न तरीकों से खुद को परिचित किया है। इसके बाद, किसी मॉडल को प्रशिक्षित करने के तरीके के लिए प्रशिक्षण मॉडल मार्गदर्शिका देखें।