לפני שמריצים משימת חיפוש של ארכיטקטורה נוירונית ב-Agent Platform כדי לחפש מודל אופטימלי, צריך להגדיר את משימת ה-proxy. ב-Stage1-search נעשה שימוש בייצוג קטן בהרבה של אימון מודל מלא, שבדרך כלל מסתיים תוך שעתיים. הייצוג הזה נקרא משימת פרוקסי, והוא מפחית באופן משמעותי את עלות החיפוש. בכל ניסיון במהלך החיפוש, המודל מאומן באמצעות הגדרות המשימה של שרת ה-proxy.
בקטעים הבאים מוסבר מה צריך לעשות כדי להחיל תכנון של משימת Proxy:
- גישות ליצירת משימת proxy.
- הדרישות ממשימת פרוקסי טובה.
- איך להשתמש בשלושת הכלים לעיצוב משימות Proxy כדי למצוא את משימת ה-Proxy האופטימלית, שמפחיתה את עלות החיפוש תוך שמירה על איכות החיפוש.
גישות ליצירת משימת פרוקסי
יש שלוש גישות נפוצות ליצירת משימת Proxy:
- להשתמש בפחות שלבי אימון.
- להשתמש במערך נתונים לאימון שכולל דגימת משנה.
- להשתמש במודל מוקטן.
שימוש בפחות שלבי אימון
הדרך הכי פשוטה ליצור משימת Proxy היא להפחית את מספר שלבי האימון של המאמן, ולדווח על ציון לבקר על סמך האימון החלקי הזה.
שימוש בקבוצת נתונים לאימון שנדגמה באופן חלקי
בקטע הזה מתואר השימוש בקבוצת נתונים לאימון שנדגמה באופן חלקי, גם לחיפוש ארכיטקטורה וגם לחיפוש מדיניות של צירוף נתונים.
חיפוש אדריכלות
אפשר ליצור משימת פרוקסי באמצעות קבוצת נתונים לאימון עם דגימת משנה במהלך החיפוש של הארכיטקטורה. עם זאת, כשמבצעים דגימת משנה, חשוב לפעול לפי ההנחיות הבאות:
- ערבוב הנתונים באופן אקראי בין המקטעים.
- אם נתוני האימון לא מאוזנים, צריך לבצע דגימת משנה כדי לאזן אותם.
חיפוש מדיניות של צירוף נתונים מאוחזרים באמצעות צירוף נתונים אוטומטי
אם אתם לא מריצים חיפוש של צירוף נתונים מאוחזרים בלבד, אלא רק חיפוש של ארכיטקטורה רגילה, דלגו על הקטע הזה. כדי לחפש מדיניות הרחבה, משתמשים ב-auto-augment. עדיף לדגום את נתוני האימון ולהריץ אימון מלא מאשר להפחית את מספר שלבי האימון. הפעלת אימון מלא עם צירוף נתונים מאוחזרים כבד שומרת על יציבות גבוהה יותר של הציונים. בנוסף, כדאי להשתמש בנתוני אימון מצומצמים כדי להוזיל את עלות החיפוש.
משימת פרוקסי שמבוססת על מודל מצומצם
אפשר גם לצמצם את המודל ביחס למודל הבסיסי כדי ליצור משימת פרוקסי. האפשרות הזו שימושית גם כשרוצים להפריד בין block-design-search לבין scaling-search.
עם זאת, כשמצמצמים את המודל ורוצים להשתמש באילוץ זמן אחזור, צריך להשתמש באילוץ זמן אחזור מחמיר יותר למודל המצומצם. טיפ: אתם יכולים לצמצם את מודל הבסיס ולמדוד את זמן האחזור שלו כדי להגדיר את מגבלת זמן האחזור המחמירה יותר.
במודל המוקטן, אפשר גם להפחית את כמות ההרחבה והרגולריזציה בהשוואה למודל הבסיסי המקורי.
דוגמאות למודל מוקטן
במשימות של ראייה ממוחשבת שבהן מאמנים את המודל על תמונות, יש שלוש דרכים נפוצות לצמצם את המודל:
- הקטנת רוחב המודל: מספר הערוצים.
- צמצום עומק המודל: מספר השכבות והחזרות על בלוקים.
- להקטין מעט את גודל התמונות לאימון (כדי לא להסיר מאפיינים) או לחתוך את התמונות לאימון, אם המשימה מאפשרת זאת.
קריאה מומלצת: המאמר EfficientNet מספק תובנות מצוינות לגבי התאמה לעומס (scaling) של מודלים למשימות של ראייה ממוחשבת. בנוסף, מוסבר איך שלוש השיטות קשורות זו לזו.
Spinenet search היא דוגמה נוספת לשינוי קנה מידה של מודל שמשמש לחיפוש ארכיטקטורה נוירונית ב-Agent Platform. בשלב הראשון של החיפוש, הוא מצמצם את מספר הערוצים ואת גודל התמונה.
משימת פרוקסי שמבוססת על שילוב
הגישות פועלות באופן עצמאי ואפשר לשלב אותן בדרגות שונות כדי ליצור משימת שרת proxy.
הדרישות ממשימת פרוקסי טובה
משימת פרוקסי צריכה לעמוד בדרישות מסוימות כדי שתוכל לתת תגמול יציב לבקר ולשמור על איכות החיפוש.
מתאם דירוג בין חיפוש בשלב 1 לבין אימון מלא בשלב 2
כשמשתמשים במשימת פרוקסי לחיפוש ארכיטקטורה נוירונית ב-Agent Platform, הנחת יסוד לחיפוש מוצלח היא שאם מודל א' מניב ביצועים טובים יותר ממודל ב' במהלך אימון משימת הפרוקסי בשלב 1, אז מודל א' מניב ביצועים טובים יותר ממודל ב' באימון המלא בשלב 2. כדי לאמת את ההנחה הזו, צריך להעריך את מתאם הדירוג בין התגמולים של החיפוש בשלב 1 לבין האימון המלא בשלב 2, ב-10 עד 20 מודלים במרחב החיפוש. המודלים האלה נקראים correlation-candidate-models.
באיור הבא מוצגת דוגמה למתאם נמוך (ציון מתאם = -0.03), ולכן משימת ה-proxy הזו היא מועמדת גרועה לחיפוש:

