API ของ AI แบบสร้างสรรค์สำหรับนักพัฒนา: หยุดปล่อยความล้มเหลวที่ "ประสบความสำเร็จ"

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

Generative AI API สำหรับนักพัฒนา ช่วยให้แอปพลิเคชันของคุณส่งอินพุตไปยังโมเดลและรับเนื้อหาที่สร้างขึ้นได้ เลือกใช้บริการโดยพิจารณาจากอินพุตที่ต้องการ รูปแบบเอาต์พุต ระยะเวลารอ และเกณฑ์การยอมรับ จากนั้นสร้างระบบจัดการงานและการตรวจสอบที่จะเปลี่ยนผลตอบกลับให้กลายเป็นสิ่งที่ผู้ใช้ใช้งานได้

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

ประเด็นสำคัญ

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

Generative AI API สำหรับนักพัฒนา: มันทำอะไรได้บ้าง

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

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

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

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

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

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

การเลือกโปรโตคอลก็แตกต่างกันไปเช่นกัน เอกสารอ้างอิงของ Google แยกความแตกต่างระหว่างการสร้างแบบมาตรฐาน การสตรีม และการโต้ตอบแบบเรียลไทม์ ควรถือเป็นหลักฐานว่าโหมดการโต้ตอบนั้นแตกต่างกัน แทนที่จะสมมติว่าที่อื่นรองรับเหมือนกัน (เอกสารอ้างอิง Google Gemini API, เข้าถึงเมื่อกันยายน 2026)

Generative AI API สำหรับนักพัฒนา: วิธีเลือก

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

ประเมินตัวเลือกตามลำดับนี้:

1. อินพุตและเอาต์พุต ตรวจสอบปลายทางของโมเดลที่แน่ชัดว่ามีไฟล์ที่รองรับ ขีดจำกัดอินพุต รูปแบบเอาต์พุต และพฤติกรรมกับภาพอ้างอิงอย่างไร ชื่อตระกูลโมเดลกว้างเกินกว่าจะใช้เป็นสัญญาได้
2. ความสอดคล้องกับงาน ลองใช้โจทย์ตัวแทน รวมถึงโจทย์ที่จับยากด้วย แยกนับความล้มเหลวด้านข้อจำกัดออกจากความล้มเหลวด้านไฟล์หรือเครือข่าย เพื่อให้รู้ว่าต้องแก้อะไร
3. ความเหมาะสมในการเชื่อมต่อ ยืนยันการยืนยันตัวตน โครงห่อผลตอบกลับ ค่าสถานะงาน และการรองรับของไลบรารีไคลเอนต์ รวมถึงงานที่ต้องทำเพื่อปรับสิ่งเหล่านี้เข้ากับแบ็กเอนด์ที่มีอยู่ของคุณ
4. ระยะเวลารอและการทำงานพร้อมกัน ตัดสินใจว่าผู้ใช้สามารถออกไปแล้วกลับมาได้หรือไม่ ทดสอบภาระงานที่คาดไว้ก่อนตัดสินใจทำประสบการณ์แบบโต้ตอบที่มีกำหนดเวลาสั้น
5. ความชัดเจนของการคิดค่าบริการ ระบุหน่วยที่คิดเงินและค่าตั้งใดที่ทำให้หน่วยนั้นเปลี่ยน ตรวจสอบการจัดการความล้มเหลวและการคืนเงิน แทนที่จะสมมติว่าทุกคำขอที่ส่งไปถูกคิดเงินเท่ากัน
6. ข้อกำหนดด้านข้อมูล ตรวจสอบการจัดการอินพุต การเก็บรักษา การลบ และข้อกำหนดที่เกี่ยวข้อง เทียบกับข้อมูลจริงที่คุณตั้งใจจะส่ง บันทึกคำถามที่ยังไม่ได้ข้อสรุปก่อนใช้ข้อมูลอ่อนไหว
7. การจัดการการเปลี่ยนแปลง เก็บชุดทดสอบถดถอยและบันทึกตัวระบุโมเดล พรอมป์ และพารามิเตอร์ วางแผนว่าจะประเมินพฤติกรรมซ้ำใหม่อย่างไรหลังมีการอัปเดตหรือเปลี่ยนโมเดล

