TensorFlow.js — إجراء التنبؤات من البيانات ثنائية الأبعاد

1. مقدمة

في هذا الدرس التطبيقي، ستدرّب نموذجًا لتقديم توقّعات من بيانات بالأرقام تصف مجموعة من السيارات.

سيوضّح هذا التمرين الخطوات الشائعة لتدريب العديد من أنواع النماذج المختلفة، ولكن سيتم استخدام مجموعة بيانات صغيرة ونموذج بسيط (سطحي). الهدف الأساسي هو مساعدتك في التعرّف على المصطلحات والمفاهيم وبنية الجمل الأساسية المتعلقة بتدريب النماذج باستخدام TensorFlow.js، وتوفير نقطة انطلاق لمزيد من الاستكشاف والتعلّم.

بما أنّنا ندرّب نموذجًا لتوقّع أرقام متواصلة، يُشار إلى هذه المهمة أحيانًا باسم مهمة انحدار. سندرب النموذج من خلال عرض العديد من الأمثلة على المدخلات مع المخرجات الصحيحة. يُشار إلى ذلك باسم التعلم المُوجّه.

ما ستنشئه

ستنشئ صفحة ويب تستخدم TensorFlow.js لتدريب نموذج في المتصفح. إذا تم إدخال "قوة حصانية" لسيارة، سيتعلّم النموذج كيفية توقّع "المسافة المقطوعة لكل غالون" (MPG).

لإجراء ذلك، عليك اتّباع الخطوات التالية:

حمِّل البيانات وجهِّزها لاستخدامها في التدريب.
حدِّد بنية النموذج.
درِّب النموذج وراقِب أدائه أثناء التدريب.
قيِّم النموذج المدرَّب من خلال وضع بعض التوقعات.

ما ستتعلمه

أفضل الممارسات لإعداد البيانات من أجل تعلُّم الآلة، بما في ذلك التبديل والتسوية
بنية TensorFlow.js لإنشاء نماذج باستخدام tf.layers API
كيفية مراقبة التدريب داخل المتصفّح باستخدام مكتبة tfjs-vis

المتطلبات

إصدار حديث من Chrome أو متصفّح حديث آخر
أداة تعديل النصوص، سواء كانت تعمل على جهازك أو على الويب من خلال خدمة مثل Codepen أو Glitch
معرفة HTML وCSS وJavaScript وأدوات مطوّري البرامج في Chrome (أو أدوات مطوّري البرامج في المتصفّحات المفضّلة لديك)
فهم مفاهيمي رفيع المستوى للشبكات العصبية إذا كنت بحاجة إلى مقدّمة أو تنشيط للذاكرة، ننصحك بمشاهدة هذا الفيديو من قناة 3blue1brown أو هذا الفيديو حول التعلّم العميق في JavaScript من Ashi Krishnan.

2. طريقة الإعداد

إنشاء صفحة HTML وتضمين JavaScript

انسخ الرمز التالي في ملف 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>

إنشاء ملف JavaScript للرمز

في المجلد نفسه الذي يحتوي على ملف HTML أعلاه، أنشئ ملفًا باسم script.js وضَع فيه الرمز التالي.

console.log('Hello TensorFlow');

تجربة الميزة

بعد إنشاء ملفات HTML وJavaScript، اختبِرها. افتح ملف index.html في المتصفّح وافتح وحدة تحكّم أدوات المطوّرين.

إذا كان كل شيء يعمل بشكل صحيح، من المفترض أن يتم إنشاء متغيّرَين عامَّين وتوفيرهما في وحدة تحكّم أدوات المطوّرين:

‫tf هي إشارة إلى مكتبة TensorFlow.js
‫tfvis هو مرجع إلى مكتبة tfjs-vis

افتح أدوات المطوّرين في المتصفّح، وسيظهر لك في ناتج وحدة التحكّم رسالة تقول Hello TensorFlow. إذا كان الأمر كذلك، تكون مستعدًا للانتقال إلى الخطوة التالية.

3- تحميل بيانات الإدخال وتنسيقها وعرضها بشكل مرئي

في الخطوة الأولى، لنحمّل البيانات التي نريد تدريب النموذج عليها وننسّقها ونعرضها بشكل مرئي.

سنحمّل مجموعة بيانات "السيارات" من ملف 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}));

ينشئ الرمز البرمجي أعلاه الطبقة النهائية. نضبط units على 1 لأنّنا نريد عرض الرقم 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]);

في هذا المثال، ننشئ مصفوفتَين، إحداهما لأمثلة الإدخال (إدخالات القدرة الحصانية)، والأخرى لقيم الإخراج الصحيحة (المعروفة باسم التصنيفات في تعلُّم الآلة).

بعد ذلك، نحول كل بيانات مصفوفة إلى متّجه متعدّد الأبعاد ثنائي الأبعاد. سيكون شكل المتّجه [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 ستحقّق المزيد من النجاح في تدريب نماذجك إذا اعتدت على تسوية بياناتك إلى نطاق معقول.

إرجاع البيانات وحدود التنميط

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 وعددًا من الحِقب:

يشير 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 لإنشاء دوال ترسم مخططات لمقياسَي "الخسارة" و"متوسط الخطأ التربيعي" اللذين حدّدناهما سابقًا.

وضع كل العناصر معًا

الآن، علينا استدعاء الدوال التي حدّدناها من الدالة 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. لمزيد من المعلومات حول دوال التنشيط، اطّلِع على هذه المقالة.

تحقَّق مما إذا كان بإمكان النموذج إنشاء ناتج مشابه لما هو معروض في الصورة أدناه.