TensorFlow.js — CNN के साथ हाथ से लिखे गए अंकों की पहचान

1. परिचय

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

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

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

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

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

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

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

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

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

आपको हमारे पहले ट्रेनिंग ट्यूटोरियल में मौजूद कॉन्टेंट के बारे में भी पता होना चाहिए.

2. सेट अप करें

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

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

index.html

<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>TensorFlow.js Tutorial</title>

  <!-- Import TensorFlow.js -->
  <script src="https://cdn.jsdelivr.net/npm/@tensorflow/tfjs@1.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>

  <!-- Import the data file -->
  <script src="data.js" type="module"></script>

  <!-- Import the main script file -->
  <script src="script.js" type="module"></script>

</head>

<body>
</body>
</html>

डेटा और कोड के लिए JavaScript फ़ाइलें बनाना

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

console.log('Hello TensorFlow');

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

इसे आज़माएं

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

अगर सब कुछ ठीक से काम कर रहा है, तो दो ग्लोबल वैरिएबल बनाए जाने चाहिए. tf, TensorFlow.js लाइब्रेरी का रेफ़रंस है. वहीं, tfvis, tfjs-vis लाइब्रेरी का रेफ़रंस है.

आपको यह मैसेज दिखना चाहिए: Hello TensorFlow. अगर ऐसा होता है, तो अगले चरण पर जाएं.

3. डेटा लोड करना

इस ट्यूटोरियल में, आपको एक मॉडल को ट्रेन करने का तरीका बताया जाएगा. इससे मॉडल, नीचे दी गई इमेज में मौजूद अंकों को पहचान पाएगा. ये इमेज, MNIST नाम के डेटासेट से ली गई हैं. ये 28x28 पिक्सल की ग्रेस्केल इमेज हैं.

mnist 4 mnist 3 mnist 8

हमने इन इमेज को लोड करने के लिए कोड उपलब्ध कराया है. यह कोड, स्प्राइट फ़ाइल (~10 एमबी) से इमेज लोड करता है. हमने यह फ़ाइल आपके लिए बनाई है, ताकि हम ट्रेनिंग वाले हिस्से पर फ़ोकस कर सकें.

डेटा लोड करने का तरीका समझने के लिए, data.js फ़ाइल देखें. इसके अलावा, इस ट्यूटोरियल को पूरा करने के बाद, डेटा लोड करने का अपना तरीका बनाएं.

दिए गए कोड में एक क्लास MnistData है. इसमें दो पब्लिक मेथड हैं:

nextTrainBatch(batchSize): ट्रेनिंग सेट से, इमेज और उनके लेबल का रैंडम बैच दिखाता है.
nextTestBatch(batchSize): यह फ़ंक्शन, टेस्ट सेट से इमेज और उनके लेबल का बैच दिखाता है

MnistData क्लास, डेटा को शफ़ल करने और सामान्य बनाने जैसे अहम चरण भी पूरे करती है.

कुल 65,000 इमेज हैं. हम मॉडल को ट्रेन करने के लिए 55, 000 इमेज का इस्तेमाल करेंगे. साथ ही,10, 000 इमेज सेव करेंगे,जिनका इस्तेमाल मॉडल की परफ़ॉर्मेंस की जांच करने के लिए किया जा सकता है. हम यह सब ब्राउज़र में करेंगे!

आइए, डेटा लोड करते हैं और देखते हैं कि वह सही तरीके से लोड हुआ है या नहीं.

नीचे दिए गए कोड को अपनी script.js फ़ाइल में जोड़ें.

import {MnistData} from './data.js';

async function showExamples(data) {
  // Create a container in the visor
  const surface =
    tfvis.visor().surface({ name: 'Input Data Examples', tab: 'Input Data'});  

  // Get the examples
  const examples = data.nextTestBatch(20);
  const numExamples = examples.xs.shape[0];
  
  // Create a canvas element to render each example
  for (let i = 0; i < numExamples; i++) {
    const imageTensor = tf.tidy(() => {
      // Reshape the image to 28x28 px
      return examples.xs
        .slice([i, 0], [1, examples.xs.shape[1]])
        .reshape([28, 28, 1]);
    });
    
    const canvas = document.createElement('canvas');
    canvas.width = 28;
    canvas.height = 28;
    canvas.style = 'margin: 4px;';
    await tf.browser.toPixels(imageTensor, canvas);
    surface.drawArea.appendChild(canvas);

    imageTensor.dispose();
  }
}