แนวปฏิบัติระดับสถาบันแสดงให้เห็นว่าเหตุใดกฎด้านการเข้าถึงและข้อมูลจึงควรอยู่ในข้อตัดสินใจนี้: Harvard อธิบายเส้นทางการเข้าถึงที่ได้รับอนุมัติและข้อจำกัดรอบเครื่องมือสำหรับนักพัฒนา AI ของตน นั่นเป็นข้อกำหนดของ Harvard ไม่ใช่สิทธิ์สากลสำหรับแอปพลิเคชันของคุณ (Harvard University Information Technology, เข้าถึงเมื่อกันยายน 2026)

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

เอกสารปลายทางรูปภาพอย่างเป็นทางการที่แสดงรูปแบบเอาต์พุต คุณภาพ และข้อจำกัดด้านขนาด

พารามิเตอร์เฉพาะโมเดลเป็นส่วนหนึ่งของสัญญาการเชื่อมต่อ อ่านค่าที่อนุญาตก่อนนำ body ของคำขอไปใช้ซ้ำ

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

Generative AI API สำหรับนักพัฒนา: คำขอแรก

ตัวอย่างนี้ใช้ GPT Image 2 Text-to-Image โดยมี model ID openai/gpt-image-2/text-to-image เอกสารปลายทางระบุ quality: high, size: 2048x1152 และ output_format: png ซึ่งเป็นค่าที่ตั้งไว้สำหรับตัวอย่างด้านล่าง

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

plaintextCopy
1Create a realistic editorial food photograph for an article about a simple breakfast.
2
3On a light oak table, show exactly one white ceramic plate holding exactly two slices of toasted sourdough bread, one small clear glass bowl of strawberry jam, and one stainless steel butter knife resting to the right of the plate.
4
5Use soft morning window light from the left, natural colors, a three-quarter overhead camera angle, and realistic bread texture. Keep every requested object fully inside the frame.
6
7No people, no hands, no drinks, no extra dishes, no packaging, no logos, no text, and no watermark. Landscape composition, 16:9.

2. เก็บการยืนยันตัวตนไว้บนเซิร์ฟเวอร์ ฟรอนต์เอนด์ควรขอให้แบ็กเอนด์ของคุณเริ่มงาน เก็บ ATLAS_API_KEY ไว้ในสภาพแวดล้อมของเซิร์ฟเวอร์ ห้ามใส่ใน JavaScript ฝั่งเบราว์เซอร์ ใน URL รูปภาพ หรือในบันทึกที่ไคลเอนต์มองเห็น ตั้งค่า ATLAS_API_HOST เป็น api.atlascloud.ai ซึ่งเป็นชื่อโฮสต์ ไม่มี scheme หรือ path

3. ส่งคำขอครั้งเดียวและเก็บ ID ไว้ เส้นทางการสร้างที่ระบุในเอกสารคือ POST /api/v1/model/generateImage อ่าน data.id แล้วเก็บไว้คู่กับงานในแอปพลิเคชันของคุณ หากผลตอบกลับของการส่งคำขอสูญหาย ให้สอบสวนก่อนสร้างงานใหม่ที่อาจมีค่าใช้จ่าย

4. Poll งานที่บันทึกไว้ เรียก GET /api/v1/model/prediction/{prediction_id} เอกสาร prediction อธิบายสถานะ processing, completed และ failed โดยมี URL ของเอาต์พุตอยู่ใน data.outputs สถานะ completed ก็ยังควรตรวจสอบว่าอาร์เรย์เอาต์พุตไม่ว่าง

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

โค้ดต่อไปนี้ประกอบขึ้นจากเอกสารอินเทอร์เฟซอย่างเป็นทางการ ไม่ได้นำเสนอเป็นการวัดประสิทธิภาพ API แบบสด เวิร์กโฟลว์สื่อของบทความนี้ใช้ playground ทดสอบในเบราว์เซอร์ ไม่ใช่ API key

