วิธีทำให้การสร้างภาพเป็นอัตโนมัติในระดับใหญ่

วิธีที่ง่ายที่สุดในการทำให้การสร้างภาพอัตโนมัติในระดับใหญ่โดยไม่ต้องจัดการ API หลายตัว คือแยกเวิร์กโฟลว์ออกจากผู้ให้บริการโมเดล ใส่คำขอภาพทุกคำขอลงในคิวเดียว กำหนดเส้นทางงานแต่ละงานไปยังรหัสโมเดลปัจจุบัน และส่งคำขอที่เข้ากันได้ผ่าน CometAPI key เดียวและ OpenAI-compatible base URL https://api.cometapi.com/v1.

บทความสอนนี้จะสร้างไปป์ไลน์ดังกล่าวใน Python โดยรับงานด้านสินค้า โฆษณา และคอนเทนต์จากคิวแบบ JSON Lines เลือกโมเดล จำกัดความพร้อมกัน ลองใหม่เมื่อเกิดความล้มเหลวชั่วคราว จัดเก็บผลลัพธ์ทั้งแบบ URL หรือ base64 และบันทึกการใช้งานและต้นทุนโดยประมาณต่อหนึ่งงาน ตัวอย่างนี้เก็บหัวใจสำคัญระดับโปรดักชันไว้ในบล็อกกะทัดรัดเดียว เพื่อให้คุณทดสอบเวิร์กโฟลว์ได้โดยไม่ทำให้บทความกลายเป็นเอกสารอ้างอิงโค้ด

Unified Image API ช่วยให้การสร้างแบบเป็นชุดง่ายขึ้นอย่างไร

เมื่อจบกระบวนการ เวิร์กโฟลว์จะมีลักษณะดังนี้:

jobs.jsonl → bounded worker pool → CometAPI /v1/images/generations → object storage → manifest.jsonl

ชั้นคิวและการจัดเก็บยังเป็นของคุณเอง การสลับโมเดลภาพจะเปลี่ยนเพียงค่า model ไม่ใช่ระบบยืนยันตัวตนหรือเส้นทางคำขอหลัก นั่นคือข้อได้เปรียบเชิงปฏิบัติของ Unified Image API: การเลือกโมเดลกลายเป็นการตัดสินใจด้านการกำหนดเส้นทางภายในไปป์ไลน์เดียว แทนที่จะเป็นการผสานรวมผู้ให้บริการแยกกัน

ต้องการอะไรบ้างเพื่อทำให้การสร้างภาพอัตโนมัติ?

คุณต้องมี Python 3.10 ขึ้นไป แพ็กเกจ requests CometAPI key ตำแหน่งเอาต์พุตที่เขียนได้ และอย่างน้อยหนึ่งรหัสโมเดลภาพที่ใช้งานอยู่ปัจจุบัน

ติดตั้ง dependency เพียงตัวเดียว:

pip install requests

ตั้งค่า key ของคุณบนเซิร์ฟเวอร์ ห้ามใส่ไว้ในโค้ดฝั่งเบราว์เซอร์หรือในรีโพสิทอรี:

export COMETAPI_KEY="your-key"

Base URL คือ https://api.cometapi.com/v1 และงาน text-to-image ที่เข้ากันได้ใช้ POST /images/generations ก่อนดีพลอย ตรวจสอบแต่ละโมเดลใน แค็ตตาล็อกโมเดลสด; แค็ตตาล็อกจะส่งคืนรหัสปัจจุบัน เอ็นด์พอยต์ที่รองรับ ฟีเจอร์ และเมตาดาต้าการตั้งราคา โดยไม่ต้องใช้ authorization header

ณ วันที่ 20 สิงหาคม 2026 แค็ตตาล็อกสดแสดงเส้นทางที่มีประโยชน์สองรายการนี้:

ตารางนี้เป็นเพียงจุดเริ่มต้น ไม่ได้อ้างว่าโมเดลมีความสามารถเหมือนกัน ขนาด คุณภาพ รูปแบบ การรองรับภาพอ้างอิง และพฤติกรรมการตอบกลับยังขึ้นกับแต่ละโมเดล ตรวจสอบระเบียนโมเดลและเอกสารที่เชื่อมโยงก่อนส่งพารามิเตอร์เสริม

วิธีสร้างเวิร์กโฟลว์การสร้างภาพแบบเป็นชุดใน Python

1. ให้ทุกงานมี ID ที่ทนทาน

