วิธีใช้ Flux.2 API สิ่งที่คุณต้องรู้

FLUX.2 คือโมเดลสร้างและแก้ไขภาพรุ่นที่สองของ Black Forest Labs (เปิดตัวเมื่อวันที่ 25 พฤศจิกายน 2025) นำเสนอภาพเสมือนจริงระดับโปรดักชั่น การแก้ไขแบบอ้างอิงหลายรายการสูงสุด 4MP การแจ้งเตือนแบบ Structured/JSON และตัวเลือกปลายทางที่จัดการได้ (Pro, Flex) และตัวเลือก open-weight (Dev)

ข่าวดีคือ CometAPI ได้ผสานรวม Flux.2 API ไว้แล้ว คู่มือนี้จะอธิบายว่า FLUX.2 คืออะไร วิธีการเรียกใช้ API และเวิร์กโฟลว์ขั้นสูง (ข้อความ→รูปภาพ การควบคุมที่ยืดหยุ่น การแก้ไขแบบหลายการอ้างอิง) พร้อมตัวอย่างโค้ดและแนวทางปฏิบัติที่ดีที่สุด

FLUX.2 คืออะไร และเหตุใดจึงสำคัญ?

FLUX.2 คือโมเดลภาพต่อยอดจากตระกูล FLUX ซึ่งออกแบบมาเพื่อการสร้างข้อความเป็นภาพที่มีความเที่ยงตรงสูง และการแก้ไขภาพแบบอ้างอิงหลายรายการ ที่ความละเอียดระดับโปรดักชั่น (สูงสุด ~4 เมกะพิกเซล) FLUX.2 สร้างขึ้นเพื่อเวิร์กโฟลว์สร้างสรรค์อย่างแท้จริง (ทรัพยากรที่ปลอดภัยต่อแบรนด์ ตัวละครและสไตล์ที่สอดคล้องกันในทุกรายการอ้างอิง การจัดวางตัวอักษรที่ดีขึ้น และรายละเอียดเล็กๆ น้อยๆ) มากกว่าการสาธิต และมีเป้าหมายเพื่อลดช่องว่างระหว่างภาพที่สร้างขึ้นและภาพจริง

ผลลัพธ์ที่สำคัญ FLUX.2 ได้รับการออกแบบมาเพื่อส่งมอบ

• ผลลัพธ์ที่เหมือนจริง เหมาะสำหรับการโฆษณา ภาพผลิตภัณฑ์ และการจำลอง UI
• การแก้ไขการอ้างอิงหลายรายการดั้งเดิม: รวม สลับ หรือจัดองค์ประกอบจากรูปภาพอินพุตหลายภาพในการแก้ไขครั้งเดียว
• รูปแบบต่างๆ สำหรับกรณีการใช้งานที่แตกต่างกัน: โมเดลนักพัฒนาที่เปิดเผยได้, จุดสิ้นสุด Pro ที่ได้รับการปรับให้เหมาะสมสำหรับการผลิต และจุดสิ้นสุด Flex สำหรับการควบคุมระดับต่ำ

ในระดับสูง FLUX.2 ได้ผสานโครงสร้างหลักแบบสร้างแฝง (สถาปัตยกรรมโฟลว์/ทรานส์ฟอร์เมอร์) เข้ากับแบบจำลองวิสัยทัศน์-ภาษาสำหรับการกราวด์เชิงความหมาย และ VAE ที่ผ่านการฝึกอบรมใหม่ เพื่อให้มีพื้นที่แฝงที่ใช้ร่วมกันระหว่างตัวแปรต่างๆ การออกแบบนี้ช่วยให้แบบจำลองสามารถทั้งสร้างและสร้างขึ้นใหม่ (แก้ไข) ได้อย่างแม่นยำยิ่งขึ้น ในขณะเดียวกันก็ยังคงสามารถเรียนรู้การแสดงผลเพื่อฝึกฝนและปรับแต่งได้ VAE แบบเปิดมีความโดดเด่นเป็นพิเศษ เนื่องจากเป็นการกำหนดพื้นที่แฝงให้เป็นมาตรฐานสำหรับเวิร์กโฟลว์ที่โฮสต์และโฮสต์ด้วยตนเอง

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