บันทึกพรอมป์อาหารเช้าแบบตรงตัวเป็น prompt.txt สำหรับ Node.js ให้ใช้สภาพแวดล้อมที่มี fetch ในตัว ติดตั้ง sharp และบันทึกโค้ดนี้เป็น generate.mjs รันในไดเรกทอรีทำงานเฉพาะ รันตัวอย่างภาษาใดภาษาหนึ่งเท่านั้น เว้นแต่คุณตั้งใจจะสร้างสองงาน

javascriptCopy
1import { readFile, writeFile, mkdir } from 'node:fs/promises';
2import sharp from 'sharp';
3
4const key = process.env.ATLAS_API_KEY;
5const host = process.env.ATLAS_API_HOST;
6if (!key || host !== 'api.atlascloud.ai') {
7  throw new Error('Set ATLAS_API_KEY and ATLAS_API_HOST');
8}
9const base = 'https:' + '//' + host;
10const headers = { Authorization: `Bearer ${key}` };
11const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
12const payload = {
13  model: 'openai/gpt-image-2/text-to-image',
14  prompt: await readFile('prompt.txt', 'utf8'),
15  quality: 'high', size: '2048x1152', output_format: 'png'
16};
17await mkdir('output', { recursive: true });
18await writeFile('output/request.json', JSON.stringify(payload, null, 2));
19
20async function api(path, method = 'GET', body) {
21  const response = await fetch(base + path, {
22    method,
23    headers: { ...headers, 'Content-Type': 'application/json' },
24    body: body ? JSON.stringify(body) : undefined,
25    signal: AbortSignal.timeout(30000)
26  });
27  const requestId = response.headers.get('x-request-id');
28  console.error(JSON.stringify({ method, status: response.status, requestId }));
29  if (!response.ok) {
30    const error = new Error(`HTTP ${response.status}; request ${requestId}`);
31    error.retryable = [429, 500, 503, 504].includes(response.status);
32    throw error;
33  }
34  const json = await response.json();
35  if (!json.data) throw new Error('Missing response data');
36  return json.data;
37}
38
39let id = process.env.PREDICTION_ID;
40try {
41  if (!id) {
42    // Deliberately no automatic retry for submission.
43    const submitted = await api('/api/v1/model/generateImage', 'POST', payload);
44    id = submitted.id;
45    if (typeof id !== 'string' || !id) throw new Error('Missing prediction ID');
46    await writeFile('output/prediction-id.txt', id);
47  }
48  const deadline = Date.now() + 600000;
49  let errors = 0;
50  let outputUrl;
51  while (Date.now() < deadline) {
52    let job;
53    try {
54      job = await api('/api/v1/model/prediction/' + encodeURIComponent(id));
55      errors = 0;
56    } catch (error) {
57      const transient = error.retryable ||
58        ['TimeoutError', 'AbortError'].includes(error.name) ||
59        error instanceof TypeError;
60      if (!transient || ++errors > 3) throw error;
61      await sleep(Math.min(30000, 1000 * 2 ** errors) + Math.random() * 500);
62      continue;
63    }
64    if (job.status === 'failed') {
65      throw new Error(`Task failed; code ${job.error_code ?? 'unknown'}`);
66    }
67    if (job.status === 'completed') {
68      outputUrl = job.outputs?.[0];
69      if (typeof outputUrl !== 'string' || !outputUrl) {
70        throw new Error('Completed task has no output');
71      }
72      break;
73    }
74    if (job.status !== 'processing') throw new Error('Unexpected task status');
75    await sleep(2000);
76  }
77  if (!outputUrl) throw new Error('Polling deadline reached; resume this ID');
78  const url = new URL(outputUrl);
79  if (url.protocol !== 'https:') throw new Error('Unexpected output protocol');
80  // Do not forward the API credential to the media host.
81  const file = await fetch(url, { signal: AbortSignal.timeout(60000) });
82  if (!file.ok) throw new Error(`Download HTTP ${file.status}`);
83  const bytes = Buffer.from(await file.arrayBuffer());
84  await sharp(bytes, { limitInputPixels: 20000000 }).raw().toBuffer();
85  const meta = await sharp(bytes).metadata();
86  if (meta.format !== 'png' || meta.width !== 2048 || meta.height !== 1152) {
87    throw new Error('File format or dimensions differ from the request');
88  }
89  await writeFile('output/breakfast.png', bytes);
90  console.log(JSON.stringify({ id, state: 'ready_for_review',
91    file: 'output/breakfast.png' }));
92} catch (error) {
93  console.error(JSON.stringify({ id: id ?? null, state: 'needs_attention',
94    error: error.message }));
95  process.exitCode = 1;
96}

