הצג באתר TensorFlow.org

הפעל בגוגל קולאב

צפה במקור ב-GitHub

הורד מחברת

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

שימושי ספריית Maker דגם להעברה למידה כדי לפשט את תהליך הכשרת מודל לייט TensorFlow באמצעות בסיס נתון מנהג. אימון מחדש של מודל TensorFlow Lite עם מערך נתונים מותאם אישית משלך מפחית את כמות נתוני האימון הנדרשים ויקצר את זמן האימון.

תשתמש במערך הסלטים הזמין לציבור, אשר נוצר מן פתח תמונות מערך הנתונים V4 .

כל תמונה במערך הנתונים מכילה אובייקטים המסומנים כאחת מהמחלקות הבאות:

• נאפה טוב
• גבינה
• סלט
• פירות ים
• עגבנייה

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

הנה תמונה לדוגמה מתוך מערך הנתונים:

דרישות מוקדמות

התקן את החבילות הנדרשות

התחל על ידי התקנת חבילות הנדרשים, ובכלל זה חבילת Maker דגם מן ריפו GitHub והספרייה pycocotools תשתמש לצורך הערכה.

pip install -q --use-deprecated=legacy-resolver tflite-model-maker
pip install -q pycocotools

ייבא את החבילות הנדרשות.

import numpy as np
import os

from tflite_model_maker.config import QuantizationConfig
from tflite_model_maker.config import ExportFormat
from tflite_model_maker import model_spec
from tflite_model_maker import object_detector

import tensorflow as tf
assert tf.__version__.startswith('2')

tf.get_logger().setLevel('ERROR')
from absl import logging
logging.set_verbosity(logging.ERROR)

/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/pkg_resources/__init__.py:119: PkgResourcesDeprecationWarning: 0.18ubuntu0.18.04.1 is an invalid version and will not be supported in a future release
  PkgResourcesDeprecationWarning,
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/numba/core/errors.py:154: UserWarning: Insufficiently recent colorama version found. Numba requires colorama >= 0.3.9
  warnings.warn(msg)

הכן את מערך הנתונים

כאן תוכלו להשתמש באותו מערך נתונים כמו AutoML QuickStart .

הסלטים במערך זמין בכתובת: gs://cloud-ml-data/img/openimage/csv/salads_ml_use.csv .

הוא מכיל 175 תמונות לאימון, 25 תמונות לאימות ו-25 תמונות לבדיקה. יש מערך הנתונים של חמש כיתות: Salad , Seafood , Tomato , Baked goods , Cheese .

מערך הנתונים מסופק בפורמט CSV:

TRAINING,gs://cloud-ml-data/img/openimage/3/2520/3916261642_0a504acd60_o.jpg,Salad,0.0,0.0954,,,0.977,0.957,,
VALIDATION,gs://cloud-ml-data/img/openimage/3/2520/3916261642_0a504acd60_o.jpg,Seafood,0.0154,0.1538,,,1.0,0.802,,
TEST,gs://cloud-ml-data/img/openimage/3/2520/3916261642_0a504acd60_o.jpg,Tomato,0.0,0.655,,,0.231,0.839,,

• כל שורה מתאימה לאובייקט הממוקם בתוך תמונה גדולה יותר, כאשר כל אובייקט מוגדר באופן ספציפי כנתוני בדיקה, רכבת או אימות. תוכל ללמוד עוד על המשמעות של זה בשלב מאוחר יותר במחברת זו.
• שלוש השורות כלולים כאן מצביעים שלושה עצמים נפרדים הממוקמים בתוך אותה תמונה זמין ב gs://cloud-ml-data/img/openimage/3/2520/3916261642_0a504acd60_o.jpg .
• יש כל שורה תווית אחרת: Salad , Seafood , Tomato , וכו '
• תיבות תוחמות מצוינות עבור כל תמונה באמצעות הקודקודים השמאלי העליון והימני התחתון.

להלן תצוגה חזותית של שלושת השורות הללו:

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

אם אתה חדש ל- Google Cloud Print, אתה עשוי לתהות מה gs:// אמצעי URL. הם כתובות של קבצים המאוחסנים על Google Cloud Storage (GCS). אם אתם עושים את הקבצים שלך על ציבור GCS או לאמת לקוח שלך , מכונת הדגם יכולה לקרוא קבצים אלו באופן דומה לקבצים המקומיים שלך.

עם זאת, אינך צריך לשמור את התמונות שלך ב-Google Cloud כדי להשתמש ב-Model Maker. אתה יכול להשתמש בנתיב מקומי בקובץ ה-CSV שלך ו-Model Maker פשוט יעבוד.

התחלה מהירה

ישנם שישה שלבים לאימון מודל זיהוי עצמים:

שלב 1. בחר ארכיקטורת מודל לזיהוי אובייקט.

מדריך זה משתמש במודל EfficientDet-Lite0. EfficientDet-לייט [0-4] הם משפחה של מודלים זיהוי האובייקט ניידים / IOT ידידותי נגזר EfficientDet אדריכלות.

להלן הביצועים של כל דגמי EfficientDet-Lite בהשוואה זה לזה.

* גודל המודלים המקובצים במספרים שלמים.
** זמן האחזור נמדד ב-Pixel 4 באמצעות 4 שרשורים במעבד.
*** דיוק ממוצע הוא ה-mAP (דיוק ממוצע) במערך האימות של COCO 2017.

spec = model_spec.get('efficientdet_lite0')

שלב 2. טען את מערך הנתונים.

Model Maker ייקח נתוני קלט בפורמט CSV. השתמש object_detector.DataLoader.from_csv שיטת לטעון את הנתונים ולפצל אותם אימונים, תמונות אימות ובדיקה.

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

אתה יכול לטעון את קובץ ה-CSV ישירות מ-Google Cloud Storage, אך אינך צריך לשמור את התמונות שלך ב-Google Cloud כדי להשתמש ב-Model Maker. אתה יכול לציין קובץ CSV מקומי במחשב שלך, ו-Model Maker יעבוד מצוין.

train_data, validation_data, test_data = object_detector.DataLoader.from_csv('gs://cloud-ml-data/img/openimage/csv/salads_ml_use.csv')

שלב 3. אימון מודל TensorFlow עם נתוני האימון.

