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 के इस्तेमाल और Vertex AI Gemini टोकन की लागत शामिल है.

इसकी जांच, 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 को सेवा देता है. इसके अलावा, Vertex AI API भी शामिल है, जो उम्मीदवार जनरेट करने वाले Gemini मॉडल को सेवा देता है:

gcloud services enable \
  discoveryengine.googleapis.com \
  aiplatform.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 की मदद से टॉप पैकिंग रेंडर करता है.

ध्यान दें: समस्या हल करना: अगर कोई एक्सपेरिमेंट तुरंत FAILED_PRECONDITION और "AlphaEvolve requires the Vertex AI API to be enabled in this project" के साथ खत्म होता है, तो इसका मतलब है कि aiplatform.googleapis.com मौजूद नहीं है. इसे "शुरू करने से पहले" में बताए गए तरीके से चालू करें. 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 के इस्तेमाल और Vertex AI Gemini टोकन का शुल्क लगता है. छोटे बजट से शुरुआत करें.

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 के सैंपल का रेपो
• सर्कल पैकिंग का उदाहरण
• टीएसपी का उदाहरण