ตัวอย่าง Python ที่สั้นกว่านี้ใช้ requests และ Pillow ใช้ prompt.txt เดียวกัน และใช้การตั้งค่าเหมือนกัน นอกจากนี้ยังรับค่า PREDICTION_ID เพื่อทำงานต่อได้ สคริปต์เหล่านี้สาธิตงานในเครื่องหนึ่งงาน บริการที่ปรับใช้จริงต้องมีบันทึกงานแบบถาวรและการดาวน์โหลดที่มีขอบเขต

pythonCopy
1import io, json, os, random, time
2from pathlib import Path
3from urllib.parse import quote, urlparse
4import requests
5from PIL import Image
6
7key = os.environ['ATLAS_API_KEY']
8assert os.environ['ATLAS_API_HOST'] == 'api.atlascloud.ai'
9base = 'https:' + '//' + os.environ['ATLAS_API_HOST']
10headers = {'Authorization': 'Bearer ' + key}
11out = Path('output')
12out.mkdir(exist_ok=True)
13payload = dict(model='openai/gpt-image-2/text-to-image',
14               prompt=Path('prompt.txt').read_text(encoding='utf-8'),
15               quality='high', size='2048x1152', output_format='png')
16job_id = os.getenv('PREDICTION_ID')
17try:
18    if not job_id:
19        # A submission timeout needs investigation, not a blind retry.
20        r = requests.post(base + '/api/v1/model/generateImage',
21                          headers=headers, json=payload, timeout=30)
22        r.raise_for_status()
23        job_id = r.json()['data']['id']
24        if not isinstance(job_id, str) or not job_id:
25            raise ValueError('Missing prediction ID')
26        (out / 'prediction-id.txt').write_text(job_id)
27    deadline, errors, url = time.monotonic() + 600, 0, None
28    while time.monotonic() < deadline:
29        try:
30            r = requests.get(base + '/api/v1/model/prediction/' +
31                             quote(job_id, safe=''), headers=headers, timeout=30)
32            r.raise_for_status()
33        except requests.RequestException as exc:
34            status = exc.response.status_code if exc.response is not None else None
35            if status not in (None, 429, 500, 503, 504) or errors >= 3:
36                raise
37            errors += 1
38            time.sleep(min(30, 2 ** errors) + random.random() / 2)
39            continue
40        errors = 0
41        job = r.json()['data']
42        if job['status'] == 'failed':
43            raise RuntimeError('Task failed: ' + str(job.get('error_code')))
44        if job['status'] == 'completed':
45            outputs = job.get('outputs') or []
46            if not outputs or not isinstance(outputs[0], str) or not outputs[0]:
47                raise ValueError('Completed task has no output')
48            url = outputs[0]
49            break
50        if job['status'] != 'processing':
51            raise ValueError('Unexpected task status')
52        time.sleep(2)
53    if not url:
54        raise TimeoutError('Polling deadline reached; resume this ID')
55    if urlparse(url).scheme != 'https':
56        raise ValueError('Unexpected output protocol')
57    r = requests.get(url, timeout=60)  # No Authorization header here.
58    r.raise_for_status()
59    with Image.open(io.BytesIO(r.content)) as image:
60        image.load()
61        if image.format != 'PNG' or image.size != (2048, 1152):
62            raise ValueError('Unexpected file format or dimensions')
63    (out / 'breakfast.png').write_bytes(r.content)
64    print(json.dumps(dict(id=job_id, state='ready_for_review')))
65except Exception as exc:
66    print(json.dumps(dict(id=job_id, state='needs_attention', error=str(exc))))
67    raise SystemExit(1)