• שימושי מודל EfficientDet-Lite0 epochs = 50 כברירת מחדל, מה שאומר שזה יהיה לעבור את נתון הכשרים 50 פעמים. אתה יכול להסתכל על דיוק האימות במהלך האימון ולהפסיק מוקדם כדי למנוע התאמת יתר.
• סט batch_size = 8 כאן אז אתה תראה שזה לוקח 21 צעדים כדי לעבור 175 תמונות במערך ההדרכה.
• סט train_whole_model=True כדי לכוונן את המודל כולו ולא רק אימון שכבת הראש לשיפור דיוק. הפשרה היא שייתכן שייקח יותר זמן לאמן את הדגם.

model = object_detector.create(train_data, model_spec=spec, batch_size=8, train_whole_model=True, validation_data=validation_data)

Epoch 1/50
21/21 [==============================] - 48s 455ms/step - det_loss: 1.7625 - cls_loss: 1.1351 - box_loss: 0.0125 - reg_l2_loss: 0.0635 - loss: 1.8260 - learning_rate: 0.0090 - gradient_norm: 0.7406 - val_det_loss: 1.6586 - val_cls_loss: 1.1076 - val_box_loss: 0.0110 - val_reg_l2_loss: 0.0635 - val_loss: 1.7221
Epoch 2/50
21/21 [==============================] - 9s 452ms/step - det_loss: 1.6224 - cls_loss: 1.0936 - box_loss: 0.0106 - reg_l2_loss: 0.0635 - loss: 1.6860 - learning_rate: 0.0100 - gradient_norm: 0.8392 - val_det_loss: 1.5282 - val_cls_loss: 1.0231 - val_box_loss: 0.0101 - val_reg_l2_loss: 0.0635 - val_loss: 1.5917
Epoch 3/50
21/21 [==============================] - 11s 566ms/step - det_loss: 1.4834 - cls_loss: 1.0031 - box_loss: 0.0096 - reg_l2_loss: 0.0635 - loss: 1.5469 - learning_rate: 0.0099 - gradient_norm: 1.4031 - val_det_loss: 1.7022 - val_cls_loss: 1.2259 - val_box_loss: 0.0095 - val_reg_l2_loss: 0.0636 - val_loss: 1.7657
Epoch 4/50
21/21 [==============================] - 11s 541ms/step - det_loss: 1.2898 - cls_loss: 0.8467 - box_loss: 0.0089 - reg_l2_loss: 0.0636 - loss: 1.3534 - learning_rate: 0.0099 - gradient_norm: 1.8163 - val_det_loss: 1.5550 - val_cls_loss: 1.1171 - val_box_loss: 0.0088 - val_reg_l2_loss: 0.0636 - val_loss: 1.6185
Epoch 5/50
21/21 [==============================] - 20s 970ms/step - det_loss: 1.1272 - cls_loss: 0.7315 - box_loss: 0.0079 - reg_l2_loss: 0.0636 - loss: 1.1908 - learning_rate: 0.0098 - gradient_norm: 1.7106 - val_det_loss: 1.4876 - val_cls_loss: 1.0551 - val_box_loss: 0.0087 - val_reg_l2_loss: 0.0636 - val_loss: 1.5512
Epoch 6/50
21/21 [==============================] - 7s 364ms/step - det_loss: 1.0534 - cls_loss: 0.6823 - box_loss: 0.0074 - reg_l2_loss: 0.0636 - loss: 1.1170 - learning_rate: 0.0097 - gradient_norm: 1.8554 - val_det_loss: 1.1807 - val_cls_loss: 0.7640 - val_box_loss: 0.0083 - val_reg_l2_loss: 0.0636 - val_loss: 1.2443
Epoch 7/50
21/21 [==============================] - 12s 602ms/step - det_loss: 1.0153 - cls_loss: 0.6592 - box_loss: 0.0071 - reg_l2_loss: 0.0636 - loss: 1.0789 - learning_rate: 0.0096 - gradient_norm: 1.8227 - val_det_loss: 1.0752 - val_cls_loss: 0.6828 - val_box_loss: 0.0078 - val_reg_l2_loss: 0.0636 - val_loss: 1.1388
Epoch 8/50
21/21 [==============================] - 11s 519ms/step - det_loss: 0.9751 - cls_loss: 0.6304 - box_loss: 0.0069 - reg_l2_loss: 0.0636 - loss: 1.0387 - learning_rate: 0.0094 - gradient_norm: 1.7939 - val_det_loss: 1.0385 - val_cls_loss: 0.6612 - val_box_loss: 0.0075 - val_reg_l2_loss: 0.0636 - val_loss: 1.1021
Epoch 9/50
21/21 [==============================] - 12s 601ms/step - det_loss: 0.8982 - cls_loss: 0.5847 - box_loss: 0.0063 - reg_l2_loss: 0.0636 - loss: 0.9618 - learning_rate: 0.0093 - gradient_norm: 1.8244 - val_det_loss: 1.0142 - val_cls_loss: 0.6526 - val_box_loss: 0.0072 - val_reg_l2_loss: 0.0636 - val_loss: 1.0778
Epoch 10/50
21/21 [==============================] - 14s 691ms/step - det_loss: 0.9462 - cls_loss: 0.5986 - box_loss: 0.0070 - reg_l2_loss: 0.0636 - loss: 1.0098 - learning_rate: 0.0091 - gradient_norm: 1.9298 - val_det_loss: 0.9879 - val_cls_loss: 0.6335 - val_box_loss: 0.0071 - val_reg_l2_loss: 0.0636 - val_loss: 1.0515
Epoch 11/50
21/21 [==============================] - 11s 519ms/step - det_loss: 0.8871 - cls_loss: 0.5824 - box_loss: 0.0061 - reg_l2_loss: 0.0636 - loss: 0.9507 - learning_rate: 0.0089 - gradient_norm: 1.9898 - val_det_loss: 1.0021 - val_cls_loss: 0.6509 - val_box_loss: 0.0070 - val_reg_l2_loss: 0.0636 - val_loss: 1.0658
Epoch 12/50
21/21 [==============================] - 11s 549ms/step - det_loss: 0.8640 - cls_loss: 0.5624 - box_loss: 0.0060 - reg_l2_loss: 0.0636 - loss: 0.9277 - learning_rate: 0.0087 - gradient_norm: 1.9360 - val_det_loss: 1.0265 - val_cls_loss: 0.6728 - val_box_loss: 0.0071 - val_reg_l2_loss: 0.0636 - val_loss: 1.0901
Epoch 13/50
21/21 [==============================] - 11s 523ms/step - det_loss: 0.8405 - cls_loss: 0.5484 - box_loss: 0.0058 - reg_l2_loss: 0.0636 - loss: 0.9042 - learning_rate: 0.0085 - gradient_norm: 2.1855 - val_det_loss: 1.0291 - val_cls_loss: 0.6903 - val_box_loss: 0.0068 - val_reg_l2_loss: 0.0636 - val_loss: 1.0927
Epoch 14/50
21/21 [==============================] - 12s 572ms/step - det_loss: 0.8082 - cls_loss: 0.5297 - box_loss: 0.0056 - reg_l2_loss: 0.0636 - loss: 0.8718 - learning_rate: 0.0082 - gradient_norm: 1.9138 - val_det_loss: 0.9104 - val_cls_loss: 0.5838 - val_box_loss: 0.0065 - val_reg_l2_loss: 0.0636 - val_loss: 0.9740
Epoch 15/50
21/21 [==============================] - 14s 696ms/step - det_loss: 0.8106 - cls_loss: 0.5221 - box_loss: 0.0058 - reg_l2_loss: 0.0636 - loss: 0.8743 - learning_rate: 0.0080 - gradient_norm: 2.0386 - val_det_loss: 0.9510 - val_cls_loss: 0.6047 - val_box_loss: 0.0069 - val_reg_l2_loss: 0.0636 - val_loss: 1.0146
Epoch 16/50
21/21 [==============================] - 10s 474ms/step - det_loss: 0.7988 - cls_loss: 0.5177 - box_loss: 0.0056 - reg_l2_loss: 0.0636 - loss: 0.8624 - learning_rate: 0.0077 - gradient_norm: 2.1009 - val_det_loss: 0.9642 - val_cls_loss: 0.6307 - val_box_loss: 0.0067 - val_reg_l2_loss: 0.0637 - val_loss: 1.0278
Epoch 17/50
21/21 [==============================] - 12s 601ms/step - det_loss: 0.8057 - cls_loss: 0.5239 - box_loss: 0.0056 - reg_l2_loss: 0.0637 - loss: 0.8694 - learning_rate: 0.0075 - gradient_norm: 2.1718 - val_det_loss: 0.9152 - val_cls_loss: 0.5938 - val_box_loss: 0.0064 - val_reg_l2_loss: 0.0637 - val_loss: 0.9789
Epoch 18/50
21/21 [==============================] - 12s 609ms/step - det_loss: 0.7801 - cls_loss: 0.4993 - box_loss: 0.0056 - reg_l2_loss: 0.0637 - loss: 0.8437 - learning_rate: 0.0072 - gradient_norm: 2.1518 - val_det_loss: 0.9262 - val_cls_loss: 0.5967 - val_box_loss: 0.0066 - val_reg_l2_loss: 0.0637 - val_loss: 0.9899
Epoch 19/50
21/21 [==============================] - 12s 614ms/step - det_loss: 0.7595 - cls_loss: 0.4977 - box_loss: 0.0052 - reg_l2_loss: 0.0637 - loss: 0.8232 - learning_rate: 0.0069 - gradient_norm: 2.3707 - val_det_loss: 0.8870 - val_cls_loss: 0.5698 - val_box_loss: 0.0063 - val_reg_l2_loss: 0.0637 - val_loss: 0.9506
Epoch 20/50
21/21 [==============================] - 13s 632ms/step - det_loss: 0.7826 - cls_loss: 0.5115 - box_loss: 0.0054 - reg_l2_loss: 0.0637 - loss: 0.8463 - learning_rate: 0.0066 - gradient_norm: 2.4091 - val_det_loss: 0.8975 - val_cls_loss: 0.5811 - val_box_loss: 0.0063 - val_reg_l2_loss: 0.0637 - val_loss: 0.9611
Epoch 21/50
21/21 [==============================] - 9s 454ms/step - det_loss: 0.7434 - cls_loss: 0.4903 - box_loss: 0.0051 - reg_l2_loss: 0.0637 - loss: 0.8070 - learning_rate: 0.0063 - gradient_norm: 2.3592 - val_det_loss: 0.8526 - val_cls_loss: 0.5450 - val_box_loss: 0.0062 - val_reg_l2_loss: 0.0637 - val_loss: 0.9163
Epoch 22/50
21/21 [==============================] - 12s 600ms/step - det_loss: 0.7349 - cls_loss: 0.4803 - box_loss: 0.0051 - reg_l2_loss: 0.0637 - loss: 0.7986 - learning_rate: 0.0060 - gradient_norm: 2.3296 - val_det_loss: 0.8977 - val_cls_loss: 0.5602 - val_box_loss: 0.0068 - val_reg_l2_loss: 0.0637 - val_loss: 0.9614
Epoch 23/50
21/21 [==============================] - 12s 591ms/step - det_loss: 0.7190 - cls_loss: 0.4670 - box_loss: 0.0050 - reg_l2_loss: 0.0637 - loss: 0.7826 - learning_rate: 0.0056 - gradient_norm: 2.2218 - val_det_loss: 0.8986 - val_cls_loss: 0.5744 - val_box_loss: 0.0065 - val_reg_l2_loss: 0.0637 - val_loss: 0.9623
Epoch 24/50
21/21 [==============================] - 11s 553ms/step - det_loss: 0.7025 - cls_loss: 0.4588 - box_loss: 0.0049 - reg_l2_loss: 0.0637 - loss: 0.7661 - learning_rate: 0.0053 - gradient_norm: 2.4710 - val_det_loss: 0.8835 - val_cls_loss: 0.5701 - val_box_loss: 0.0063 - val_reg_l2_loss: 0.0637 - val_loss: 0.9472
Epoch 25/50
21/21 [==============================] - 14s 700ms/step - det_loss: 0.7462 - cls_loss: 0.4776 - box_loss: 0.0054 - reg_l2_loss: 0.0637 - loss: 0.8099 - learning_rate: 0.0050 - gradient_norm: 2.5728 - val_det_loss: 0.8594 - val_cls_loss: 0.5605 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.9231
Epoch 26/50
21/21 [==============================] - 10s 482ms/step - det_loss: 0.7219 - cls_loss: 0.4731 - box_loss: 0.0050 - reg_l2_loss: 0.0637 - loss: 0.7856 - learning_rate: 0.0047 - gradient_norm: 2.4891 - val_det_loss: 0.8701 - val_cls_loss: 0.5630 - val_box_loss: 0.0061 - val_reg_l2_loss: 0.0637 - val_loss: 0.9338
Epoch 27/50
21/21 [==============================] - 11s 543ms/step - det_loss: 0.6914 - cls_loss: 0.4505 - box_loss: 0.0048 - reg_l2_loss: 0.0637 - loss: 0.7551 - learning_rate: 0.0044 - gradient_norm: 2.3125 - val_det_loss: 0.8986 - val_cls_loss: 0.5850 - val_box_loss: 0.0063 - val_reg_l2_loss: 0.0637 - val_loss: 0.9623
Epoch 28/50
21/21 [==============================] - 13s 630ms/step - det_loss: 0.7018 - cls_loss: 0.4516 - box_loss: 0.0050 - reg_l2_loss: 0.0637 - loss: 0.7655 - learning_rate: 0.0040 - gradient_norm: 2.7033 - val_det_loss: 0.8693 - val_cls_loss: 0.5590 - val_box_loss: 0.0062 - val_reg_l2_loss: 0.0637 - val_loss: 0.9330
Epoch 29/50
21/21 [==============================] - 11s 529ms/step - det_loss: 0.6712 - cls_loss: 0.4463 - box_loss: 0.0045 - reg_l2_loss: 0.0637 - loss: 0.7349 - learning_rate: 0.0037 - gradient_norm: 2.3739 - val_det_loss: 0.8901 - val_cls_loss: 0.5790 - val_box_loss: 0.0062 - val_reg_l2_loss: 0.0637 - val_loss: 0.9538
Epoch 30/50
21/21 [==============================] - 15s 735ms/step - det_loss: 0.6619 - cls_loss: 0.4346 - box_loss: 0.0045 - reg_l2_loss: 0.0637 - loss: 0.7256 - learning_rate: 0.0034 - gradient_norm: 2.3940 - val_det_loss: 0.8855 - val_cls_loss: 0.5565 - val_box_loss: 0.0066 - val_reg_l2_loss: 0.0637 - val_loss: 0.9492
Epoch 31/50
21/21 [==============================] - 10s 499ms/step - det_loss: 0.6752 - cls_loss: 0.4406 - box_loss: 0.0047 - reg_l2_loss: 0.0637 - loss: 0.7389 - learning_rate: 0.0031 - gradient_norm: 2.6153 - val_det_loss: 0.8728 - val_cls_loss: 0.5536 - val_box_loss: 0.0064 - val_reg_l2_loss: 0.0637 - val_loss: 0.9365
Epoch 32/50
21/21 [==============================] - 11s 547ms/step - det_loss: 0.6605 - cls_loss: 0.4393 - box_loss: 0.0044 - reg_l2_loss: 0.0637 - loss: 0.7242 - learning_rate: 0.0028 - gradient_norm: 2.2926 - val_det_loss: 0.8503 - val_cls_loss: 0.5434 - val_box_loss: 0.0061 - val_reg_l2_loss: 0.0637 - val_loss: 0.9140
Epoch 33/50
21/21 [==============================] - 12s 573ms/step - det_loss: 0.6700 - cls_loss: 0.4388 - box_loss: 0.0046 - reg_l2_loss: 0.0637 - loss: 0.7337 - learning_rate: 0.0025 - gradient_norm: 2.4563 - val_det_loss: 0.8520 - val_cls_loss: 0.5442 - val_box_loss: 0.0062 - val_reg_l2_loss: 0.0637 - val_loss: 0.9157
Epoch 34/50
21/21 [==============================] - 12s 596ms/step - det_loss: 0.6754 - cls_loss: 0.4314 - box_loss: 0.0049 - reg_l2_loss: 0.0637 - loss: 0.7391 - learning_rate: 0.0023 - gradient_norm: 2.5527 - val_det_loss: 0.8223 - val_cls_loss: 0.5216 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.8860
Epoch 35/50
21/21 [==============================] - 13s 623ms/step - det_loss: 0.6499 - cls_loss: 0.4243 - box_loss: 0.0045 - reg_l2_loss: 0.0637 - loss: 0.7136 - learning_rate: 0.0020 - gradient_norm: 2.3485 - val_det_loss: 0.8405 - val_cls_loss: 0.5408 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.9042
Epoch 36/50
21/21 [==============================] - 12s 574ms/step - det_loss: 0.6290 - cls_loss: 0.4186 - box_loss: 0.0042 - reg_l2_loss: 0.0637 - loss: 0.6927 - learning_rate: 0.0018 - gradient_norm: 2.3488 - val_det_loss: 0.8436 - val_cls_loss: 0.5452 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.9073
Epoch 37/50
21/21 [==============================] - 13s 631ms/step - det_loss: 0.6446 - cls_loss: 0.4157 - box_loss: 0.0046 - reg_l2_loss: 0.0637 - loss: 0.7083 - learning_rate: 0.0015 - gradient_norm: 2.3455 - val_det_loss: 0.8361 - val_cls_loss: 0.5410 - val_box_loss: 0.0059 - val_reg_l2_loss: 0.0637 - val_loss: 0.8998
Epoch 38/50
21/21 [==============================] - 12s 595ms/step - det_loss: 0.6640 - cls_loss: 0.4317 - box_loss: 0.0046 - reg_l2_loss: 0.0637 - loss: 0.7277 - learning_rate: 0.0013 - gradient_norm: 2.5982 - val_det_loss: 0.8390 - val_cls_loss: 0.5402 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.9027
Epoch 39/50
21/21 [==============================] - 13s 623ms/step - det_loss: 0.6280 - cls_loss: 0.4117 - box_loss: 0.0043 - reg_l2_loss: 0.0637 - loss: 0.6916 - learning_rate: 0.0011 - gradient_norm: 2.3441 - val_det_loss: 0.8396 - val_cls_loss: 0.5415 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.9033
Epoch 40/50
21/21 [==============================] - 15s 721ms/step - det_loss: 0.6398 - cls_loss: 0.4240 - box_loss: 0.0043 - reg_l2_loss: 0.0637 - loss: 0.7035 - learning_rate: 9.0029e-04 - gradient_norm: 2.6224 - val_det_loss: 0.8326 - val_cls_loss: 0.5328 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.8963
Epoch 41/50
21/21 [==============================] - 10s 484ms/step - det_loss: 0.6361 - cls_loss: 0.4179 - box_loss: 0.0044 - reg_l2_loss: 0.0637 - loss: 0.6998 - learning_rate: 7.2543e-04 - gradient_norm: 2.4665 - val_det_loss: 0.8264 - val_cls_loss: 0.5282 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.8901
Epoch 42/50
21/21 [==============================] - 13s 654ms/step - det_loss: 0.6565 - cls_loss: 0.4141 - box_loss: 0.0048 - reg_l2_loss: 0.0637 - loss: 0.7202 - learning_rate: 5.6814e-04 - gradient_norm: 2.5693 - val_det_loss: 0.8190 - val_cls_loss: 0.5205 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.8827
Epoch 43/50
21/21 [==============================] - 12s 577ms/step - det_loss: 0.6390 - cls_loss: 0.4156 - box_loss: 0.0045 - reg_l2_loss: 0.0637 - loss: 0.7027 - learning_rate: 4.2906e-04 - gradient_norm: 2.6238 - val_det_loss: 0.8214 - val_cls_loss: 0.5218 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.8851
Epoch 44/50
21/21 [==============================] - 11s 543ms/step - det_loss: 0.6325 - cls_loss: 0.4210 - box_loss: 0.0042 - reg_l2_loss: 0.0637 - loss: 0.6962 - learning_rate: 3.0876e-04 - gradient_norm: 2.5348 - val_det_loss: 0.8233 - val_cls_loss: 0.5214 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.8870
Epoch 45/50
21/21 [==============================] - 14s 712ms/step - det_loss: 0.6318 - cls_loss: 0.4115 - box_loss: 0.0044 - reg_l2_loss: 0.0637 - loss: 0.6955 - learning_rate: 2.0774e-04 - gradient_norm: 2.3124 - val_det_loss: 0.8264 - val_cls_loss: 0.5243 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.8901
Epoch 46/50
21/21 [==============================] - 11s 518ms/step - det_loss: 0.6508 - cls_loss: 0.4240 - box_loss: 0.0045 - reg_l2_loss: 0.0637 - loss: 0.7145 - learning_rate: 1.2641e-04 - gradient_norm: 2.5532 - val_det_loss: 0.8275 - val_cls_loss: 0.5252 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.8912
Epoch 47/50
21/21 [==============================] - 13s 630ms/step - det_loss: 0.6284 - cls_loss: 0.4146 - box_loss: 0.0043 - reg_l2_loss: 0.0637 - loss: 0.6921 - learning_rate: 6.5107e-05 - gradient_norm: 2.5420 - val_det_loss: 0.8269 - val_cls_loss: 0.5248 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.8906
Epoch 48/50
21/21 [==============================] - 11s 539ms/step - det_loss: 0.6273 - cls_loss: 0.4124 - box_loss: 0.0043 - reg_l2_loss: 0.0637 - loss: 0.6910 - learning_rate: 2.4083e-05 - gradient_norm: 2.4386 - val_det_loss: 0.8249 - val_cls_loss: 0.5233 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.8886
Epoch 49/50
21/21 [==============================] - 13s 627ms/step - det_loss: 0.6412 - cls_loss: 0.4040 - box_loss: 0.0047 - reg_l2_loss: 0.0637 - loss: 0.7049 - learning_rate: 3.5074e-06 - gradient_norm: 2.4736 - val_det_loss: 0.8231 - val_cls_loss: 0.5223 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.8868
Epoch 50/50
21/21 [==============================] - 15s 721ms/step - det_loss: 0.6425 - cls_loss: 0.4205 - box_loss: 0.0044 - reg_l2_loss: 0.0637 - loss: 0.7062 - learning_rate: 3.4629e-06 - gradient_norm: 2.4394 - val_det_loss: 0.8218 - val_cls_loss: 0.5215 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.8855

