דגמים ושכבות

בשנת למידת מכונה, מודל הוא פונקציה עם ללמידת פרמטרים ממפה קלט פלט. הפרמטרים האופטימליים מתקבלים על ידי אימון המודל על נתונים. מודל מאומן היטב יספק מיפוי מדויק מהקלט לפלט הרצוי.

ב-TensorFlow.js יש שתי דרכים ליצור מודל למידת מכונה:

  1. באמצעות ה- API השכבות שבו אתה לבנות מודל באמצעות שכבות.
  2. באמצעות ה- API Core עם ops ברמה נמוכה כגון tf.matMul() , tf.add() , וכו '

ראשית, נבחן את Layers API, שהוא API ברמה גבוהה יותר לבניית מודלים. לאחר מכן, נראה כיצד לבנות את אותו מודל באמצעות Core API.

יצירת מודלים עם Layers API

ישנן שתי דרכים ליצור מודל באמצעות API שכבות: מודל סדרתי, ומודל פונקציונלי. שני הסעיפים הבאים בוחנים כל סוג מקרוב יותר.

המודל הרציף

הסוג הנפוץ ביותר של מודל הוא Sequential המודל, המהווה ערימה ליניארי של שכבות. אתה יכול ליצור Sequential מודל ידי העברת רשימת שכבות על sequential() פונקציה:

const model = tf.sequential({
 layers: [
   tf.layers.dense({inputShape: [784], units: 32, activation: 'relu'}),
   tf.layers.dense({units: 10, activation: 'softmax'}),
 ]
});

או דרך add() שיטה:

const model = tf.sequential();
model.add(tf.layers.dense({inputShape: [784], units: 32, activation: 'relu'}));
model.add(tf.layers.dense({units: 10, activation: 'softmax'}));

חשוב: השכבה הראשונה במודל זקוקה inputShape . הקפד לכלול את הגודל יצווה כאשר מתן inputShape . לדוגמה, אם אתם מתכננים להאכיל את המודל tensors בכושר [B, 784] , שבו B יכול להיות בכל גודל אצווה, ציין inputShape כפי [784] בעת יצירת המודל.

אתה יכול לגשת שכבות של המודל באמצעות model.layers , ובאופן ספציפי model.inputLayers ו model.outputLayers .

המודל הפונקציונלי

דרך נוספת ליצור LayersModel היא דרך tf.model() הפונקציה. ההבדל העיקרי בין tf.model() ו tf.sequential() הוא כי tf.model() מאפשר לך ליצור גרף שרירותי של שכבות, כל עוד אין להם מחזורים.

הנה קטע קוד שמגדיר אותו המודל כאמור באמצעות tf.model() API:

// Create an arbitrary graph of layers, by connecting them
// via the apply() method.
const input = tf.input({shape: [784]});
const dense1 = tf.layers.dense({units: 32, activation: 'relu'}).apply(input);
const dense2 = tf.layers.dense({units: 10, activation: 'softmax'}).apply(dense1);
const model = tf.model({inputs: input, outputs: dense2});

אנו קוראים apply() על כל שכבה כדי לחבר אותו פלט של עוד שכבה. התוצאה של apply() במקרה זה הוא SymbolicTensor , אשר מתנהג כמו Tensor אך ללא כל הערכים בטון.

לידיעתך, בשונה המודל הרציף, אנו יוצרים SymbolicTensor באמצעות tf.input() במקום מתן inputShape לשכבה הראשונה.

apply() גם יכול לתת לך בטון Tensor , אם תעבור את הבטון Tensor אליו:

const t = tf.tensor([-2, 1, 0, 5]);
const o = tf.layers.activation({activation: 'relu'}).apply(t);
o.print(); // [0, 1, 0, 5]

זה יכול להיות שימושי בעת בדיקת שכבות בבידוד וראיית הפלט שלהן.

בדיוק כמו במודל רציף, אתה יכול לגשת השכבות של המודל באמצעות model.layers , ובאופן ספציפי model.inputLayers ו model.outputLayers .

מַתַן תוֹקֵף

שניהם המודל הרציף והמודל הפונקציונלי מקרים של LayersModel בכיתה. אחד היתרונות הגדולים של עבודה עם LayersModel הוא אימות: זה מכריח אותך לציין את צורת הקלט יהיה להשתמש בו מאוחרת יותר לאמת הקלט שלך. LayersModel גם עושה היקש צורה אוטומטית את הנתונים זורמים דרך שכבות. הכרת הצורה מראש מאפשרת לדגם ליצור אוטומטית את הפרמטרים שלו, ויכולה לומר לך אם שתי שכבות עוקבות אינן תואמות זו לזו.

תקציר הדגם

