प्रशिक्षण मॉडल

इस गाइड मान लिया गया है आप पहले से ही पढ़ा है मॉडल और परतों गाइड।

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

  1. साथ परतें एपीआई का उपयोग कर LayersModel.fit() या LayersModel.fitDataset()
  2. साथ कोर एपीआई का उपयोग कर Optimizer.minimize()

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

परिचय

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

प्रशिक्षण में कई चरण शामिल हैं:

  • एक हो रही बैच मॉडल के लिए डेटा के।
  • मॉडल को भविष्यवाणी करने के लिए कहना।
  • उस भविष्यवाणी की तुलना "सत्य" मान से करना।
  • यह तय करना कि प्रत्येक पैरामीटर को कितना बदलना है ताकि मॉडल भविष्य में उस बैच के लिए बेहतर भविष्यवाणी कर सके।

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

मॉडल पैरामीटर

आइए लेयर्स एपीआई का उपयोग करके एक साधारण 2-लेयर मॉडल को परिभाषित करें:

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

हुड के अंतर्गत, मॉडल मानकों (अक्सर वजन के रूप में) है कि डेटा पर प्रशिक्षण के द्वारा learnable हैं। आइए इस मॉडल से जुड़े वज़न के नाम और उनके आकार को प्रिंट करें:

model.weights.forEach(w => {
 console.log(w.name, w.shape);
});

हमें निम्नलिखित आउटपुट मिलता है:

> dense_Dense1/kernel [784, 32]
> dense_Dense1/bias [32]
> dense_Dense2/kernel [32, 10]
> dense_Dense2/bias [10]

कुल 4 वज़न हैं, 2 प्रति घनी परत। यह आशा की जाती है के बाद से घने परतों एक समारोह है कि नक्शे इनपुट टेन्सर प्रतिनिधित्व x एक निर्गम टेन्सर को y समीकरण के माध्यम से y = Ax + b जहां A (कर्नेल) और b (पूर्वाग्रह) घने परत के मापदंडों हैं।

नोट: डिफ़ॉल्ट रूप से घने परतों एक पूर्वाग्रह शामिल हैं, लेकिन आप को निर्दिष्ट करके यह बाहर कर सकते हैं {useBias: false} विकल्पों में जब कोई सघन परत का निर्माण।

model.summary() एक उपयोगी विधि आप अपने मॉडल का अवलोकन कर सकें और मानकों की कुल संख्या को देखने के लिए चाहते हैं:

परत (प्रकार) आउटपुट आकार परम #
सघन_घना1 (घना) [शून्य, 32] 25120
सघन_घना 2 (घना) [शून्य, 10] 330
कुल पैरा: 25450
प्रशिक्षित करने योग्य पैरा: 25450
गैर-प्रशिक्षित पैराम्स: 0

मॉडल में प्रत्येक वजन एक से बैकेंड है Variable वस्तु। TensorFlow.js में, एक Variable एक फ्लोटिंग प्वाइंट है Tensor एक अतिरिक्त विधि के साथ assign() अपने मूल्यों को अद्यतन करने के लिए इस्तेमाल किया। Layers API स्वचालित रूप से सर्वोत्तम प्रथाओं का उपयोग करके वज़न को प्रारंभ करता है। प्रदर्शन के लिए, हम फोन करके वजन के ऊपर लिख सकता है assign() अंतर्निहित चर पर:

model.weights.forEach(w => {
  const newVals = tf.randomNormal(w.shape);
  // w.val is an instance of tf.Variable
  w.val.assign(newVals);
});

अनुकूलक, हानि और मीट्रिक