שלב 4. הערך את המודל עם נתוני הבדיקה.

לאחר אימון מודל זיהוי האובייקטים באמצעות התמונות במערך הנתונים האימון, השתמש ב-25 התמונות הנותרות במערך הנתונים של הבדיקה כדי להעריך את ביצועי המודל מול נתונים חדשים שלא ראה מעולם.

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

המדדים להערכה הם זהים COCO .

model.evaluate(test_data)

1/1 [==============================] - 7s 7s/step
{'AP': 0.23457745,
 'AP50': 0.38357082,
 'AP75': 0.25038385,
 'APs': -1.0,
 'APm': 0.43640736,
 'APl': 0.234312,
 'ARmax1': 0.1664717,
 'ARmax10': 0.33019942,
 'ARmax100': 0.37375557,
 'ARs': -1.0,
 'ARm': 0.5416667,
 'ARl': 0.37200606,
 'AP_/Baked Goods': 0.07057314,
 'AP_/Salad': 0.53682375,
 'AP_/Cheese': 0.20270571,
 'AP_/Seafood': 0.08837805,
 'AP_/Tomato': 0.2744066}

שלב 5. ייצוא כדגם TensorFlow Lite.

ייצא את מודל זיהוי האובייקטים המאומן לפורמט TensorFlow Lite על-ידי ציון לאיזו תיקייה ברצונך לייצא את המודל הקוונטי. ברירת המחדל של טכניקת הקוונטיזציה שלאחר האימון היא קוונטיזציה מלאה של מספרים שלמים.

