Bắt đầu sử dụng AlphaEvolve trên Google Cloud

1. Giới thiệu

Trong lớp học lập trình này, bạn sẽ chạy 2 thử nghiệm AlphaEvolve đầu tiên trên Google Cloud. AlphaEvolve là một khung lập trình tiến hoá dựa trên AI của Google DeepMind: khung này sử dụng Gemini để viết và cải thiện mã, được tính điểm theo một chỉ số do bạn xác định. Bạn bắt đầu với việc đóng gói hình tròn — một vấn đề nhỏ về hình học mà bạn có thể theo dõi kết quả cải thiện theo đúng nghĩa đen — sau đó lặp lại trên một Vấn đề khó hơn về người bán hàng lưu động để mẫu hình này được giữ lại.

Cả hai thử nghiệm đều sử dụng đánh giá cục bộ – mã đề xuất chạy trên máy của riêng bạn, vì vậy không có GPU và không có cụm nào để quản lý. Việc sử dụng đám mây duy nhất là API AlphaEvolve tạo ra các đề xuất.

Bạn sẽ thực hiện

• Định cấu hình một thử nghiệm AlphaEvolve dựa trên dự án trên đám mây của bạn trên Google Cloud
• Chạy một tìm kiếm mang tính tiến hoá giúp cải thiện thuật toán đóng gói hình tròn cục bộ
• Đọc điểm số, thứ hạng và hình ảnh trực quan của chương trình phát triển tốt nhất
• Lặp lại vòng lặp trong bài toán người bán hàng lưu động để khái quát hoá mẫu
• Điều chỉnh ngân sách tìm kiếm (số lượng đề xuất, mức độ đồng thời, mô hình)

Bạn cần có

• Một trình duyệt web như Chrome
• Một dự án trên Google Cloud đã bật tính năng thanh toán
• Python 3.9 trở lên và uv
• Hiểu biết cơ bản về Python và dòng lệnh

Lớp học lập trình này dành cho các kỹ sư và nhà phát triển AI/ML ở mọi cấp độ. Bạn không cần có kiến thức về tính toán tiến hoá.

Thời gian hoàn thành ước tính: 45 – 60 phút.

Chi phí: lớp học lập trình này sử dụng hoạt động đánh giá cục bộ (không có GPU, không có GKE). Bạn chỉ phải trả phí cho việc tạo các đề xuất – mức sử dụng AlphaEvolve API và số lượng mã thông báo Vertex AI Gemini mà API này sử dụng.

Đã thử nghiệm với: thư viện ứng dụng AlphaEvolve Cloud phiên bản 0.1.0, Python 3.9 trở lên, trên các ví dụ circle_packing và tsp.

2. Trước khi bắt đầu

Chọn dự án của bạn và bật API

1. Trong Google Cloud Console, hãy chọn hoặc tạo một dự án có bật tính năng thanh toán, sau đó thiết lập dự án đó trong thiết bị đầu cuối:

gcloud config set project <YOUR_PROJECT_ID>

2. Bật 2 API mà lớp học lập trình này sử dụng – Discovery Engine API (phục vụ AlphaEvolve) và Vertex AI API (phục vụ các mô hình Gemini tạo ra các đề xuất):

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

Tìm mã ứng dụng Gemini Enterprise

AlphaEvolve được cung cấp thông qua Gemini Enterprise (giao diện REST cơ bản là Discovery Engine API). Bạn cần mã nhận dạng của ứng dụng (không phải tên hiển thị) cho chế độ cài đặt GE_APP_ID.

1. Mở trang Các ứng dụng Gemini Enterprise cho dự án của bạn.
2. Nhấp vào ứng dụng của bạn rồi sao chép trường ID (ví dụ: gemini-enterprise-1234567890_1234567890123).

Hãy lưu giữ mã nhận dạng này vì bạn sẽ dán mã này vào .env trong giây lát. Để trống ASSISTANT=default_assistant, trừ phi bạn đã cung cấp một trợ lý tuỳ chỉnh.

Xác thực, sao chép và cài đặt

1. Xác thực cho thông tin xác thực mặc định của ứng dụng:

gcloud auth application-default login