כל נקודה בתרשים מייצגת מודל מועמד לקורלציה.
ציר ה-x מייצג את הציונים של המודלים באימון המלא בשלב 2, וציר ה-y מייצג את הציונים של אותם מודלים במשימת ה-proxy בשלב 1.
מסתכלים על הנקודה הגבוהה ביותר. המודל הזה קיבל את הציון הגבוה ביותר במשימת הפרוקסי (ציר y), אבל הביצועים שלו נמוכים במהלך האימון המלא בשלב 2 (ציר x) בהשוואה למודלים אחרים. לעומת זאת, באיור הבא מוצגת דוגמה לקורלציה טובה (ציון קורלציה = 0.67), ולכן משימת ה-proxy הזו היא מועמדת טובה לחיפוש:

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

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

החלקה נוספת
אם אתם משתמשים בהרחבה כבדה, יכול להיות שעקומת האימות לא תהיה חלקה מספיק עם דעיכת קוסינוס. שימוש בהרחבה משמעותית מצביע על מחסור בנתוני אימון. במקרה כזה, לא מומלץ להשתמש ב-Agent Platform Neural Architecture Search, אלא ב-augmentation-search.
אם הגורם הוא לא הגברה כבדה וכבר ניסיתם דעיכת קוסינוס, אבל אתם עדיין רוצים להשיג יותר חלקות, השתמשו ב-exponential-moving-average ל-TensorFlow-2 או ב-stochastic-weighted-averaging ל-PyTorch. במצביע הקוד הזה יש דוגמה לשימוש באופטימיזציה של ממוצע נע אקספוננציאלי עם TensorFlow 2, ובדוגמה הזו יש דוגמה לממוצע משוקלל סטוכסטי עם PyTorch.
אם תרשימי הדיוק/תקופה של הניסויים נראים כך:

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

שגיאות שקשורות לזיכרון לא מספיק (OOM) ולקצב הלמידה
מרחב החיפוש של הארכיטקטורה יכול ליצור מודלים גדולים בהרבה מקו הבסיס. יכול להיות ששיניתם את גודל האצווה של מודל הבסיס, אבל ההגדרה הזו עלולה להיכשל כשמודלים גדולים יותר נדגמים במהלך החיפוש, וכתוצאה מכך מתקבלות שגיאות OOM. במקרה כזה, צריך להקטין את גודל האצווה.
סוג השגיאה השני שמופיע הוא שגיאת NaN (לא מספר). צריך להקטין את קצב הלמידה הראשוני או להוסיף חיתוך גרדיאנט.
כמו שצוין בtutorial-2, אם יותר מ-20% מהמודלים במרחב החיפוש מחזירים ציונים לא חוקיים, לא מריצים את החיפוש המלא. כלי העיצוב שלנו למשימות פרוקסי מספקים דרך להעריך את שיעור הכשלים.
כלים לעיצוב משימות פרוקסי
בקטעים הקודמים דיברנו על העקרונות של תכנון משימות Proxy. בקטע הזה מוצגים שלושה כלים לתכנון משימות Proxy, שמאפשרים למצוא באופן אוטומטי את משימת ה-Proxy האופטימלית על סמך גישות התכנון השונות, שעומדת בכל הדרישות.
שינויים נדרשים בקוד
קודם צריך לשנות קצת את קוד המאמן כדי שהוא יוכל לקיים אינטראקציה עם כלי העיצוב של משימות ה-proxy במהלך תהליך איטרטיבי.
בtf_vision/train_lib.py מוצגת דוגמה. קודם צריך לייבא את הספרייה שלנו:
from google.cloud.visionsolutions.nas.proxy_task import proxy_task_utils
לפני שמתחיל מחזור אימון בלולאת האימון, צריך לבדוק אם צריך להפסיק את האימון מוקדם, כי כלי העיצוב של משימת ה-proxy דורש שימוש בספרייה שלנו:
if proxy_task_utils.get_stop_training(
model_dir,
end_training_cycle_step=<last-training-step-idx done so far>,
total_training_steps=<total-training-steps>):
break
אחרי שכל מחזור אימון בלולאת האימון מסתיים, מעדכנים את ציון הדיוק החדש, את שלב ההתחלה והסיום של מחזור האימון, את משך מחזור פעילות האימון בשניות ואת סך כל שלבי האימון.
proxy_task_utils.update_trial_training_accuracy_metric(
model_dir=model_dir,
accuracy=<latest accuracy value>,
begin_training_cycle_step=<beginning training step for this cycle>,
end_training_cycle_step=<end training step for this cycle>,
training_cycle_time_in_secs=<training cycle time (excluding validation)>,
total_training_steps=<total-training-steps>)
שימו לב שמשך מחזור פעילות האימון לא צריך לכלול את הזמן שנדרש להערכת ציון האימות. חשוב לוודא שהמאמן מחשב את ציוני האימות לעיתים קרובות (evaluation-frequency) כדי שיהיו מספיק דגימות של עקומת האימות. אם משתמשים באילוץ זמן אחזור, צריך לעדכן את מדד זמן האחזור אחרי שמחשבים אותו:
proxy_task_utils.update_trial_training_latency_metric(
model_dir=model_dir,
latency=<measured_latency>)
כדי להשתמש בכלי לבחירת מודלים, צריך לטעון את נקודת הבדיקה הקודמת לאיטרציה הבאה.
כדי לאפשר שימוש חוזר בנקודת ביקורת קודמת, מוסיפים דגל למאמן, כמו שמוצג ב-tf_vision/cloud_search_main.py:
parser.add_argument(
"--retrain_use_search_job_checkpoint",
type=cloud_nas_utils.str_2_bool,
default=False,
help="True to use previous NAS search job checkpoint."
)
טוענים את נקודת הבדיקה הזו לפני שמאמנים את המודל:
if FLAGS.retrain_use_search_job_checkpoint:
prev_checkpoint_dir = cloud_nas_utils.get_retrain_search_job_model_dir(
retrain_search_job_trials=FLAGS.retrain_search_job_trials,
retrain_search_job_dir=FLAGS.retrain_search_job_dir)
logging.info("Setting checkpoint to %s.", prev_checkpoint_dir)
# Now set your checkpoint using 'prev_checkpoint_dir'.
צריך גם את הערך של metric-id שתואם לערכי הדיוק והזמן האחזור שדווחו על ידי המאמן. אם התגמול של המאמן (שלפעמים הוא שילוב של דיוק וזמן אחזור) שונה מהדיוק, חשוב לוודא שאתם מדווחים גם על מדד של דיוק בלבד באמצעות other_metrics מהמאמן.
לדוגמה, בדוגמה הבאה מוצגים מדדי דיוק בלבד ומדדי זמן אחזור שדווחו על ידי המאמן המובנה שלנו:

מדידת השונות
אחרי ששיניתם את קוד המאמן, השלב הראשון הוא למדוד את השונות של המאמן. כדי למדוד את השונות, משנים את הגדרות האימון הבסיסיות באופן הבא:
- להפחית את שלבי האימון כך שירוצו רק כשעה עם GPU אחד או שניים. אנחנו צריכים דוגמה קטנה של אימון מלא.
- משתמשים בקצב למידה של דעיכת קוסינוס ומגדירים את השלבים שלו כך שיהיו זהים לשלבים המופחתים האלה, כדי שקצב הלמידה יהיה כמעט אפס לקראת הסוף.
כלי המדידה של השונות דוגם מודל אחד ממרחב החיפוש, מוודא שאפשר להתחיל לאמן את המודל הזה בלי שגיאות OOM או NAN, מריץ חמישה עותקים של המודל הזה עם ההגדרות שלכם למשך כשעה, ואז מדווח על השונות והחלקות של ציון האימון. העלות הכוללת של הפעלת הכלי הזה זהה בערך לעלות של הפעלת חמישה מודלים עם ההגדרות שלכם למשך כשעה.
מפעילים את משימת מדידת השונות באמצעות הפקודה הבאה (צריך חשבון שירות):
DATE="$(date '+%Y%m%d_%H%M%S')"
project_id=<your project-id>
# You can choose any unique docker id below.
trainer_docker_id=${USER}_trainer_${DATE}
trainer_docker_file=<path to your trainer dockerfile>
region=<your job region such as 'us-central1'>
search_space_module=<path to your search space module>
accelerator_type="NVIDIA_TESLA_V100"
num_gpus=2
# Your bucket should be for your project and in the same region as the job.
root_output_dir=<gs://your-bucket>
####### Variance measurement related parameters ######
proxy_task_variance_measurement_docker_id=${USER}_variance_measurement_${DATE}
# Use the service account that you set-up for your project.
service_account=<your service account>
job_name=<your job name>
############################################################
python3 vertex_nas_cli.py build \
--project_id=${project_id} \
--region=${region} \
--trainer_docker_id=${trainer_docker_id} \
--trainer_docker_file=${trainer_docker_file} \
--proxy_task_variance_measurement_docker_id=${proxy_task_variance_measurement_docker_id}
# The command below passes 'dummy' arguments for the training docker.
# You need to modify them for your own docker.
python3 vertex_nas_cli.py measure_proxy_task_variance \
--proxy_task_variance_measurement_docker_id=${proxy_task_variance_measurement_docker_id} \
--project_id=${project_id} \
--service_account=${service_account} \
--region=${region} \
--trainer_docker_id=${trainer_docker_id} \
--job_name=${job_name} \
--search_space_module=${search_space_module} \
--accelerator_type=${accelerator_type} \
--num_gpus=${num_gpus} \
--root_output_dir=${root_output_dir} \
--search_docker_flags \
dummy_trainer_flag1="dummy_trainer_val"
אחרי שתפעילו את משימת מדידת השונות, תקבלו קישור למשימה. הערך של job-name צריך להתחיל בקידומת Variance_Measurement. דוגמה לממשק משתמש של משימה:

השדה variance_measurement_dir יכיל את כל הפלט, ואפשר לבדוק את היומנים בלחיצה על הקישור View logs.
כברירת מחדל, המשימה הזו משתמשת במעבד אחד בענן כדי לפעול ברקע כמשימה ייעודית, ואז מפעילה ומנהלת משימות NAS צאצא.

בקטע NAS, תראו משימה בשם Find_workable_model_<your job name>. המשימה הזו תדגום את מרחב החיפוש כדי למצוא מודל אחד שלא יוצר שגיאות. אחרי שמוצאים מודל כזה, משימת מדידת השונות מפעילה משימת NAS נוספת <your job name>, שמריצה חמישה עותקים של המודל הזה למספר שלבי האימון שהגדרתם קודם. אחרי שהמודלים האלה מסיימים את האימון, משימת מדידת השונות מודדת את השונות והחלקות של הניקוד ומדווחת עליהן ביומנים שלה:

אם השונות גבוהה, אפשר לנסות את השיטות שמפורטות כאן.
בחירת מודל
אחרי שמוודאים שאין שונות גבוהה במודל האימון, השלבים הבאים הם:
- correlation-candidate-models
- לחשב את הציונים של האימון המלא, שישמשו כנקודת ייחוס כשתחשבו בהמשך את ציוני המתאם של משימות ה-proxy לאפשרויות שונות של משימות proxy.
הכלי שלנו מוצא את המודלים האלה באופן אוטומטי ויעיל, ומוודא שיש להם התפלגות ציונים טובה גם מבחינת הדיוק וגם מבחינת זמן האחזור, כדי שלחישוב המתאם העתידי יהיה בסיס טוב. לשם כך, הכלי מבצע את הפעולות הבאות:
- דגימה אקראית של
N_beginמודלים ממרחב החיפוש. בדוגמה הזו, נניח ש-N_begin = 30. הכלי מאמן אותם במשך 1/30 מזמן האימון המלא. - דוחים חמישה מתוך 30 מודלים שלא מוסיפים עוד להתפלגות של הדיוק וזמן האחזור. האיור הבא מציג דוגמה לכך. המודלים שנדחו מוצגים כנקודות אדומות:

- מאמנים את 25 המודלים שנבחרו במשך 1/25 מזמן האימון המלא, ואז דוחים חמישה מודלים נוספים על סמך הציונים עד כה. שימו לב שהאימון של 25 המודלים ממשיך מנקודת הבדיקה הקודמת שלהם.
- חוזרים על התהליך הזה עד שנשארים רק
Nמודלים עם התפלגות טובה. - לאמן את
Nהמודלים האחרונים עד להשלמה.
הגדרת ברירת המחדל של N_begin היא 30, והיא מופיעה בתור START_NUM_MODELS בקובץ proxy_task/proxy_task_model_selection_lib_constants.py.
הגדרת ברירת המחדל של N היא 10, והיא מופיעה בתור FINAL_NUM_MODELS בקובץ proxy_task/proxy_task_model_selection_lib_constants.py.
העלות הנוספת של תהליך בחירת המודל מחושבת באופן הבא:
= (30*1/30 + 25*1/25 + 20*1/20 + 15*1/15 + 10*(remaining-training-time-fraction)) * full-training-time
= (4 + 10*(0.81)) * full-training-time
~= 12 * full-training-time
עם זאת, חשוב להישאר מעל ההגדרה N=10. כלי החיפוש של משימות ה-proxy מריץ בהמשך את N המודלים האלה במקביל. לכן, ודאו שיש לכם מספיק מכסת GPU בשביל זה. לדוגמה, אם המשימה ב-proxy משתמשת בשני GPUs למודל אחד, צריכה להיות לכם מכסה של לפחות 2*N GPUs.
במשימה לבחירת המודל, משתמשים באותה מחיצה של מערך הנתונים כמו במשימה לאימון מלא בשלב 2, ומשתמשים באותה הגדרת מאמן לאימון המלא הבסיסי.
עכשיו אפשר להפעיל את משימת בחירת המודל באמצעות הפקודה הבאה (צריך חשבון שירות):
DATE="$(date '+%Y%m%d_%H%M%S')"
project_id=<your project-id>
# You can choose any unique docker id below.
trainer_docker_id=${USER}_trainer_${DATE}
trainer_docker_file=<path to your trainer dockerfile>
latency_calculator_docker_id=${USER}_model_selection_${DATE}
latency_calculator_docker_file=${USER}_latency_${DATE}
region=<your job region such as 'us-central1'>
search_space_module=<path to your search space module>
accelerator_type="NVIDIA_TESLA_V100"
num_gpus=2
# Your bucket should be for your project and in the same region as the job.
root_output_dir=<gs://your-bucket>
# Your latency computation device.
target_device_type="CPU"
####### Proxy task model-selection related parameters ######
proxy_task_model_selection_docker_id=${USER}_model_selection_${DATE}
# Use the service account that you set-up for your project.
service_account=<your service account>
job_name=<your job name>
# The value below depends on your accelerator quota. By default
# the model-selection job runs 30 trials. However, depending on
# your quota, you can choose to only run 10 trials in parallel at a time.
# However, lowering this number can increase the overall runtime for the job.
max_parallel_nas_trial=<num parallel trials>
# The value below is the 'metric-id' corresponding to the accuracy ONLY
# metric reported by your trainer. Note that this metric may
# be different from the 'reward'.
accuracy_metric_id=<set accuracy metric id used by your trainer>
latency_metric_id=<set latency metric id used by your trainer>
############################################################
python3 vertex_nas_cli.py build \
--project_id=${project_id} \
--region=${region} \
--trainer_docker_id=${trainer_docker_id} \
--trainer_docker_file=${trainer_docker_file} \
--latency_calculator_docker_id=${latency_calculator_docker_id} \
--latency_calculator_docker_file=${latency_calculator_docker_file} \
--proxy_task_model_selection_docker_id=${proxy_task_model_selection_docker_id}
# The command below passes 'dummy' arguments for trainer-docker
# and latency-docker. You need to modify them for your own docker.
python3 vertex_nas_cli.py select_proxy_task_models \
--service_account=${service_account} \
--proxy_task_model_selection_docker_id=${proxy_task_model_selection_docker_id} \
--project_id=${project_id} \
--region=${region} \
--trainer_docker_id=${trainer_docker_id} \
--job_name=${job_name} \
--max_parallel_nas_trial=${max_parallel_nas_trial} \
--accuracy_metric_id=${accuracy_metric_id} \
--latency_metric_id=${latency_metric_id} \
--search_space_module=${search_space_module} \
--accelerator_type=${accelerator_type} \
--num_gpus=${num_gpus} \
--root_output_dir=${root_output_dir} \
--latency_calculator_docker_id=${latency_calculator_docker_id} \
--latency_docker_flags \
dummy_latency_flag1="dummy_latency_val" \
--target_device_type=${target_device_type} \
--search_docker_flags \
dummy_trainer_flag1="dummy_trainer_val"
אחרי שמפעילים את משימת בקר בחירת המודל, מקבלים קישור למשימה. השם של המשימה מתחיל בקידומת Model_Selection_. דוגמה לממשק משתמש של משימה:

ה-model_selection_dir מכיל את כל הפלטים. כדי לבדוק את היומנים, לוחצים על הקישור View logs.
כברירת מחדל, המשימה של בקר בחירת המודל משתמשת במעבד אחד ב- Google Cloud כדי לפעול ברקע כמשימה ייעודית, ואז מפעילה ומנהלת משימות NAS צאצא לכל איטרציה של בחירת המודל.