ฉันจะเข้าถึง FLUX.2 API ได้อย่างไร

เตรียมสภาพแวดล้อม

ลงทะเบียนและเข้าสู่ระบบ CometAPI และรับรหัส API จากแผงโปรไฟล์ของคุณ นักพัฒนาควรมีความรู้เกี่ยวกับ API บ้าง (เราจะให้ความช่วยเหลือในเรื่องนี้ โปรดอย่ากังวล)

คุณจะต้องเลือกวิธีการร้องขอที่คุณต้องการและโมเดล Flux.2 ที่เหมาะสมด้วย

จำเป็นต้องมีจุดสิ้นสุดและการยืนยันตัวตนใดบ้าง?

Replicate Predictions API ช่วยให้สามารถสร้างภาพคุณภาพสูงโดยใช้โมเดล FLUX หลากหลายรูปแบบจาก Black Forest Labs ผ่านรูปแบบ Replicate มาตรฐาน API นี้รองรับโมเดล FLUX หลากหลายรูปแบบ ซึ่งแต่ละแบบได้รับการปรับแต่งให้เหมาะสมกับกรณีการใช้งานที่แตกต่างกัน ตั้งแต่การสร้างต้นแบบอย่างรวดเร็วไปจนถึงการสร้างภาพระดับมืออาชีพ ผู้ใช้สามารถสลับระหว่างโมเดลต่างๆ ได้อย่างราบรื่น เพียงเปลี่ยนชื่อโมเดลในเส้นทาง URL (https://api.cometapi.com/replicate/v1/models/{models}/predictions) ทำให้มีความยืดหยุ่นสำหรับการใช้งานด้านสร้างสรรค์และเชิงพาณิชย์ที่หลากหลาย

โคเมทเอพีไอ เปิดเผยจุดสิ้นสุดที่ได้รับการจัดการภายใต้ https://api.cometapi.com/flux/v1/{model} และตั้งชื่อจุดสิ้นสุด เช่น flux-2-pro, flux-2-flex และ flux-2-flex สำหรับการสร้างและแก้ไขรูปภาพ คำขอต้องใช้คีย์ API ใน x-key ส่วนหัว .

ตระกูลโมเดลและการแลกเปลี่ยนการคำนวณ

• FLUX.2 (น้ำหนักเปิด) — ใช้เมื่อคุณต้องการการควบคุมภายใน การทดลองวิจัย หรือเพื่อรันการอนุมานบนโครงสร้างพื้นฐานของคุณเอง Dev เป็นแบบ open-weight (32B) และยอดเยี่ยมสำหรับการวิจัยเชิงสำรวจและการปรับแต่งอย่างละเอียด สามารถปรับแต่งได้มากกว่า แต่คุณต้องรับผิดชอบโครงสร้างพื้นฐานและการปรับแต่งให้เหมาะสมที่สุด
• ฟลักซ์.2 โปร — สมดุลที่ดีที่สุดระหว่างความเร็ว คุณภาพ และต้นทุนการผลิต Pro ได้รับการปรับแต่งให้มีความหน่วงที่คาดการณ์ได้ การทำงานรวดเร็ว สม่ำเสมอ ทรูพุตรวดเร็ว และรองรับรูปภาพอ้างอิง API สูงสุด 8 รูป (รวม 9MP ผ่าน API) เหมาะสำหรับการตัดต่อจำนวนมาก และเมื่อคุณต้องการความน่าเชื่อถือและราคาที่คาดการณ์ได้
• FLUX.2 (จัดการ + ควบคุมได้) — เปิดเผยการควบคุมการสร้างระดับต่ำ (เช่น steps, guidance) และรองรับการอ้างอิงได้มากขึ้น (สูงสุด 10 รายการ) และคุณภาพ/รายละเอียดที่สูงขึ้นเล็กน้อยเมื่อคุณยอมรับความล่าช้าและต้นทุนที่สูงขึ้น ใช้ Flex เมื่อคุณต้องการการควบคุมขั้นสุดท้ายในการสร้างสรรค์ ไม่ว่าจะเป็นความแม่นยำของตัวอักษร สีที่ตรงเป๊ะ หรือการปรับแต่งองค์ประกอบที่มีรายละเอียดสูง

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

ฉันจะใช้ FLUX.2 API ได้อย่างไร

วงจรชีวิตการร้องขอ (งาน + โมเดลการสำรวจ)

การตอบสนองต่อคำขอแก้ไข/สร้างคือ วัตถุงาน ซึ่งรวมถึงก polling_url และ idคุณสร้างคำขอแล้วจึงโพล (หรือใช้เว็บฮุก) เพื่อดึง URL ผลลัพธ์ที่ลงนามแล้ว URL ที่ลงนามแล้วจะมีอายุการใช้งานสั้น (โดยทั่วไปประมาณ 10 นาที) ดังนั้นจะดึงผลลัพธ์ได้อย่างรวดเร็ว

API ที่โฮสต์นั้นปฏิบัติตามรูปแบบงานแบบอะซิงโครนัส:

1. POST คำขอสร้าง → ส่งคืน task id และ polling_url บวกประมาณการ cost.
2. สำรวจความคิดเห็น polling_url จนกระทั่ง status == "Ready"จากนั้นดึงผลลัพธ์ของภาพ (มักจะเป็น base64 หรือ URL ที่โฮสต์)

ตัวอย่าง: Python (คำขอ) — ส่งและสำรวจความคิดเห็น

import time, requests, os

API_KEY = os.environ
API_URL = "https://api.cometapi.com/flux/v1/flux-2-pro"

payload = {
    "prompt": "A high-end product photo of a ceramic mug on a wooden desk, soft window light.",
    "width": 1024, "height": 1024, "seed": 42
}

r = requests.post(API_URL, headers={"x-key": API_KEY, "accept":"application/json"}, json=payload)
r.raise_for_status()
task = r.json()
polling_url = task

while True:
    time.sleep(0.5)
    status_r = requests.get(polling_url, headers={"x-key": API_KEY})
    status_r.raise_for_status()
    status = status_r.json()
    if status == "Ready":
        print("Result URL:", status)
        break
    elif status in ("Error", "Failed"):
        print("Generation failed:", status)
        break

รูปแบบนี้ (ส่ง → โพล หรือ เว็บฮุก) เป็นการไหลแบบซิงโครนัส/อะซิงโครนัสหลักสำหรับจุดสิ้นสุดที่จัดการ

การแก้ไขรูปภาพ — ตัวอย่างขั้นต่ำ (curl พร้อม URL อินพุต)

curl -X POST "https://api.cometapi.com/flux/v1/flux-2-pro" \
  -H "accept: application/json" \
  -H "x-key: $CometAPI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "Replace the background with a sunlit seaside boardwalk, keep the person intact and match lighting",
    "input_image": "https://example.com/my-photo.jpg",
    "width": 2048,
    "height": 1536
  }'

