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

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

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

FLUX.2 คืออะไร และทำไมจึงสำคัญ?

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

ผลลัพธ์หลักที่ FLUX.2 ออกแบบมาเพื่อมอบให้

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

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

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

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

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

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

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

ต้องใช้เอ็นด์พอยต์และการยืนยันตัวตนอะไรบ้าง?

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

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

ตระกูลโมเดลและการชั่งน้ำหนักทรัพยากรคอมพิวต์

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

เริ่มต้นสร้างต้นแบบบน Dev หรือแผน Pro ราคาประหยัด จากนั้นย้ายไป Pro เพื่อสเกล หรือ Flex สำหรับเรนเดอร์สุดท้ายที่ควบคุมอย่างประณีต

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

วัฏจักรคำขอ (task + รูปแบบการโพลล์)

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

Hosted API ใช้รูปแบบงานแบบอะซิงโครนัส:

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

ตัวอย่าง: Python (requests) — ส่งคำขอและโพลล์

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

รูปแบบนี้ (ส่ง → โพลล์หรือ webhook) คือโฟลว์ซิงก์/อะซิงก์หลักสำหรับเอ็นด์พอยต์แบบจัดการ

การแก้ไขภาพ — ตัวอย่างขั้นต่ำ (curl พร้อม input 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": "![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 ขึ้นกับหน่วยความจำ)

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

ฟิลด์สำคัญใน request body (การแก้ไขภาพ/การสร้างภาพ) ได้แก่:

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

จะใช้ FLUX.2 Pro เพื่อการสร้างภาพจากข้อความระดับมืออาชีพได้อย่างไร?

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

สูตรเวิร์กโฟลว์ — ภาพสำหรับงานผลิต

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

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

เคล็ดลับที่ดีที่สุดสำหรับการสร้างภาพ

1. การพรอมป์ต์แบบมีโครงสร้างชนะสำหรับงานผลิตจริง จัดระเบียบพรอมป์ต์ตามลำดับความสำคัญ: หัวเรื่อง → การกระทำ → สไตล์ → บริบท ใช้การพรอมป์ต์แบบ JSON (scene, subjects, camera, lighting, color_palette) เมื่อคุณต้องการองค์ประกอบที่กำหนดแน่นอนข้ามหลายภาพ ตัวอย่างการใช้สคีมา 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 เพื่อทำซ้ำภายหลัง เก็บแคตตาล็อกแม็ปปิงระหว่างพรอมป์ต์ + seed → ภาพ เพื่อการตรวจสอบย้อนกลับ

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

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

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

จะปรับแต่งผลลัพธ์ด้วยเอ็นด์พอยต์ FLUX.2 Flex ได้อย่างไร?

Flex คือรุ่น “เครื่องมือศัลยกรรม” ที่ให้คุณจูน steps, guidance, negative prompts, tile sizes และจำนวนอ้างอิง เพื่อกำหนดผลลัพธ์อย่างแม่นยำ

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

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

ตัวอย่าง — คีย์ควบคุมของ Flex และผลของมัน

• steps — มากขึ้น = รายละเอียดละเอียดยิ่งขึ้น (แลกกับความหน่วง)
• guidance_scale — สูงขึ้น = ใกล้กับข้อความพรอมป์ต์มากขึ้น ต่ำลง = สร้างสรรค์ขึ้น
• negative_prompt — ระบุให้ตัดองค์ประกอบออก (เช่น “no watermark, no extra fingers”)
• tile_size / tiled_inference — สำหรับการสร้างภาพความละเอียดสูงมาก แบ่งไทล์พื้นที่อินเฟอเรนซ์เพื่อแลกหน่วยความจำกับความเร็ว
• reference_weights — บางเอ็นด์พอยต์ให้กำหนดค่าน้ำหนักของอ้างอิงเพื่อชี้วัดว่าให้ภาพใดนำท่าทางหรือสไตล์

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

ตัวอย่าง: คำขอ Flex พร้อม steps & guidance

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 อิงตามเมกะพิกเซลของทั้งอินพุต + เอาต์พุต สำหรับการสร้างปริมาณมาก ให้เรนเดอร์พรีวิวขนาดเล็ก (ความละเอียดต่ำ steps ไว) และค่อยยกระดับไปยังเรนเดอร์สุดท้ายที่ MP สูง เก็บแคชทรัพย์สินที่เรนเดอร์แล้ว (หรือเก็บเฉพาะความต่าง) เพื่อไม่ต้องเรนเดอร์งานเดิมซ้ำ แสดง cost ในการตอบกลับและบันทึกต่อคำขอเสมอ

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

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

3) การออกแบบพรอมป์ต์ → พรอมป์ต์แบบมีโครงสร้าง & JSON

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

4) Seed + เวอร์ชันนิ่งเพื่อความทำซ้ำได้

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

บทสรุป

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

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

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

หากต้องการเคล็ดลับ คู่มือ และข่าวสารด้าน AI เพิ่มเติม ติดตามเราได้บน VK, X และ Discord!