این صفحه به‌وسیله ‏Cloud Translation API‏ ترجمه شده است.

TensorFlow.js - پیش بینی از داده های دو بعدی

۱. مقدمه

در این آزمایشگاه کد، شما یک مدل را آموزش خواهید داد تا از داده‌های عددی که مجموعه‌ای از خودروها را توصیف می‌کنند، پیش‌بینی‌هایی انجام دهد.

این تمرین مراحل رایج برای آموزش انواع مختلف مدل‌ها را نشان می‌دهد، اما از یک مجموعه داده کوچک و یک مدل ساده (کم‌عمق) استفاده خواهد کرد. هدف اصلی این است که به شما کمک کند با اصطلاحات، مفاهیم و سینتکس اولیه پیرامون مدل‌های آموزشی با TensorFlow.js آشنا شوید و زمینه‌ای برای کاوش و یادگیری بیشتر فراهم کنید.

از آنجا که ما در حال آموزش یک مدل برای پیش‌بینی اعداد پیوسته هستیم، این وظیفه گاهی اوقات به عنوان یک وظیفه رگرسیون شناخته می‌شود. ما مدل را با نشان دادن نمونه‌های زیادی از ورودی‌ها به همراه خروجی صحیح آموزش خواهیم داد. به این روش، یادگیری نظارت شده گفته می‌شود.

آنچه خواهید ساخت

شما یک صفحه وب ایجاد خواهید کرد که از TensorFlow.js برای آموزش یک مدل در مرورگر استفاده می‌کند. با دریافت «اسب بخار» برای یک ماشین، مدل یاد می‌گیرد که «مایل بر گالن» (MPG) را پیش‌بینی کند.

برای انجام این کار شما:

داده‌ها را بارگذاری کرده و برای آموزش آماده کنید.
معماری مدل را تعریف کنید.
مدل را آموزش دهید و عملکرد آن را در حین آموزش زیر نظر بگیرید.
مدل آموزش‌دیده را با انجام برخی پیش‌بینی‌ها ارزیابی کنید.

آنچه یاد خواهید گرفت

بهترین شیوه‌ها برای آماده‌سازی داده‌ها برای یادگیری ماشین، شامل ترکیب داده‌ها (shuffling) و نرمال‌سازی (normalization).
سینتکس TensorFlow.js برای ایجاد مدل‌ها با استفاده از API tf.layers .
نحوه نظارت بر آموزش درون مرورگر با استفاده از کتابخانه tfjs-vis .

آنچه نیاز دارید

نسخه جدید کروم یا یک مرورگر مدرن دیگر.
یک ویرایشگر متن، چه به صورت محلی روی دستگاه شما اجرا شود و چه از طریق چیزی مانند Codepen یا Glitch روی وب اجرا شود.
آشنایی با HTML، CSS، جاوا اسکریپت و ابزارهای توسعه کروم (یا ابزارهای توسعه مرورگر مورد نظر شما).
درک مفهومی سطح بالا از شبکه‌های عصبی. اگر به مقدمه یا یادآوری نیاز دارید، تماشای این ویدیو از 3blue1brown یا این ویدیو در مورد یادگیری عمیق در جاوا اسکریپت از Ashi Krishnan را در نظر بگیرید.

۲. آماده شوید

یک صفحه HTML ایجاد کنید و جاوا اسکریپت را در آن قرار دهید