สำหรับการแก้ไขหลายการอ้างอิง ให้ใช้ input_image, input_image_2, input_image_3, … (Pro รองรับการอ้างอิงสูงสุด 8 รายการผ่าน API; Flex สูงสุด 10; Dev แนะนำสูงสุด ~6 รายการ ขึ้นอยู่กับหน่วยความจำ)

ฉันควรส่งพารามิเตอร์พื้นฐานอะไรบ้าง?

ช่องข้อมูลเนื้อหาคำขอที่สำคัญ (การแก้ไข/สร้างรูปภาพ) ประกอบด้วย:

• guidance และ steps — ช่วยให้ควบคุมได้ละเอียดยิ่งขึ้น
• prompt (สตริง) — โทเค็นสูงสุด 32K; ภาษาธรรมชาติโดยละเอียดหรือ JSON ที่มีโครงสร้าง
• input_image (สตริง) — จำเป็นสำหรับการแก้ไข (URL หรือ base64)
• input_image_2 ... input_image_9 — รูปภาพอ้างอิงหลายรายการ
• width / height - คูณ 16; เอาท์พุตสูงสุด 4MP
• seed — จำนวนเต็มสำหรับการทำซ้ำได้
• safety_tolerance — ระดับความพอประมาณ.

ฉันจะใช้ประโยชน์จาก FLUX.2 Pro เพื่อสร้างข้อความเป็นรูปภาพอย่างมืออาชีพได้อย่างไร