model.export(export_dir='.')

2021-12-02 12:28:49.181926: W tensorflow/python/util/util.cc:368] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them.
2021-12-02 12:29:09.650356: W tensorflow/core/common_runtime/graph_constructor.cc:803] Node 'resample_p7/PartitionedCall' has 1 outputs but the _output_shapes attribute specifies shapes for 3 outputs. Output shapes may be inaccurate.
2021-12-02 12:29:20.773150: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:363] Ignored output_format.
2021-12-02 12:29:20.773204: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:366] Ignored drop_control_dependency.
2021-12-02 12:29:20.773213: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:372] Ignored change_concat_input_ranges.
fully_quantize: 0, inference_type: 6, input_inference_type: 3, output_inference_type: 0

שלב 6. הערך את מודל TensorFlow Lite.

מספר גורמים יכולים להשפיע על דיוק המודל בעת ייצוא ל-TFLite:

• קוונטיזציה עוזרת מתכווצת לגודל המודל על ידי 4 פעמים על חשבון ירידה מסוימת דיוק.
• שימושי מודל TensorFlow המקוריים לכול כיתה הלא-מקס ודיכוי (NMS) עבור שלאחר עיבוד, ואילו מודל TFLite משתמש NMS הגלובלית זה הרבה יותר מהר אבל פחות מדויק. Keras מפלט מקסימום 100 זיהויים ואילו tflite מוציא מקסימום 25 זיהויים.