किसी भी प्रशिक्षण को करने से पहले, आपको तीन बातों पर निर्णय लेने की आवश्यकता है:

  1. एक अनुकूलक। ऑप्टिमाइज़र का काम यह तय करना है कि वर्तमान मॉडल भविष्यवाणी को देखते हुए मॉडल में प्रत्येक पैरामीटर को कितना बदलना है। परतें एपीआई का उपयोग कर रहे हैं, यदि आप एक मौजूदा अनुकूलक (जैसे की एक स्ट्रिंग पहचानकर्ता या तो प्रदान कर सकते हैं 'sgd' या 'adam' , या का एक उदाहरण) Optimizer वर्ग।
  2. एक हानि कार्य करते हैं। एक उद्देश्य जिसे मॉडल कम से कम करने का प्रयास करेगा। इसका लक्ष्य मॉडल की भविष्यवाणी "कितना गलत" के लिए एकल संख्या देना है। नुकसान की गणना डेटा के हर बैच पर की जाती है ताकि मॉडल अपने वजन को अपडेट कर सके। परतें एपीआई का उपयोग कर रहे हैं, यदि आप एक मौजूदा नुकसान समारोह (जैसे की एक स्ट्रिंग पहचानकर्ता या तो प्रदान कर सकते हैं 'categoricalCrossentropy' ), या किसी भी समारोह है कि एक भविष्यवाणी की है और एक सही मूल्य और रिटर्न एक नुकसान लेता है। एक देखें उपलब्ध घाटे की सूची हमारे एपीआई डॉक्स में।
  3. मेट्रिक्स की सूची। नुकसान के समान, मेट्रिक्स एकल संख्या की गणना करते हैं, यह सारांशित करते हुए कि हमारा मॉडल कितना अच्छा कर रहा है। मेट्रिक्स की गणना आमतौर पर प्रत्येक युग के अंत में संपूर्ण डेटा पर की जाती है। कम से कम, हम यह देखना चाहते हैं कि समय के साथ हमारा नुकसान कम हो रहा है। हालांकि, हम अक्सर सटीकता जैसे अधिक मानव-अनुकूल मीट्रिक चाहते हैं। परतें API का उपयोग करते हैं, तो आप की एक स्ट्रिंग पहचानकर्ता या तो प्रदान कर सकते हैं एक मीट्रिक मौजूदा (जैसे 'accuracy' , या किसी भी समारोह है कि एक भविष्यवाणी की है और एक सही मूल्य और रिटर्न स्कोर लेता है)। एक देखें उपलब्ध मीट्रिक सूची हमारे एपीआई डॉक्स में।

जब आप तय कर लिया है, एक संकलन LayersModel फोन करके model.compile() दिए गए विकल्पों के साथ:

model.compile({
  optimizer: 'sgd',
  loss: 'categoricalCrossentropy',
  metrics: ['accuracy']
});

संकलन के दौरान, मॉडल यह सुनिश्चित करने के लिए कुछ सत्यापन करेगा कि आपके द्वारा चुने गए विकल्प एक दूसरे के अनुकूल हैं।

प्रशिक्षण

वहाँ एक प्रशिक्षित करने के लिए दो तरीके हैं LayersModel :

  • का उपयोग करते हुए model.fit() और एक बड़े टेन्सर के रूप में डेटा प्रदान करते हैं।
  • का उपयोग करते हुए model.fitDataset() और एक के माध्यम से डेटा उपलब्ध कराने के Dataset वस्तु।

मॉडल फिट ()

तो मुख्य स्मृति में आपके डेटासेट फिट, और एक एकल टेन्सर रूप में उपलब्ध है, तो आप को फोन करके एक मॉडल प्रशिक्षित कर सकते हैं fit() विधि:

// Generate dummy data.
const data = tf.randomNormal([100, 784]);
const labels = tf.randomUniform([100, 10]);

function onBatchEnd(batch, logs) {
  console.log('Accuracy', logs.acc);
}

// Train for 5 epochs with batch size of 32.
model.fit(data, labels, {
   epochs: 5,
   batchSize: 32,
   callbacks: {onBatchEnd}
 }).then(info => {
   console.log('Final accuracy', info.history.acc);
 });

हुड के अंतर्गत, model.fit() हमारे लिए बहुत कुछ कर सकते:

  • डेटा को एक ट्रेन और सत्यापन सेट में विभाजित करता है, और प्रशिक्षण के दौरान प्रगति को मापने के लिए सत्यापन सेट का उपयोग करता है।
  • डेटा में फेरबदल करता है लेकिन बंटवारे के बाद ही। सुरक्षा के लिए, आप चाहिए डेटा इसे करने के लिए पारित करने से पहले पूर्व शफ़ल fit()
  • आकार के छोटे tensors में बड़े डेटा टेन्सर विभाजन batchSize.
  • कॉल optimizer.minimize() डेटा के बैच के संबंध में मॉडल के नुकसान की गणना करते हुए।
  • यह आपको प्रत्येक युग या बैच की शुरुआत और समाप्ति पर सूचित कर सकता है। हमारे मामले में, हम प्रयोग कर हर बैच के अंत में सूचना दी जाती है callbacks.onBatchEnd विकल्प। अन्य विकल्पों में शामिल हैं: onTrainBegin , onTrainEnd , onEpochBegin , onEpochEnd और onBatchBegin
  • यह सुनिश्चित करने के लिए मुख्य धागे की पैदावार करता है कि जेएस इवेंट लूप में कतारबद्ध कार्यों को समय पर ढंग से संभाला जा सकता है।