ใช้วัตถุ JSON หนึ่งตัวต่อหนึ่งบรรทัด เพื่อให้คิว ไฟล์ส่งออกจากฐานข้อมูล หรือสเปรดชีต ให้อาหาร worker เดียวกันได้:

{"id":"sku-1001","kind":"product","prompt":"Studio product photo of a ceramic coffee dripper on a warm neutral background"}
{"id":"campaign-204","kind":"ad","prompt":"Editorial summer travel image, vivid natural light, wide composition, no text"}
{"id":"blog-088","kind":"content","prompt":"Minimal illustration of a developer automating a creative workflow, no text"}

ID จะกลายเป็นชื่อไฟล์เอาต์พุตและคีย์ใน manifest ในโปรดักชัน ใช้เป็นคีย์ idempotency และข้าม ID ที่ทำสำเร็จแล้วก่อนประมวลผลคิวซ้ำ

2. กำหนดเส้นทางตามประเภทงาน จากนั้นตรวจสอบกับแค็ตตาล็อกสด

ตัวอย่างนี้แมปงานสินค้าไปที่ gpt-image-2 และงานโฆษณาหรือคอนเทนต์ไปที่ doubao-seedream-4-5-251128 งานอาจ override ตัวเลือกนั้นด้วยฟิลด์ model ของตัวเอง ขณะเริ่มต้น worker จะดาวน์โหลดแค็ตตาล็อกสาธารณะและปฏิเสธ ID ที่ไม่มีอยู่ในรายการอีกต่อไป

นี่ปลอดภัยกว่าการฮาร์ดโค้ด SDK เฉพาะผู้ให้บริการไว้ทั่วทั้งแอปพลิเคชัน คุณสามารถเปลี่ยนเส้นทางในแมปเดียวหลังประเมินคุณภาพ เวลาแฝง และราคาให้เหมาะกับพรอมป์ต์ของคุณเอง

3. จำกัดความพร้อมกัน แทนที่จะปล่อยทั้งชุด

worker เริ่มด้วยคำขอพร้อมกัน 4 รายการ ตัวเลขนี้เป็นการตั้งค่าระดับแอปพลิเคชันแบบระมัดระวัง ไม่ใช่ขีดจำกัดสากลของบริการ วัดเวลาแฝงและการตอบกลับ 429 ของบัญชีคุณ แล้วเพิ่มหรือลด MAX_WORKERS อย่างมีเหตุผล

จะลองใหม่เฉพาะการตอบกลับ 408, 429 และ 5xx ด้วยการถอยแบบเอ็กซ์โปเนนเชียลพร้อม jitter ข้อผิดพลาดการยืนยันตัวตน รหัสโมเดลไม่ถูกต้อง และพารามิเตอร์ที่ไม่รองรับ จะล้มเหลวทันที เพราะการลองคำขอที่ไม่ถูกต้องซ้ำจะมีแต่เพิ่มความล่าช้า

4. ทำให้ผลลัพธ์เป็นมาตรฐานก่อนจัดเก็บ

โมเดลภาพไม่ได้ส่งคืนคอนเทนเนอร์เดียวกันเสมอไป GPT Image ตามเอกสารจะมี data[0].b64_json; โมเดลที่เข้ากันได้อื่นอาจส่งคืน data[0].url worker รองรับทั้งสองแบบ เขียนภาพไปยังไฟล์ชั่วคราว และเปลี่ยนชื่อเฉพาะหลังจากดาวน์โหลดหรือถอดรหัสสำเร็จ

สำหรับโปรดักชัน ให้แทนที่ไดเรกทอรีโลคัล output/ ด้วย S3, R2, GCS หรือ object store อื่นๆ อย่าถือว่า URL ที่โฮสต์โดยผู้ให้บริการเป็นที่เก็บถาวร เว้นแต่มีนโยบายการเก็บรักษาที่ระบุชัดเจน

5. บันทึกการใช้งาน จำนวนความพยายาม และต้นทุนโดยประมาณ

ทุกผลลัพธ์จะกลายเป็นแถว manifest ที่กะทัดรัดพร้อม ID งาน โมเดล เส้นทางที่บันทึก สถานะ และต้นทุน USD โดยประมาณ เมื่อแค็ตตาล็อกสดให้ข้อมูลราคามากพอ งานที่ล้มเหลวจะเก็บข้อผิดพลาดไว้แทนที่จะหายไปจากชุดงาน

