Google Cloud पर AlphaEvolve का इस्तेमाल शुरू करना

1. परिचय

इस कोडलैब में, Google Cloud पर AlphaEvolve के दो एक्सपेरिमेंट चलाए जाते हैं. AlphaEvolve, Google DeepMind का एआई-गाइडेड इवोल्यूशनरी कोडिंग फ़्रेमवर्क है. यह कोड लिखने और उसे बेहतर बनाने के लिए Gemini का इस्तेमाल करता है. साथ ही, आपके तय की गई मेट्रिक के आधार पर कोड को स्कोर करता है. इसकी शुरुआत, सर्कल पैकिंग से होती है. यह ज्यामिति से जुड़ी एक छोटी समस्या है, जिसमें नतीजे को बेहतर होते हुए देखा जा सकता है. इसके बाद, इसे ट्रैवलिंग सेल्समैन प्रॉब्लम पर दोहराया जाता है, ताकि पैटर्न बना रहे.

दोनों एक्सपेरिमेंट में लोकल इवैल्यूएशन का इस्तेमाल किया जाता है. इसमें, उम्मीदवार का कोड आपकी मशीन पर चलता है. इसलिए, इसमें जीपीयू और क्लस्टर को मैनेज करने की ज़रूरत नहीं होती. क्लाउड का इस्तेमाल सिर्फ़ AlphaEvolve API करता है, जो उम्मीदवार जनरेट करता है.

आप क्या करेंगे

• अपने Google Cloud प्रोजेक्ट के लिए, AlphaEvolve का एक्सपेरिमेंट कॉन्फ़िगर करना
• सर्कल-पैकिंग एल्गोरिदम को स्थानीय तौर पर बेहतर बनाने के लिए, इवोल्यूशनरी सर्च चलाना
• सबसे बेहतर तरीके से विकसित हुए प्रोग्राम का स्कोर, रैंकिंग, और विज़ुअलाइज़ेशन पढ़ना
• पैटर्न को सामान्य बनाने के लिए, ट्रैवलिंग सेल्समैन प्रॉब्लम पर लूप को दोहराना
• सर्च बजट (उम्मीदवार, कॉनकरेंसी, मॉडल) को ट्यून करना

आपको किन चीज़ों की ज़रूरत होगी

• Chrome जैसे वेब ब्राउज़र
• बिलिंग की सुविधा वाला Google Cloud प्रोजेक्ट
• Python 3.9 या इसके बाद का वर्शन और uv
• Python और कमांड लाइन की बुनियादी जानकारी

यह कोडलैब, एआई/एमएल इंजीनियरों और सभी लेवल के डेवलपर के लिए है. इसके लिए, इवोल्यूशनरी-कंप्यूटेशन की जानकारी होना ज़रूरी नहीं है.

इसे पूरा करने में लगने वाला अनुमानित समय: 45–60 मिनट.

लागत: इस कोडलैब में लोकल इवैल्यूएशन का इस्तेमाल किया जाता है. इसलिए, इसमें जीपीयू और GKE का इस्तेमाल नहीं किया जाता. इसमें सिर्फ़ AlphaEvolve API के इस्तेमाल का शुल्क लगता है. यह शुल्क, उम्मीदवार जनरेट करने के लिए लगता है.

इसकी जांच, AlphaEvolve Cloud क्लाइंट लाइब्रेरी v0.1.0, Python 3.9+, circle_packing और tsp के उदाहरणों पर की गई है.

2. शुरू करने से पहले

अपना प्रोजेक्ट चुनें और एपीआई चालू करें

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 के ज़रिए काम करता है. इसके लिए, Discovery Engine API का इस्तेमाल किया जाता है. GE_APP_ID सेटिंग के लिए, आपको अपने ऐप्लिकेशन का आईडी चाहिए. डिसप्ले नेम नहीं.

1. अपने प्रोजेक्ट के लिए, Gemini Enterprise ऐप्लिकेशन का पेज खोलें.
2. अपने ऐप्लिकेशन पर क्लिक करें और आईडी फ़ील्ड को कॉपी करें. उदाहरण के लिए, gemini-enterprise-1234567890_1234567890123.

इस आईडी को अपने पास रखें. इसे जल्द ही .env में चिपकाया जाएगा. ASSISTANT=default_assistant को डिफ़ॉल्ट पर सेट रहने दें. ऐसा तब करें, जब आपने कोई कस्टम Assistant सेट अप न किया हो.

पुष्टि करना, क्लोन करना, और इंस्टॉल करना

1. ऐप्लिकेशन-डिफ़ॉल्ट क्रेडेंशियल के लिए पुष्टि करें:

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-END के बाहर EVOLVE-BLOCK-START मौजूद सभी चीज़ें, जैसे कि evaluate() फ़ंक्शन और ओवरलैप की जांच, फ़्रीज़ रहती हैं. यह सेपरेशन ही असली ट्रिक है. Gemini, अपनी पसंद के हिसाब से कोई भी पैकिंग एल्गोरिदम सुझा सकता है. हालांकि, यह उम्मीदवार को स्कोर करने के तरीके में बदलाव नहीं कर सकता.

