Google sử dụng công nghệ AI để dịch nội dung sang ngôn ngữ bạn ưu tiên. Bản dịch bằng AI có thể có lỗi.

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à khung mã hoá tiến hoá được hướng dẫn bằng 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 sẽ bắt đầu với việc đóng gói hình tròn – một bài toán nhỏ về hình học mà bạn có thể theo dõi kết quả cải thiện – sau đó lặp lại bài toán khó hơn về Người bán hàng lưu động để ghi nhớ mẫu.

Cả hai thử nghiệm đều sử dụng đánh giá cục bộ – mã ứng cử viên 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 để quản lý. Việc sử dụng đám mây duy nhất là AlphaEvolve API tạo ra các ứng cử viên.

Vòng lặp cục bộ AlphaEvolve: tác nhân AlphaEvolve trên Gemini Enterprise trong Google Cloud tạo ra các chương trình đề xuất; vòng lặp phát triển của máy (run_evolution.py) sẽ thu thập các chương trình đó bằng acquire_programs(), tính điểm cho từng chương trình trong hộp cát exec() cục bộ bằng evaluate.py và trả về điểm bằng submit_program_evaluations().

Bạn sẽ thực hiện

Định cấu hình thử nghiệm AlphaEvolve cho dự án Google Cloud của bạn
Chạy tìm kiếm 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 tiến hoá 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 (ứng cử viên, mức đồng thời, mô hình)

Bạn cần có

Trình duyệt web như Chrome
Dự án Google Cloud đã bật tính năng thanh toán
Python 3.9 trở lên và uv
Quen thuộc cơ bản với 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 độ. Không cần có kiến thức nền tảng 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 đánh giá cục bộ (không có GPU, không có GKE). Chi phí duy nhất là phí sử dụng AlphaEvolve API để tạo ứng cử viên.

Đã thử nghiệm với: thư viện ứng dụng AlphaEvolve Cloud v0.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 và bật API

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

gcloud config set project <YOUR_PROJECT_ID>

Bật Discovery Engine API, API này phục vụ AlphaEvolve:

gcloud services enable discoveryengine.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ã của ứng dụng (không phải tên hiển thị) cho chế độ cài đặt GE_APP_ID.

Mở trang ứng dụng Gemini Enterprise cho dự án của bạn.
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).

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

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

Sao chép kho lưu trữ mẫu và 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

Tạo 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 .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 các thử nghiệm bằng uv run, 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ẽ sử dụng lại cho mọi thử nghiệm.

Chương trình ban đầu và EVOLVE-BLOCK

AlphaEvolve chỉ viết lại mã giữa hai điểm đánh dấu. Mọi nội dung khác trong tệp đều là khung cố định mà khung này không thể chạm vào. Mở examples/circle_packing/src/program.py – chương trình ban đầu là một gói hình 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 nội dung bên ngoài EVOLVE-BLOCK-START / EVOLVE-BLOCK-END – bao gồm cả hàm evaluate() và các lượt kiểm tra mức độ trùng lặp – vẫn bị đóng băng. Sự tách biệt đó 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 ứng cử viên.

Trình đánh giá và điểm số

examples/circle_packing/src/evaluate.py chạy từng ứng cử viên trong một hộp cát và trả về điểm số. Đối với việc đóng gói hình tròn, chỉ số là sum_of_radii và điểm 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 hình tròn trùng lặp hoặc rời khỏi hình vuông), trình đánh giá sẽ trả về -inf cùng với thông tin chi tiết giải thích những gì đã xảy ra. Những thông tin chi tiết đó sẽ phản hồi cho Gemini để thế hệ tiếp theo tránh mắc phải lỗi tương tự.

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 hình tròn:

cp examples/circle_packing/example.env .env

Mở .env và chỉ đặt mã dự án và ứng dụng – mọi nội dung khác đều 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>

Giá trị mặc định tạo ra các ứng cử viên với 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 – đủ để theo dõi 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 ứng cử viên đượ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ư:

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 cử viên ban đầu thường đạt điểm trong phạm vi 0,8–1,0 ; quá trình tìm kiếm sẽ cải thiện từ đó. Khi vòng lặp kết thúc, vòng lặp này 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ố: PERMISSION_DENIED hoặc 403 thường có nghĩa là Discovery Engine API chưa được bật trên dự án. Hãy kiểm tra lại bước "Trước khi bắt đầu". Một lần chạy kết thúc ngay lập tức với thông báo "Không tạo được thử nghiệm" có nghĩa là thông tin xác thực hoặc GE_APP_ID trong .env không chính xác.