התקשר model.summary() כדי להדפיס סיכום מועיל של המודל, הכוללת:

  • שם וסוג של כל השכבות בדגם.
  • צורת פלט עבור כל שכבה.
  • מספר פרמטרי משקל של כל שכבה.
  • אם למודל יש טופולוגיה כללית (נדון להלן), הכניסות שכל שכבה מקבלת
  • המספר הכולל של פרמטרים ניתנים לאימון ולא ניתנים לאימון של הדגם.

עבור הדגם שהגדרנו למעלה, נקבל את הפלט הבא בקונסולה:

שכבה (סוג) צורת פלט פראם מס'
צפוף_צפוף1 (צפוף) [null,32] 25120
dense_Dense2 (צפוף) [null,10] 330
סה"כ פרמים: 25450
פרמטרים ניתנים לאימון: 25450
פרמטרים שאינם ניתנים לאימון: 0

שים לב null ערכי צורות הפלט של השכבות: תזכורת שהמודל מצפה הקלט להיות בגודל יצווה כממד החיצוני ביותר, אשר במקרה זה יכול להיות גמיש בשל null הערך.

סדרה

אחד היתרונות הגדולים של שימוש LayersModel רחב API ברמה הנמוכה יותר הוא היכולת לשמור ולטעון מודל. LayersModel יודע על:

  • הארכיטקטורה של המודל, המאפשרת לך ליצור מחדש את המודל.
  • המשקלים של הדגם
  • תצורת האימון (הפסד, מייעל, מדדים).
  • מצב האופטימיזציה, המאפשר לך לחדש את האימון.

כדי לשמור או לטעון מודל זה רק שורת קוד אחת:

const saveResult = await model.save('localstorage://my-model-1');
const model = await tf.loadLayersModel('localstorage://my-model-1');

הדוגמה למעלה שומרת את הדגם לאחסון מקומי בדפדפן. עיין model.save() documentation ואת לשמור ולטעון להדריך אותך איך לחסוך מדיומים שונים (אחסון קבצים למשל, IndexedDB , לעורר הורדת דפדפן, וכו ')

שכבות מותאמות אישית

שכבות הן אבני הבניין של מודל. אם המודל שלך מבצע חישוב מותאם אישית, אתה יכול להגדיר שכבה מותאמת אישית, שמקיימת אינטראקציה טובה עם שאר השכבות. להלן מגדירים שכבה מותאמת אישית המחשבת את סכום הריבועים:

class SquaredSumLayer extends tf.layers.Layer {
 constructor() {
   super({});
 }
 // In this case, the output is a scalar.
 computeOutputShape(inputShape) { return []; }

 // call() is where we do the computation.
 call(input, kwargs) { return input.square().sum();}

 // Every layer needs a unique name.
 getClassName() { return 'SquaredSum'; }
}

כדי לנסות זאת, נוכל להתקשר apply() שיטה עם מותח בטון:

const t = tf.tensor([-2, 1, 0, 5]);
const o = new SquaredSumLayer().apply(t);
o.print(); // prints 30

חשוב: אם אתה מוסיף שכבה מותאמת אישית, אתה מאבד את היכולת להרכיב מודל בסידרה.

יצירת מודלים עם Core API

בתחילת המדריך הזה, הזכרנו שיש שתי דרכים ליצור מודל למידת מכונה ב-TensorFlow.js.

הכלל המנחה הוא לנסות תמיד להשתמש ב- API השכבות הראשונות, שכן הוא במתכונת API Keras היטב אימצה אשר עוקב אחר שיטות העבודה המומלצות ומפחית עומס קוגניטיבי . ה-API של Layers מציע גם פתרונות מדף שונים כגון אתחול משקל, סדרת מודלים, הדרכות ניטור, ניידות ובדיקת בטיחות.

ייתכן שתרצה להשתמש ב-Core API בכל פעם:

  • אתה צריך גמישות או שליטה מקסימלית.
  • אינך זקוק לסידרה, או שאתה יכול ליישם את היגיון ההסדרה שלך.

מודלים ב- API Core הן פונקציות רק כי לקחת אחד או יותר Tensors ולהחזיר Tensor . אותו דגם כמו לעיל שנכתב באמצעות Core API נראה כך:

// 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).softmax();
}

שימו לב שב-Core API אנחנו אחראים על יצירה ואתחול של משקלי המודל. כל משקל מגובה Variable אשר מאותת TensorFlow.js כי tensors אלה ללמידה. אתה יכול ליצור Variable באמצעות tf.variable () ו חולף קיים Tensor .

במדריך זה הכרת את הדרכים השונות ליצירת מודל באמצעות השכבות וה-Core API. הבא, לראות את הדגמים הכשרים להדריך אותך איך לאמן מודל.