इवैल्यूएटर और स्कोर

examples/circle_packing/src/evaluate.py, हर उम्मीदवार को सैंडबॉक्स में चलाता है और स्कोर दिखाता है. सर्कल पैकिंग के लिए, मेट्रिक 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 उम्मीदवारों का इवैल्यूएशन नहीं हो जाता. मॉड्यूल को सीधे तौर पर कॉल करने की वजह से (कोई रैपर नहीं), यह देखा जा सकता है कि क्या चल रहा है. साथ ही, एक्सपेरिमेंट करने के लिए फ़ाइल को एडिट किया जा सकता है.

आपको कुछ ऐसा आउटपुट दिखेगा:

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" मैसेज के साथ खत्म हो जाता है, तो इसका मतलब है कि .env में क्रेडेंशियल या GE_APP_ID गलत हैं.

5. नतीजे पढ़ना

एक्सपेरिमेंट के नतीजे में, sum_of_radii के आधार पर रैंक किए गए टॉप प्रोग्राम प्रिंट होते हैं. इसमें ज़्यादा स्कोर बेहतर होता है. इन दो चीज़ों पर ध्यान दें:

• स्कोर बढ़ गया है. सबसे बेहतर तरीके से विकसित हुए sum_of_radii को सीड के कॉन्सेंट्रिक-रिंग लेआउट से बेहतर होना चाहिए. Gemini आम तौर पर यह पता लगाता है कि कोनों और किनारों के पास मौजूद सर्कल बड़े हो सकते हैं. साथ ही, यह अंदरूनी हिस्से को फिर से बैलेंस करता है.
• अमान्य उम्मीदवारों को स्किप कर दिया जाता है. जिस प्रोग्राम से ओवरलैप होने वाले या बाउंड्री से बाहर जाने वाले सर्कल बने हैं उसे -inf स्कोर मिलता है. साथ ही, उसे रैंकिंग में स्किप कर दिया जाता है. यह कंस्ट्रेंट फ़ीडबैक के काम करने की वजह से होता है, न कि किसी गड़बड़ी की वजह से.

एक्सपेरिमेंट की शुरुआत में, कम स्कोर वाले या स्किप किए गए कुछ उम्मीदवारों का दिखना सामान्य और सही है. इसका मतलब है कि Gemini एक्सप्लोर कर रहा है. साथ ही, गड़बड़ियों से मिली जानकारी, बाद की जनरेशन को बेहतर बनाने में मदद करती है.

अब आपके पास पूरा लूप है: सीड -> जनरेट -> इवैल्यूएट -> स्कोर -> दोहराना. AlphaEvolve में बाकी सभी चीज़ें, इवैल्यूएशन के चलने की जगह के हिसाब से अलग-अलग होती हैं.

6. किसी असली सर्च को इवॉल्व करना: टीएसपी

सर्कल पैकिंग, तेज़ी से कन्वर्ज होती है. सर्च को किसी मुश्किल समस्या पर काम करते हुए देखने के लिए, ट्रैवलिंग सेल्समैन प्रॉब्लम के लिए ह्यूरिस्टिक को इवॉल्व करें. पैटर्न एक जैसा होता है. इसमें सिर्फ़ सीड और मेट्रिक बदलती है. साथ ही, टीएसपी का उदाहरण आपके .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

यहां सीड, 50 शहरों के लिए नियरेस्ट-नेबर टूर है. मेट्रिक neg_tour_length है. यह पांच फ़िक्स्ड इंस्टेंस के लिए, नेगेटिव औसत टूर की लंबाई है. इसलिए, ज़्यादा स्कोर बेहतर होता है. examples/tsp/src/program.py खोलें और ध्यान दें कि EVOLVE-BLOCK के अंदर सिर्फ़ construct_tour(distances, n) है.

दोनों समस्याएं, अलग-अलग हिस्सों के साथ एक ही पैटर्न की हैं:

समस्या	भाषा	इवैल्यूएशन	मेट्रिक (ज़्यादा स्कोर बेहतर होता है)	क्या इवॉल्व होता है
circle_packing	Python	लोकल exec()	sum_of_radii	construct_packing()
tsp	Python	लोकल exec()	neg_tour_length	construct_tour()

सर्च चलने के दौरान, neg_tour_length को बढ़ते हुए (शून्य के करीब) देखें. ऐसा तब होता है, जब Gemini, नियरेस्ट-नेबर से आगे बढ़कर 2-ऑप्ट / या-ऑप्ट-स्टाइल के सुधारों की ओर बढ़ता है. ये ऐसी रणनीतियां हैं जिन्हें आपने नहीं लिखा है.

