תחילת העבודה עם AlphaEvolve ב-Google Cloud

1. מבוא

בשיעור Codelab הזה, תריצו את שני הניסויים הראשונים שלכם ב-AlphaEvolve ב-Google Cloud. ‫AlphaEvolve הוא מסגרת קוד אבולוציונית מבוססת-AI של Google DeepMind: היא משתמשת ב-Gemini כדי לכתוב ולשפר קוד, שמקבל ציון לפי מדד שאתם מגדירים. מתחילים בבעיה קטנה של גיאומטריה שנקראת 'אריזת מעגלים', שבה אפשר לראות את התוצאה משתפרת, ואז חוזרים על התהליך בבעיה קשה יותר שנקראת 'בעיית הסוכן הנוסע', כדי שהדפוס יישאר בזיכרון.

שני הניסויים משתמשים בהערכה מקומית – קוד המועמד פועל במחשב שלכם, כך שאין GPU ואין אשכול לניהול. השימוש היחיד בענן הוא ב-AlphaEvolve API שיוצר מועמדים.

הפעולות שתבצעו:

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

הדרישות

• דפדפן אינטרנט כמו Chrome
• פרויקט ב-Google Cloud שהחיוב בו מופעל
• ‫Python 3.9 ואילך ו-uv
• היכרות בסיסית עם Python ועם שורת הפקודה

ה-Codelab הזה מיועד למהנדסי AI/ML ולמפתחים בכל הרמות. לא נדרש ידע בחישוב אבולוציוני.

הזמן המשוער לסיום: 45-60 דקות.

עלות: בשיעור Codelab הזה נעשה שימוש בהערכה מקומית (ללא GPU, ללא GKE). החיוב היחיד הוא על השימוש ב-AlphaEvolve API ליצירת מועמדים.

נבדק עם: ספריית הלקוח AlphaEvolve Cloud גרסה v0.1.0, ‏ Python 3.9 ומעלה, בדוגמאות circle_packing ו-tsp.

‫2. לפני שמתחילים

בוחרים את הפרויקט ומפעילים את ה-API

1. ב-Google Cloud Console, בוחרים פרויקט שמופעל בו חיוב או יוצרים פרויקט חדש עם חיוב מופעל, ואז מגדירים אותו במסוף:

gcloud config set project <YOUR_PROJECT_ID>

2. מפעילים את Discovery Engine API, שמשמש את AlphaEvolve:

gcloud services enable discoveryengine.googleapis.com

איך מוצאים את המזהה של אפליקציית Gemini Enterprise

‫AlphaEvolve מופעל באמצעות Gemini Enterprise (ממשק ה-REST הבסיסי הוא Discovery Engine API). להגדרה של GE_APP_ID צריך את המזהה של האפליקציה, ולא את השם המוצג שלה.

1. פותחים את הדף Gemini Enterprise apps (אפליקציות Gemini Enterprise) של הפרויקט.
2. לוחצים על האפליקציה ומעתיקים את השדה ID (לדוגמה, gemini-enterprise-1234567890_1234567890123).

חשוב לשמור את המזהה הזה כי תצטרכו להדביק אותו ב-.env בהמשך. משאירים את ASSISTANT=default_assistant אלא אם הקציתם Assistant בהתאמה אישית.

אימות, שיבוט והתקנה

1. אימות באמצעות Application Default Credentials:

gcloud auth application-default login

2. משכפלים את מאגר הדוגמאות ופותחים אותו. מריצים כל פקודה מהספרייה הבסיסית של המאגר הזה:

git clone https://github.com/Google-Cloud-AI/alphaevolve-on-googlecloud.git
cd alphaevolve-on-googlecloud

3. יוצרים סביבה וירטואלית ומתקינים בה את ספריית הלקוח AlphaEvolve:

uv venv
uv pip install -e ".[dev]"