לכל משימת NAS צאצא יש שם כמו <your_job_name>_iter_3 (חוץ מהאיטרציה 0). בכל פעם פועלת רק איטרציה אחת. בכל איטרציה, מספר המודלים (מספר הניסיונות) מצטמצם ומשך האימון מתארך. בסוף כל איטרציה, כל משימת NAS שומרת קובץ gs://<job-output-dir>/search/filtered_trial_scores.png שמציג באופן חזותי אילו מודלים נדחו באיטרציה הזו.
אפשר גם להריץ את הפקודה הבאה:
gcloud storage cat gs://<path to 'model_selection_dir'>/MODEL_SELECTION_STATE.json
שמציג סיכום של החזרות והמצב הנוכחי של משימת הבקר לבחירת המודל, שם המשימה וקישורים לכל חזרה:
{
"start_num_models": 30,
"final_num_models": 10,
"num_models_to_remove_per_iter": 5,
"accuracy_metric_id": "top_1_accuracy_without_latency",
"latency_metric_id": "latency_milli_seconds",
"iterations": [
{
"num_trials": 30,
"trials_to_retrain": [
"27",
"16",
...,
"14"
],
"search_job_name": "projects/123456/locations/europe-west4/nasJobs/2111217356469436416",
"search_job_link": "https://console.cloud.google.com/agent-platform/locations/europe-west4/training/2111217356469436416/cpu?project=my-project",
"latency_calculator_job_name": "projects/123456/locations/europe-west4/customJobs/6909239809479278592",
"latency_calculator_job_link": "https://console.cloud.google.com/agent-platform/locations/europe-west4/training/6909239809479278592/cpu?project=my-project",
"desired_training_step_pct": 2.0
},
...,
{
"num_trials": 15,
"trials_to_retrain": [
"14",
...,
"5"
],
"search_job_name": "projects/123456/locations/europe-west4/nasJobs/7045544066951413760",
"search_job_link": "https://console.cloud.google.com/agent-platform/locations/europe-west4/training/7045544066951413760/cpu?project=my-project",
"latency_calculator_job_name": "projects/123456/locations/europe-west4/customJobs/2790768318993137664",
"latency_calculator_job_link": "https://console.cloud.google.com/agent-platform/locations/europe-west4/training/2790768318993137664/cpu?project=my-project",
"desired_training_step_pct": 28.57936507936508
},
{
"num_trials": 10,
"trials_to_retrain": [],
"search_job_name": "projects/123456/locations/europe-west4/nasJobs/2742864796394192896",
"search_job_link": "https://console.cloud.google.com/agent-platform/locations/europe-west4/training/2742864796394192896/cpu?project=my-project",
"latency_calculator_job_name": "projects/123456/locations/europe-west4/customJobs/1490864099985195008",
"latency_calculator_job_link": "https://console.cloud.google.com/agent-platform/locations/europe-west4/training/1490864099985195008/cpu?project=my-project",
"desired_training_step_pct": 101.0
}
]
}
האיטרציה האחרונה כוללת את המספר הסופי של מודלים לדוגמה עם התפלגות ציונים טובה. המודלים האלה והציונים שלהם משמשים לחיפוש משימות ה-proxy בשלב הבא. אם טווח הניקוד הסופי של הדיוק והזמן של מודלי הייחוס נראה טוב יותר או קרוב למודל הבסיס הקיים, זה סימן מוקדם טוב לגבי מרחב החיפוש. אם טווח הניקוד הסופי של הדיוק וזמן האחזור גרוע משמעותית מהבסיס, צריך לבדוק שוב את מרחב החיפוש.
שימו לב: אם יותר מ-20% מהניסויים באיטרציה הראשונה נכשלים, צריך לבטל את משימת בחירת המודל ולזהות את שורש הבעיה. יכול להיות שזו בעיה במרחב החיפוש או בהגדרות של גודל האצווה וקצב הלמידה.
שימוש במכשיר מקומי למדידת זמן אחזור כדי לבחור מודל
כדי להשתמש במכשיר מקומי לבדיקת זמן אחזור לצורך בחירת מודל, מריצים את הפקודה select_proxy_task_models בלי הדגלים latency docker ו-latency-docker, כי לא רוצים להפעיל את latency docker ב- Google Cloud. בשלב הבא, משתמשים בפקודה run_latency_calculator_local שמתוארת במדריך 4 כדי להפעיל את משימת חישוב זמן האחזור המקומי. במקום להעביר את הדגל --search_job_id, מעבירים את הדגל --controller_job_id עם מזהה המשימה המספרי של בחירת המודל, שמתקבל אחרי שמריצים את הפקודה select_proxy_task_models.
המשך העבודה של בקר בחירת המודל
במצבים הבאים צריך להמשיך את משימת הבקר לבחירת המודל:
- משימת הבקר לבחירת מודל ההורה נכשלת (מקרה נדיר).
- בטעות ביטלתם את המשימה של בקר בחירת המודל.
קודם כול, אל תבטלו את משימת האיטרציה של ה-NAS הצאצא (בכרטיסייה NAS) אם היא כבר פועלת. כדי להמשיך את משימת הבקר לבחירת מודל ההורה, מריצים את הפקודה select_proxy_task_models כמו קודם, אבל הפעם מעבירים את הדגל --previous_model_selection_dir ומגדירים אותו לספריית הפלט של משימת הבקר הקודמת לבחירת מודל. משימת הבקר לבחירת המודל שחודשה טוענת את המצב הקודם שלה מהספרייה וממשיכה לפעול כמו קודם.
חיפוש משימות חלופיות
אחרי שמוצאים את המודלים המועמדים לקורלציה ואת הציונים שלהם באימון מלא, השלב הבא הוא להשתמש בהם כדי להעריך את ציוני הקורלציה של אפשרויות שונות למשימות פרוקסי, ולבחור את משימת הפרוקסי האופטימלית. כלי החיפוש של משימות Proxy יכול למצוא באופן אוטומטי משימת Proxy, שמציעה את היתרונות הבאים:
- עלות החיפוש הנמוכה ביותר של NAS.
- עומד בדרישות הסף המינימליות למתאם אחרי שמספקים לו הגדרה של מרחב חיפוש של משימת פרוקסי.
חשוב לזכור שיש שלושה מאפיינים נפוצים לחיפוש משימת Proxy אופטימלית:
- מספר קטן יותר של שלבי אימון.
- כמות קטנה יותר של נתוני אימון.
- המודל הוקטן.
כדי ליצור מרחב חיפוש נפרד של משימות Proxy, אפשר לדגום את המאפיינים האלה כמו שמוצג כאן:

האחוזים שמופיעים למעלה הם רק הצעה משוערת ודוגמה. בפועל, אתם יכולים לבחור כל אפשרות נפרדת.
שימו לב שלא כללנו את המאפיין training-steps במרחב החיפוש שלמעלה. הסיבה לכך היא שכלי החיפוש של משימת ה-proxy מחשב את שלב האימון האופטימלי בהתאם לבחירה של משימת ה-proxy.
כדאי לבחור במשימת פרוקסי של [50% training data, 25% model scale]. מגדירים את מספר שלבי האימון לאותה כמות כמו באימון בסיסי מלא.
כדי להעריך את משימת ה-proxy, כלי החיפוש של משימת ה-proxy מפעיל אימון למודלים המועמדים למתאם, עוקב אחרי ציוני הדיוק הנוכחיים שלהם ומחשב באופן רציף את ציון המתאם של הדירוג (באמצעות ציוני האימון המלאים הקודמים של מודלי העזר):