לכן תצטרך להעריך את מודל TFLite המיוצא ולהשוות את הדיוק שלו עם מודל TensorFlow המקורי.

model.evaluate_tflite('model.tflite', test_data)

25/25 [==============================] - 60s 2s/step
{'AP': 0.22160971,
 'AP50': 0.36216733,
 'AP75': 0.24560829,
 'APs': -1.0,
 'APm': 0.52389216,
 'APl': 0.21991307,
 'ARmax1': 0.16296011,
 'ARmax10': 0.2850546,
 'ARmax100': 0.29889038,
 'ARs': -1.0,
 'ARm': 0.6166667,
 'ARl': 0.29492828,
 'AP_/Baked Goods': 0.06930693,
 'AP_/Salad': 0.5064266,
 'AP_/Cheese': 0.1904948,
 'AP_/Seafood': 0.074257426,
 'AP_/Tomato': 0.26756287}

אתה יכול להוריד את קובץ הדגם של TensorFlow Lite באמצעות סרגל הצד השמאלי של Colab. לחץ לחיצה ימנית על model.tflite הקובץ ובחר Download כדי להוריד אותו למחשב המקומי שלך.

ניתן לשלב מודל זה לתוך אנדרואיד או אפליקצית iOS באמצעות API ObjectDetector של הספרייה המשימה לייט TensorFlow .