playground ของ GPT Image 2 ที่เสร็จแล้ว แสดงพรอมป์อาหารเช้าที่ส่งไปและเอาต์พุตที่เสร็จสมบูรณ์

การรัน playground ที่เสร็จสมบูรณ์จะบันทึกพรอมป์ที่ส่งไป ขนาดเอาต์พุต ค่าคุณภาพ และผลลัพธ์ที่สร้างขึ้นไว้ด้วยกัน

กำหนดเวลาสิ้นสุดการ poll ทำให้ไคลเอนต์นี้หยุดรอ แต่ไม่ได้ยกเลิกงานฝั่งเซิร์ฟเวอร์ คำขอที่อยู่ระหว่างดำเนินการอาจเสร็จหลังหน้าต่างการ poll ดังนั้นจึงไม่ใช่การรับประกันความหน่วงแบบ end-to-end ที่เข้มงวด ให้เก็บ ID ไว้และปล่อยให้ worker มาตรวจสอบภายหลัง

Generative AI API สำหรับนักพัฒนา: การใช้งานจริง

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

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

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

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

B. ปกบทความ: พื้นที่พาดหัวที่ใช้งานได้ คำขอนี้ถือว่าองค์ประกอบภาพเป็นเงื่อนไขด้านเลย์เอาต์ บรรณาธิการหน้าต้องการพื้นที่ว่างทางซ้าย ขณะที่ด้านขวามีเครื่องมือและกระถางต้นไม้ ให้เพิ่มชื่อเรื่องจริงภายหลังด้วย HTML/CSS เพื่อให้ยังแก้ไขได้และอ่านง่าย

plaintextCopy
1Create a realistic editorial photograph for an article about repairing everyday objects.
2
3On the right half of a light wooden workbench, show one pair of worn gardening gloves, one small metal hand trowel, and one unbranded terracotta plant pot. The left 45 percent of the image must remain an empty, softly lit section of the same workbench, suitable for adding a headline later.
4
5Use natural side light from a nearby window, believable material textures, neutral colors, and a slightly elevated camera angle.
6
7No people, no hands, no extra tools, no plants, no logos, no letters, no text, and no watermark. Landscape composition, 16:9.

ตัวอย่างปกโต๊ะทำงานที่แสดงพื้นที่พาดหัวด้านซ้ายตามที่ขอและวัตถุด้านขวา

ผลลัพธ์ยังคงพื้นที่ว่างที่ใช้งานได้ทางซ้าย ขณะที่ถุงมือ กระถาง และพลั่วปลูกต้นไม้ยังอยู่ทางขวา

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

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

plaintextCopy
1Create a realistic close-up editorial photograph for an article explaining common fabric textures.
2
3Show exactly three folded fabric swatches arranged side by side on a neutral matte gray surface: natural beige linen on the left, blue cotton denim in the center, and dark green wool on the right.
4
5Use the same soft daylight across all three fabrics, an overhead camera angle, and sufficient depth of field to keep the visible weave of each fabric in focus. Preserve natural wrinkles and believable fiber detail.
6
7No labels, no rulers, no sewing tools, no hands, no additional objects, no text, no logos, and no watermark. Landscape composition, 16:9.

ภาพประกอบผ้าที่สร้างด้วย AI พร้อมการตรวจสอบการวางตำแหน่งตัวอย่างผ้าสีเบจ สีน้ำเงิน และสีเขียวเข้ม

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

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

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

Generative AI API สำหรับนักพัฒนา: จัดการความล้มเหลว

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

กำหนดนาฬิกา 3 ตัวอย่างตั้งใจ: timeout ของคำขอ HTTP แต่ละครั้ง ช่วงเวลาการ poll และหน้าต่างการรอโดยรวม ตัวอย่างใช้ timeout ของคำขอ API 30 วินาที poll ทุก 2 วินาที และหน้าต่างการ poll 10 นาที สิ่งเหล่านี้เป็นทางเลือกของแอปพลิเคชัน ไม่ใช่สมรรถนะบริการที่โฆษณาไว้