‫uv venv יוצר .venv במאגר; ‫uv pip install -e ".[dev]" מתקין את חבילת alpha_evolve (ניתנת לעריכה) בתוספת כלי בדיקה. תריצו ניסויים באמצעות uv run, שמשתמש בסביבה הזו באופן אוטומטי.

3. הסבר על הלולאה של AlphaEvolve

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

תוכנית הזרעים ו-EVOLVE-BLOCK

‫AlphaEvolve משכתב רק את הקוד שבין שני סמנים. כל השאר בקובץ הוא פיגום קבוע שהיא לא יכולה לגעת בו. פותחים את examples/circle_packing/src/program.py – הגרעין הוא אריזה פשוטה של טבעות קונצנטריות:

# EVOLVE-BLOCK-START
"""Constructor-based circle packing for n=26 circles"""
import numpy as np


def construct_packing(n, random_seed: int):
    """Construct an arrangement of 26 circles in a unit square.

    The goal is to maximize the sum of their radii.
    Returns (centers, radii, sum_of_radii).
    """
    rng = np.random.default_rng(random_seed)
    centers = np.zeros((n, 2))

    # A simple starting pattern — evolution will improve this.
    centers[0] = [0.5, 0.5]                      # one circle in the center
    for i in range(8):                           # 8 in an inner ring
        angle = 2 * np.pi * i / 8
        centers[i + 1] = [0.5 + 0.3 * np.cos(angle), 0.5 + 0.3 * np.sin(angle)]
    for i in range(16):                          # 16 in an outer ring
        angle = 2 * np.pi * i / 16 * rng.uniform(0.9, 1.1)
        centers[i + 9] = [0.5 + 0.7 * np.cos(angle), 0.5 + 0.7 * np.sin(angle)]

    centers = np.clip(centers, 0.01, 0.99)       # keep everything in the square
    radii = compute_max_radii(centers, random_seed)
    return centers, radii, np.sum(radii)


def compute_max_radii(centers, random_seed: int):
    """Grow each circle to touch its nearest border or neighbor (no overlaps)."""
    # ... see src/program.py for the full helper ...
# EVOLVE-BLOCK-END

כל מה שמחוץ ל-EVOLVE-BLOCK-START / EVOLVE-BLOCK-END – כולל הפונקציה evaluate() והבדיקות של החפיפה – נשאר קפוא. ההפרדה הזו היא כל הסוד: Gemini יכול להציע כל אלגוריתם אריזה שהוא רוצה, אבל הוא לא יכול לשנות את הניקוד של מועמד.

המעריך והציון

‫examples/circle_packing/src/evaluate.py מריץ כל מועמד בארגז חול ומחזיר ציון. במקרה של circle packing, המדד הוא sum_of_radii, וככל שהערך גבוה יותר, כך טוב יותר:

CIRCLE_PACKING_EVALUATION_METRIC = "sum_of_radii"
CIRCLE_PACKING_EVALUATION_INPUTS = {"n": 26}

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

זו הצורה של כל בעיה ב-AlphaEvolve: קוד שאפשר לבטא ב-EVOLVE-BLOCK, הערכה שאפשר לבצע אוטומטית וציון סקלרי יחיד שאפשר למקסם.

4. הפעלת הניסוי הראשון

הגדרת הניסוי

מתיקיית הבסיס של המאגר, יוצרים את .env מהתבנית של דיאגרמת עיגולים:

cp examples/circle_packing/example.env .env

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

PROJECT_ID=<YOUR_PROJECT_ID>
GE_APP_ID=<YOUR_GEMINI_ENTERPRISE_APP_ID>

הגדרות ברירת המחדל יוצרות מועמדים עם שילוב של מודלים של Gemini (MODEL_1=gemini-3.5-flash במשקל 0.7, MODEL_2=gemini-3.1-pro-preview במשקל 0.3) ומגבילות את החיפוש ל-MAX_PROGRAMS_EVALUATED=10 עם CONCURRENCY=4 – מספיק כדי לראות את הלולאה פועלת במהירות.

