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

यह मार्गदर्शिका मानती है कि आप पहले से ही मॉडल और परत मार्गदर्शिका पढ़ चुके हैं।

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

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

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

परिचय

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

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

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

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

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

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

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

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

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 प्रति घनी परत। यह अपेक्षित है क्योंकि घनी परतें एक फ़ंक्शन का प्रतिनिधित्व करती हैं जो समीकरण y = Ax + b के माध्यम से इनपुट टेंसर x को आउटपुट टेंसर y में मैप करती है, जहां A (कर्नेल) और b (पूर्वाग्रह) सघन परत के पैरामीटर हैं।

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

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

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

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

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() पर भेजने से पहले उसे पहले से फेरबदल करना चाहिए।
• बड़े डेटा टेंसर को बैच आकार के छोटे टेंसर में विभाजित करता है 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 में मशीन लर्निंग मॉडल को प्रशिक्षित करने के दो तरीके हैं।

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

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

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

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

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

// 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 नुकसान की गणना करता है। यह मॉडल की भविष्यवाणी और सही मूल्य का उपयोग करके पूर्वनिर्धारित हानि कार्यों में से एक को कॉल करता है।