TensorFlow.js — 2D डेटा से अनुमान लगाना

1. परिचय

इस कोडलैब में, आपको कारों के सेट के बारे में बताने वाले संख्यात्मक डेटा से अनुमान लगाने के लिए, एक मॉडल को ट्रेन करना होगा.

इस अभ्यास में, अलग-अलग तरह के कई मॉडल को ट्रेनिंग देने के लिए इस्तेमाल किए जाने वाले सामान्य चरणों के बारे में बताया जाएगा. हालांकि, इसमें छोटे डेटासेट और सामान्य (शैलो) मॉडल का इस्तेमाल किया जाएगा. इस गाइड का मुख्य मकसद, आपको TensorFlow.js की मदद से मॉडल को ट्रेन करने से जुड़ी बुनियादी शब्दावली, कॉन्सेप्ट, और सिंटैक्स के बारे में जानकारी देना है. साथ ही, आगे की खोज और सीखने के लिए एक शुरुआती बिंदु उपलब्ध कराना है.

हम लगातार संख्याओं का अनुमान लगाने के लिए मॉडल को ट्रेन कर रहे हैं. इसलिए, इस टास्क को कभी-कभी रिग्रेशन टास्क भी कहा जाता है. हम मॉडल को ट्रेनिंग देने के लिए, इनपुट के कई उदाहरण दिखाएंगे. साथ ही, सही आउटपुट भी दिखाएंगे. इसे सुपरवाइज़्ड लर्निंग कहा जाता है.

आपको क्या बनाना है

आपको एक ऐसा वेबपेज बनाना होगा जो ब्राउज़र में मॉडल को ट्रेन करने के लिए, TensorFlow.js का इस्तेमाल करता हो. किसी कार के लिए "हॉर्सपावर" की जानकारी देने पर, मॉडल "मील प्रति गैलन" (एमपीजी) का अनुमान लगाना सीख जाएगा.

इसके लिए, आपको:

डेटा लोड करें और उसे ट्रेनिंग के लिए तैयार करें.
मॉडल का आर्किटेक्चर तय करें.
मॉडल को ट्रेन करें और ट्रेनिंग के दौरान उसकी परफ़ॉर्मेंस को मॉनिटर करें.
कुछ अनुमान लगाकर, ट्रेन किए गए मॉडल का आकलन करें.

आपको क्या सीखने को मिलेगा

मशीन लर्निंग के लिए डेटा तैयार करने के सबसे सही तरीके. इनमें शफ़लिंग और नॉर्मलाइज़ेशन शामिल हैं.
tf.layers API का इस्तेमाल करके मॉडल बनाने के लिए, TensorFlow.js सिंटैक्स.
tfjs-vis लाइब्रेरी का इस्तेमाल करके, ब्राउज़र में ट्रेनिंग को मॉनिटर करने का तरीका.

आपको किन चीज़ों की ज़रूरत होगी

Chrome या किसी अन्य मॉडर्न ब्राउज़र का नया वर्शन.
टेक्स्ट एडिटर, जो आपकी मशीन पर स्थानीय तौर पर चल रहा हो या वेब पर Codepen या Glitch जैसे किसी टूल के ज़रिए चल रहा हो.
एचटीएमएल, सीएसएस, JavaScript, और Chrome DevTools (या आपके पसंदीदा ब्राउज़र के डेवलपर टूल) के बारे में जानकारी.
न्यूरल नेटवर्क के बारे में बुनियादी जानकारी. अगर आपको इस बारे में जानकारी चाहिए या आपको इसे फिर से समझना है, तो 3blue1brown का यह वीडियो या आशी कृष्णन का JavaScript में डीप लर्निंग के बारे में यह वीडियो देखें.

2. सेट अप करें

एचटीएमएल पेज बनाएं और उसमें JavaScript शामिल करें

नीचे दिए गए कोड को नाम की एचटीएमएल फ़ाइल में कॉपी करें

index.html

<!DOCTYPE html>
<html>
<head>
  <title>TensorFlow.js Tutorial</title>

  <!-- Import TensorFlow.js -->
  <script src="https://cdn.jsdelivr.net/npm/@tensorflow/tfjs@2.0.0/dist/tf.min.js"></script>
  <!-- Import tfjs-vis -->
  <script src="https://cdn.jsdelivr.net/npm/@tensorflow/tfjs-vis@1.0.2/dist/tfjs-vis.umd.min.js"></script>
</head>
<body>
  <!-- Import the main script file -->
  <script src="script.js"></script>