2. Nhân bản kho lưu trữ mẫu rồi mở kho lưu trữ đó. Bạn sẽ chạy mọi lệnh từ thư mục gốc của kho lưu trữ này:

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

3. Tạo một môi trường ảo và cài đặt thư viện ứng dụng AlphaEvolve vào đó:

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

uv venv tạo một .venv trong kho lưu trữ; uv pip install -e ".[dev]" cài đặt gói alpha_evolve (có thể chỉnh sửa) cùng với các công cụ kiểm thử. Bạn sẽ chạy thử nghiệm bằng uv run. Thử nghiệm này sẽ tự động sử dụng môi trường này.

3. Tìm hiểu về vòng lặp AlphaEvolve

Trước khi chạy bất kỳ nội dung nào, hãy tìm hiểu 3 phần mà AlphaEvolve cần. Đây là mô hình tư duy mà bạn sẽ dùng lại cho mọi thử nghiệm.

Chương trình gieo mầm và EVOLVE-BLOCK

AlphaEvolve chỉ viết lại mã giữa hai điểm đánh dấu. Mọi thứ khác trong tệp đều là cấu trúc cố định mà bạn không thể chỉnh sửa. Mở examples/circle_packing/src/program.py – hạt giống là một gói vòng tròn đồng tâm đơn giản:

# 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

Mọi thứ bên ngoài EVOLVE-BLOCK-START / EVOLVE-BLOCK-END (bao gồm cả hàm evaluate() và các quy trình kiểm tra trùng lặp) vẫn giữ nguyên. Việc tách biệt này là toàn bộ thủ thuật: Gemini có thể đề xuất bất kỳ thuật toán đóng gói nào mà nó thích, nhưng không thể thay đổi cách tính điểm cho một đề xuất.

Người đánh giá và điểm số

examples/circle_packing/src/evaluate.py chạy từng đề xuất trong một hộp cát và trả về điểm số. Đối với phương pháp đóng gói theo vòng tròn, chỉ số là sum_of_radii và chỉ số càng cao càng tốt:

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

Nếu một ứng cử viên vi phạm quy tắc (các vòng tròn chồng lên nhau hoặc rời khỏi hình vuông), người đánh giá sẽ trả về -inf cùng với một thông tin chi tiết giải thích vấn đề. Những thông tin chi tiết đó được gửi lại cho Gemini để thế hệ tiếp theo tránh mắc phải sai lầm tương tự.

Đây là dạng thức của mọi vấn đề AlphaEvolve: mã mà bạn có thể biểu thị trong một EVOLVE-BLOCK, một quy trình đánh giá có thể tự động hoá và một điểm số vô hướng duy nhất để tối đa hoá.

4. Chạy thử nghiệm đầu tiên

Định cấu hình thử nghiệm

Từ thư mục gốc của kho lưu trữ, hãy tạo .env từ mẫu đóng gói theo vòng tròn:

cp examples/circle_packing/example.env .env

Mở .env và chỉ đặt mã dự án và mã ứng dụng của bạn – mọi thứ khác đều có các giá trị mặc định hoạt động cho lần chạy đầu tiên:

PROJECT_ID=<YOUR_PROJECT_ID>
GE_APP_ID=<YOUR_GEMINI_ENTERPRISE_APP_ID>

Các giá trị mặc định tạo ra các đề xuất bằng hỗn hợp mô hình Gemini (MODEL_1=gemini-3.5-flash ở trọng số 0.7, MODEL_2=gemini-3.1-pro-preview ở 0.3) và giới hạn tìm kiếm ở MAX_PROGRAMS_EVALUATED=10 với CONCURRENCY=4 — đủ để xem vòng lặp hoạt động nhanh chóng.

Bắt đầu quá trình tiến hoá

Chạy thử nghiệm từ thư mục gốc của kho lưu trữ:

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

Thao tác này sẽ tải chương trình ban đầu lên, bắt đầu tìm kiếm và chạy vòng lặp kiểm soát cục bộ cho đến khi 10 đề xuất được đánh giá. Vì bạn đang gọi trực tiếp mô-đun (không có trình bao bọc), nên bạn có thể thấy chính xác những gì đang chạy và chỉnh sửa tệp để thử nghiệm.