התחלת האבולוציה

מריצים את הניסוי מהספרייה הראשית של המאגר:

uv run python -m examples.circle_packing.src.run_evolution

הפעולה הזו תעלה את תוכנית הזרע, תתחיל את החיפוש ותפעיל את לולאת הבקרה המקומית עד ש-10 מועמדים ייבדקו. מכיוון שאתם קוראים למודול ישירות (ללא wrapper), אתם יכולים לראות בדיוק מה מופעל – ולערוך את הקובץ כדי להתנסות.

הפלט אמור להיראות כך:

INFO:alpha_evolve.experiment:Creating a new AlphaEvolve experiment
INFO:alpha_evolve.controller:Evolution loop started: 4 sampler(s), 32 evaluator(s), target=10 programs
INFO:alpha_evolve.controller:Waiting for the backend to generate candidates... (generated=0, evaluated=0/10, idle=10s)
INFO:alpha_evolve.workers:Candidate 1060655338894100 evaluated → sum_of_radii=0.8114
INFO:alpha_evolve.controller:Progress: generated=2, evaluated=1/10, queued=0
...
INFO:alpha_evolve.controller:Stopping criteria met (10/10 programs evaluated).

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

הערה: פתרון בעיות: בדרך כלל, השגיאות PERMISSION_DENIED או 403 מציינות ש-Discovery Engine API לא מופעל בפרויקט. בודקים שוב את השלב 'לפני שמתחילים'. אם הריצה מסתיימת מיד עם ההודעה 'Failed to create experiment' (הניסיון ליצור ניסוי נכשל), סימן שפרטי הכניסה או GE_APP_ID ב-.env שגויים.

5. קריאת התוצאות

הדוח מציג את התוכניות המובילות לפי דירוג sum_of_radii (דירוג גבוה יותר טוב יותר). שני דברים שכדאי לבדוק:

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

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

עכשיו יש לכם את הלולאה המלאה: seed -> generate -> evaluate -> score -> repeat. כל השאר ב-AlphaEvolve הוא וריאציה של המקום שבו ההערכה מתבצעת.

6. פיתוח חיפוש אמיתי: TSP

האלגוריתם של Circle packing מתכנס במהירות. כדי לראות את החיפוש פועל על בעיה מורכבת יותר, אפשר לפתח היוריסטיקה של בעיית הסוכן הנוסע. הדפוס זהה – רק ה-seed והמדד משתנים, והדוגמה של TSP עושה שימוש חוזר ב-.env (פרויקט, תקציב ובו-זמניות).

1. כדאי להגדיל את התקציב ב-.env כדי לאפשר לחיפוש הארוך יותר להשתפר:

# in .env — raise the generation cap and the evaluation target together
MAX_PROGRAMS_GENERATED=20
MAX_PROGRAMS_EVALUATED=20

2. מריצים אותו מהתיקייה הראשית של המאגר:

uv run python -m examples.tsp.src.run_evolution

ה-seed כאן הוא סיור שכן קרוב ב-50 ערים. המדד הוא neg_tour_length (אורך הסיור הממוצע השלילי ב-5 מקרים קבועים, כך שערך גבוה יותר הוא טוב יותר). פותחים את examples/tsp/src/program.py ורואים שרק construct_tour(distances, n) נמצא בתוך EVOLVE-BLOCK.

שתי הבעיות הן מאותו סוג, אבל הן מתייחסות לחלקים שונים:

בעיה	שפה	הערכה	מטריקה (ערך גבוה יותר מצביע על ביצועים טובים יותר)	מה משתנה
circle_packing	Python	לפי אזור הזמן המקומי exec()	sum_of_radii	construct_packing()
tsp	Python	לפי אזור הזמן המקומי exec()	neg_tour_length	construct_tour()

