मॉडल और परतें

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

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 । उदाहरण के लिए, यदि आप आकार के मॉडल tensors को खिलाने के लिए योजना बना रहे हैं [B, 784] , जहां B किसी भी बैच का आकार हो सकता है, यह निर्दिष्ट inputShape के रूप में [784] जब मॉडल का निर्माण।

आप के माध्यम से मॉडल की परतों का उपयोग कर सकते model.layers , और अधिक विशेष रूप model.inputLayers और model.outputLayers

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

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

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

// 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 लेकिन कोई ठोस मूल्यों के बिना।

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

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');

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

कस्टम परतें

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

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 में मशीन लर्निंग मॉडल बनाने के दो तरीके हैं।

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

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

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

कोर एपीआई में मॉडल बस कार्यों कि एक या अधिक ले रहे हैं 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 का संकेत है कि इन tensors learnable हैं। आप एक बना सकते हैं Variable का उपयोग कर tf.variable () और एक मौजूदा गुजर रहा Tensor

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