Bạn sẽ thấy kết quả tương tự như sau:

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).

Các ứng viên ban đầu thường đạt điểm trong khoảng 0,8 – 1,0; sau đó, tìm kiếm sẽ cải thiện. Khi vòng lặp kết thúc, vòng lặp sẽ in các chương trình được xếp hạng và hiển thị các gói hàng đầu bằng matplotlib.

Lưu ý: Khắc phục sự cố: một lần chạy kết thúc ngay lập tức bằng FAILED_PRECONDITION và "AlphaEvolve requires the Vertex AI API to be enabled in this project" (AlphaEvolve yêu cầu bạn bật Vertex AI API trong dự án này) có nghĩa là aiplatform.googleapis.com bị thiếu – hãy bật như minh hoạ trong phần "Trước khi bắt đầu". PERMISSION_DENIED hoặc 403 thường có nghĩa là Discovery Engine API chưa được bật. Lỗi "Không tạo được thử nghiệm" mà không có nghĩa nào trong số đó cho thấy thông tin đăng nhập hoặc GE_APP_ID trong .env không chính xác.

5. Đọc kết quả

Lệnh chạy sẽ in các chương trình hàng đầu được xếp hạng theo sum_of_radii (càng cao càng tốt). Có hai điều cần lưu ý:

• Điểm số đã tăng. sum_of_radii được tiến hoá tốt nhất sẽ đánh bại bố cục vòng tròn đồng tâm của hạt giống. Gemini thường nhận thấy những vòng tròn gần các góc và cạnh có thể lớn hơn, đồng thời cân bằng lại phần bên trong.
• Các ứng cử viên không hợp lệ sẽ bị bỏ qua. Mọi chương trình tạo ra các vòng tròn chồng lên nhau hoặc nằm ngoài phạm vi đều được chấm điểm -inf và bị bỏ qua trong bảng xếp hạng. Đó là phản hồi về ràng buộc đang hoạt động, chứ không phải lỗi.

Việc thấy một vài đề xuất có điểm số thấp hoặc bị bỏ qua ở giai đoạn đầu là điều bình thường và tích cực. Điều này có nghĩa là Gemini đang khám phá và thông tin chi tiết từ những đề xuất không thành công sẽ định hướng cho các đề xuất sau này.

Giờ đây, bạn đã có toàn bộ vòng lặp: gieo mầm -> tạo -> đánh giá -> tính điểm -> lặp lại. Mọi thứ khác trong AlphaEvolve đều là một biến thể của nơi chạy quy trình đánh giá.

6. Phát triển một cụm từ tìm kiếm thực tế: TSP

Việc đóng gói hình tròn diễn ra nhanh chóng. Để cảm nhận được hiệu quả của việc tìm kiếm đối với một vấn đề phức tạp hơn, hãy phát triển một phương pháp phỏng đoán Bài toán người bán hàng lưu động. Mẫu này giống hệt nhau – chỉ có hạt giống và chỉ số thay đổi, còn ví dụ về TSP sẽ sử dụng lại .env (dự án, ngân sách và tính đồng thời) của bạn.

1. Tăng ngân sách trong .env để cụm từ tìm kiếm dài có thể cải thiện hiệu suất:

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

2. Kích hoạt lệnh này từ thư mục gốc của kho lưu trữ:

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

Hạt giống ở đây là một chuyến tham quan hàng xóm gần nhất qua 50 thành phố; chỉ số là neg_tour_length (độ dài trung bình âm của chuyến tham quan trên 5 phiên bản cố định, vì vậy càng cao càng tốt). Mở examples/tsp/src/program.py và lưu ý rằng chỉ có construct_tour(distances, n) nằm trong EVOLVE-BLOCK.

Hai vấn đề này có cùng một mẫu nhưng có các phần khác nhau:

Vấn đề	Ngôn ngữ	Đánh giá	Chỉ số (càng cao càng tốt)	Những gì sẽ phát triển
circle_packing	Python	theo giờ địa phương exec()	sum_of_radii	construct_packing()
tsp	Python	theo giờ địa phương exec()	neg_tour_length	construct_tour()