</body>
</html>

कोड के लिए JavaScript फ़ाइल बनाना

ऊपर दी गई एचटीएमएल फ़ाइल वाले फ़ोल्डर में, script.js नाम की एक फ़ाइल बनाएं और उसमें यह कोड डालें.

console.log('Hello TensorFlow');

ध्यान दें: सेटअप करने के इन निर्देशों (और ट्यूटोरियल के बाकी हिस्सों) में, स्क्रिप्ट टैग के ज़रिए फ़ाइलें लोड करने पर फ़ोकस किया गया है. कई JavaScript डेवलपर, डिपेंडेंसी इंस्टॉल करने के लिए npm का इस्तेमाल करते हैं. साथ ही, वे अपने प्रोजेक्ट बनाने के लिए बंडलर का इस्तेमाल करते हैं. अगर आप भी ऐसे डेवलपर हैं, तो NPM से tensorflow.js और tfjs-vis को इंस्टॉल किया जा सकता है.

इसे आज़माएं

अब जब आपने एचटीएमएल और JavaScript फ़ाइलें बना ली हैं, तो उन्हें आज़माएं. अपने ब्राउज़र में index.html फ़ाइल खोलें और devtools कंसोल खोलें.

अगर सब कुछ ठीक से काम कर रहा है, तो दो ग्लोबल वैरिएबल बनने चाहिए और devtools कंसोल में उपलब्ध होने चाहिए.:

tf, TensorFlow.js लाइब्रेरी का रेफ़रंस है
tfvis tfjs-vis लाइब्रेरी का रेफ़रंस है

अपने ब्राउज़र के डेवलपर टूल खोलें. आपको कंसोल आउटपुट में Hello TensorFlow वाला मैसेज दिखेगा. अगर ऐसा है, तो अगले चरण पर जाएं.

3. इनपुट डेटा को लोड करना, फ़ॉर्मैट करना, और विज़ुअलाइज़ करना

सबसे पहले, हमें उस डेटा को लोड करना होगा, फ़ॉर्मैट करना होगा, और विज़ुअलाइज़ करना होगा जिसका इस्तेमाल करके मॉडल को ट्रेन करना है.

हम "cars" डेटासेट को एक JSON फ़ाइल से लोड करेंगे. हमने इस फ़ाइल को आपके लिए होस्ट किया है. इसमें हर कार के बारे में कई अलग-अलग फ़ीचर शामिल होते हैं. इस ट्यूटोरियल के लिए, हमें सिर्फ़ हॉर्सपावर और माइल्स पर गैलन के बारे में डेटा निकालना है.

यह कोड

script.js फ़ाइल

/**
 * Get the car data reduced to just the variables we are interested
 * and cleaned of missing data.
 */
async function getData() {
  const carsDataResponse = await fetch('https://storage.googleapis.com/tfjs-tutorials/carsData.json');
  const carsData = await carsDataResponse.json();
  const cleaned = carsData.map(car => ({
    mpg: car.Miles_per_Gallon,
    horsepower: car.Horsepower,
  }))
  .filter(car => (car.mpg != null && car.horsepower != null));

  return cleaned;
}

इससे ऐसी सभी एंट्री भी हट जाएंगी जिनमें माइलेज या हॉर्सपावर की जानकारी नहीं दी गई है. आइए, इस डेटा को स्कैटरप्लॉट में भी प्लॉट करके देखें कि यह कैसा दिखता है.

नीचे दिया गया कोड, अपनी वेबसाइट के

script.js file.

async function run() {
  // Load and plot the original input data that we are going to train on.
  const data = await getData();
  const values = data.map(d => ({
    x: d.horsepower,
    y: d.mpg,
  }));

  tfvis.render.scatterplot(
    {name: 'Horsepower v MPG'},
    {values},
    {
      xLabel: 'Horsepower',
      yLabel: 'MPG',
      height: 300
    }
  );

  // More code will be added below
}

document.addEventListener('DOMContentLoaded', run);

पेज को रीफ़्रेश करने पर. आपको पेज के बाईं ओर एक पैनल दिखेगा. इसमें डेटा का स्कैटरप्लॉट होगा. यह कुछ ऐसा नज़र आना चाहिए.

इस पैनल को विज़र कहा जाता है. इसे tfjs-vis उपलब्ध कराता है. यह विज़ुअलाइज़ेशन दिखाने के लिए एक सुविधाजनक जगह उपलब्ध कराता है.