เอกสารข้อผิดพลาดของแพลตฟอร์มปัจจุบันระบุว่าปลายทาง LLM และสื่อไม่ได้ให้เฮดเดอร์ Retry-After หรือเฮดเดอร์แสดงอัตราการเรียกที่เหลือ ให้ใช้นโยบายหน่วงเวลาฝั่งไคลเอนต์ อย่าทำให้การกู้คืนต้องพึ่งเฮดเดอร์ที่เส้นทางเหล่านี้ไม่ส่งคืน กลุ่ม API อื่นอาจมีพฤติกรรมต่างออกไป

จำกัดการลองอ่านซ้ำอัตโนมัติให้มีขอบเขต การหน่วงแบบเอกซ์โพเนนเชียลบวก jitter สุ่มเล็กน้อยช่วยป้องกันไม่ให้ worker จำนวนมากลองซ้ำพร้อมกัน ลดการทำงานพร้อมกันหากยังถูกจำกัดอัตราอยู่ ความล้มเหลวซ้ำ ๆ ควรกลายเป็นเหตุการณ์ที่สังเกตเห็นได้ ไม่ใช่วงวนไม่รู้จบที่ซ่อนอยู่หลังสปินเนอร์

การลองส่งซ้ำควรได้รับการจัดการที่เข้มงวดกว่า เมื่อการเชื่อมต่อปิดลงหลังคุณส่ง body ไปแล้ว คุณอาจไม่รู้ว่าเซิร์ฟเวอร์สร้างงานขึ้นมาหรือไม่ บันทึกความตั้งใจไว้ในเครื่องก่อนส่ง และสอบสวนประวัติคำขอหรือร่องรอยจากฝ่ายสนับสนุนเมื่อไม่มี prediction ID ส่งกลับมา อย่าคิดค้นเฮดเดอร์ idempotency ขึ้นเอง เว้นแต่ปลายทางระบุไว้ในเอกสาร

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

สำหรับทุกงาน ให้เก็บ job ID ของแอปพลิเคชัน prediction ID request ID โมเดล การตั้งค่า เวลา และผลสรุปสุดท้ายไว้ เก็บพรอมป์ภายใต้นโยบายข้อมูลที่เหมาะสมเท่านั้น ห้ามใส่เฮดเดอร์การอนุญาตหรือเนื้อหาผู้ใช้ที่อ่อนไหวลงในบันทึกข้อผิดพลาดทั่วไป

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

Generative AI API สำหรับนักพัฒนา: ต้นทุนจริง

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

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

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

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

ใช้การคำนวณ 2 แบบที่เกี่ยวข้องกัน:

plaintextCopy
1API cost per accepted output = actual API charges / accepted outputs
2
3Full feature cost per accepted output =
4(API charges + attributable review + storage + transfer + processing costs)
5/ accepted outputs

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

ตัวอย่างสมมติ: คุณส่ง 100 คำขอ และยอมรับ 80 เอาต์พุต ให้นำค่าใช้จ่ายรวมจริงของล็อตนั้นหารด้วย 80 หากทั้ง 100 คำขอถูกคิดเงินในจำนวนเท่ากันคือ c ต้นทุน API ต่อเอาต์พุตที่ยอมรับจะเป็น 1.25c เงื่อนไขนี้สำคัญ เพราะไม่ได้สมมติว่าทุกคำขอที่ล้มเหลวถูกคิดเงิน

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

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

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

ทดสอบเอาต์พุต ไม่ใช่แค่ผลตอบกลับ

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

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

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

การตรวจทานอาหารเช้าควรมีรายการตรวจสอบอิสระต่อไปนี้:

• ขนมปังปิ้ง 2 แผ่นพอดี จานสีขาว 1 ใบ ชามแยมใส 1 ใบ และมีด 1 เล่ม
• มีดอยู่ทางขวาของจาน; วัตถุที่กำหนดอยู่ในเฟรมครบถ้วน
• ไม่มีถ้วย จาน มือ บรรจุภัณฑ์ หรือแบรนด์ที่มองเห็นได้เกินมา
• ไฟล์ PNG ที่อ่านได้ในขนาดตามที่ขอ