async function run() {  
  const data = new MnistData();
  await data.load();
  await showExamples(data);
}

document.addEventListener('DOMContentLoaded', run);

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

4. हमारे टास्क को कॉन्सेप्ट के तौर पर तैयार करो

हमारा इनपुट डेटा ऐसा दिखता है.

हमारा लक्ष्य एक ऐसे मॉडल को ट्रेन करना है जो एक इमेज को इनपुट के तौर पर ले और उस इमेज के लिए, 10 संभावित क्लास में से हर क्लास के लिए स्कोर का अनुमान लगाना सीखे. ये क्लास, अंक 0 से 9 तक की हो सकती हैं.

हर इमेज 28 पिक्सल चौड़ी और 28 पिक्सल लंबी है. साथ ही, इसमें एक कलर चैनल है, क्योंकि यह एक ग्रेस्केल इमेज है. इसलिए, हर इमेज का आकार [28, 28, 1] है.

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

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

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

मशीन लर्निंग में, हम एक आर्किटेक्चर (या एल्गोरिदम) तय करते हैं. इसके बाद, ट्रेनिंग प्रोसेस को उस एल्गोरिदम के पैरामीटर सीखने देते हैं.

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

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

function getModel() {
  const model = tf.sequential();
  
  const IMAGE_WIDTH = 28;
  const IMAGE_HEIGHT = 28;
  const IMAGE_CHANNELS = 1;  
  
  // In the first layer of our convolutional neural network we have 
  // to specify the input shape. Then we specify some parameters for 
  // the convolution operation that takes place in this layer.
  model.add(tf.layers.conv2d({
    inputShape: [IMAGE_WIDTH, IMAGE_HEIGHT, IMAGE_CHANNELS],
    kernelSize: 5,
    filters: 8,
    strides: 1,
    activation: 'relu',
    kernelInitializer: 'varianceScaling'
  }));

  // The MaxPooling layer acts as a sort of downsampling using max values
  // in a region instead of averaging.  
  model.add(tf.layers.maxPooling2d({poolSize: [2, 2], strides: [2, 2]}));
  
  // Repeat another conv2d + maxPooling stack. 
  // Note that we have more filters in the convolution.
  model.add(tf.layers.conv2d({
    kernelSize: 5,
    filters: 16,
    strides: 1,
    activation: 'relu',
    kernelInitializer: 'varianceScaling'
  }));
  model.add(tf.layers.maxPooling2d({poolSize: [2, 2], strides: [2, 2]}));
  
  // Now we flatten the output from the 2D filters into a 1D vector to prepare
  // it for input into our last layer. This is common practice when feeding
  // higher dimensional data to a final classification output layer.
  model.add(tf.layers.flatten());

  // Our last layer is a dense layer which has 10 output units, one for each
  // output class (i.e. 0, 1, 2, 3, 4, 5, 6, 7, 8, 9).
  const NUM_OUTPUT_CLASSES = 10;
  model.add(tf.layers.dense({
    units: NUM_OUTPUT_CLASSES,
    kernelInitializer: 'varianceScaling',
    activation: 'softmax'
  }));

  
  // Choose an optimizer, loss function and accuracy metric,
  // then compile and return the model
  const optimizer = tf.train.adam();
  model.compile({
    optimizer: optimizer,
    loss: 'categoricalCrossentropy',
    metrics: ['accuracy'],
  });

  return model;
}

आइए, इस बारे में थोड़ी और जानकारी देखें.

कॉन्वोल्यूशन

model.add(tf.layers.conv2d({
  inputShape: [IMAGE_WIDTH, IMAGE_HEIGHT, IMAGE_CHANNELS],
  kernelSize: 5,
  filters: 8,
  strides: 1,
  activation: 'relu',
  kernelInitializer: 'varianceScaling'
}));

यहां हम सीक्वेंशियल मॉडल का इस्तेमाल कर रहे हैं.

हम डेंस लेयर के बजाय conv2d लेयर का इस्तेमाल कर रहे हैं. हम कन्वलूशन के काम करने के तरीके के बारे में पूरी जानकारी नहीं दे सकते. हालांकि, यहां कुछ ऐसे संसाधन दिए गए हैं जिनमें इसके बारे में बताया गया है:

आइए, conv2d के लिए कॉन्फ़िगरेशन ऑब्जेक्ट में मौजूद हर तर्क के बारे में जानें:

inputShape. यह मॉडल की पहली लेयर में फ़्लो होने वाले डेटा का शेप होता है. इस मामले में, हमारे MNIST उदाहरण 28x28 पिक्सल की ब्लैक ऐंड व्हाइट इमेज हैं. इमेज डेटा के लिए कैननिकल फ़ॉर्मैट [row, column, depth] है. इसलिए, यहां हमें [28, 28, 1] का शेप कॉन्फ़िगर करना है. हर डाइमेंशन में पिक्सल की संख्या के लिए 28 लाइनें और कॉलम, और डेप्थ 1 है, क्योंकि हमारी इमेज में सिर्फ़ एक कलर चैनल है. ध्यान दें कि हम इनपुट शेप में बैच साइज़ के बारे में नहीं बताते हैं. लेयर को बैच साइज़ से अलग रखने के लिए डिज़ाइन किया गया है, ताकि अनुमान के दौरान किसी भी बैच साइज़ का टेंसर पास किया जा सके.
kernelSize. इनपुट डेटा पर लागू किए जाने वाले स्लाइडिंग कनवोल्यूशनल फ़िल्टर विंडो का साइज़. यहां हमने kernelSize को 5 पर सेट किया है. इससे पता चलता है कि यह एक स्क्वेयर, 5x5 कनवोल्यूशनल विंडो है.
filters. इनपुट डेटा पर लागू करने के लिए, kernelSize साइज़ वाली फ़िल्टर विंडो की संख्या. यहां हम डेटा पर आठ फ़िल्टर लागू करेंगे.
strides. स्लाइडिंग विंडो का "स्टेप साइज़" यानी कि फ़िल्टर, इमेज पर हर बार कितने पिक्सल तक जाएगा. यहां हमने स्ट्राइड को 1 पर सेट किया है. इसका मतलब है कि फ़िल्टर, इमेज पर 1 पिक्सल के चरणों में स्लाइड होगा.
activation. कनवोल्यूशन पूरा होने के बाद, डेटा पर लागू करने के लिए ऐक्टिवेशन फ़ंक्शन. इस मामले में, हम रेक्टिफ़ाइड लीनियर यूनिट (आरईएलयू) फ़ंक्शन लागू कर रहे हैं. यह एमएल मॉडल में इस्तेमाल होने वाला एक बहुत ही सामान्य ऐक्टिवेशन फ़ंक्शन है.
kernelInitializer. मॉडल के वेट को रैंडम तरीके से शुरू करने के लिए इस्तेमाल किया जाने वाला तरीका. यह ट्रेनिंग के लिए बहुत ज़रूरी है. हम यहां पर, वैरिएबल को शुरू करने के बारे में ज़्यादा जानकारी नहीं देंगे. हालांकि, आम तौर पर VarianceScaling (यहां इस्तेमाल किया गया) एक अच्छा इनिशियलाइज़र विकल्प होता है.

डेटा को एक ही लेवल पर दिखाना

model.add(tf.layers.flatten());

इमेज, ज़्यादा डाइमेंशन वाला डेटा होती हैं. साथ ही, कनवोल्यूशन ऑपरेशन से, इमेज में इस्तेमाल किए गए डेटा का साइज़ बढ़ जाता है. इन्हें फ़ाइनल क्लासिफ़िकेशन लेयर में भेजने से पहले, हमें डेटा को एक लंबी ऐरे में बदलना होगा. डेंस लेयर (जिसे हम अपनी फ़ाइनल लेयर के तौर पर इस्तेमाल करते हैं) में सिर्फ़ tensor1d लगते हैं. इसलिए, यह चरण कई क्लासिफ़िकेशन टास्क में आम है.

फ़ाइनल प्रायिकता बंटन का हिसाब लगाना

const NUM_OUTPUT_CLASSES = 10;
model.add(tf.layers.dense({
  units: NUM_OUTPUT_CLASSES,
  kernelInitializer: 'varianceScaling',
  activation: 'softmax'
}));

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

ऑप्टिमाइज़र और लॉस फ़ंक्शन चुनना

const optimizer = tf.train.adam();
model.compile({
  optimizer: optimizer,
  loss: 'categoricalCrossentropy',
  metrics: ['accuracy'],
});

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

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

उदाहरण के लिए, अगर हमारा अंक वाकई में 7 है, तो हमें ये नतीजे मिल सकते हैं

इंडेक्स	0	1	2	3	4	5	6	7	8	9
सही लेबल	0	0	0	0	0	0	0	1	0	0
अनुमान	0.1	0.01	0.01	0.01	0.20	0.01	0.01	0.60	0.03	0.02

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

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