Khi quá trình tìm kiếm diễn ra, hãy quan sát neg_tour_length tăng lên (tiến gần đến 0) khi Gemini chuyển từ tìm kiếm lân cận sang các phương pháp cải tiến theo kiểu 2-opt / or-opt – những chiến lược mà bạn không viết.

7. Điều chỉnh nội dung tìm kiếm

Giờ đây, cả hai lượt chạy đều hoạt động, hãy điều chỉnh ngân sách trong .env:

• MAX_PROGRAMS_EVALUATED – số lượng ứng cử viên cần chấm điểm. Nhiều đề xuất hơn = tìm kiếm sâu hơn và chi phí/thời gian cao hơn.
• CONCURRENCY – số lượng đề xuất được tạo cùng một lúc.
• MODEL_1 / MODEL_2 (với MODEL_1_WEIGHT / MODEL_2_WEIGHT) – hỗn hợp có trọng số của các mô hình Gemini tạo ra các đề xuất trong quá trình chạy đóng gói hình tròn (mô-đun TSP đọc một MODEL duy nhất). Giá trị được phép là gemini-3.5-flash và gemini-3.1-pro-preview. Chuyển trọng số sang mô hình mạnh hơn để tìm được các chương trình tốt hơn trong ít thế hệ hơn.

Chạy lại bằng uv run python -m examples.circle_packing.src.run_evolution (hoặc mô-đun tsp) sau mỗi lần thay đổi.

Lưu ý: Việc tăng MAX_PROGRAMS_EVALUATED và chuyển sang một mô hình lớn hơn đều làm tăng chi phí. Vì lớp học lập trình này sử dụng quy trình đánh giá cục bộ nên bạn không phải trả phí GPU, nhưng bạn vẫn phải trả phí cho việc sử dụng API AlphaEvolve và mã thông báo Vertex AI Gemini cho mỗi đề xuất được tạo. Bắt đầu từ quy mô nhỏ.

8. Dọn dẹp

Lớp học lập trình này sử dụng quy trình đánh giá cục bộ, vì vậy không còn gì có thể tính phí – không có cụm, không có GPU, không có dịch vụ được triển khai. Cách đặt lại hoàn toàn quy trình thanh toán:

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

Lưu ý: git clean -xfd sẽ xoá .env (bao gồm cả chế độ cài đặt dự án) và .venv. Bỏ qua nếu bạn muốn tiếp tục thử nghiệm.

Nếu bạn chỉ tạo một dự án cho lớp học lập trình này, hãy xoá dự án đó trong Bảng điều khiển để ngừng tất cả các khoản phí.

9. Xin chúc mừng

Xin chúc mừng! Bạn đã chạy các thử nghiệm AlphaEvolve đầu tiên trên Google Cloud và phát triển hai thuật toán (một thuật toán đóng gói hình tròn và một thuật toán TSP) chỉ bằng một chương trình ban đầu, một hàm tính điểm và Gemini.

Kiến thức bạn học được

• Cách hoạt động của vòng lặp AlphaEvolve: seed -> generate -> evaluate -> score -> repeat
• Hợp đồng EVOLVE-BLOCK cho phép hoạt động tìm kiếm tối ưu hoá một công thức mà không cần phải điều chỉnh chỉ số
• Cách điểm số và thông tin chi tiết về lỗi định hướng thế hệ tiếp theo
• Cách định cấu hình, chạy, đọc và điều chỉnh một thử nghiệm đánh giá cục bộ

Các lớp học lập trình khác

Đây là những nhiệm vụ độc lập, bạn có thể thực hiện theo thứ tự bất kỳ.

• Phát triển mã đã biên dịch bằng một trình đánh giá từ xa: phát triển một thuật toán Rust/C++ được trình đánh giá trong vùng chứa tính điểm trên Cloud Run.
• Phát triển quy trình tinh chỉnh LLM trên GKE + Ray: chạy các quy trình đánh giá GPU song song, có mức sử dụng cao trên cụm của riêng bạn.

Tài liệu tham khảo

• Hướng dẫn cho nhà phát triển AlphaEvolve
• Kho lưu trữ mẫu AlphaEvolve
• Ví dụ về biểu đồ đóng gói hình tròn
• Ví dụ về TSP