आम तौर पर, डेटा के साथ काम करते समय, अपने डेटा को देखने और ज़रूरत पड़ने पर उसे साफ़ करने के तरीके ढूंढना एक अच्छा विचार है. इस मामले में, हमें carsData से कुछ ऐसी एंट्री हटानी पड़ी जिनमें सभी ज़रूरी फ़ील्ड मौजूद नहीं थे. डेटा को विज़ुअलाइज़ करने से, हमें यह पता चल सकता है कि डेटा में कोई ऐसा स्ट्रक्चर है जिसे मॉडल सीख सकता है.

ऊपर दिए गए प्लॉट से पता चलता है कि हॉर्सपावर और माइलेज के बीच नेगेटिव कोरिलेशन है. इसका मतलब है कि हॉर्सपावर बढ़ने पर, आम तौर पर कार का माइलेज कम हो जाता है.

टास्क के बारे में कॉन्सेप्ट तैयार करना

अब हमारा इनपुट डेटा ऐसा दिखेगा.

...
{
  "mpg":15,
  "horsepower":165,
},
{
  "mpg":18,
  "horsepower":150,
},
{
  "mpg":16,
  "horsepower":150,
},
...

हमारा मकसद एक ऐसा मॉडल तैयार करना है जो एक संख्या, हॉर्सपावर को इनपुट के तौर पर ले और एक संख्या, माइलेज का अनुमान लगाना सीखे. एक-से-एक मैपिंग को याद रखें, क्योंकि यह अगले सेक्शन के लिए ज़रूरी होगी.

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

4. मॉडल आर्किटेक्चर तय करना

इस सेक्शन में, हम मॉडल आर्किटेक्चर के बारे में बताने के लिए कोड लिखेंगे. मॉडल आर्किटेक्चर का मतलब है कि "मॉडल को एक्ज़ीक्यूट करते समय कौनसे फ़ंक्शन इस्तेमाल किए जाएंगे". इसका दूसरा मतलब यह भी है कि "जवाबों का हिसाब लगाने के लिए, हमारा मॉडल कौनसा एल्गोरिदम इस्तेमाल करेगा".

एमएल मॉडल, ऐसे एल्गोरिदम होते हैं जो इनपुट लेते हैं और आउटपुट देते हैं. न्यूरल नेटवर्क का इस्तेमाल करते समय, एल्गोरिदम न्यूरॉन की लेयर का एक सेट होता है. इसमें ‘वज़न' (संख्याएं) होती हैं, जो उनके आउटपुट को कंट्रोल करती हैं. ट्रेनिंग प्रोसेस से, उन वेट के लिए सबसे सही वैल्यू का पता चलता है.

अपने विज्ञापन में यह फ़ंक्शन जोड़ें:

script.js मॉडल के आर्किटेक्चर को तय करने वाली फ़ाइल.

function createModel() {
  // Create a sequential model
  const model = tf.sequential();

  // Add a single input layer
  model.add(tf.layers.dense({inputShape: [1], units: 1, useBias: true}));

  // Add an output layer
  model.add(tf.layers.dense({units: 1, useBias: true}));

  return model;
}

यह सबसे आसान मॉडल है, जिसे हम tensorflow.js में तय कर सकते हैं. आइए, हर लाइन के बारे में थोड़ी जानकारी देते हैं.

मॉडल को इंस्टैंशिएट करना

const model = tf.sequential();

इससे tf.Model ऑब्जेक्ट इंस्टैंशिएट होता है. यह मॉडल sequential है, क्योंकि इसके इनपुट सीधे इसके आउटपुट में जाते हैं. अन्य तरह के मॉडल में ब्रांच हो सकती हैं या एक से ज़्यादा इनपुट और आउटपुट भी हो सकते हैं. हालांकि, ज़्यादातर मामलों में आपके मॉडल क्रमवार होंगे. सीक्वेंशियल मॉडल में, इस्तेमाल करने में आसान एपीआई भी होता है.

लेयर जोड़ना

model.add(tf.layers.dense({inputShape: [1], units: 1, useBias: true}));

इससे हमारे नेटवर्क में एक इनपुट लेयर जुड़ जाती है. यह अपने-आप एक छिपी हुई यूनिट वाली dense लेयर से कनेक्ट हो जाती है. dense लेयर, एक तरह की लेयर होती है. यह अपने इनपुट को मैट्रिक्स (जिसे वज़न कहा जाता है) से गुणा करती है. इसके बाद, नतीजे में एक संख्या (जिसे बायस कहा जाता है) जोड़ती है. यह नेटवर्क की पहली लेयर है. इसलिए, हमें inputShape तय करना होगा. inputShape की वैल्यू [1] है, क्योंकि हमने 1 नंबर को इनपुट के तौर पर इस्तेमाल किया है. यह किसी कार का हॉर्सपावर है.