हम जिस दूसरी मेट्रिक पर नज़र रखेंगे वह accuracy है. क्लासिफ़िकेशन की समस्या के लिए, यह सभी अनुमानों में से सही अनुमानों का प्रतिशत होता है.

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

नीचे दिए गए फ़ंक्शन को अपनी script.js फ़ाइल में कॉपी करें.

async function train(model, data) {
  const metrics = ['loss', 'val_loss', 'acc', 'val_acc'];
  const container = {
    name: 'Model Training', tab: 'Model', styles: { height: '1000px' }
  };
  const fitCallbacks = tfvis.show.fitCallbacks(container, metrics);
  
  const BATCH_SIZE = 512;
  const TRAIN_DATA_SIZE = 5500;
  const TEST_DATA_SIZE = 1000;

  const [trainXs, trainYs] = tf.tidy(() => {
    const d = data.nextTrainBatch(TRAIN_DATA_SIZE);
    return [
      d.xs.reshape([TRAIN_DATA_SIZE, 28, 28, 1]),
      d.labels
    ];
  });

  const [testXs, testYs] = tf.tidy(() => {
    const d = data.nextTestBatch(TEST_DATA_SIZE);
    return [
      d.xs.reshape([TEST_DATA_SIZE, 28, 28, 1]),
      d.labels
    ];
  });

  return model.fit(trainXs, trainYs, {
    batchSize: BATCH_SIZE,
    validationData: [testXs, testYs],
    epochs: 10,
    shuffle: true,
    callbacks: fitCallbacks
  });
}

इसके बाद, यहां दिया गया कोड

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

const model = getModel();
tfvis.show.modelSummary({name: 'Model Architecture', tab: 'Model'}, model);
  
await train(model, data);

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

आइए, इसके बारे में थोड़ी और जानकारी पाएं.

मेट्रिक मॉनिटर करना

const metrics = ['loss', 'val_loss', 'acc', 'val_acc'];

यहां हम यह तय करते हैं कि हमें किन मेट्रिक को मॉनिटर करना है. हम ट्रेनिंग सेट के साथ-साथ पुष्टि करने वाले सेट (val_loss और val_acc) पर भी नुकसान और सटीकता की निगरानी करेंगे. हम यहां पुष्टि करने वाले सेट के बारे में ज़्यादा जानकारी देंगे.

डेटा को टेंसर के तौर पर तैयार करना

const BATCH_SIZE = 512;
const TRAIN_DATA_SIZE = 5500;
const TEST_DATA_SIZE = 1000;

const [trainXs, trainYs] = tf.tidy(() => {
  const d = data.nextTrainBatch(TRAIN_DATA_SIZE);
  return [
    d.xs.reshape([TRAIN_DATA_SIZE, 28, 28, 1]),
    d.labels
  ];
});

const [testXs, testYs] = tf.tidy(() => {
  const d = data.nextTestBatch(TEST_DATA_SIZE);
  return [
    d.xs.reshape([TEST_DATA_SIZE, 28, 28, 1]),
    d.labels
  ];
});

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

हमने जो डेटा क्लास दी है उसकी मदद से, इमेज डेटा से आसानी से टेंसर पाए जा सकते हैं. हालांकि, मॉडल को इनपुट देने से पहले, हम अब भी टेंसर को मॉडल के हिसाब से [num_examples, image_width, image_height, channels] के आकार में बदलते हैं. हर डेटासेट के लिए, हमारे पास इनपुट (X) और लेबल (Y) दोनों होते हैं.

return model.fit(trainXs, trainYs, {
  batchSize: BATCH_SIZE,
  validationData: [testXs, testYs],
  epochs: 10,
  shuffle: true,
  callbacks: fitCallbacks
});

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

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

7. हमारे मॉडल का आकलन करना

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

tfjs-vis में ऐसे कई तरीके हैं जिनसे आपको इस काम में मदद मिल सकती है.

नीचे दिए गए कोड को अपनी script.js फ़ाइल के सबसे नीचे जोड़ें

const classNames = ['Zero', 'One', 'Two', 'Three', 'Four', 'Five', 'Six', 'Seven', 'Eight', 'Nine'];