FLUX.2 Pro ได้รับการปรับแต่งเพื่อผลลัพธ์ที่เชื่อถือได้และมีคุณภาพสูง ใช้งานได้เมื่อคุณต้องการผลลัพธ์ระดับแบรนด์ที่สม่ำเสมอ การตอบสนองที่รวดเร็ว และ SLA ระดับองค์กร

สูตรเวิร์กโฟลว์ — ภาพการผลิต

1. คำเตือนก่อนดำเนินการ: รักษาบรรทัด "เจตนา" สั้นๆ ไว้พร้อมกับส่วนแอตทริบิวต์ที่มีโครงสร้าง (แสง เลนส์ อารมณ์ รหัสสีฐานสิบหกสำหรับสีของแบรนด์) FLUX.2 รองรับการควบคุมสีฐานสิบหกเพื่อช่วยรักษาจานสีของแบรนด์
2. เริ่มต้นด้วยค่าเริ่มต้นแบบอนุรักษ์นิยม: ขั้นตอนที่ 30–50 และระดับคำแนะนำ 6–9.0 เพิ่มขั้นตอนสำหรับรายละเอียด เพิ่มคำแนะนำเพื่อให้ผลลัพธ์เป็นไปตามคำแนะนำอย่างเคร่งครัดมากขึ้น
3. ใช้เมล็ดพันธุ์ + การสุ่มตัวอย่างแบบกำหนด เพื่อการทำซ้ำได้ในการทดสอบ A/B
4. ใช้จุดสิ้นสุด Pro สำหรับการสุ่มตัวอย่างหลายครั้ง: ขอให้มีการเปลี่ยนแปลง N แบบขนานและเลือกสิ่งที่ดีที่สุด — ราคาถูกกว่าและเร็วกว่าการปรับไฮเปอร์พารามิเตอร์ด้วยตนเอง
5. หลังกระบวนการ: การลดเสียงรบกวน การแมปโทนเสียงเล็กน้อย หรือการปรับแต่งแบบเวกเตอร์ในไปป์ไลน์แบบกำหนดได้ พิจารณาใช้ GAN ขนาดเล็กหรือการส่งแบบความละเอียดสูงพิเศษ หากคุณต้องการเอาต์พุตที่สูงกว่าเนทีฟ

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

เคล็ดลับดีๆ ในการสร้างภาพ

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

{
  "scene": "product shot",
  "subjects": [
    {"type":"mug","pose":"center","style":"ceramic, matte"},
    {"type":"background","style":"wooden desk, window light"}
  ],
  "camera": {"focal_length":"85mm","aperture":"f2.8","angle":"slightly above"}
}

2. ความสามารถในการทำซ้ำ: ส่ง seed เพื่อทำซ้ำในภายหลัง เก็บคำแนะนำการแมปแคตตาล็อก + เมล็ดพันธุ์ → รูปภาพไว้เพื่อการตรวจสอบย้อนกลับ

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

