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

‫1. מבוא

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

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

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

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

הדרישות

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

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

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

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

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

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

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

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

gcloud config set project <YOUR_PROJECT_ID>

2. מפעילים את שני ממשקי ה-API שמשמשים ב-Codelab הזה – Discovery Engine API, שמשמש את AlphaEvolve, ו-Vertex AI API, שמשמש את מודלי Gemini שיוצרים מועמדים:

gcloud services enable \
  discoveryengine.googleapis.com \
  aiplatform.googleapis.com

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

‫AlphaEvolve מופעל באמצעות Gemini Enterprise (ה-API הבסיסי בארכיטקטורת 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.

הערה: פתרון בעיות: אם הפעלתם את התוסף והוא הסתיים מיד עם השגיאה FAILED_PRECONDITION וההודעה AlphaEvolve requires the Vertex AI API to be enabled in this project (נדרשת הפעלה של Vertex AI API בפרויקט הזה), סימן שהשירות aiplatform.googleapis.com חסר. צריך להפעיל אותו כמו שמוסבר בקטע 'לפני שמתחילים'. בדרך כלל, השגיאות PERMISSION_DENIED או 403 מציינות שממשק Discovery Engine API לא מופעל. אם מופיעה השגיאה 'יצירת הניסוי נכשלה' בלי אף אחת מהשגיאות האלה, סימן שפרטי הכניסה או GE_APP_ID ב-.env שגויים.

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

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

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

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

עכשיו יש לכם את הלולאה המלאה: נתונים ראשוניים -> יצירה -> הערכה -> ניקוד -> חזרה על התהליך. כל השאר ב-AlphaEvolve הוא וריאציה של המקום שבו ההערכה מתבצעת.

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

השיטה של אריזת עיגולים מתכנסת במהירות. כדי לראות את החיפוש פועל על בעיה מורכבת יותר, אפשר לפתח היוריסטיקה של בעיית הסוכן הנוסע. הדפוס זהה – רק ה-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 ובטוקנים של Vertex AI Gemini לכל מועמד שנוצר. התחילו בקטן.

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.
• פיתוח של כוונון מדויק של LLM ב-GKE + Ray: הרצת הערכות כבדות ומקבילות של GPU באשכול שלכם.

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

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