function doPrediction(model, data, testDataSize = 500) {
  const IMAGE_WIDTH = 28;
  const IMAGE_HEIGHT = 28;
  const testData = data.nextTestBatch(testDataSize);
  const testxs = testData.xs.reshape([testDataSize, IMAGE_WIDTH, IMAGE_HEIGHT, 1]);
  const labels = testData.labels.argMax(-1);
  const preds = model.predict(testxs).argMax(-1);

  testxs.dispose();
  return [preds, labels];
}


async function showAccuracy(model, data) {
  const [preds, labels] = doPrediction(model, data);
  const classAccuracy = await tfvis.metrics.perClassAccuracy(labels, preds);
  const container = {name: 'Accuracy', tab: 'Evaluation'};
  tfvis.show.perClassAccuracy(container, classAccuracy, classNames);

  labels.dispose();
}

async function showConfusion(model, data) {
  const [preds, labels] = doPrediction(model, data);
  const confusionMatrix = await tfvis.metrics.confusionMatrix(labels, preds);
  const container = {name: 'Confusion Matrix', tab: 'Evaluation'};
  tfvis.render.confusionMatrix(container, {values: confusionMatrix, tickLabels: classNames});

  labels.dispose();
}

यह कोड क्या कर रहा है?

पूर्वानुमान लगाता है.
यह कुकी, सटीक होने की मेट्रिक का हिसाब लगाती है.
मेट्रिक दिखाता है

आइए, हर चरण के बारे में ज़्यादा जानें.

अनुमान लगाना

function doPrediction(model, data, testDataSize = 500) {
  const IMAGE_WIDTH = 28;
  const IMAGE_HEIGHT = 28;
  const testData = data.nextTestBatch(testDataSize);
  const testxs = testData.xs.reshape([testDataSize, IMAGE_WIDTH, IMAGE_HEIGHT, 1]);
  const labels = testData.labels.argMax(-1);
  const preds = model.predict(testxs).argMax(-1);

  testxs.dispose();
  return [preds, labels];
}

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

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

आपको यह भी दिख सकता है कि हम सभी 500 उदाहरणों के लिए एक साथ अनुमान लगा सकते हैं. यह वेक्टर बनाने की ऐसी सुविधा है जो TensorFlow.js देता है.

ध्यान दें: हम यहां किसी भी संभावना थ्रेशोल्ड का इस्तेमाल नहीं करते हैं. हम सबसे ज़्यादा वैल्यू को चुनते हैं, भले ही वह वैल्यू कम हो. इस प्रोजेक्ट को और बेहतर बनाने के लिए, कम से कम ज़रूरी संभावना सेट की जा सकती है. साथ ही, अगर कोई क्लास इस क्लासिफ़िकेशन थ्रेशोल्ड को पूरा नहीं करती है, तो 'कोई अंक नहीं मिला' दिखाया जा सकता है.

हर क्लास के हिसाब से सटीकता दिखाएं

async function showAccuracy() {
  const [preds, labels] = doPrediction();
  const classAccuracy = await tfvis.metrics.perClassAccuracy(labels, preds);
  const container = { name: 'Accuracy', tab: 'Evaluation' };
  tfvis.show.perClassAccuracy(container, classAccuracy, classNames);

  labels.dispose();
}

अनुमानों और लेबल के सेट की मदद से, हम हर क्लास के लिए सटीकता का हिसाब लगा सकते हैं.

कन्फ़्यूज़न मैट्रिक्स दिखाओ

async function showConfusion() {
  const [preds, labels] = doPrediction();
  const confusionMatrix = await tfvis.metrics.confusionMatrix(labels, preds);
  const container = { name: 'Confusion Matrix', tab: 'Evaluation' };
  tfvis.render.confusionMatrix(container, {values: confusionMatrix, tickLabels: classNames});

  labels.dispose();
}

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

ब्यौरेदार जानकारी दिखाना

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

await showAccuracy(model, data);
await showConfusion(model, data);

आपको कुछ ऐसा डिसप्ले दिखेगा.

बधाई हो! आपने अभी-अभी एक कनवोल्यूशनल न्यूरल नेटवर्क को ट्रेन किया है!

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

इनपुट डेटा के लिए कैटगरी का अनुमान लगाने को क्लासिफ़िकेशन टास्क कहा जाता है.

क्लासिफ़िकेशन टास्क के लिए, लेबल के हिसाब से डेटा को सही तरीके से दिखाना ज़रूरी है

लेबल को आम तौर पर, कैटगरी की वन-हॉट एन्कोडिंग के तौर पर दिखाया जाता है

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

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

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

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

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

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