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

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

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

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

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

मॉडल में प्रत्येक वज़न एक Variable ऑब्जेक्ट द्वारा बैकएंड होता है। TensorFlow.js में, एक Variable एक फ़्लोटिंग-पॉइंट Tensor है जिसके मानों को अपडेट करने के लिए एक अतिरिक्त विधि assign() उपयोग किया जाता है। लेयर्स एपीआई सर्वोत्तम प्रथाओं का उपयोग करके स्वचालित रूप से वज़न आरंभ करता है। प्रदर्शन के लिए, हम अंतर्निहित चर पर 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. मेट्रिक्स की सूची. घाटे के समान, मेट्रिक्स एक एकल संख्या की गणना करते हैं, यह सारांशित करते हुए कि हमारा मॉडल कितना अच्छा प्रदर्शन कर रहा है। मैट्रिक्स की गणना आमतौर पर प्रत्येक युग के अंत में संपूर्ण डेटा पर की जाती है। कम से कम, हम यह निगरानी करना चाहते हैं कि समय के साथ हमारा नुकसान कम हो रहा है। हालाँकि, हम अक्सर सटीकता जैसे अधिक मानव-अनुकूल मीट्रिक चाहते हैं। लेयर्स एपीआई का उपयोग करते समय, आप या तो मौजूदा मीट्रिक का एक स्ट्रिंग पहचानकर्ता (जैसे 'accuracy' ) प्रदान कर सकते हैं, या कोई फ़ंक्शन जो अनुमानित और सही मान लेता है और एक स्कोर लौटाता है। हमारे एपीआई दस्तावेज़ों में उपलब्ध मेट्रिक्स की सूची देखें।

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