units से यह तय होता है कि लेयर में वेट मैट्रिक्स कितना बड़ा होगा. यहां इसे 1 पर सेट करने का मतलब है कि डेटा की हर इनपुट सुविधा के लिए एक वेट होगा.

model.add(tf.layers.dense({units: 1}));

ऊपर दिया गया कोड, हमारी आउटपुट लेयर बनाता है. हमें 1 नंबर का आउटपुट चाहिए. इसलिए, हमने units को 1 पर सेट किया है.

ध्यान दें: इस उदाहरण में, हिडन लेयर में एक यूनिट है.इसलिए, हमें ऊपर फ़ाइनल आउटपुट लेयर जोड़ने की ज़रूरत नहीं है. इसका मतलब है कि हम हिडन लेयर को आउटपुट लेयर के तौर पर इस्तेमाल कर सकते हैं. हालांकि, अलग आउटपुट लेयर तय करने से हमें इनपुट और आउटपुट की वन-टू-वन मैपिंग को बनाए रखते हुए, हिडन लेयर में यूनिट की संख्या में बदलाव करने की अनुमति मिलती है.

कोई इंस्टेंस बनाना

नीचे दिया गया कोड,

run फ़ंक्शन को हमने पहले ही तय कर लिया था.

// Create the model
const model = createModel();
tfvis.show.modelSummary({name: 'Model Summary'}, model);

इससे मॉडल का एक इंस्टेंस बन जाएगा और वेबपेज पर लेयर की खास जानकारी दिखेगी.

5. ट्रेनिंग के लिए डेटा तैयार करना

मशीन लर्निंग मॉडल को ट्रेनिंग देने के लिए, हमें अपने डेटा को टेंसर में बदलना होगा. इससे हमें TensorFlow.js की परफ़ॉर्मेंस से जुड़े फ़ायदे मिलेंगे. हम अपने डेटा में कई तरह के बदलाव भी करेंगे. ये बदलाव, सबसे सही तरीके से किए जाएंगे. जैसे, शफ़ल करना और नॉर्मलाइज़ेशन.

यह कोड

script.js फ़ाइल

/**
 * Convert the input data to tensors that we can use for machine
 * learning. We will also do the important best practices of _shuffling_
 * the data and _normalizing_ the data
 * MPG on the y-axis.
 */
function convertToTensor(data) {
  // Wrapping these calculations in a tidy will dispose any
  // intermediate tensors.

  return tf.tidy(() => {
    // Step 1. Shuffle the data
    tf.util.shuffle(data);

    // Step 2. Convert data to Tensor
    const inputs = data.map(d => d.horsepower)
    const labels = data.map(d => d.mpg);

    const inputTensor = tf.tensor2d(inputs, [inputs.length, 1]);
    const labelTensor = tf.tensor2d(labels, [labels.length, 1]);

    //Step 3. Normalize the data to the range 0 - 1 using min-max scaling
    const inputMax = inputTensor.max();
    const inputMin = inputTensor.min();
    const labelMax = labelTensor.max();
    const labelMin = labelTensor.min();

    const normalizedInputs = inputTensor.sub(inputMin).div(inputMax.sub(inputMin));
    const normalizedLabels = labelTensor.sub(labelMin).div(labelMax.sub(labelMin));

    return {
      inputs: normalizedInputs,
      labels: normalizedLabels,
      // Return the min/max bounds so we can use them later.
      inputMax,
      inputMin,
      labelMax,
      labelMin,
    }
  });
}

आइए, इस बारे में ज़्यादा जानें.

डेटा को शफ़ल करना

// Step 1. Shuffle the data
tf.util.shuffle(data);

यहां हम उन उदाहरणों के क्रम को बदल देते हैं जिन्हें ट्रेनिंग एल्गोरिदम को दिया जाएगा. डेटा को शफ़ल करना ज़रूरी है, क्योंकि आम तौर पर ट्रेनिंग के दौरान डेटासेट को छोटे-छोटे सबसेट में बांटा जाता है. इन्हें बैच कहा जाता है. मॉडल को इन्हीं बैच पर ट्रेन किया जाता है. शफ़ल करने से, हर बैच में डेटा डिस्ट्रिब्यूशन के हिसाब से अलग-अलग तरह का डेटा होता है. ऐसा करने से, हम मॉडल की इन कामों में मदद करते हैं:

ऐसी चीज़ें न सीखें जो सिर्फ़ इस बात पर निर्भर करती हैं कि डेटा किस क्रम में डाला गया था
सबग्रुप में मौजूद स्ट्रक्चर के हिसाब से काम न करे. उदाहरण के लिए, अगर ट्रेनिंग के पहले हिस्से में सिर्फ़ ज़्यादा हॉर्सपावर वाली कारें दिखती हैं, तो हो सकता है कि यह एक ऐसा संबंध सीख ले जो डेटासेट के बाकी हिस्से पर लागू नहीं होता.

टेंसर में बदलना

// Step 2. Convert data to Tensor
const inputs = data.map(d => d.horsepower)
const labels = data.map(d => d.mpg);

const inputTensor = tf.tensor2d(inputs, [inputs.length, 1]);
const labelTensor = tf.tensor2d(labels, [labels.length, 1]);

यहाँ हमने दो ऐरे बनाए हैं. एक ऐरे में इनपुट के उदाहरण (हॉर्सपावर की एंट्री) दिए गए हैं और दूसरे में सही आउटपुट वैल्यू दी गई हैं. मशीन लर्निंग में इन्हें लेबल कहा जाता है.

इसके बाद, हम हर ऐरे डेटा को 2D टेंसर में बदलते हैं. टेंसर का आकार [num_examples, num_features_per_example] होगा. यहां inputs.length उदाहरण दिए गए हैं. हर उदाहरण में 1 इनपुट फ़ीचर (हॉर्सपावर) है.

डेटा को सामान्य बनाना

//Step 3. Normalize the data to the range 0 - 1 using min-max scaling
const inputMax = inputTensor.max();
const inputMin = inputTensor.min();
const labelMax = labelTensor.max();
const labelMin = labelTensor.min();

const normalizedInputs = inputTensor.sub(inputMin).div(inputMax.sub(inputMin));
const normalizedLabels = labelTensor.sub(labelMin).div(labelMax.sub(labelMin));

इसके बाद, हम मशीन लर्निंग की ट्रेनिंग के लिए एक और सबसे सही तरीका अपनाते हैं. हम डेटा को नॉर्मलाइज़ करते हैं. यहां हम डेटा को 0-1 की संख्यात्मक सीमा में सामान्य करते हैं. इसके लिए, मिन-मैक्स स्केलिंग का इस्तेमाल किया जाता है. सामान्य बनाना ज़रूरी है, क्योंकि tensorflow.js की मदद से बनाए जाने वाले कई मशीन लर्निंग मॉडल, बहुत बड़ी संख्याओं के साथ काम करने के लिए डिज़ाइन नहीं किए गए हैं. डेटा को नॉर्मलाइज़ करने के लिए सामान्य रेंज में 0 to 1 या -1 to 1 शामिल हैं. अगर डेटा को सामान्य सीमा में रखने की आदत डाल ली जाए, तो मॉडल को बेहतर तरीके से ट्रेन किया जा सकता है.

दूसरा सबसे सही तरीका: ट्रेनिंग से पहले, आपको हमेशा अपने डेटा को सामान्य बनाना चाहिए. कुछ डेटासेट को बिना नॉर्मलाइज़ किए भी सीखा जा सकता है. हालांकि, डेटा को नॉर्मलाइज़ करने से, अक्सर उन सभी समस्याओं को हल किया जा सकता है जिनकी वजह से मशीन लर्निंग ठीक से काम नहीं कर पाती.

डेटा को टेंसर में बदलने से पहले, उसे नॉर्मलाइज़ किया जा सकता है. हम ऐसा बाद में करते हैं, क्योंकि हम TensorFlow.js में वेक्टर बनाने की सुविधा का इस्तेमाल करके, min-max स्केलिंग ऑपरेशन कर सकते हैं. इसके लिए, हमें कोई भी फ़ॉर लूप लिखने की ज़रूरत नहीं होती.

डेटा और सामान्य बनाने की सीमाएं वापस पाएं

return {
  inputs: normalizedInputs,
  labels: normalizedLabels,
  // Return the min/max bounds so we can use them later.
  inputMax,
  inputMin,
  labelMax,
  labelMin,
}

हम ट्रेनिंग के दौरान इस्तेमाल की गई वैल्यू को सेव करना चाहते हैं, ताकि हम आउटपुट को वापस अपने ओरिजनल स्केल में ला सकें. साथ ही, हम आने वाले समय में इनपुट डेटा को इसी तरह से अडजस्ट कर सकें.