บันทึกการตรวจสอบที่แยกการตรวจเมทาดาทาของไฟล์ออกจากการตรวจการยอมรับทางสายตา

บันทึกนี้รายงานขนาดและขนาดไฟล์จริงของไฟล์ที่สร้างขึ้น แยกจากการตรวจการยอมรับทางสายตา

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

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

ผลสำรวจนักพัฒนาในปี 2025 พบว่า 46% ไม่ไว้วางใจความแม่นยำของเครื่องมือ AI และ 33% ไว้วางใจ ส่วน 3% ระบุว่าไว้วางใจสูง คำตอบเหล่านี้เกี่ยวกับเครื่องมือ AI ในเวิร์กโฟลว์การพัฒนา ไม่ใช่อัตราความล้มเหลวที่วัดได้ของ API สำหรับการสร้างเนื้อหา (Stack Overflow Developer Survey, 2025)

เช่นเดียวกัน การรันเพื่อสาธิต 3 ครั้งไม่อาจยืนยันความแม่นยำโดยรวมหรือค่า p95 latency ที่มีประโยชน์ได้ ให้เก็บตัวอย่างที่ใหญ่ขึ้นและเกี่ยวข้อง ครอบคลุมเงื่อนไขที่คุณคาดว่าจะเจอในการผลิต และเก็บค่าผิดปกติไว้ ใช้การสาธิตเพื่อพัฒนาการตรวจสอบ จากนั้นใช้การประเมินอย่างเป็นระบบเพื่อตัดสินใจปล่อยเวอร์ชัน

เช็กลิสต์ก่อนปล่อยขึ้นโปรดักชัน

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

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

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

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

บันทึกสถานะลงหน่วยเก็บข้อมูลถาวร เขียนงานในเครื่องก่อนเรียกผู้ให้บริการ บันทึก prediction ID ที่ได้กลับมาทันที และทำให้การ poll กลับมาทำต่อได้หลังโปรเซสรีสตาร์ต หากสถานะการส่งคำขอไม่ทราบแน่ชัด ให้ใช้สถานะ "กำลังสอบสวน" แทนการบอกผู้ใช้ว่างานล้มเหลวอย่างแน่นอน

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

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

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

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

คำถามที่พบบ่อย

ควรเลือก generative AI API ตัวไหนสำหรับแอปพลิเคชันของฉัน?

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

มี generative AI API ฟรีสำหรับนักพัฒนาหรือไม่?

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

ต้องมีประสบการณ์ด้านแมชชีนเลิร์นนิงไหมจึงจะใช้ generative AI API ได้?

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

API ตัวเดียวจัดการข้อความ รูปภาพ และวิดีโอได้ไหม?

แพลตฟอร์มหนึ่งอาจให้บริการทั้ง 3 อย่าง แต่แต่ละความสามารถอาจใช้ปลายทาง พารามิเตอร์ ชนิดเอาต์พุต และรูปแบบการรอที่ต่างกัน ตรวจสอบแต่ละอินเทอร์เฟซแยกกัน บัญชีหรือข้อมูลรับรองที่ใช้ร่วมกันไม่ได้ทำให้ body ของคำขอข้อความเข้ากันได้กับโมเดลรูปภาพหรือวิดีโอ

ทำไมคำขอสร้างรูปภาพของฉันจึงส่งคืน task ID แทนรูปภาพ?

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

จะลดต้นทุน API ได้อย่างไรโดยไม่ทำให้เวิร์กโฟลว์พัง?

ป้องกันการส่งซ้ำ ตรวจสอบอินพุตตั้งแต่เนิ่น ๆ นำสินทรัพย์ที่ยอมรับแล้วกลับมาใช้เมื่อเหมาะสม และทดสอบการตั้งค่าที่ถูกกว่ากับเกณฑ์การยอมรับที่ไม่เปลี่ยน วัดค่าใช้จ่ายจริงต่อผลลัพธ์ที่ยอมรับ generative AI API สำหรับนักพัฒนาจะคุ้มค่าก็ต่อเมื่อแอปพลิเคชันโดยรอบสามารถส่งมอบงานที่ใช้งานได้ในต้นทุนที่คุณรับไหว