สคริปต์ Python แบบครบถ้วนสำหรับการสร้างภาพแบบเป็นชุด

บันทึกสิ่งต่อไปนี้เป็น batch_image_pipeline.py วางคิวไว้ข้างกันเป็น jobs.jsonl แล้วรัน python3 batch_image_pipeline.py

import base64, json, os, random, time
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path
import requests

BASE_URL = "https://api.cometapi.com/v1"
KEY = os.environ["COMETAPI_KEY"]
WORKERS = int(os.getenv("MAX_WORKERS", "4"))
OUT = Path("output")
ROUTES = {
    "product": "gpt-image-2",
    "ad": "doubao-seedream-4-5-251128",
    "content": "doubao-seedream-4-5-251128",
}

catalog = requests.get("https://api.cometapi.com/api/models", timeout=30)
catalog.raise_for_status()
CATALOG = {model["id"]: model for model in catalog.json()["data"]}

def generate(job):
    model = job.get("model", ROUTES[job["kind"]])
    if model not in CATALOG:
        raise ValueError(f"Unknown model: {model}")
    payload = {"model": model, "prompt": job["prompt"], "n": 1}
    if model == "gpt-image-2":
        payload.update(quality="low", size="1024x1024", output_format="jpeg")

    for attempt in range(4):
        response = requests.post(
            f"{BASE_URL}/images/generations",
            headers={"Authorization": f"Bearer {KEY}"},
            json=payload,
            timeout=180,
        )
        if response.status_code not in {408, 429} and response.status_code < 500:
            break
        time.sleep(2**attempt + random.random())
    response.raise_for_status()
    body = response.json()
    item = body["data"][0]

    if item.get("b64_json"):
        data = base64.b64decode(item["b64_json"])
        extension = body.get("output_format", "png")
    else:
        download = requests.get(item["url"], timeout=120)
        download.raise_for_status()
        data = download.content
        extension = {"image/png": "png", "image/webp": "webp"}.get(
            download.headers.get("content-type"), "jpg"
        )
    path = OUT / f"{job['id']}.{extension}"
    path.write_bytes(data)

    price, usage = CATALOG[model].get("pricing") or {}, body.get("usage", {})
    cost = price.get("per_request")
    if cost is None and price.get("input") is not None:
        cost = (usage.get("input_tokens", 0) * price["input"] +
                usage.get("output_tokens", 0) * price["output"]) / 1_000_000
    return {"id": job["id"], "model": model, "path": str(path),
            "estimated_usd": cost * price.get("ratio", 1) if cost is not None else None}

def safe_generate(job):
    try:
        return {"status": "success", **generate(job)}
    except Exception as error:
        return {"id": job["id"], "status": "failed", "error": str(error)}

OUT.mkdir(exist_ok=True)
jobs = [json.loads(line) for line in Path("jobs.jsonl").read_text().splitlines() if line]
with ThreadPoolExecutor(max_workers=WORKERS) as pool:
    results = list(pool.map(safe_generate, jobs))
with (OUT / "manifest.jsonl").open("w") as manifest:
    manifest.writelines(json.dumps(result) + "\n" for result in results)

สคริปต์ใช้แค็ตตาล็อกปัจจุบันขณะรัน ในขณะที่แมปสำรองสองรายการเป็นตัวอย่างที่ตรวจสอบเมื่อวันที่ 20 สิงหาคม 2026 โปรดตรวจสอบอีกครั้งก่อนเผยแพร่หรือดีพลอยโค้ดในวันที่อื่น

วิธีทดสอบเวิร์กโฟลว์การสร้างภาพแบบเป็นชุด

เริ่มจากงานเดียวและ worker เดียว:

MAX_WORKERS=1 python3 batch_image_pipeline.py

การตอบกลับ GPT Image ที่สำเร็จจะมีโครงสร้างดังนี้:

{
  "created": 1776841943,
  "output_format": "jpeg",
  "quality": "low",
  "size": "1024x1024",
  "usage": {
    "input_tokens": 16,
    "output_tokens": 208,
    "total_tokens": 224
  },
  "data": [{"b64_json": "<base64-image-data>"}]
}

worker จะถอดรหัสภาพ เขียนไฟล์ output/<job-id>.jpeg และเพิ่มแถว success ไปยัง output/manifest.jsonl หากโมเดลส่งคืน URL แทน worker จะดาวน์โหลดและจัดเก็บเส้นทางโลคัลในรูปแบบ manifest เดียวกัน