6. मॉडल को ट्रेनिंग देना

मॉडल इंस्टेंस बनाने और डेटा को टेंसर के तौर पर दिखाने के बाद, हमारे पास ट्रेनिंग प्रोसेस शुरू करने के लिए सब कुछ तैयार है.

नीचे दिए गए फ़ंक्शन को अपने

script.js file.

async function trainModel(model, inputs, labels) {
  // Prepare the model for training.
  model.compile({
    optimizer: tf.train.adam(),
    loss: tf.losses.meanSquaredError,
    metrics: ['mse'],
  });

  const batchSize = 32;
  const epochs = 50;

  return await model.fit(inputs, labels, {
    batchSize,
    epochs,
    shuffle: true,
    callbacks: tfvis.show.fitCallbacks(
      { name: 'Training Performance' },
      ['loss', 'mse'],
      { height: 200, callbacks: ['onEpochEnd'] }
    )
  });
}

इसके बारे में जानते हैं.

ट्रेनिंग के लिए तैयारी करना

// Prepare the model for training.
model.compile({
  optimizer: tf.train.adam(),
  loss: tf.losses.meanSquaredError,
  metrics: ['mse'],
});

मॉडल को ट्रेन करने से पहले, हमें उसे ‘कंपाइल' करना होगा. इसके लिए, हमें कई ज़रूरी चीज़ों के बारे में बताना होगा:

optimizer: यह वह एल्गोरिदम है जो मॉडल को अपडेट करने के लिए ज़िम्मेदार होगा, क्योंकि यह उदाहरणों को देखता है. TensorFlow.js में कई ऑप्टिमाइज़र उपलब्ध हैं. यहां हमने ऐडम ऑप्टिमाइज़र को चुना है, क्योंकि यह काफ़ी असरदार है और इसे कॉन्फ़िगर करने की ज़रूरत नहीं होती.
loss: यह एक ऐसा फ़ंक्शन है जो मॉडल को यह बताता है कि उसे दिखाए गए हर बैच (डेटा सबसेट) को सीखने में वह कितना अच्छा है. यहां हम meanSquaredError का इस्तेमाल करके, मॉडल के अनुमानों की तुलना असल वैल्यू से करते हैं.

const batchSize = 32;
const epochs = 50;

इसके बाद, हम batchSize और epochs की संख्या चुनते हैं:

batchSize से, डेटा के उन सबसेट के साइज़ का पता चलता है जिन्हें मॉडल, ट्रेनिंग के हर इटरेशन पर देखेगा. आम तौर पर, बैच का साइज़ 32 से 512 के बीच होता है. सभी समस्याओं के लिए, बैच का कोई आदर्श साइज़ नहीं होता. साथ ही, इस ट्यूटोरियल में अलग-अलग बैच साइज़ के लिए गणित के सिद्धांतों के बारे में बताना संभव नहीं है.
epochs से पता चलता है कि मॉडल, आपके दिए गए पूरे डेटासेट को कितनी बार देखेगा. यहां हम डेटासेट के लिए 50 इटरेशन लेंगे.

ट्रेन का लूप शुरू करना

return await model.fit(inputs, labels, {
  batchSize,
  epochs,
  callbacks: tfvis.show.fitCallbacks(
    { name: 'Training Performance' },
    ['loss', 'mse'],
    { height: 200, callbacks: ['onEpochEnd'] }
  )
});

model.fit वह फ़ंक्शन है जिसे ट्रेनिंग लूप शुरू करने के लिए कॉल किया जाता है. यह एक एसिंक्रोनस फ़ंक्शन है. इसलिए, हम इससे मिलने वाले प्रॉमिस को वापस कर देते हैं, ताकि कॉलर यह तय कर सके कि ट्रेनिंग कब पूरी होगी.

ट्रेनिंग की प्रोग्रेस पर नज़र रखने के लिए, हम model.fit को कुछ कॉलबैक पास करते हैं. हमने tfvis.show.fitCallbacks का इस्तेमाल करके ऐसे फ़ंक्शन जनरेट किए हैं जो ‘loss' और ‘mse' मेट्रिक के लिए चार्ट बनाते हैं. इन मेट्रिक के बारे में हमने पहले बताया था.

पूरी जानकारी का इस्तेमाल करना

अब हमें उन फ़ंक्शन को कॉल करना होगा जिन्हें हमने अपने run फ़ंक्शन में तय किया है.