4. ความพอประมาณและความปลอดภัย: ใช้ safety_tolerance เพื่อควบคุมความเข้มงวดในการควบคุมเนื้อหา จุดสิ้นสุดของ Pro ประกอบด้วยนโยบายการใช้งานและจุดเชื่อมโยงการควบคุมเนื้อหา ผสานรวมการตรวจสอบฝั่งเซิร์ฟเวอร์ก่อนเผยแพร่

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

ฉันจะปรับแต่งเอาท์พุตด้วยจุดสิ้นสุด FLUX.2 Flex ได้อย่างไร

Flex คือตัวแปร "เครื่องมือผ่าตัด": ปรับแต่งขั้นตอน คำแนะนำ คำเตือนเชิงลบ ขนาดไทล์ และจำนวนอ้างอิงเพื่อกำหนดผลลัพธ์อย่างแม่นยำ

เมื่อใดควรเลือก Flex

• คุณต้องมีการเรนเดอร์ตัวอักษรที่แม่นยำ (โมเดล UI, ป้ายกำกับ)
• คุณจะต้องรวมการอ้างอิงหลายๆ รายการเข้าด้วยกันโดยควบคุมท่าทางและแสง
• คุณกำลังทดลองใช้เทคนิคการแจ้งเตือนขั้นสูง (การแจ้งเตือนที่มีโครงสร้าง โซ่แห่งข้อจำกัด)

ตัวอย่าง — ปุ่มควบคุม Flex และเอฟเฟกต์ต่างๆ

• steps — ยิ่งมีขั้นตอนมากขึ้น = มีรายละเอียดมากขึ้น (โดยแลกกับความล่าช้า)
• guidance_scale — ยิ่งสูง = ยิ่งใกล้เคียงกับข้อความมากขึ้น ยิ่งต่ำ = ยิ่งมีความคิดสร้างสรรค์มากขึ้น
• negative_prompt — ลบองค์ประกอบออกอย่างชัดเจน (เช่น "ไม่มีลายน้ำ ไม่มีนิ้วพิเศษ")
• tile_size / tiled_inference — สำหรับการสร้างความละเอียดสูงมาก พื้นที่อนุมานไทล์เพื่อแลกหน่วยความจำเพื่อความเร็ว
• reference_weights จุดสิ้นสุดบางจุดให้คุณถ่วงน้ำหนักการอ้างอิงตามอคติว่าภาพใดจะขับเคลื่อนท่าทางหรือสไตล์

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

ตัวอย่าง: คำขอแบบยืดหยุ่นพร้อมขั้นตอนและคำแนะนำ

curl -X POST "https://api.bfl.ai/v1/flux-2-flex" \
  -H "Content-Type: application/json" \
  -H "x-key: $BFL_API_KEY" \
  -d '{
    "prompt": "Cinematic movie poster, bold typography at top, main character centered, dramatic rim lighting",
    "width": 1536, "height": 2048,
    "steps": 50,
    "guidance": 7.5,
    "seed": 99999
  }'

เคล็ดลับ: ใช้ Flex ระหว่างการลงนามอนุมัติขั้นสุดท้ายสำหรับงานสร้างสรรค์ และใช้ Pro สำหรับกระบวนการทำงานขนาดใหญ่ที่รวดเร็วขึ้น Flex สามารถควบคุมได้ดีกว่าอย่างเห็นได้ชัดสำหรับงานพิมพ์และงานรายละเอียดเล็กๆ น้อยๆ

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

ด้านล่างนี้เป็นรูปแบบที่ผ่านการทดสอบในสนามรบและคำแนะนำเชิงปฏิบัติสำหรับการบูรณาการ FLUX.2 ในระดับขนาดใหญ่

1) ควบคุมต้นทุนโดยการติดตามเมกะพิกเซลและการแคช