לכן, כלי החיפוש של משימת ה-proxy יכול להפסיק את האימון של משימת ה-proxy ברגע שמתקבלת הקורלציה הרצויה (למשל 0.65), או להפסיק מוקדם יותר אם יש חריגה ממכסת עלות החיפוש (למשל מגבלה של 3 שעות לכל משימת proxy). לכן, לא צריך לחפש באופן מפורש בשלבי האימון. כלי החיפוש של משימות ה-proxy מעריך כל משימת proxy ממרחב החיפוש הנפרד שלכם כחיפוש Grid, ומספק לכם את האפשרות הטובה ביותר.
כדי להדגים איך אתם יכולים להגדיר מרחב חיפוש משלכם, בהמשך מופיעה דוגמה להגדרה של מרחב חיפוש למשימת פרוקסי ב-MnasNet mnasnet_proxy_task_config_generator, שמוגדרת בקובץ proxy_task/proxy_task_search_spaces.py:
# MNasnet training-data size choices.
MNASNET_TRAINING_DATA_PCT_LIST = [25, 50, 75, 95]
# Training data path regex pattern.
_TRAINING_DATA_PATH_REGEX = r"gs://.*/.*"
def update_mnasnet_proxy_training_data(
baseline_docker_args_map: Dict[str, Any],
training_data_pct: int) -> Optional[Dict[str, Any]]:
"""Updates MNasnet baseline docker to use a certain training_data_pct."""
proxy_task_docker_args_map = copy.deepcopy(baseline_docker_args_map)
# Imagenet training data path looks like:
# gs://<path to imagenet data>/train-00[0-7]??-of-01024.
if not re.match(_TRAINING_DATA_PATH_REGEX,
baseline_docker_args_map["training_data_path"]):
raise ValueError(
"Training data path %s does not match the desired pattern." %
baseline_docker_args_map["training_data_path"])
root_path, _ = baseline_docker_args_map["training_data_path"].rsplit("/", 1)
if training_data_% == 25:
proxy_task_docker_args_map["training_data_path"] = os.path.join(
root_path, "train-00[0-1][0-4]?-of-01024*")
elif training_data_% == 50:
proxy_task_docker_args_map["training_data_path"] = os.path.join(
root_path, "train-00[0-4]??-of-01024*")
elif training_data_% == 75:
proxy_task_docker_args_map["training_data_path"] = os.path.join(
root_path, "train-00[0-6][0-4]?-of-01024*")
elif training_data_% == 95:
proxy_task_docker_args_map["training_data_path"] = os.path.join(
root_path, "train-00[0-8][0-4]?-of-01024*")
else:
logging.warning("Mnasnet training_data_% %d is not supported.",
training_data_pct)
return None
proxy_task_docker_args_map["validation_data_path"] = os.path.join(
root_path, "train-009[0-4]?-of-01024")
return proxy_task_docker_args_map
def mnasnet_proxy_task_config_generator(
baseline_docker_args_map: Dict[str, Any]
) -> List[proxy_task_utils.ProxyTaskConfig]:
"""Returns a list of proxy-task configs to be evaluated for MNasnet.
Args:
baseline_docker_args_map: A set of baseline training-docker arguments in
the form of a dictionary of {'key', val}. The different proxy-task
configs to try can be built by modifying this baseline.
Returns:
A list of proxy-task configs to be evaluated for this
proxy-task search space.
"""
proxy_task_config_list = []
# NOTE: Will not search over model-scale for MNasnet.
for training_data_% in MNASNET_TRAINING_DATA_PCT_LIST:
proxy_task_docker_args_map = update_mnasnet_proxy_training_data(
baseline_docker_args_map=baseline_docker_args_map,
training_data_pct=training_data_pct)
if not proxy_task_docker_args_map:
continue
proxy_task_name = "mnasnet_proxy_training_data_pct_{}".format(
training_data_pct)
proxy_task_config_list.append(
proxy_task_utils.ProxyTaskConfig(
name=proxy_task_name, docker_args_map=proxy_task_docker_args_map))
return proxy_task_config_list
בדוגמה הזו, אנחנו יוצרים מרחב חיפוש פשוט על אחוז נתוני האימון 25, 50, 75 ו-95 (שימו לב ש-100 אחוז מנתוני האימון לא משמשים ל-stage1-search).
הפונקציה mnasnet_proxy_task_config_generator מקבלת תבנית בסיסית נפוצה של ארגומנטים לאימון Docker, ואז משנה את הארגומנטים האלה לכל גודל רצוי של נתוני אימון למשימת פרוקסי. לאחר מכן, היא מחזירה רשימה של proxy-task-config, שכלי החיפוש של proxy-task מעבד מאוחר יותר בזה אחר זה באותו סדר. לכל הגדרת proxy-task יש name ו-docker_args_map, שהם מפת מפתח/ערך לארגומנטים של Docker ב-proxy-task.
אתם יכולים להגדיר את מרחב החיפוש לפי הדרישות שלכם, ולתכנן מרחבי חיפוש למשימות proxy אפילו ליותר משני הממדים של נתוני אימון מצומצמים או קנה מידה מצומצם של מודל. עם זאת, לא מומלץ לחפש באופן מפורש בשלבי האימון כי זה יגרום לבזבוז של חישובים חוזרים. כלי החיפוש של משימות ה-proxy יכול לטפל במאפיין הזה בשבילכם.
בחיפוש הראשון של משימת Proxy, אפשר לנסות לצמצם רק את נתוני האימון (כמו בדוגמה של MnasNet) ולדלג על צמצום קנה המידה של המודל, כי שינוי קנה המידה של המודל יכול לכלול כמה פרמטרים ב-image-size, ב-num-filters או ב-num-blocks.
ברוב המקרים, נתוני האימון המצומצמים (והחיפוש המשתמע בשלבי האימון המצומצמים) מספיקים כדי למצוא משימת Proxy טובה.
מגדירים את מספר שלבי האימון למספר שבו השתמשתם באימון המלא של המודל הבסיסי.
יש הבדלים בין הגדרות האימון המלא בשלב 2 לבין הגדרות האימון של משימת ה-proxy בשלב 1. במשימת ה-proxy, צריך להקטין את batch-size בהשוואה להגדרת האימון המלאה של בסיס ההשוואה, כדי להשתמש רק ב-2 או ב-4 יחידות GPU.
בדרך כלל, אימון מלא משתמש ב-4 מעבדי GPU, ב-8 מעבדי GPU או יותר, אבל משימת ה-proxy משתמשת רק ב-2 מעבדי GPU או ב-4 מעבדי GPU.
הבדל נוסף הוא הפיצול בין האימון לאימות.
הנה דוגמה לשינויים בהגדרות של MnasNet, מ-4 מעבדי GPU לאימון מלא בשלב 2 ל-2 מעבדי GPU ופיצול אימות שונה לחיפוש משימות פרוקסי:

מפעילים את משימת בקר החיפוש של משימת ה-proxy באמצעות הפקודה הבאה (צריך חשבון שירות):
DATE="$(date '+%Y%m%d_%H%M%S')"
project_id=<your project-id>
# You can choose any unique docker id below.
trainer_docker_id=${USER}_trainer_${DATE}
trainer_docker_file=<path to your trainer dockerfile>
latency_calculator_docker_id=${USER}_model_selection_${DATE}
latency_calculator_docker_file=${USER}_latency_${DATE}
region=<your job region such as 'us-central1'>
search_space_module=<path to your NAS job search space module>
accelerator_type="NVIDIA_TESLA_V100"
num_gpus=2
# Your bucket should be for your project and in the same region as the job.
root_output_dir=<gs://your-bucket>
# Your latency computation device.
target_device_type="CPU"
####### Proxy task search related parameters ######
proxy_task_search_controller_docker_id=${USER}_proxy_task_search_${DATE}
job_name=<your job name>
# Path to your proxy task search space definition. For ex:
# 'proxy_task.proxy_task_search_spaces.mnasnet_proxy_task_config_generator'
proxy_task_config_generator_module=<path to your proxy task config generator module>
# The previous model-slection job provides the candidate-correlation-models
# and their scores.
proxy_task_model_selection_job_id=<Numeric job id of your previous model-selection>
# During proxy-task search, the proxy-task training is stopped
# when the following correlation score is achieved.
desired_accuracy_correlation=0.65
# During proxy-task search, the proxy-task training is stopped
# if the runtime exceeds this limit: 4 hrs.
training_time_hrs_limit=4
# The proxy-task is marked a good candidate only if the latency
# correlation is also above the required threshold.
# Note: This won't be used if you do not have a latency job.
desired_latency_correlation=0.65
# Early stop a proxy-task evaluation if you already have a better candidate.
# If False, evaluate all proxy-taask candidates.
early_stop_proxy_task_if_not_best=False
# Use the service account that you set-up for your project.
service_account=<your service account>
###################################################
python3 vertex_nas_cli.py build \
--project_id=${project_id} \
--region=${region} \
--trainer_docker_id=${trainer_docker_id} \
--trainer_docker_file=${trainer_docker_file} \
--latency_calculator_docker_id=${latency_calculator_docker_id} \
--latency_calculator_docker_file=${latency_calculator_docker_file} \
--proxy_task_search_controller_docker_id=${proxy_task_search_controller_docker_id}
# The command below passes 'dummy' arguments for trainer-docker
# and latency-docker. You need to modify them for your own docker.
python3 vertex_nas_cli.py search_proxy_task \
--service_account=${service_account} \
--proxy_task_search_controller_docker_id=${proxy_task_search_controller_docker_id} \
--proxy_task_config_generator_module=${proxy_task_config_generator_module} \
--proxy_task_model_selection_job_id=${proxy_task_model_selection_job_id} \
--proxy_task_model_selection_job_region=${region} \
--desired_accuracy_correlation={$desired_accuracy_correlation}\
--training_time_hrs_limit=${training_time_hrs_limit} \
--desired_latency_correlation=${desired_latency_correlation} \
--early_stop_proxy_task_if_not_best=${early_stop_proxy_task_if_not_best} \
--project_id=${project_id} \
--region=${region} \
--trainer_docker_id=${trainer_docker_id} \
--job_name=${job_name} \
--search_space_module=${search_space_module} \
--accelerator_type=${accelerator_type} \
--num_gpus=${num_gpus} \
--root_output_dir=${root_output_dir} \
--latency_calculator_docker_id=${latency_calculator_docker_id} \
--latency_docker_flags \
dummy_latency_flag1="dummy_latency_val" \
--target_device_type=${target_device_type} \
--search_docker_flags \
dummy_trainer_flag1="dummy_trainer_val"
אחרי שמפעילים את משימת ה-proxy הזו לבקרת החיפוש, מקבלים קישור למשימה. שם המשימה מתחיל בקידומת Search_controller_. דוגמה לממשק משתמש של משימה:

ה-search_controller_dir יכיל את כל הפלטים, ואפשר לבדוק את היומנים בלחיצה על הקישור View logs.
כברירת מחדל, המשימה הזו משתמשת במעבד אחד בענן כדי לפעול ברקע כמשימה ייעודית, ואז משיקה ומנהלת משימות NAS צאצא לכל הערכה של משימת פרוקסי.