अधिक जानकारी के लिए, देखें प्रलेखन के fit() । ध्यान दें कि यदि आप कोर एपीआई का उपयोग करना चुनते हैं, तो आपको इस तर्क को स्वयं लागू करना होगा।

मॉडल.फिटडेटासेट ()

अपने डेटा स्मृति में पूरी तरह से फिट नहीं करता है, तो या स्ट्रीम किया जा रहा है, तो आप को फोन करके एक मॉडल को प्रशिक्षित कर सकते fitDataset() है, जो एक लेता Dataset वस्तु। यहाँ एक ही प्रशिक्षण कोड है, लेकिन एक डेटासेट के साथ जो एक जनरेटर फ़ंक्शन को लपेटता है:

function* data() {
 for (let i = 0; i < 100; i++) {
   // Generate one sample at a time.
   yield tf.randomNormal([784]);
 }
}

function* labels() {
 for (let i = 0; i < 100; i++) {
   // Generate one sample at a time.
   yield tf.randomUniform([10]);
 }
}

const xs = tf.data.generator(data);
const ys = tf.data.generator(labels);
// We zip the data and labels together, shuffle and batch 32 samples at a time.
const ds = tf.data.zip({xs, ys}).shuffle(100 /* bufferSize */).batch(32);

// Train the model for 5 epochs.
model.fitDataset(ds, {epochs: 5}).then(info => {
 console.log('Accuracy', info.history.acc);
});

डेटासेट के बारे में अधिक जानकारी के लिए, देखें प्रलेखन के model.fitDataset()

नए डेटा की भविष्यवाणी

एक बार जब मॉडल प्रशिक्षित किया गया है, तो आप कॉल कर सकते हैं model.predict() अनदेखी डेटा पर अनुमान लगाने के लिए:

// Predict 3 random samples.
const prediction = model.predict(tf.randomNormal([3, 784]));
prediction.print();

कोर एपीआई

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

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

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

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

इस API के बारे में अधिक जानकारी के लिए में "कोर एपीआई" खंड को पढ़ने के मॉडल और परतें गाइड।

कोर एपीआई का उपयोग करके ऊपर लिखा गया मॉडल इस तरह दिखता है:

// 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);
}

लेयर्स एपीआई के अलावा, डेटा एपीआई भी कोर एपीआई के साथ मूल रूप से काम करता है। चलो डाटासेट है कि हम में पहले परिभाषित पुन: उपयोग model.fitDataset () अनुभाग, जो फेरबदल करता है और हमारे लिए बैचिंग:

const xs = tf.data.generator(data);
const ys = tf.data.generator(labels);
// Zip the data and labels together, shuffle and batch 32 samples at a time.
const ds = tf.data.zip({xs, ys}).shuffle(100 /* bufferSize */).batch(32);

आइए मॉडल को प्रशिक्षित करें:

const optimizer = tf.train.sgd(0.1 /* learningRate */);
// Train for 5 epochs.
for (let epoch = 0; epoch < 5; epoch++) {
  await ds.forEachAsync(({xs, ys}) => {
    optimizer.minimize(() => {
      const predYs = model(xs);
      const loss = tf.losses.softmaxCrossEntropy(ys, predYs);
      loss.data().then(l => console.log('Loss', l));
      return loss;
    });
  });
  console.log('Epoch', epoch);
}

कोर एपीआई के साथ एक मॉडल को प्रशिक्षित करते समय उपरोक्त कोड मानक नुस्खा है:

  • युगों की संख्या पर लूप।
  • प्रत्येक युग के अंदर, डेटा के अपने बैचों पर लूप करें। एक का उपयोग करते समय Dataset , dataset.forEachAsync() अपने बैच के ऊपर पाश करने के लिए एक सुविधाजनक तरीका है।
  • प्रत्येक बैच, कॉल के लिए optimizer.minimize(f) है, जो कार्यान्वित f और चार चर कि हम पहले परिभाषित के संबंध में कंप्यूटिंग ढ़ाल से इसके उत्पादन को कम करता है।
  • f नुकसान गणना करता है। यह मॉडल की भविष्यवाणी और सही मूल्य का उपयोग करके पूर्वनिर्धारित हानि कार्यों में से एक को कॉल करता है।