การเรียกเก็บเงิน FLUX.2 ขึ้นอยู่กับเมกะพิกเซลของ อินพุต + เอาท์พุตสำหรับการสร้างงานปริมาณมาก ควรใช้การเรนเดอร์ตัวอย่างขนาดเล็ก (ขั้นตอนด่วนความละเอียดต่ำ) และขยายไปยังการเรนเดอร์ขั้นสุดท้ายที่มี MP สูงกว่าเท่านั้น แคชทรัพยากรที่เรนเดอร์แล้ว (หรือเก็บความแตกต่างของงาน) เพื่อไม่ให้เรนเดอร์งานที่เหมือนกันซ้ำ การแสดงผลเสมอ cost ในการตอบกลับและบันทึกไว้ตามคำขอ

2) ใช้ระดับอย่างชาญฉลาด: การแยกตัวอย่างกับการเรนเดอร์ขั้นสุดท้าย

• รันโปรแกรม Pro ที่มีขั้นตอนต่ำและรวดเร็วเพื่อสร้างต้นแบบหรือตัวแปรต่างๆ มากมาย
• ใช้ Flex หรือ High-MP Pro สำหรับผลลัพธ์ขั้นสุดท้ายที่ได้รับการอนุมัติ ซึ่งความเที่ยงตรงเป็นสิ่งสำคัญ วิธีการแบบผสมผสานนี้ช่วยสร้างสมดุลระหว่างปริมาณงานและคุณภาพของภาพขั้นสุดท้าย

3) วิศวกรรมพร้อมท์ → พร้อมท์ที่มีโครงสร้างและ JSON

ใช้ประโยชน์จาก FLUX.2 การแจ้งเตือน JSON ที่มีโครงสร้าง เมื่อคุณต้องการองค์ประกอบแบบกำหนดได้ (วัตถุฉาก, กล้อง, ท่าทาง, ตัวอย่างสีแบบเลขฐานสิบหก) วิธีนี้ช่วยลดรอบการแจ้งแบบวนซ้ำและทำให้สามารถทำซ้ำได้เป็นชุดมากขึ้น ตัวอย่าง Cloudflare แสดงการแจ้งแบบ JSON ที่ฝังอยู่ในแบบฟอร์มหลายส่วน

4) เมล็ดพันธุ์ + การกำหนดเวอร์ชันสำหรับการทำซ้ำได้

เมื่อคุณต้องการผลลัพธ์ที่ทำซ้ำได้ ให้ส่ง seed และบันทึกเวอร์ชัน/ไทม์สแตมป์ของโมเดลในเมตาดาต้า สำหรับกระบวนการสินทรัพย์แบบกำหนดตายตัว ให้เก็บรายการ (manifest): พรอมต์, เมล็ดพันธุ์, ตัวแปรโมเดล, ความละเอียด, แฮชรูปภาพอ้างอิง วิธีนี้ช่วยเพิ่มความสามารถในการตรวจสอบย้อนกลับและตัวเลือกการย้อนกลับ

สรุป

FLUX.2 มุ่งเป้าไปที่การปิดช่องว่างระหว่าง "เดโมที่น่าประทับใจ" และ "เครื่องมือสร้างสรรค์สำหรับการผลิต" อย่างแท้จริง ด้วยการแก้ไขแบบอ้างอิงหลายรายการ ผลลัพธ์ความละเอียดสูง และชุดปลายทางที่โฮสต์ไว้ (รวมถึงโค้ดอนุมานแบบเปิดและรุ่นสำหรับผู้บริโภคแบบควอนไทซ์) ทำให้ทีมมีตัวเลือกที่ใช้งานได้จริงมากมาย: รันในเครื่องเพื่อการวิจัยและปรับแต่ง หรือใช้ปลายทาง Pro/Flex ที่โฮสต์ไว้สำหรับขั้นตอนการผลิตที่เสถียร

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

พร้อมไปหรือยัง?→ ลงทะเบียน CometAPI วันนี้ !

หากคุณต้องการทราบเคล็ดลับ คำแนะนำ และข่าวสารเกี่ยวกับ AI เพิ่มเติม โปรดติดตามเราที่ VK, X และ ไม่ลงรอยกัน!