לכל משימת NAS של proxy-task יש שם כמו ProxyTask_<your-job-name>_<proxy-task-name>, כאשר <proxy-task-name> הוא מה שמודול מחולל ההגדרות של proxy-task מספק לכל proxy-task. אפשר להריץ רק הערכה אחת של משימת פרוקסי בכל פעם.
אפשר גם להריץ את הפקודה הבאה:
gcloud storage cat gs://<path to 'search_controller_dir'>/SEARCH_CONTROLLER_STATE.json
הפקודה הזו מציגה סיכום של כל הערכות המשימות של שרת ה-proxy, המצב הנוכחי של משימת בקר החיפוש, שם המשימה וקישורים לכל הערכה:
{
"proxy_tasks_map": {
"mnasnet_proxy_training_data_pct_25": {
"proxy_task_stats": {
"training_steps": [
1249,
2499,
...,
18749
],
"accuracy_correlation_over_step": [
-0.06666666666666667,
-0.6,
...,
0.7857142857142856
],
"accuracy_correlation_p_value_over_step": [
0.8618005952380953,
0.016666115520282188,
...,
0.005505952380952381
],
"median_accuracy_over_step": [
0.011478611268103123,
0.04956454783678055,
...,
0.32932570576667786
],
"median_training_time_hrs_over_step": [
0.11611097933475001,
0.22913257125276987,
...,
1.6682701704073444
],
"latency_correlation": 0.9555555555555554,
"latency_correlation_p_value": 5.5114638447971785e-06,
"stopping_state": "Met desired correlation",
"posted_stop_trials_message": true,
"final_training_time_in_hours": 1.6675102778428197,
"final_training_steps": 18512
},
"proxy_task_name": "mnasnet_proxy_training_data_pct_25",
"search_job_name": "projects/123456/locations/europe-west4/nasJobs/4173661476642357248",
"search_job_link": "https://console.cloud.google.com/agent-platform/locations/europe-west4/training/4173661476642357248/cpu?project=my-project",
"latency_calculator_job_name": "projects/123456/locations/europe-west4/customJobs/8785347495069745152",
"latency_calculator_job_link": "https://console.cloud.google.com/agent-platform/locations/europe-west4/training/8785347495069745152/cpu?project=my-project"
},
...,
"mnasnet_proxy_training_data_pct_95": {
"proxy_task_stats": {
"training_steps": [
1249,
...,
18749
],
"accuracy_correlation_over_step": [
-0.3333333333333333,
...,
0.7857142857142856,
-5.0
],
"accuracy_correlation_p_value_over_step": [
0.21637345679012346,
...,
0.005505952380952381,
-5.0
],
"median_accuracy_over_step": [
0.01120645459741354,
...,
0.38238024711608887,
-1.0
],
"median_training_time_hrs_over_step": [
0.11385884770307843,
...,
1.5466042930547819,
-1.0
],
"latency_correlation": 0.9555555555555554,
"latency_correlation_p_value": 5.5114638447971785e-06,
"stopping_state": "Met desired correlation",
"posted_stop_trials_message": true,
"final_training_time_in_hours": 1.533235285929564,
"final_training_steps": 17108
},
"proxy_task_name": "mnasnet_proxy_training_data_pct_95",
"search_job_name": "projects/123456/locations/europe-west4/nasJobs/2341822328209408000",
"search_job_link": "https://console.cloud.google.com/agent-platform/locations/europe-west4/training/2341822328209408000/cpu?project=my-project",
"latency_calculator_job_name": "projects/123456/locations/europe-west4/customJobs/7575005095213924352",
"latency_calculator_job_link": "https://console.cloud.google.com/agent-platform/locations/europe-west4/training/7575005095213924352/cpu?project=my-project"
}
},
"best_proxy_task_name": "mnasnet_proxy_training_data_pct_75"
}
המשתנה proxy_tasks_map מאחסן את הפלט של כל הערכת משימת פרוקסי, והמשתנה best_proxy_task_name מתעד את משימת הפרוקסי הטובה ביותר לחיפוש. לכל רשומה של משימת פרוקסי יש נתונים נוספים כמו proxy_task_stats, שמתעד את ההתקדמות של מתאם הדיוק, ערכי ה-p שלו, הדיוק החציוני וזמן האימון החציוני בשלבי האימון. הוא גם מתעד את הקורלציה שקשורה לזמן האחזור, אם רלוונטי, ומתעד את הסיבה להפסקת המשימה (למשל, חריגה ממגבלת זמן האימון) ואת שלב האימון שבו היא נעצרה. אפשר גם להציג את הנתונים הסטטיסטיים האלה כתרשימים. לשם כך, מעתיקים את התוכן של search_controller_dir לתיקייה המקומית באמצעות הפקודה הבאה:
gcloud storage cp gs://<path to 'search_controller_dir'>/* /your/local/dir
ולבדוק את תמונות העלילה. לדוגמה, בתרשים הבא מוצג הקשר בין הדיוק לזמן האימון של משימת ה-proxy הטובה ביותר:

אחרי שהחיפוש הסתיים ומצאתם את ההגדרה הטובה ביותר למשימת ה-proxy, אתם צריכים:
- מגדירים את מספר שלבי האימון ל-
final_training_stepsשל משימת ה-proxy המנצחת. - מגדירים את שלבי ה-cosine-decay כמו
final_training_steps, כך שקצב הלמידה יהיה כמעט אפס לקראת הסוף. - [אופציונלי] לבצע הערכה אחת של ציון האימות בסוף האימון, כדי לחסוך בעלויות של הערכות מרובות.
שימוש במכשיר מקומי למדידת זמן אחזור לצורך חיפוש משימות פרוקסי
כדי להשתמש במכשיר מקומי לבדיקת זמן אחזור לחיפוש משימות פרוקסי, מריצים את הפקודה search_proxy_task בלי הדגלים latency docker ו-latency-docker, כי לא רוצים להפעיל את ה-latency docker ב- Google Cloud. בשלב הבא, משתמשים בפקודה run_latency_calculator_local שמתוארת במדריך 4 כדי להפעיל את משימת חישוב זמן האחזור המקומי. במקום להעביר את הדגל --search_job_id, מעבירים את הדגל --controller_job_id עם מזהה המשימה המספרי של proxy-task-search שמתקבל אחרי שמריצים את הפקודה search_proxy_task.
המשך של משימת בקר החיפוש של משימת ה-proxy
במצבים הבאים צריך להמשיך את משימת בקר החיפוש של משימת ה-proxy:
- משימת הבקר לחיפוש משימות פרוקסי של ההורה מסתיימת (מקרה נדיר).
- בטעות ביטלתם את המשימה של בקר החיפוש של משימת ה-proxy.
- אתם רוצים להרחיב את מרחב החיפוש של משימת ה-proxy בשלב מאוחר יותר (אפילו אחרי כמה ימים).
קודם כול, אל תבטלו את משימת האיטרציה של ה-NAS הצאצא (בכרטיסייה NAS) אם היא כבר פועלת. כדי להמשיך את משימת בקר החיפוש של משימת ה-proxy הראשית, מריצים את הפקודה search_proxy_task כמו קודם, אבל הפעם מעבירים את הדגל --previous_proxy_task_search_dir ומגדירים אותו לספריית הפלט של משימת בקר החיפוש של משימת ה-proxy הקודמת. משימת בקר החיפוש של שרת ה-proxy שחודשה טוענת את המצב הקודם שלה מהספרייה וממשיכה לפעול כמו קודם.
בדיקות אחרונות
שתי הבדיקות האחרונות של משימת ה-proxy כוללות את טווח התגמול ושמירת הנתונים לניתוח לאחר החיפוש.
טווח התגמול
התגמול שמדווח לבקר צריך להיות בטווח [1e-3, 10]. אם זה לא המצב, אפשר להגדיל את התגמול באופן מלאכותי כדי להשיג את היעד הזה.
שמירת נתונים לניתוח אחרי החיפוש
קוד המשימה של שרת ה-proxy צריך לשמור את כל המדדים והנתונים הנוספים במיקום ב-Cloud Storage, שיכול להיות שימושי לניתוח מרחב החיפוש בהמשך. החיפוש של ארכיטקטורה נוירונית בפלטפורמת הסוכנים שלנו תומך רק בעד חמישה ערכים של נקודה צפה (other_metrics) שניתן לתעד.
כל מדד נוסף צריך להישמר במיקום ב-Cloud Storage לניתוח מאוחר יותר.