במהלך החיפוש, אפשר לראות את הערך של neg_tour_length עולה (מתקרב לאפס) כש-Gemini עובר משיטת השכן הקרוב ביותר לשיפורים בסגנון 2-opt או or-opt – אסטרטגיות שלא כתבתם.

7. שינוי החיפוש

עכשיו, אחרי ששתי ההרצות פועלות, אפשר לשנות את התקציב ב-.env:

• ‫MAX_PROGRAMS_EVALUATED – כמה מועמדים להבקיע. יותר מועמדים = חיפוש מעמיק יותר ועלות/זמן גבוהים יותר.
• ‫CONCURRENCY – כמה מועמדים נוצרים בבת אחת.
• ‫MODEL_1 / MODEL_2 (עם MODEL_1_WEIGHT / MODEL_2_WEIGHT) – התערובת המשוקללת של מודלים של Gemini שמייצרים מועמדים בהרצה של circle-packing (מודול ה-TSP קורא MODEL אחד במקום). הערכים המותרים הם gemini-3.5-flash ו-gemini-3.1-pro-preview. כדי למצוא תוכניות טובות יותר בפחות דורות, כדאי להטות את המשקל לכיוון המודל החזק יותר.

אחרי כל שינוי, מריצים מחדש את הפקודה עם uv run python -m examples.circle_packing.src.run_evolution (או עם מודול tsp).

הערה: הגדלת MAX_PROGRAMS_EVALUATED ומעבר למודל גדול יותר מגדילים את העלות. בשיעור Codelab הזה נעשה שימוש בהערכה מקומית, ולכן לא נחייב אתכם על שימוש ב-GPU. עם זאת, עדיין תצטרכו לשלם על השימוש ב-AlphaEvolve API לפי כל מועמד שנוצר. התחילו בקטן.

8. הסרת המשאבים

ב-codelab הזה נעשה שימוש בהערכה מקומית, כך שלא נשארים תהליכים שניתן לחייב עליהם – אין אשכולות, אין יחידות GPU ואין שירותים שנפרסו. כדי לאפס את תהליך התשלום באופן מלא:

git clean -xfd   # removes .env, .venv, and generated outputs

הערה: הפקודה git clean -xfd מוחקת את .env (כולל הגדרות הפרויקט) ואת .venv. אם רוצים להמשיך להתנסות, אפשר לדלג על השלב הזה.

אם יצרתם פרויקט רק בשביל ה-Codelab הזה, מוחקים אותו במסוף כדי להפסיק את כל החיובים.

9. מזל טוב

מעולה! הפעלתם את הניסויים הראשונים שלכם ב-AlphaEvolve ב-Google Cloud, ופיתחתם שני אלגוריתמים – circle packing ו-TSP heuristic – באמצעות תוכנת seed, פונקציית ניקוד ו-Gemini בלבד.

מה למדתם

• איך הלולאה של AlphaEvolve פועלת: seed -> generate -> evaluate -> score -> repeat
• הסכם EVOLVE-BLOCK שמאפשר למנוע את האופטימיזציה של המתכון על ידי חיפוש בלי להשפיע על המדד
• איך תובנות לגבי ציונים וכישלונות עוזרות לדור הבא
• איך מגדירים, מריצים, קוראים ומשפרים ניסוי של הערכה מקומית

Codelabs נוספים

הן עומדות בפני עצמן – אפשר לבצע אותן בכל סדר.

• פיתוח קוד שעבר קומפילציה באמצעות כלי הערכה מרחוק: פיתוח אלגוריתם Rust/C++ שמוערך על ידי כלי הערכה בקונטיינר ב-Cloud Run.
• פיתוח של כוונון עדין של מודלים גדולים של שפה ב-GKE + Ray: הרצת הערכות כבדות ומקבילות של GPU באשכול משלכם.

מסמכים לדוגמה

• מדריך למפתחים בנושא AlphaEvolve
• מאגר דוגמאות של AlphaEvolve
• דוגמה לתרשים אריזת עיגולים
• דוגמה ל-TSP