Chương trình học Bài 187 trên tổng số 250 · Khuôn mẫu cho môi trường thật: thử lại, bất đồng bộ, streaming và bộ nhớ
Khuôn mẫu cho môi trường thật: thử lại, bất đồng bộ, streaming và bộ nhớ

Gọi theo lô đồng thời (tỏa ra có giới hạn)

Khi bạn cần câu trả lời cho một nghìn prompt, gọi mô hình từng cái một và chờ từng câu trả lời thì chậm đến khổ sở. Các ứng dụng thật bắn nhiều yêu cầu đồng thời -> nhưng không phải không giới hạn: mọi nhà cung cấp đều giới hạn số lệnh gọi đang bay mà họ cho phép, nên bạn xử lý công việc theo lô có kích thước cố định. Hai sự thật làm cho tính đồng thời trở nên khó, và cả hai đều xuất hiện ở đây.

  • Kết quả trở về không theo thứ tự. Một prompt ngắn có thể xong trước một prompt dài bạn đã gửi trước. Mã của bạn phải ráp lại các câu trả lời theo vị trí đầu vào ban đầu của chúng, không theo cái nào xong trước.
  • Thông lượng bị giới hạn bởi mức trần. Với n prompt và mức trần c, bạn chạy ceil(n / c) lô -> con số mà mọi kế hoạch năng lực đều xây quanh.

Một phiên bản thật sẽ dùng asyncio và một client mạng thật. Để phiên bản đầu tiên này dễ theo dõi, bạn mô hình hóa cùng hình dạng đó bằng các hàm thường và một vòng lặp lập lịch -> không event loop, không mạng, không mô hình thật. Đây là hình dạng thật, để tham khảo, cùng logic đó với một event loop đang chạy:

import asyncio

async def run_batch(prompts, worker, cap=4):
    sem = asyncio.Semaphore(cap)            # the concurrency cap
    async def one(i):
        async with sem:                     # at most cap in flight
            return i, await worker(prompts[i])
    pairs = await asyncio.gather(*(one(i) for i in range(len(prompts))))
    results = [None] * len(prompts)
    for i, r in pairs:                       # reassemble by ORIGINAL index
        results[i] = r["result"]
    return results

Một Semaphore áp đặt mức trần, gather chạy các lệnh gọi cùng nhau, và bạn vẫn ghi từng câu trả lời trở lại vào ô ban đầu của nó. Để ý một khác biệt với các lô bạn sắp xây: với một semaphore, một lệnh gọi mới bắt đầu ngay khi bất kỳ lệnh nào xong, nên luôn có tới cap lệnh đang bay, trong khi các lô cố định chờ lệnh chậm nhất trong mỗi lô trước khi bắt đầu lô tiếp theo. Phiên bản semaphore nhanh hơn; các lô thì dễ suy luận hơn. Mã bất đồng bộ cũng kiểm tra được (với asyncio.run và worker giả); ở đây bạn xây phiên bản theo lô với một bộ lập lịch thường để logic luôn trong tầm mắt. Một worker(prompt) đứng thay cho lệnh gọi mô hình và trả về {"result": ..., "cost": ...}, trong đó cost biểu thị mục đó sẽ tốn bao lâu. Bạn cố ý lập lịch mỗi lô theo một thứ tự chi phí khác để chứng minh việc ráp kết quả của bạn không ngầm phụ thuộc vào nó.

for start in range(0, len(prompts), cap):
    window = range(start, min(start + cap, len(prompts)))
    # work the window in ANY order, but write results[i] = worker(prompts[i])["result"]
    ...

Xây run_batch(prompts, worker, cap=4). Ánh xạ worker lên mọi prompt theo các lô kích thước cap, và trả về {"results": [...], "batches": n_batches} trong đó results[i] là kết quả của worker cho prompts[i] (giữ thứ tự đầu vào) và batches là ceil(len(prompts) / cap). Một list prompt rỗng chạy không lô nào.

Đến lượt bạn

Viết run_batch(prompts, worker, cap=4) ánh xạ một worker (giả lập) lên mọi prompt theo các lô cap và trả về {"results", "batches"}. results phải theo thứ tự ĐẦU VÀO dù mỗi mục mang một cost khác nhau mà bạn có thể lập lịch theo; batches là ceil(len(prompts) / cap). Dùng các hàm thường và một vòng lặp lập lịch -> không asyncio, không mạng. Một tập đầu vào khác thứ hai phải cho kết quả khác; một list rỗng chạy không lô nào.

Bạn thấy vấn đề gì trong bài học này? Hãy báo cáo nó · Hỏi về bài học này

Bài tập này sẽ sớm mở.

Hoàn thành bài học trước đó để mở khóa bài này. Toàn bộ khóa học là miễn phí, không cần tài khoản, và bạn có thể đọc bài học này ngay bây giờ.