۹۶۹۱۴ff۶۵fc۳b۷۴c.png کد زیر را در یک فایل html با نام ``` کپی کنید.

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>

فایل جاوا اسکریپت را برای کد ایجاد کنید

در همان پوشه‌ای که فایل HTML بالا قرار دارد، فایلی به نام script.js ایجاد کنید و کد زیر را در آن قرار دهید.

console.log('Hello TensorFlow');

آن را آزمایش کنید

حالا که فایل‌های HTML و جاوا اسکریپت را ایجاد کرده‌اید، آن‌ها را آزمایش کنید. فایل index.html را در مرورگر خود باز کنید و کنسول devtools را باز کنید.

اگر همه چیز درست کار کند، باید دو متغیر سراسری ایجاد شده و در کنسول devtools در دسترس باشند:

tf ارجاعی به کتابخانه TensorFlow.js است.
tfvis ارجاعی به کتابخانه tfjs-vis است.

ابزارهای توسعه‌دهنده مرورگر خود را باز کنید. باید پیامی با عنوان Hello TensorFlow در خروجی کنسول مشاهده کنید. در این صورت، آماده رفتن به مرحله بعدی هستید.

۳. بارگذاری، قالب‌بندی و مصورسازی داده‌های ورودی

به عنوان اولین قدم، اجازه دهید داده‌هایی را که می‌خواهیم مدل را روی آنها آموزش دهیم، بارگذاری، قالب‌بندی و مصورسازی کنیم.

ما مجموعه داده "cars" را از یک فایل JSON که برای شما میزبانی کرده‌ایم، بارگذاری خواهیم کرد. این فایل شامل ویژگی‌های مختلف زیادی در مورد هر ماشین داده شده است. برای این آموزش، ما فقط می‌خواهیم داده‌های مربوط به اسب بخار و مایل در هر گالن را استخراج کنیم.

۹۶۹۱۴ff۶۵fc۳b۷۴c.png کد زیر را به قالب خود اضافه کنید

فایل 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;
}

این کار همچنین هر ورودی که نه مایل بر گالن و نه اسب بخار تعریف شده نداشته باشد را حذف می‌کند. بیایید این داده‌ها را در یک نمودار پراکندگی نیز رسم کنیم تا ببینیم چگونه به نظر می‌رسد.

۹۶۹۱۴ff۶۵fc۳b۷۴c.png کد زیر را به انتهای قالب خود اضافه کنید

فایل script.js .

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

وقتی صفحه را رفرش می‌کنید، باید پنلی در سمت چپ صفحه با نمودار پراکندگی داده‌ها ببینید. باید چیزی شبیه به این باشد.

این پنل به عنوان Visor شناخته می‌شود و توسط tfjs-vis ارائه شده است. این پنل مکان مناسبی برای نمایش تصاویر فراهم می‌کند.

به طور کلی هنگام کار با داده‌ها، ایده خوبی است که راه‌هایی برای بررسی داده‌ها و در صورت لزوم پاکسازی آنها پیدا کنید. در این مورد، ما مجبور شدیم ورودی‌های خاصی را از carsData که تمام فیلدهای مورد نیاز را نداشتند، حذف کنیم. تجسم داده‌ها می‌تواند به ما این حس را بدهد که آیا ساختاری در داده‌ها وجود دارد که مدل بتواند آن را یاد بگیرد یا خیر.

از نمودار بالا می‌توانیم ببینیم که بین اسب بخار و مصرف سوخت (MPG) همبستگی منفی وجود دارد، یعنی با افزایش اسب بخار، خودروها عموماً مسافت کمتری را به ازای هر گالن طی می‌کنند.

وظیفه خود را به صورت مفهومی بیان کنیم

داده‌های ورودی ما اکنون به این شکل خواهند بود.

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

هدف ما آموزش مدلی است که یک عدد ، اسب بخار، را دریافت کند و یاد بگیرد که یک عدد، مایل بر گالن، را پیش‌بینی کند. این نگاشت یک به یک را به خاطر داشته باشید، زیرا برای بخش بعدی مهم خواهد بود.

ما قصد داریم این مثال‌ها، اسب بخار و MPG، را به یک شبکه عصبی بدهیم که از این مثال‌ها یک فرمول (یا تابع) برای پیش‌بینی MPG با توجه به اسب بخار داده شده یاد می‌گیرد. این یادگیری از مثال‌هایی که برای آنها پاسخ‌های صحیح داریم ، یادگیری نظارت شده نامیده می‌شود .

۴. معماری مدل را تعریف کنید

در این بخش، کدی برای توصیف معماری مدل خواهیم نوشت. معماری مدل صرفاً روشی فانتزی برای بیان این است که «مدل هنگام اجرا، کدام توابع را اجرا خواهد کرد» یا به عبارت دیگر «مدل ما از چه الگوریتمی برای محاسبه پاسخ‌های خود استفاده خواهد کرد» .

مدل‌های یادگیری ماشین الگوریتم‌هایی هستند که ورودی را دریافت کرده و خروجی تولید می‌کنند. هنگام استفاده از شبکه‌های عصبی، الگوریتم مجموعه‌ای از لایه‌های نورون‌ها با «وزن‌ها» (اعداد) است که خروجی آنها را کنترل می‌کنند. فرآیند آموزش، مقادیر ایده‌آل برای آن وزن‌ها را یاد می‌گیرد.

۹۶۹۱۴ff۶۵fc۳b۷۴c.png تابع زیر را به برنامه خود اضافه کنید

فایل 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 است زیرا ورودی‌های آن مستقیماً به خروجی آن جریان می‌یابند. انواع دیگر مدل‌ها می‌توانند شاخه یا حتی چندین ورودی و خروجی داشته باشند، اما در بسیاری از موارد مدل‌های شما ترتیبی خواهند بود. مدل‌های ترتیبی همچنین دارای API با کاربرد آسان‌تری هستند.

لایه‌ها را اضافه کنید

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

این یک لایه ورودی به شبکه ما اضافه می‌کند که به طور خودکار به یک لایه dense با یک واحد پنهان متصل می‌شود. یک لایه dense نوعی لایه است که ورودی‌های خود را در یک ماتریس (به نام وزن‌ها ) ضرب می‌کند و سپس یک عدد (به نام بایاس ) به نتیجه اضافه می‌کند. از آنجایی که این اولین لایه شبکه است، باید inputShape خود را تعریف کنیم. inputShape برابر با [1] است زیرا ما 1 عدد به عنوان ورودی خود داریم (اسب بخار یک ماشین معین).

units تعیین می‌کنند که ماتریس وزن در لایه چقدر بزرگ باشد. با تنظیم آن روی ۱ در اینجا، می‌گوییم که برای هر یک از ویژگی‌های ورودی داده‌ها، ۱ وزن وجود خواهد داشت.

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

کد بالا لایه خروجی ما را ایجاد می‌کند. ما units روی 1 تنظیم می‌کنیم زیرا می‌خواهیم 1 عدد را در خروجی نمایش دهیم.

یک نمونه ایجاد کنید

۹۶۹۱۴ff۶۵fc۳b۷۴c.png کد زیر را به آن اضافه کنید

تابعی را که قبلاً تعریف کردیم، run .

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

این یک نمونه از مدل ایجاد می‌کند و خلاصه‌ای از لایه‌های موجود در صفحه وب را نشان می‌دهد.

۵. داده‌ها را برای آموزش آماده کنید

برای بهره‌مندی از مزایای عملکردی TensorFlow.js که آموزش مدل‌های یادگیری ماشین را عملی می‌کند، باید داده‌های خود را به تانسور تبدیل کنیم. همچنین تعدادی تبدیل روی داده‌های خود انجام خواهیم داد که بهترین شیوه‌ها هستند، یعنی درهم‌آمیختگی (shuffling) و نرمال‌سازی (normalization ).

۹۶۹۱۴ff۶۵fc۳b۷۴c.png کد زیر را به قالب خود اضافه کنید

فایل 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]);

در اینجا ما دو آرایه می‌سازیم، یکی برای مثال‌های ورودی‌مان (ورودی‌های اسب بخار) و دیگری برای مقادیر خروجی واقعی (که در یادگیری ماشین به عنوان برچسب‌ها شناخته می‌شوند).

سپس هر داده آرایه را به یک تانسور دوبعدی تبدیل می‌کنیم. تانسور شکلی به صورت [num_examples, num_features_per_example] خواهد داشت. در اینجا ما inputs.length examples داریم و هر مثال دارای 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));

در مرحله بعد، ما یک روش برتر دیگر برای آموزش یادگیری ماشین انجام می‌دهیم. داده‌ها را نرمال‌سازی می‌کنیم. در اینجا داده‌ها را با استفاده از مقیاس‌بندی min-max در محدوده عددی 0-1 نرمال‌سازی می‌کنیم . نرمال‌سازی مهم است زیرا اجزای داخلی بسیاری از مدل‌های یادگیری ماشینی که با tensorflow.js خواهید ساخت، برای کار با اعدادی طراحی شده‌اند که خیلی بزرگ نیستند. محدوده‌های رایج برای نرمال‌سازی داده‌ها شامل 0 to 1 یا -1 to 1 است. اگر عادت کنید که داده‌های خود را در محدوده معقولی نرمال‌سازی کنید، در آموزش مدل‌های خود موفقیت بیشتری خواهید داشت.

بهترین روش ۲ : همیشه باید نرمال‌سازی داده‌های خود را قبل از آموزش در نظر بگیرید. برخی از مجموعه داده‌ها را می‌توان بدون نرمال‌سازی یاد گرفت، اما نرمال‌سازی داده‌ها اغلب کل دسته از مشکلاتی را که مانع یادگیری مؤثر می‌شوند، از بین می‌برد.

شما می‌توانید داده‌های خود را قبل از تبدیل به تانسورها نرمال‌سازی کنید. ما این کار را بعداً انجام می‌دهیم زیرا می‌توانیم از برداری‌سازی در TensorFlow.js برای انجام عملیات مقیاس‌بندی حداقل-حداکثر بدون نوشتن هیچ حلقه for صریحی استفاده کنیم.

داده‌ها و محدوده‌های نرمال‌سازی را برگردانید

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

ما می‌خواهیم مقادیری را که برای نرمال‌سازی در طول آموزش استفاده کردیم، حفظ کنیم تا بتوانیم خروجی‌ها را از حالت نرمال خارج کنیم و آنها را به مقیاس اصلی خود برگردانیم و به ما امکان دهد داده‌های ورودی آینده را نیز به همین روش نرمال‌سازی کنیم.

۶. مدل را آموزش دهید

با ایجاد نمونه مدل و نمایش داده‌ها به صورت تانسور، همه چیز برای شروع فرآیند آموزش آماده است.

۹۶۹۱۴ff۶۵fc۳b۷۴c.png تابع زیر را در فایل خود کپی کنید

فایل script.js .

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 موجود است. در اینجا ما بهینه‌ساز adam را انتخاب کرده‌ایم زیرا در عمل کاملاً مؤثر است و نیازی به پیکربندی ندارد.
loss : این تابعی است که به مدل می‌گوید در یادگیری هر یک از دسته‌ها (زیرمجموعه‌های داده) که نشان داده می‌شود، چقدر خوب عمل می‌کند. در اینجا ما meanSquaredError برای مقایسه پیش‌بینی‌های انجام شده توسط مدل با مقادیر واقعی استفاده می‌کنیم.

const batchSize = 32;
const epochs = 50;

سپس یک batchSize و تعدادی epoch انتخاب می‌کنیم:

batchSize به اندازه زیرمجموعه‌های داده‌ای اشاره دارد که مدل در هر تکرار آموزش مشاهده خواهد کرد. اندازه‌های دسته‌ای رایج معمولاً در محدوده ۳۲ تا ۵۱۲ هستند. در واقع یک اندازه دسته ایده‌آل برای همه مسائل وجود ندارد و توصیف انگیزه‌های ریاضی برای اندازه‌های مختلف دسته، فراتر از محدوده این آموزش است.
epochs به تعداد دفعاتی اشاره دارد که مدل قرار است کل مجموعه داده‌ای را که شما در اختیارش قرار می‌دهید، بررسی کند. در اینجا ما ۵۰ تکرار را در مجموعه داده انجام خواهیم داد.

حلقه قطار را شروع کنید

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

model.fit تابعی است که برای شروع حلقه آموزش فراخوانی می‌کنیم. این یک تابع ناهمزمان است، بنابراین ما promiseای را که به ما می‌دهد برمی‌گردانیم تا فراخواننده بتواند زمان تکمیل آموزش را تعیین کند.

برای نظارت بر پیشرفت آموزش، چند تابع فراخوانی به model.fit ارسال می‌کنیم. tfvis.show.fitCallbacks برای تولید توابعی استفاده می‌کنیم که نمودارهایی را برای معیارهای «loss» و «mse» که قبلاً مشخص کرده‌ایم، رسم می‌کنند.

همه را کنار هم بگذارید

حالا باید توابعی که تعریف کرده‌ایم را از تابع run فراخوانی کنیم.

۹۶۹۱۴ff۶۵fc۳b۷۴c.png کد زیر را به انتهای قالب خود اضافه کنید

تابع را 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');

وقتی صفحه را رفرش می‌کنید، پس از چند ثانیه باید نمودارهای زیر را در حال به‌روزرسانی ببینید.

این‌ها توسط توابع فراخوانی که قبلاً ایجاد کردیم ایجاد می‌شوند. آن‌ها در پایان هر دوره، میانگین زیان و mse را در کل مجموعه داده‌ها نمایش می‌دهند.

هنگام آموزش یک مدل، می‌خواهیم شاهد کاهش میزان تلفات باشیم. در این مورد، از آنجا که معیار ما معیار خطا است، می‌خواهیم شاهد کاهش آن نیز باشیم.

۷. پیش‌بینی کنید

حالا که مدل ما آموزش دیده است، می‌خواهیم پیش‌بینی‌هایی انجام دهیم. بیایید مدل را با دیدن آنچه که برای طیف یکنواختی از تعداد اسب بخارهای کم تا زیاد پیش‌بینی می‌کند، ارزیابی کنیم.

۹۶۹۱۴ff۶۵fc۳b۷۴c.png تابع زیر را به فایل 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]));

ما ۱۰۰ «مثال» جدید برای تغذیه مدل تولید می‌کنیم. 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);

برای برگرداندن داده‌ها به محدوده اصلی خود (به جای ۰-۱)، از مقادیری که هنگام نرمال‌سازی محاسبه کرده‌ایم استفاده می‌کنیم، اما فقط عملیات را معکوس می‌کنیم.

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

.dataSync() ‎ روشی است که می‌توانیم برای دریافت یک typedarray از مقادیر ذخیره شده در یک تانسور از آن استفاده کنیم. این به ما امکان می‌دهد تا آن مقادیر را در جاوا اسکریپت معمولی پردازش کنیم. این یک نسخه همگام از روش .data() ‎ است که عموماً ترجیح داده می‌شود.

در نهایت از tfjs-vis برای رسم نمودار داده‌های اصلی و پیش‌بینی‌های مدل استفاده می‌کنیم.

۹۶۹۱۴ff۶۵fc۳b۷۴c.png کد زیر را به قالب خود اضافه کنید

تابع را run .

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

صفحه را رفرش کنید. پس از اتمام آموزش مدل، باید چیزی شبیه به تصویر زیر را مشاهده کنید.

تبریک! شما به تازگی یک مدل یادگیری ماشین ساده را آموزش داده‌اید. در حال حاضر، این مدل چیزی را که به عنوان رگرسیون خطی شناخته می‌شود، انجام می‌دهد که سعی می‌کند یک خط را با روند موجود در داده‌های ورودی تطبیق دهد.

۸. نکات اصلی

مراحل آموزش یک مدل یادگیری ماشین شامل موارد زیر است:

وظیفه خود را تدوین کنید:

آیا این یک مسئله رگرسیون است یا یک مسئله طبقه‌بندی؟
آیا می‌توان این کار را با یادگیری نظارت‌شده یا یادگیری بدون نظارت انجام داد؟
شکل داده‌های ورودی چگونه است؟ داده‌های خروجی باید چگونه باشند؟

داده‌های خود را آماده کنید:

داده‌ها را پاکسازی کنید و در صورت امکان، الگوها را به صورت دستی بررسی کنید
قبل از استفاده از داده‌ها برای آموزش، آنها را به هم بریزید (یا تغییر دهید)
داده‌های خود را در یک محدوده‌ی معقول برای شبکه‌ی عصبی نرمال‌سازی کنید. معمولاً ۰-۱ یا -۱-۱ محدوده‌های خوبی برای داده‌های عددی هستند.
تبدیل داده‌ها به تانسورها

مدل خود را بسازید و اجرا کنید:

مدل خود را با استفاده از tf.sequential یا tf.model تعریف کنید و سپس با استفاده از tf.layers.*
یک بهینه‌ساز (که معمولاً adam گزینه‌ی خوبی است) و پارامترهایی مانند اندازه‌ی دسته و تعداد دوره‌ها (epoch) انتخاب کنید.
یک تابع زیان مناسب برای مسئله خود و یک معیار دقت برای کمک به ارزیابی پیشرفت خود انتخاب کنید. meanSquaredError یک تابع زیان رایج برای مسائل رگرسیون است.
آموزش را زیر نظر داشته باشید تا ببینید آیا ضرر کاهش می‌یابد یا خیر

مدل خود را ارزیابی کنید

یک معیار ارزیابی برای مدل خود انتخاب کنید که بتوانید در حین آموزش آن را رصد کنید. پس از آموزش، سعی کنید چند پیش‌بینی آزمایشی انجام دهید تا از کیفیت پیش‌بینی‌ها مطلع شوید.

۹. امتیاز اضافی: چیزهایی که باید امتحان کنید

تغییر تعداد دوره‌ها را آزمایش کنید. قبل از اینکه نمودار مسطح شود، به چند دوره نیاز دارید؟
با افزایش تعداد واحدها در لایه پنهان آزمایش کنید.
با اضافه کردن لایه‌های پنهان بیشتر بین اولین لایه پنهانی که اضافه کردیم و لایه خروجی نهایی، آزمایش کنید. کد این لایه‌های اضافی باید چیزی شبیه به این باشد.

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

مهمترین نکته جدید در مورد این لایه‌های پنهان این است که آنها یک تابع فعال‌سازی غیرخطی، در این مورد فعال‌سازی سیگموئید ، را معرفی می‌کنند. برای کسب اطلاعات بیشتر در مورد توابع فعال‌سازی، به این مقاله مراجعه کنید .

ببینید آیا می‌توانید مدل را وادار کنید تا خروجی مانند تصویر زیر تولید کند یا خیر.