मशीन लर्निंग में, एक मॉडल सीखने योग्य मापदंडों के साथ एक फ़ंक्शन है जो एक इनपुट को आउटपुट में मैप करता है। डेटा पर मॉडल को प्रशिक्षित करके इष्टतम पैरामीटर प्राप्त किए जाते हैं। एक अच्छी तरह से प्रशिक्षित मॉडल इनपुट से वांछित आउटपुट तक सटीक मैपिंग प्रदान करेगा।
TensorFlow.js में मशीन लर्निंग मॉडल बनाने के दो तरीके हैं:
- Layers API का उपयोग करके जहां आप लेयर्स का उपयोग करके एक मॉडल बनाते हैं।
- निचले स्तर के ऑप्स जैसे
tf.matMul(),tf.add(), आदि के साथ कोर एपीआई का उपयोग करना।
सबसे पहले, हम लेयर्स एपीआई को देखेंगे, जो मॉडल बनाने के लिए एक उच्च-स्तरीय एपीआई है। फिर, हम दिखाएंगे कि कोर एपीआई का उपयोग करके एक ही मॉडल कैसे बनाया जाए।
Layers API के साथ मॉडल बनाना
लेयर्स एपीआई का उपयोग करके मॉडल बनाने के दो तरीके हैं: अनुक्रमिक मॉडल और कार्यात्मक मॉडल। अगले दो खंड प्रत्येक प्रकार को अधिक बारीकी से देखते हैं।
अनुक्रमिक मॉडल
मॉडल का सबसे आम प्रकार 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() पर कॉल करें, जिसमें शामिल हैं:
- मॉडल में सभी परतों का नाम और प्रकार।
- प्रत्येक परत के लिए आउटपुट आकार।
- प्रत्येक परत के वजन मापदंडों की संख्या।
- यदि मॉडल में सामान्य टोपोलॉजी (नीचे चर्चा की गई) है, तो प्रत्येक परत को प्राप्त होने वाले इनपुट
- मॉडल के प्रशिक्षित और गैर-प्रशिक्षित मापदंडों की कुल संख्या।
ऊपर परिभाषित मॉडल के लिए, हमें कंसोल पर निम्न आउटपुट मिलता है:
| परत (प्रकार) | आउटपुट आकार | परम # |
| सघन_घना1 (घना) | [शून्य, 32] | 25120 |
| सघन_घना 2 (घना) | [शून्य, 10] | 330 |
| कुल पैरा: 25450 प्रशिक्षित करने योग्य पैरा: 25450 गैर-प्रशिक्षित पैराम्स: 0 | ||
परतों के आउटपुट आकार में 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() का उपयोग करके एक Variable बना सकते हैं और मौजूदा Tensor में पास कर सकते हैं।
इस गाइड में आपने लेयर्स और कोर एपीआई का उपयोग करके मॉडल बनाने के विभिन्न तरीकों से खुद को परिचित किया है। इसके बाद, किसी मॉडल को प्रशिक्षित करने के तरीके के लिए प्रशिक्षण मॉडल मार्गदर्शिका देखें।