עיין האפליקציה לדוגמא זיהוי אובייקט TFLite לפרטים נוספים על איך המודל משמש אפליקצית עבודה.

(אופציונלי) בדוק את מודל TFLite על התמונה שלך

אתה יכול לבדוק את מודל ה-TFLite המיומן באמצעות תמונות מהאינטרנט.

• החלף את INPUT_IMAGE_URL מתחת עם תמונת הקלט הרצוי.
• התאם את DETECTION_THRESHOLD לשנות את הרגישות של המודל. סף נמוך יותר אומר שהדגם יאסוף יותר חפצים אבל יהיה גם יותר זיהוי שווא. בינתיים, סף גבוה יותר אומר שהדגם יאסוף רק אובייקטים שהוא זיהה בביטחון.

למרות שזה דורש חלק מקוד ה-boilerplate כדי להפעיל את המודל ב-Python ברגע זה, שילוב המודל באפליקציה לנייד דורש רק כמה שורות קוד.

טען את מודל TFLite המאומן והגדר כמה פונקציות הדמיה

import cv2

from PIL import Image

model_path = 'model.tflite'

# Load the labels into a list
classes = ['???'] * model.model_spec.config.num_classes
label_map = model.model_spec.config.label_map
for label_id, label_name in label_map.as_dict().items():
  classes[label_id-1] = label_name

# Define a list of colors for visualization
COLORS = np.random.randint(0, 255, size=(len(classes), 3), dtype=np.uint8)

def preprocess_image(image_path, input_size):
  """Preprocess the input image to feed to the TFLite model"""
  img = tf.io.read_file(image_path)
  img = tf.io.decode_image(img, channels=3)
  img = tf.image.convert_image_dtype(img, tf.uint8)
  original_image = img
  resized_img = tf.image.resize(img, input_size)
  resized_img = resized_img[tf.newaxis, :]
  resized_img = tf.cast(resized_img, dtype=tf.uint8)
  return resized_img, original_image


def detect_objects(interpreter, image, threshold):
  """Returns a list of detection results, each a dictionary of object info."""

  signature_fn = interpreter.get_signature_runner()

  # Feed the input image to the model
  output = signature_fn(images=image)

  # Get all outputs from the model
  count = int(np.squeeze(output['output_0']))
  scores = np.squeeze(output['output_1'])
  classes = np.squeeze(output['output_2'])
  boxes = np.squeeze(output['output_3'])

  results = []
  for i in range(count):
    if scores[i] >= threshold:
      result = {
        'bounding_box': boxes[i],
        'class_id': classes[i],
        'score': scores[i]
      }
      results.append(result)
  return results


def run_odt_and_draw_results(image_path, interpreter, threshold=0.5):
  """Run object detection on the input image and draw the detection results"""
  # Load the input shape required by the model
  _, input_height, input_width, _ = interpreter.get_input_details()[0]['shape']

  # Load the input image and preprocess it
  preprocessed_image, original_image = preprocess_image(
      image_path,
      (input_height, input_width)
    )

  # Run object detection on the input image
  results = detect_objects(interpreter, preprocessed_image, threshold=threshold)

  # Plot the detection results on the input image
  original_image_np = original_image.numpy().astype(np.uint8)
  for obj in results:
    # Convert the object bounding box from relative coordinates to absolute
    # coordinates based on the original image resolution
    ymin, xmin, ymax, xmax = obj['bounding_box']
    xmin = int(xmin * original_image_np.shape[1])
    xmax = int(xmax * original_image_np.shape[1])
    ymin = int(ymin * original_image_np.shape[0])
    ymax = int(ymax * original_image_np.shape[0])

    # Find the class index of the current object
    class_id = int(obj['class_id'])

    # Draw the bounding box and label on the image
    color = [int(c) for c in COLORS[class_id]]
    cv2.rectangle(original_image_np, (xmin, ymin), (xmax, ymax), color, 2)
    # Make adjustments to make the label visible for all objects
    y = ymin - 15 if ymin - 15 > 15 else ymin + 15
    label = "{}: {:.0f}%".format(classes[class_id], obj['score'] * 100)
    cv2.putText(original_image_np, label, (xmin, y),
        cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)

  # Return the final image
  original_uint8 = original_image_np.astype(np.uint8)
  return original_uint8

הפעל את זיהוי האובייקטים והצג את תוצאות הזיהוי

INPUT_IMAGE_URL = "https://storage.googleapis.com/cloud-ml-data/img/openimage/3/2520/3916261642_0a504acd60_o.jpg"
DETECTION_THRESHOLD = 0.3

TEMP_FILE = '/tmp/image.png'

!wget -q -O $TEMP_FILE $INPUT_IMAGE_URL
im = Image.open(TEMP_FILE)
im.thumbnail((512, 512), Image.ANTIALIAS)
im.save(TEMP_FILE, 'PNG')

# Load the TFLite model
interpreter = tf.lite.Interpreter(model_path=model_path)
interpreter.allocate_tensors()

# Run inference and draw detection result on the local copy of the original file
detection_result_image = run_odt_and_draw_results(
    TEMP_FILE,
    interpreter,
    threshold=DETECTION_THRESHOLD
)

# Show the detection result
Image.fromarray(detection_result_image)

(אופציונלי) קומפילציה עבור Edge TPU

עכשיו שיש לך מודל בדיד לייט EfficientDet, אפשר לקמפל ולפרוס אל קורל EdgeTPU .

שלב 1. התקן את מהדר EdgeTPU

 curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -

 echo "deb https://packages.cloud.google.com/apt coral-edgetpu-stable main" | sudo tee /etc/apt/sources.list.d/coral-edgetpu.list

 sudo apt-get update

 sudo apt-get install edgetpu-compiler

% Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100  2537  100  2537    0     0   130k      0 --:--:-- --:--:-- --:--:--  130k
OK
deb https://packages.cloud.google.com/apt coral-edgetpu-stable main
Hit:1 http://asia-east1.gce.archive.ubuntu.com/ubuntu bionic InRelease
Hit:2 http://asia-east1.gce.archive.ubuntu.com/ubuntu bionic-updates InRelease
Hit:3 http://asia-east1.gce.archive.ubuntu.com/ubuntu bionic-backports InRelease
Hit:4 https://nvidia.github.io/libnvidia-container/stable/ubuntu18.04/amd64  InRelease
Get:5 https://nvidia.github.io/nvidia-container-runtime/ubuntu18.04/amd64  InRelease [1481 B]
Get:6 https://nvidia.github.io/nvidia-docker/ubuntu18.04/amd64  InRelease [1474 B]
Ign:7 http://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1804/x86_64  InRelease
Hit:8 http://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1804/x86_64  Release
Get:9 http://packages.cloud.google.com/apt google-cloud-logging-wheezy InRelease [5483 B]
Hit:10 http://archive.canonical.com/ubuntu bionic InRelease
Hit:11 http://security.ubuntu.com/ubuntu bionic-security InRelease
Get:13 https://packages.cloud.google.com/apt coral-edgetpu-stable InRelease [6722 B]
Get:14 https://packages.cloud.google.com/apt eip-cloud-bionic InRelease [5419 B]
Ign:15 https://packages.cloud.google.com/apt coral-edgetpu-stable/main amd64 Packages
Get:15 https://packages.cloud.google.com/apt coral-edgetpu-stable/main amd64 Packages [2327 B]
Fetched 22.9 kB in 1s (18.7 kB/s)




The following packages were automatically installed and are no longer required:
  linux-gcp-5.4-headers-5.4.0-1040 linux-gcp-5.4-headers-5.4.0-1043
  linux-gcp-5.4-headers-5.4.0-1044 linux-gcp-5.4-headers-5.4.0-1049
  linux-headers-5.4.0-1049-gcp linux-image-5.4.0-1049-gcp
  linux-modules-5.4.0-1044-gcp linux-modules-5.4.0-1049-gcp
  linux-modules-extra-5.4.0-1049-gcp
Use 'sudo apt autoremove' to remove them.
The following NEW packages will be installed:
  edgetpu-compiler
0 upgraded, 1 newly installed, 0 to remove and 119 not upgraded.
Need to get 7913 kB of archives.
After this operation, 31.2 MB of additional disk space will be used.
Get:1 https://packages.cloud.google.com/apt coral-edgetpu-stable/main amd64 edgetpu-compiler amd64 16.0 [7913 kB]
Fetched 7913 kB in 1s (11.2 MB/s)
Selecting previously unselected package edgetpu-compiler.
(Reading database ... 283192 files and directories currently installed.)
Preparing to unpack .../edgetpu-compiler_16.0_amd64.deb ...
Unpacking edgetpu-compiler (16.0) ...
Setting up edgetpu-compiler (16.0) ...
Processing triggers for libc-bin (2.27-3ubuntu1.2) ...

שלב 2. בחר מספר של Edge TPUs, קומפיל

EdgeTPU יש 8MB של SRAM עבור במטמון PARAMATERS מודל ( מידע נוסף ). המשמעות היא שעבור דגמים שגדולים מ-8MB, זמן ההסקה יגדל על מנת להעביר פרמטרים של המודל. אחת הדרכים למנוע זאת היא חפיפת דגם - פיצול המודל למקטעים שיכול להיות EdgeTPU ייעודי. זה יכול לשפר משמעותית את השהיה.

הטבלה שלמטה יכולה לשמש כאסמכתא למספר ה-Edge TPUs לשימוש - הדגמים הגדולים יותר לא יקומפלו עבור TPU בודד מכיוון שהטנסורים הביניים לא יכולים להיכנס לזיכרון שבשבב.

NUMBER_OF_TPUS =  1

!edgetpu_compiler model.tflite --num_segments=$NUMBER_OF_TPUS

Edge TPU Compiler version 16.0.384591198
Started a compilation timeout timer of 180 seconds.

Model compiled successfully in 4410 ms.

Input model: model.tflite
Input size: 4.24MiB
Output model: model_edgetpu.tflite
Output size: 5.61MiB
On-chip memory used for caching model parameters: 4.24MiB
On-chip memory remaining for caching model parameters: 3.27MiB
Off-chip memory used for streaming uncached model parameters: 0.00B
Number of Edge TPU subgraphs: 1
Total number of operations: 267
Operation log: model_edgetpu.log

Model successfully compiled but not all operations are supported by the Edge TPU. A percentage of the model will instead run on the CPU, which is slower. If possible, consider updating your model to use only operations supported by the Edge TPU. For details, visit g.co/coral/model-reqs.
Number of operations that will run on Edge TPU: 264
Number of operations that will run on CPU: 3
See the operation log file for individual operation details.
Compilation child process completed within timeout period.
Compilation succeeded!

שלב 3. הורד, הפעל את המודל

עם הידור/ים של המודלים, כעת ניתן להפעיל אותם ב-EdgeTPU/ים לזיהוי אובייקטים. ראשית, הורד את קובץ הדגם של TensorFlow Lite המהודר באמצעות סרגל הצד השמאלי של Colab. לחץ לחיצה ימנית על model_edgetpu.tflite הקובץ ובחר Download כדי להוריד אותו למחשב המקומי שלך.

כעת אתה יכול להפעיל את הדגם בצורה המועדפת עליך. דוגמאות לזיהוי כוללות:

• זיהוי pycoral
• זיהוי TFLite בסיסי
• דוגמה לזיהוי וידאו
• libcoral C++ API

שימוש מתקדם

חלק זה מכסה נושאי שימוש מתקדמים כמו התאמת המודל וההיפרפרמטרים של האימון.

טען את מערך הנתונים

טען את הנתונים שלך

אתה יכול להעלות את מערך הנתונים שלך כדי לעבוד באמצעות הדרכה זו. העלה את מערך הנתונים שלך באמצעות סרגל הצד השמאלי ב-Colab.

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

טען את הנתונים שלך בפורמט נתונים אחר

ספריית Maker הדגם תומכת גם object_detector.DataLoader.from_pascal_voc שיטת נתון עומס עם VOC פסקל פורמט. makesense.ai ו LabelImg הם כלים שיכולים ויסמנו את התמונה ולשמור הערות כפי קבצי XML בפורמט נתונים VOC פסקל:

object_detector.DataLoader.from_pascal_voc(image_dir, annotations_dir, label_map={1: "person", 2: "notperson"})

התאם אישית את ההיפרפרמטרים של מודל EfficientDet

הפרמטרים של המודל ושל צינור ההדרכה שניתן להתאים הם:

• model_dir : המיקום לשמירת קבצים במחסום מודל. אם לא מוגדר, תיעשה שימוש בספרייה זמנית.
• steps_per_execution : מספר הצעדים לכל ביצוע אימונים.
• moving_average_decay : לצוף. הדעיכה לשימוש לשמירה על ממוצעים נעים של הפרמטרים המאומנים.
• var_freeze_expr : הביטוי הרגיל כדי למפות שם קידומת של משתנים כדי להיות קפוא אשר נותר אמצעי זהה במהלך האימונים. נוסף ספציפי, השימוש re.match(var_freeze_expr, variable_name) ב בבסיס הקוד למפות המשתנים להיות קפוא.
• tflite_max_detections : שלם, 25 כברירת מחדל. המספר המרבי של זיהוי פלט במודל TFLite.
• strategy : A המפרט מחרוזת אשר הפצת אסטרטגיה לשימוש. הערכים המקובלים הם 'tpu', 'gpus', None. tpu' פירושו להשתמש ב-TPUStrategy. 'gpus' פירושו להשתמש ב-MirroredStrategy עבור multi-gpus. אם אין, השתמש ב-TF ברירת מחדל עם OneDeviceStrategy.
• tpu : ענן TPU להשתמש לאימונים. זה צריך להיות השם המשמש בעת יצירת ה-Cloud TPU, או כתובת URL grpc://ip.address.of.tpu:8470.
• use_xla : השתמש XLA גם אם האסטרטגיה היא לא TPU. אם האסטרטגיה היא tpu, השתמש תמיד ב-XLA, ולדגל זה אין השפעה.
• profile : הפעל מצב לפרופיל.
• debug : הפעל מצב debug.

פרמטרים אחרים שיכול להיות מותאם מוצגים hparams_config.py .

למשל, אתה יכול להגדיר את var_freeze_expr='efficientnet' שקופא המשתנים עם שם קידומת efficientnet (ברירת המחדל היא '(efficientnet|fpn_cells|resample_p6)' ). זה מאפשר למודל להקפיא משתנים בלתי ניתנים לאימון ולשמור על ערכם זהה באמצעות אימון.

spec = model_spec.get('efficientdet_lite0')
spec.config.var_freeze_expr = 'efficientnet'

שנה את ארכיטקטורת המודל

אתה יכול לשנות את ארכיטקטורת המודל ידי שינוי model_spec . למשל, לשנות את model_spec למודל EfficientDet-Lite4.

spec = model_spec.get('efficientdet_lite4')

כוונן את ההיפרפרמטרים של האימון

create פונקציה היא פונקצית הנהג כי שימושי ספריית Maker הדגם ליצור מודלים. model_spec פרמטר המגדיר את המפרט מודל. object_detector.EfficientDetSpec הייצוגית נתמך כרגע. create פונקציה מורכבת מהשלבים הבאים:

1. יצירת מודל לאיתור עצמים על פי model_spec .
2. מאמן את הדגם. התקופות ברירת המחדל ואת גודל המנה ברירת המחדל נקבעים על ידי epochs ו batch_size המשתנים model_spec האובייקט. ניתן גם לכוונן את hyperparameters אימונים כמו epochs ו batch_size המשפיעים על דיוק המודל. לדוגמה,

• epochs : שלם, 50 כברירת מחדל. תקופות נוספות יכולות להשיג דיוק טוב יותר, אך עלולות להוביל להתאמת יתר.
• batch_size : שלם, 64 כברירת מחדל. מספר הדגימות לשימוש בשלב אימון אחד.
• train_whole_model : בוליאני, False כברירת מחדל. אם זה נכון, אמנו את כל הדגם. אחרת, רק לאמן את השכבות שאינו תואם var_freeze_expr .

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

model = object_detector.create(train_data, model_spec=spec, epochs=10, validation_data=validation_data)

ייצוא לפורמטים שונים

פורמטי הייצוא יכולים להיות אחד או רשימה של הפורמטים הבאים:

• ExportFormat.TFLITE
• ExportFormat.LABEL
• ExportFormat.SAVED_MODEL

כברירת מחדל, היא מייצאת רק את קובץ המודל לייט TensorFlow המכיל את מודל metadata כך שמאוחר יותר תוכל להשתמש ביישום ML על-התקן. קובץ התווית מוטבע במטא נתונים.

ביישומי ML רבים במכשיר, גודל הדגם הוא גורם חשוב. לכן, מומלץ לכמת את המודל כדי להפוך אותו לקטן יותר ועלול לרוץ מהר יותר. באשר למודלים של EfficientDet-Lite, קוונטיזציה מלאה של מספרים שלמים משמשת לכימות המודל כברירת מחדל. עיין קוונטיזציה פוסט-הכשרה לקבלת פרטים נוספים.

model.export(export_dir='.')

אתה יכול גם לבחור לייצא קבצים אחרים הקשורים למודל לבדיקה טובה יותר. לדוגמה, ייצוא גם את הדגם השמור וגם את קובץ התווית באופן הבא:

model.export(export_dir='.', export_format=[ExportFormat.SAVED_MODEL, ExportFormat.LABEL])

התאם אישית קוונטיזציה לאחר אימון בדגם TensorFlow Lite

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

ספריית Model Maker מיישמת טכניקת קוונטיזציה שלאחר אימון ברירת מחדל בעת ייצוא המודל. אם ברצונך להתאים אישית קוונטיזציה שלאחר אימון, מכונת הדגם תומכת אפשרויות קוונטיזציה שלאחר אימון מרובות באמצעות QuantizationConfig גם כן. בואו ניקח כדוגמה לכימות float16. ראשית, הגדר את תצורת הקוונטיזציה.

config = QuantizationConfig.for_float16()

לאחר מכן אנו מייצאים את דגם TensorFlow Lite עם תצורה כזו.

model.export(export_dir='.', tflite_filename='model_fp16.tflite', quantization_config=config)

קרא עוד

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

• TensorFlow לייט דגם מכונת מדריך ו פניית API .
• הספרייה משימה: ObjectDetector לפריסה.
• ההתייחסות מקצה לקצה Apps: Android , iOS , ו- פטל PI .