โค้ดได้รับการตรวจไวยากรณ์ในเครื่องแล้ว การเรียกสร้างภาพจริงยังต้องใช้ CometAPI key ของคุณ ดังนั้นให้รันทดสอบควันแบบงานเดียวก่อนเพิ่มความพร้อมกัน

การสร้างภาพแบบเป็นชุดมีค่าใช้จ่ายเท่าไร?

การกำหนดราคาต้องมีการประทับเวลา เพราะอัตราของโมเดลเปลี่ยนได้ ณ วันที่ 20 สิงหาคม 2026 แค็ตตาล็อกโมเดลสดของ CometAPI ส่งคืนฟิลด์ราคาเบื้องต้นต่อไปนี้และอัตราส่วนการคิดบิล 0.8:

• gpt-image-2: $5 ต่อ 1M input tokens และ $30 ต่อ 1M output tokens; เมื่อนำอัตราส่วนที่ระบุไปใช้ จะได้อัตราที่มีผลจริงเท่ากับ $4 และ $24 ต่อ 1M tokens
• doubao-seedream-4-5-251128: $0.04 ต่อคำขอ; เมื่อนำอัตราส่วนที่ระบุไปใช้ จะได้ $0.032 ต่อคำขอ

CometAPI pricing guide อธิบายการคิดค่าบริการตามโทเค็นสำหรับโมเดลที่มีราคาทางการ และการคิดค่าบริการต่อคำขอสำหรับโมเดลที่กำหนดราคาแบบต่อคำขอ สคริปต์อ่านแค็ตตาล็อกขณะรันและใช้กฎเดียวกัน:

token cost = ratio × (input tokens × input rate + output tokens × output rate) / 1,000,000

request cost = ratio × per-request price

ตัวอย่างเช่น การตอบกลับ GPT Image ที่บันทึกไว้ข้างต้นรายงาน 16 input tokens และ 208 output tokens โดยใช้ค่าจากแค็ตตาล็อกเมื่อวันที่ 20 สิงหาคม ผลลัพธ์ตัวอย่างนั้นประเมินได้ประมาณ $0.005056 ยอดจริงเปลี่ยนตามโมเดล คุณภาพ ขนาด พรอมป์ต์ การลองใหม่ และการใช้งานที่ตอบกลับมา จงยึดการตอบกลับของ API และแดชบอร์ดการใช้งานบัญชีเป็นหลักฐานการคิดบิล ไม่ใช่สมมติฐานค่าต่อภาพคงที่

กันงบสำหรับงานที่ไม่สำเร็จด้วย การลองใหม่หลังหมดเวลาที่ไม่ยืนยันอาจก่อให้เกิดผลลัพธ์ที่มีค่าใช้จ่ายครั้งที่สอง และภาพที่สำเร็จทางเทคนิคแต่ไม่ผ่านการรีวิวก็ยังสิ้นเปลืองงบประมาณ ติดตามทั้งค่าใช้จ่าย API และอัตราการได้รับการอนุมัติ:

effective cost per accepted image = total batch spend / approved images

ข้อผิดพลาด API การสร้างภาพที่พบบ่อยและวิธีแก้ไข

อย่าลองใหม่กับทุกข้อผิดพลาด คำขอ 400 แบบถาวรจะยังไม่ถูกต้องเหมือนเดิม ขณะที่ลูปลองใหม่ 429 แบบไม่จำกัดอาจเปลี่ยนความหนาแน่นการจราจรให้เป็นงานคั่งค้าง

แนวทางปฏิบัติที่ดีที่สุดสำหรับการสร้างภาพในโปรดักชันที่ระดับสเกล

ย้ายจาก JSON Lines ไปยังคิวที่ทนทานเมื่อมี worker หลายตัว กำหนด visibility timeout ให้นานกว่าเวลาสร้างสูงสุด รับรองงานเฉพาะหลังจากจัดเก็บภาพและ manifest แล้ว และส่งงานที่หมดความพยายามไปยังคิว dead-letter เพื่อทบทวน

เก็บตัวควบคุมแบบออปชันไว้ในคอนฟิกเฉพาะโมเดล พารามิเตอร์ payload ร่วมควรมีเฉพาะฟิลด์ที่ใช้ร่วมกัน เช่น model, prompt และ n: 1; เพิ่ม quality, size หรือ output_format เฉพาะหลังจากเอกสารของโมเดลที่เลือกยืนยันแล้ว หากเพิ่มเส้นทางสำรอง ให้เลือกโมเดลที่รองรับงานเดียวกันและสร้าง payload ใหม่ให้เหมาะกับโมเดลนั้น แทนที่จะเล่นซ้ำออปชันเฉพาะผู้ให้บริการแบบไม่ไตร่ตรอง