नीचे दिया गया कोड, अपनी वेबसाइट के

run फ़ंक्शन का इस्तेमाल करना होगा.

// Convert the data to a form we can use for training.
const tensorData = convertToTensor(data);
const {inputs, labels} = tensorData;

// Train the model
await trainModel(model, inputs, labels);
console.log('Done Training');

पेज को रीफ़्रेश करने के बाद, कुछ सेकंड में आपको ये ग्राफ़ अपडेट होते हुए दिखेंगे.

इन्हें हमने पहले बनाए गए कॉलबैक से बनाया है. ये हर युग के आखिर में, पूरे डेटासेट के लिए नुकसान और एमएसई को औसत करके दिखाते हैं.

किसी मॉडल को ट्रेन करते समय, हम चाहते हैं कि लॉस कम हो. इस मामले में, हमारी मेट्रिक गड़बड़ी को मेज़र करती है. इसलिए, हम चाहते हैं कि यह भी कम हो.

7. अनुमान लगाना

अब हमारा मॉडल ट्रेन हो गया है. इसलिए, हम कुछ अनुमान लगाना चाहते हैं. आइए, मॉडल का आकलन करें. इसके लिए, हम देखते हैं कि यह कम से लेकर ज़्यादा हॉर्सपावर तक की एक जैसी रेंज की संख्याओं के लिए क्या अनुमान लगाता है.

अपनी script.js फ़ाइल में यह फ़ंक्शन जोड़ें

function testModel(model, inputData, normalizationData) {
  const {inputMax, inputMin, labelMin, labelMax} = normalizationData;

  // Generate predictions for a uniform range of numbers between 0 and 1;
  // We un-normalize the data by doing the inverse of the min-max scaling
  // that we did earlier.
  const [xs, preds] = tf.tidy(() => {

    const xsNorm = tf.linspace(0, 1, 100);
    const predictions = model.predict(xsNorm.reshape([100, 1]));

    const unNormXs = xsNorm
      .mul(inputMax.sub(inputMin))
      .add(inputMin);

    const unNormPreds = predictions
      .mul(labelMax.sub(labelMin))
      .add(labelMin);

    // Un-normalize the data
    return [unNormXs.dataSync(), unNormPreds.dataSync()];
  });


  const predictedPoints = Array.from(xs).map((val, i) => {
    return {x: val, y: preds[i]}
  });

  const originalPoints = inputData.map(d => ({
    x: d.horsepower, y: d.mpg,
  }));


  tfvis.render.scatterplot(
    {name: 'Model Predictions vs Original Data'},
    {values: [originalPoints, predictedPoints], series: ['original', 'predicted']},
    {
      xLabel: 'Horsepower',
      yLabel: 'MPG',
      height: 300
    }
  );
}

ऊपर दिए गए फ़ंक्शन में कुछ बातों का ध्यान रखें.

const xsNorm = tf.linspace(0, 1, 100);
const predictions = model.predict(xsNorm.reshape([100, 1]));

हम मॉडल को ट्रेनिंग देने के लिए, 100 नए ‘उदाहरण' जनरेट करते हैं. Model.predict का इस्तेमाल करके, हम उन उदाहरणों को मॉडल में डालते हैं. ध्यान दें कि इनकी शेप ([num_examples, num_features_per_example]) वैसी ही होनी चाहिए जैसी ट्रेनिंग के दौरान थी.

// Un-normalize the data
const unNormXs = xsNorm
  .mul(inputMax.sub(inputMin))
  .add(inputMin);

const unNormPreds = predictions
  .mul(labelMax.sub(labelMin))
  .add(labelMin);

डेटा को वापस हमारी मूल रेंज (0-1 के बजाय) में लाने के लिए, हम सामान्य करते समय कैलकुलेट की गई वैल्यू का इस्तेमाल करते हैं. हालांकि, हम सिर्फ़ ऑपरेशन को उलट देते हैं.

return [unNormXs.dataSync(), unNormPreds.dataSync()];

.dataSync() एक ऐसा तरीका है जिसका इस्तेमाल करके, हम किसी टेंसर में सेव की गई वैल्यू का typedarray पा सकते हैं. इससे हमें उन वैल्यू को सामान्य JavaScript में प्रोसेस करने की अनुमति मिलती है. यह .data() तरीके का सिंक्रोनस वर्शन है. आम तौर पर, इसे प्राथमिकता दी जाती है.