5. Đọc kết quả

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

Điểm số đã tăng lên. sum_of_radii tiến hoá tốt nhất sẽ đánh bại bố cục vòng tròn đồng tâm của chương trình ban đầu. Gemini thường phát hiện ra rằng các hình tròn gần các góc và cạnh có thể lớn hơn và 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. Bất kỳ chương trình nào tạo ra các hình tròn trùng lặp hoặc nằm ngoài phạm vi đều đạt đ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, không phải lỗi.

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

6. Tiến hoá một lượt tìm kiếm thực tế: TSP

Việc đóng gói hình tròn sẽ hội tụ nhanh chóng. Để cảm nhận quá trình tìm kiếm hoạt động trên một bài toán phức tạp hơn, hãy tiến hoá một thuật toán heuristic Người bán hàng lưu động. Mẫu này giống hệt nhau – chỉ chương trình ban đầu và chỉ số thay đổi, đồng thời ví dụ về TSP sử dụng lại .env (dự án, ngân sách và mức đồng thời).

Tăng ngân sách trong .env để quá trình tìm kiếm dài hơn có thể cải thiện:

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

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

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

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

Hai bài toán này có cùng mẫu nhưng có các phần khác nhau:

Vấn đề	Ngôn ngữ	Đánh giá	Chỉ số (điểm càng cao càng tốt)	Nội dung tiến hoá
`circle_packing`	Python	`exec()` cục bộ	`sum_of_radii`	`construct_packing()`
`tsp`	Python	`exec()` cục bộ	`neg_tour_length`	`construct_tour()`

Khi quá trình tìm kiếm chạy, hãy theo dõi neg_tour_length tăng lên (tiến gần đến 0) khi Gemini chuyển từ láng giềng gần nhất sang các cải tiến theo kiểu 2-opt / or-opt – các chiến lược mà bạn không viết.

7. Điều chỉnh quá trình tìm kiếm

Bây giờ cả hai lần 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 tính điểm. Càng nhiều ứng cử viên thì quá trình tìm kiếm càng sâu và chi phí/thời gian càng cao.
CONCURRENCY – số lượng ứng cử viên đượ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 ứng cử viên trong lần chạy đóng gói hình tròn (mô-đun TSP đọc một MODEL duy nhất). Các 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 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 thay đổi.

Lưu ý: Việc tăng MAX_PROGRAMS_EVALUATED và chuyển sang 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 đánh giá cục bộ nên không có phí GPU, nhưng bạn vẫn phải trả phí sử dụng AlphaEvolve API cho mỗi ứng cử viên được tạo. Bắt đầu từ những bước nhỏ.

8. Dọn dẹp

Lớp học lập trình này sử dụng đánh giá cục bộ, vì vậy không có nội dung nào có thể tính phí đang chạy – không có cụm, không có GPU, không có dịch vụ đã 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 bước này 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à tiến hoá 2 thuật toán – một thuật toán đóng gói hình tròn và một thuật toán heuristic TSP – chỉ sử dụng chương trình ban đầu, 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: chương trình ban đầu -> tạo -> đánh giá -> tính điểm -> lặp lại
Hợp đồng EVOLVE-BLOCK cho phép quá trình tìm kiếm tối ưu hoá công thức mà không cần chơi trò gian lận chỉ số
Cách điểm số và thông tin chi tiết về lỗi hướng dẫn thế hệ tiếp theo
Cách định cấu hình, chạy, đọc và điều chỉnh thử nghiệm đánh giá cục bộ

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

Đây là các lớp học lập trình độc lập – bạn có thể thực hiện theo bất kỳ thứ tự nào.

Tiến hoá mã đã biên dịch bằng trình đánh giá từ xa: tiến hoá thuật toán Rust/C++ được tính điểm bởi trình đánh giá được chứa trong vùng chứa trên Cloud Run.
Tiến hoá quá trình tinh chỉnh LLM trên GKE + Ray: chạy các lượt đánh giá GPU song song, nặng trên cụm của riêng bạn.