7. सर्च को ट्यून करना

अब दोनों एक्सपेरिमेंट काम कर रहे हैं. इसलिए, .env में बजट को ट्यून करें:

• MAX_PROGRAMS_EVALUATED — कितने उम्मीदवारों को स्कोर करना है. ज़्यादा उम्मीदवार = डीपर सर्च और ज़्यादा लागत/समय.
• CONCURRENCY — एक साथ कितने उम्मीदवार जनरेट किए जाते हैं.
• MODEL_1 / MODEL_2 (साथ ही, MODEL_1_WEIGHT / MODEL_2_WEIGHT) — Gemini मॉडल का वेटेड मिक्सचर, जो सर्कल-पैकिंग एक्सपेरिमेंट में उम्मीदवार जनरेट करता है. वहीं, टीएसपी मॉड्यूल, सिर्फ़ एक MODEL को पढ़ता है. gemini-3.5-flash और gemini-3.1-pro-preview को वैल्यू के तौर पर इस्तेमाल किया जा सकता है. कम जनरेशन में बेहतर प्रोग्राम ढूंढने के लिए, ज़्यादा बेहतर मॉडल की ओर वेट शिफ़्ट करें.

हर बदलाव के बाद, uv run python -m examples.circle_packing.src.run_evolution (या tsp मॉड्यूल) का इस्तेमाल करके फिर से एक्सपेरिमेंट चलाएं.

ध्यान दें: MAX_PROGRAMS_EVALUATED को बढ़ाने और बड़े मॉडल पर स्विच करने, दोनों से लागत बढ़ती है. इस कोडलैब में लोकल इवैल्यूएशन का इस्तेमाल किया जाता है. इसलिए, इसमें जीपीयू का शुल्क नहीं लगता. हालांकि, जनरेट किए गए हर उम्मीदवार के लिए, AlphaEvolve API के इस्तेमाल का शुल्क लगता है. छोटे बजट से शुरू करें.

8. व्यवस्थित करें

इस कोडलैब में लोकल इवैल्यूएशन का इस्तेमाल किया जाता है. इसलिए, बिलिंग के लिए कुछ भी चालू नहीं है — न तो क्लस्टर, न जीपीयू, और न ही डिप्लॉय की गई सेवाएं. चेकआउट को पूरी तरह से रीसेट करने के लिए:

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

ध्यान दें: git clean -xfd से आपका .env (इसमें प्रोजेक्ट सेटिंग भी शामिल हैं) और .venv मिट जाता है. अगर आपको एक्सपेरिमेंट जारी रखने हैं, तो इसे स्किप करें.

अगर आपने सिर्फ़ इस कोडलैब के लिए कोई प्रोजेक्ट बनाया है, तो सभी शुल्क रोकने के लिए उसे कंसोल में मिटाएं.

9. बधाई हो

बधाई हो! आपने Google Cloud पर AlphaEvolve के पहले एक्सपेरिमेंट चलाए हैं. साथ ही, दो एल्गोरिदम — सर्कल पैकिंग और टीएसपी ह्यूरिस्टिक — को इवॉल्व किया है. इसके लिए, आपने सिर्फ़ सीड प्रोग्राम, स्कोरिंग फ़ंक्शन, और Gemini का इस्तेमाल किया है.

आपको क्या सीखने को मिला

• AlphaEvolve का लूप कैसे काम करता है: सीड -> जनरेट -> इवैल्यूएट -> स्कोर -> दोहराना
• EVOLVE-BLOCK कॉन्ट्रैक्ट, जिसकी मदद से सर्च, मेट्रिक को गेम किए बिना किसी रेसिपी को ऑप्टिमाइज़ कर सकती है
• स्कोर और गड़बड़ियों से मिली जानकारी, अगली जनरेशन को कैसे बेहतर बनाती है
• लोकल-इवैल्यूएशन एक्सपेरिमेंट को कॉन्फ़िगर करने, चलाने, पढ़ने, और ट्यून करने का तरीका

अन्य कोडलैब

ये कोडलैब, एक-दूसरे से अलग हैं. इन्हें किसी भी क्रम में किया जा सकता है.

• रिमोट इवैल्यूएटर की मदद से, कंपाइल किए गए कोड को इवॉल्व करना: Cloud Run पर कंटेनराइज़्ड इवैल्यूएटर की मदद से, Rust/C++ एल्गोरिदम को इवॉल्व करना.
• GKE + Ray पर, एलएलएम फ़ाइन-ट्यूनिंग को इवॉल्व करना: अपने क्लस्टर पर, पैरलल जीपीयू इवैल्यूएशन चलाना.

रेफ़रंस के लिए दस्तावेज़

• AlphaEvolve की डेवलपर गाइड
• AlphaEvolve के सैंपल का रेपो
• सर्कल पैकिंग का उदाहरण
• टीएसपी का उदाहरण