आखिर में, हम tfjs-vis का इस्तेमाल करके, ओरिजनल डेटा और मॉडल से मिले अनुमानों को प्लॉट करते हैं.

यह कोड

run फ़ंक्शन का इस्तेमाल करना होगा.

// Make some predictions using the model and compare them to the
// original data
testModel(model, data, tensorData);

पेज को रीफ़्रेश करें. मॉडल की ट्रेनिंग पूरी होने के बाद, आपको कुछ ऐसा दिखेगा.

बधाई हो! आपने अभी-अभी एक सामान्य मशीन लर्निंग मॉडल को ट्रेन किया है. फ़िलहाल, यह लीनियर रिग्रेशन करता है. इससे इनपुट डेटा में मौजूद ट्रेंड के हिसाब से लाइन को फ़िट करने की कोशिश की जाती है.

8. मुख्य बातें

मशीन लर्निंग मॉडल को ट्रेन करने के लिए, यह तरीका अपनाएं:

अपना टास्क तय करें:

क्या यह रिग्रेशन की समस्या है या क्लासिफ़िकेशन की?
क्या ऐसा सुपरवाइज़्ड लर्निंग या अनसुपरवाइज़्ड लर्निंग की मदद से किया जा सकता है?
इनपुट डेटा का आकार क्या है? आउटपुट डेटा कैसा दिखना चाहिए?

अपना डेटा तैयार करें:

अपने डेटा को साफ़ करें और जब भी हो सके, पैटर्न के लिए उसकी मैन्युअल तरीके से जांच करें
ट्रेनिंग के लिए डेटा का इस्तेमाल करने से पहले, उसे शफ़ल करें
अपने डेटा को न्यूरल नेटवर्क के लिए, सही रेंज में नॉर्मलाइज़ करें. आम तौर पर, संख्या वाले डेटा के लिए 0 से 1 या -1 से 1 अच्छी रेंज होती हैं.
अपने डेटा को टेंसर में बदलना

अपना मॉडल बनाएं और उसे चलाएं:

tf.sequential या tf.model का इस्तेमाल करके अपना मॉडल तय करें. इसके बाद, tf.layers.* का इस्तेमाल करके उसमें लेयर जोड़ें
कोई ऑप्टिमाइज़र चुनें. आम तौर पर, adam एक अच्छा ऑप्टिमाइज़र होता है. साथ ही, बैच साइज़ और इपॉक की संख्या जैसे पैरामीटर चुनें.
अपनी समस्या के लिए सही लॉस फ़ंक्शन चुनें. साथ ही, प्रोग्रेस का आकलन करने के लिए सटीक मेट्रिक चुनें. meanSquaredError, रिग्रेशन की समस्याओं के लिए एक सामान्य लॉस फ़ंक्शन है.
ट्रेनिंग पर नज़र रखें, ताकि यह पता चल सके कि लॉस कम हो रहा है या नहीं

अपने मॉडल का आकलन करना

अपने मॉडल के लिए ऐसी आकलन मेट्रिक चुनें जिसे ट्रेनिंग के दौरान मॉनिटर किया जा सके. ट्रेनिंग पूरी होने के बाद, कुछ टेस्ट अनुमान लगाएं. इससे आपको अनुमान की क्वालिटी का पता चलेगा.

9. अतिरिक्त क्रेडिट: आज़माने के लिए चीज़ें

इपॉक की संख्या बदलकर एक्सपेरिमेंट करें. ग्राफ़ के फ़्लैट होने से पहले, आपको कितने इपॉक की ज़रूरत है.
छिपी हुई लेयर में यूनिट की संख्या बढ़ाकर एक्सपेरिमेंट करें.
हमने जो पहली हिडन लेयर जोड़ी है और फ़ाइनल आउटपुट लेयर के बीच में ज़्यादा हिडन लेयर जोड़ने का एक्सपेरिमेंट करें. इन अतिरिक्त लेयर का कोड कुछ ऐसा दिखना चाहिए.

model.add(tf.layers.dense({units: 50, activation: 'sigmoid'}));

इन हिडन लेयर की सबसे अहम नई बात यह है कि ये नॉन-लीनियर ऐक्टिवेशन फ़ंक्शन को लागू करती हैं. इस मामले में, sigmoid ऐक्टिवेशन. ऐक्टिवेशन फ़ंक्शन के बारे में ज़्यादा जानने के लिए, यह लेख पढ़ें.

देखें कि क्या मॉडल, यहां दी गई इमेज जैसा आउटपुट जनरेट कर सकता है.