เก็บ API key ในตัวจัดการความลับ จำกัดอินพุตพรอมป์ต์ สแกนทรัพย์สินที่สร้างตามนโยบายของคุณ และอย่าเก็บ URL ของผู้ให้บริการไว้ในระเบียนผลิตภัณฑ์ระยะยาว บันทึก ID งาน รหัสโมเดล เวลาแฝง จำนวนความพยายาม การใช้งาน เส้นทางการจัดเก็บ ผลรีวิว และวันที่สแน็ปชอตแค็ตตาล็อก ฟิลด์เหล่านี้ช่วยให้คุณเปรียบเทียบโมเดลด้วยต้นทุนต่อภาพที่ได้รับการอนุมัติ มากกว่าราคาโฆษณา

สุดท้าย ตั้งเกาะป้องกันงบประมาณ: ขนาดชุดงานสูงสุด ขีดจำกัดการลองใหม่ต่อหนึ่งงาน การแจ้งเตือนค่าใช้จ่ายรายวัน และเงื่อนไขหยุดเมื่ออัตราการอนุมัติลดลง การเร่งสเกลพรอมป์ต์ที่ไม่ดีไม่ใช่การเพิ่มประสิทธิภาพ

FAQs เกี่ยวกับการทำให้การสร้างภาพอัตโนมัติในระดับสเกล

วิธีที่ง่ายที่สุดในการทำให้การสร้างภาพอัตโนมัติในระดับสเกลโดยไม่ต้องจัดการ API หลายตัวคืออะไร?

ใช้เวิร์กโฟลว์คิวและการจัดเก็บชุดเดียว จากนั้นส่งคำขอภาพที่เข้ากันได้ผ่าน CometAPI key เดียวและ https://api.cometapi.com/v1/images/generations. เปลี่ยนรหัสโมเดลในเลเยอร์กำหนดเส้นทาง แทนที่จะดูแลระบบยืนยันตัวตนและ SDK ของผู้ให้บริการแต่ละราย

ส่งคำขอเดียวแล้วให้หลายโมเดลสร้างพร้อมกันได้ไหม?

ตัวอย่างนี้ส่งหนึ่งโมเดลต่อหนึ่งงาน การแตกพัดเป็นเวิร์กโฟลว์ระดับแอปพลิเคชัน: ทำสำเนางานโดยให้ ID และค่าโมเดลต่างกัน จากนั้นเปรียบเทียบเอาต์พุตที่จัดเก็บ วิธีนี้ทำให้ต้นทุนและสถานะรีวิวระบุถึงแต่ละโมเดลได้

ควรใช้ความพร้อมกันเท่าไร?

ไม่มีตัวเลขสากลสำหรับทุกบัญชีและโมเดล เริ่มจากพูลขนาดเล็กที่จำกัด เช่น 4 worker เฝ้าดูเวลาแฝงและการตอบกลับ 429 แล้วปรับจากหลักฐาน

ควรเก็บ URL ที่ส่งคืนหรือเก็บตัวภาพเอง?

เก็บภาพไว้ใน object storage ของคุณเอง URL ที่ส่งคืนอาจเป็นเพียงชั่วคราว ขณะที่โมเดล GPT Image อาจส่งคืนเนื้อหา base64 แทน URL

จะเลือกโมเดลที่ถูกที่สุดได้อย่างไร?

คำนวณต้นทุนต่อภาพที่ได้รับการอนุมัติ ไม่ใช่แค่ราคาต่อการเรียก รวมค่าตามโทเค็นหรือคำขอ การลองใหม่ ดาวน์โหลดที่ล้มเหลว ทรัพย์สินที่ถูกปฏิเสธ การประมวลผลภายหลัง และการรีวิวโดยมนุษย์ ตรวจสอบ แค็ตตาล็อกโมเดลสด ในวันที่คุณเผยแพร่หรือดีพลอย

ควรตรวจสอบเอ็นด์พอยต์และรูปแบบการตอบกลับที่ไหน?

ใช้ CometAPI Quick Start, เอกสารแค็ตตาล็อกโมเดล, เอกสารอ้างอิงการสร้างภาพ และ pricing guide