วิธีใช้ GPT-5.4 API

TL;DR / สรุปอย่างรวดเร็ว

วิธีใช้ GPT-5.4 API: ติดตั้ง OpenAI SDK (pip install openai) กำหนดค่าไคลเอนต์ด้วย API key เรียกใช้ chat.completions.create() ด้วยโมเดล gpt-5.4 คุณสมบัติหลัก: การใช้งานคอมพิวเตอร์ (ระบบอัตโนมัติของเบราว์เซอร์แบบเนทีฟ), การค้นหาเครื่องมือ (ลดโทเค็นได้ 47%), หน้าต่างบริบท 1M, ความสามารถด้านวิสัยทัศน์ ราคา: $2.50/M โทเค็นอินพุต, $15/M โทเค็นเอาต์พุต คู่มือนี้ครอบคลุมการตั้งค่า, ตัวอย่างโค้ด, การกำหนดค่าการใช้งานคอมพิวเตอร์, การรวมเครื่องมือ และแนวทางปฏิบัติที่ดีที่สุดสำหรับการใช้งานจริง

บทนำ

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

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

ไม่ว่าคุณจะกำลังสร้าง AI agents, ระบบอัตโนมัติสำหรับเบราว์เซอร์ หรือรวม GPT-5.4 เข้ากับแอปพลิเคชันที่มีอยู่ คู่มือนี้จะให้รายละเอียดการใช้งานที่คุณต้องการ

💡

เมื่อรวม GPT-5.4 เข้ากับแอปพลิเคชัน ให้ใช้ Apidog เพื่อออกแบบ ทดสอบ และจัดทำเอกสารปลายทาง API ของคุณ แพลตฟอร์มแบบรวมของ Apidog ช่วยให้คุณดีบักคำขอ API สร้างชุดการทดสอบอัตโนมัติ จำลองการตอบสนองระหว่างการพัฒนา และสร้างเอกสารประกอบสำหรับทีมของคุณ สิ่งนี้มีคุณค่าอย่างยิ่งเมื่อสร้างฟีเจอร์ที่ขับเคลื่อนด้วย AI ที่รวม GPT-5.4 กับบริการอื่นๆ

button

เริ่มต้นอย่างรวดเร็ว: คำขอ GPT-5.4 ครั้งแรกของคุณ

เริ่มใช้งาน GPT-5.4 ได้ภายใน 5 นาที ก่อนที่จะเขียนโค้ด ให้ทดสอบ คำขอ GPT-5.4 API ของคุณใน Apidog:

สร้างคำขอ HTTP ใหม่ด้วย POST ไปที่ https://api.openai.com/v1/chat/completions
เพิ่มส่วนหัว Authorization: Bearer YOUR_API_KEY
ตั้งค่าเนื้อหาคำขอด้วย model, messages และ parameters
ส่งและตรวจสอบการตอบสนอง
บันทึกลงในคอลเลกชันเพื่อการทดสอบซ้ำๆ
ใช้ตัวแปรสภาพแวดล้อมเพื่อสลับระหว่าง API keys

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

ข้อกำหนดเบื้องต้น

บัญชี OpenAI ที่เปิดใช้งานการเรียกเก็บเงิน
API key จาก platform.openai.com/api-keys
Python 3.7+ หรือ Node.js 14+

Python เริ่มต้นอย่างรวดเร็ว

from openai import OpenAI
import os

# Initialize client
client = OpenAI(
    api_key=os.getenv("OPENAI_API_KEY")
)

# Make request
response = client.chat.completions.create(
    model="gpt-5.4",
    messages=[
        {"role": "system", "content": "You are a helpful coding assistant."},
        {"role": "user", "content": "Write a Python function to sort a list of dictionaries by a key."}
    ]
)

print(response.choices[0].message.content)

Node.js เริ่มต้นอย่างรวดเร็ว

const OpenAI = require('openai');

const client = new OpenAI({
    apiKey: process.env.OPENAI_API_KEY
});

async function main() {
    const response = await client.chat.completions.create({
        model: 'gpt-5.4',
        messages: [
            { role: 'system', content: 'You are a helpful coding assistant.' },
            { role: 'user', content: 'Write a Python function to sort a list of dictionaries by a key.' }
        ]
    });

    console.log(response.choices[0].message.content);
}

main();

ผลลัพธ์ที่คาดไว้

def sort_dicts_by_key(dict_list, key, reverse=False):
    """
    Sort a list of dictionaries by a specified key.

    Args:
        dict_list: List of dictionaries to sort
        key: The dictionary key to sort by
        reverse: If True, sort in descending order

    Returns:
        Sorted list of dictionaries
    """
    return sorted(dict_list, key=lambda x: x.get(key, ''), reverse=reverse)

# Example usage
data = [
    {'name': 'Alice', 'age': 30},
    {'name': 'Bob', 'age': 25},
    {'name': 'Charlie', 'age': 35}
]

sorted_by_age = sort_dicts_by_key(data, 'age')
print(sorted_by_age)
# [{'name': 'Bob', 'age': 25}, {'name': 'Alice', 'age': 30}, {'name': 'Charlie', 'age': 35}]

ทำความเข้าใจความสามารถของ GPT-5.4

GPT-5.4 โดดเด่นในสี่ด้านหลัก การทำความเข้าใจสิ่งเหล่านี้ช่วยให้คุณเลือกแนวทางที่เหมาะสมสำหรับแต่ละกรณีการใช้งาน

1. งานความรู้ (อัตราการชนะ GDPval 83%)

ดีที่สุดสำหรับ:

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

2. การใช้งานคอมพิวเตอร์ (75% รับรองโดย OSWorld)

ดีที่สุดสำหรับ:

ระบบอัตโนมัติของเบราว์เซอร์
การป้อนข้อมูลข้ามแอปพลิเคชัน
การดึงข้อมูลจากเว็บด้วยการโต้ตอบ
การทดสอบเวิร์กโฟลว์
ระบบอัตโนมัติสำหรับงานข้ามแอปพลิเคชัน

3. การเขียนโค้ด (57.7% SWE-Bench Pro)

ดีที่สุดสำหรับ:

การพัฒนา Full-stack
การสร้าง UI ส่วนหน้า
การดีบักปัญหาที่ซับซ้อน
การปรับปรุงโค้ด (Refactoring)
การสร้างการทดสอบ

4. การรวมเครื่องมือ (54.6% Toolathlon)

ดีที่สุดสำหรับ:

การรวมเซิร์ฟเวอร์ MCP
เวิร์กโฟลว์ API แบบหลายขั้นตอน
การประสานงานเครื่องมือภายนอก
แอปพลิเคชันแบบ Agentic

Computer Use API

ความสามารถในการใช้งานคอมพิวเตอร์แบบเนทีฟของ GPT-5.4 ถือเป็นการก้าวกระโดดที่สำคัญที่สุดในการเปิดตัวครั้งนี้ โมเดลสามารถสั่งงานคอมพิวเตอร์ผ่านการจับภาพหน้าจอ (screenshots), คำสั่งเมาส์ และการป้อนข้อมูลด้วยคีย์บอร์ด

เมื่อสร้างแอปพลิเคชันที่มีความสามารถในการใช้งานคอมพิวเตอร์ ให้ทดสอบแต่ละขั้นตอนของเวิร์กโฟลว์ใน Apidog:

ตรวจสอบจุดปลายสำหรับการอัปโหลดภาพหน้าจอ
ทดสอบ API การดำเนินการคำสั่ง (คลิก, พิมพ์, เลื่อน)
สร้างการตอบสนองจำลอง (mock responses) สำหรับแต่ละการกระทำของคอมพิวเตอร์
ทำให้การทดสอบเวิร์กโฟลว์แบบหลายรอบเป็นไปโดยอัตโนมัติ
จัดทำเอกสารสัญญา API การใช้งานคอมพิวเตอร์สำหรับการอ้างอิงของทีม

การทำงานของ Computer Use

เวิร์กโฟลว์การใช้งานคอมพิวเตอร์ใช้เครื่องมือ computer ในคำขอ API โดยโมเดลจะ:

รับภาพหน้าจอของสถานะหน้าจอปัจจุบัน
วิเคราะห์องค์ประกอบ UI และกำหนดการกระทำ
ส่งกลับคำสั่งคอมพิวเตอร์ (คลิก, พิมพ์, เลื่อน ฯลฯ)
แอปพลิเคชันของคุณจะดำเนินการคำสั่งและจับภาพหน้าจอใหม่
วนซ้ำจนกว่างานจะเสร็จสมบูรณ์

การตั้งค่า Computer Use เบื้องต้น

from openai import OpenAI
import base64

client = OpenAI()

def take_screenshot():
    """จับภาพสถานะหน้าจอปัจจุบัน - ใช้งานได้กับแพลตฟอร์มของคุณ"""
    # ใช้ pyautogui, PIL หรือการจับภาพหน้าจอเฉพาะแพลตฟอร์ม
    import pyautogui
    screenshot = pyautogui.screenshot()
    import io
    buffer = io.BytesIO()
    screenshot.save(buffer, format='PNG')
    return base64.b64encode(buffer.getvalue()).decode('utf-8')

def execute_computer_command(command):
    """ดำเนินการคำสั่งคอมพิวเตอร์ - ใช้งานตามประเภทคำสั่ง"""
    import pyautogui

    action = command.get('action')

    if action == 'click':
        x, y = command.get('coordinate', [0, 0])
        pyautogui.click(x, y)
    elif action == 'type':
        text = command.get('text', '')
        pyautogui.write(text, interval=0.05)
    elif action == 'scroll':
        amount = command.get('scroll_amount', 0)
        pyautogui.scroll(amount)
    elif action == 'keypress':
        key = command.get('key', '')
        pyautogui.press(key)

    # ส่งกลับภาพหน้าจอใหม่หลังจากการกระทำ
    return take_screenshot()

# การสนทนาเกี่ยวกับการใช้งานคอมพิวเตอร์
messages = [{
    "role": "user",
    "content": [
        {
            "type": "text",
            "text": "นำทางไปยัง gmail.com และเข้าสู่ระบบด้วยข้อมูลรับรองที่ฉันให้มา"
        },
        {
            "type": "image_url",
            "image_url": {
                "url": f"data:image/png;base64,{take_screenshot()}"
            }
        }
    ]
}]

# คำขอพร้อมเครื่องมือคอมพิวเตอร์
response = client.chat.completions.create(
    model="gpt-5.4",
    messages=messages,
    tools=[{
        "type": "computer",
        "display_width": 1920,
        "display_height": 1080,
        "display_number": 1
    }],
    tool_choice="required"
)

# แยกวิเคราะห์และดำเนินการคำสั่งคอมพิวเตอร์
for tool_call in response.choices[0].message.tool_calls:
    if tool_call.type == "computer":
        command = tool_call.function.arguments
        new_screenshot = execute_computer_command(command)

        # ดำเนินการสนทนาต่อด้วยภาพหน้าจอใหม่
        messages.append({
            "role": "assistant",
            "content": response.choices[0].message.content
        })
        messages.append({
            "role": "user",
            "content": [{
                "type": "image_url",
                "image_url": {"url": f"data:image/png;base64,{new_screenshot}"}
            }]
        })

นโยบายความปลอดภัยในการใช้งานคอมพิวเตอร์

กำหนดพฤติกรรมด้านความปลอดภัยตามระดับความเสี่ยงที่คุณยอมรับ:

# โหมดปลอดภัย - ต้องมีการยืนยันสำหรับการกระทำที่ละเอียดอ่อน
response = client.chat.completions.create(
    model="gpt-5.4",
    messages=messages,
    tools=[{
        "type": "computer",
        "display_width": 1920,
        "display_height": 1080,
        "confirmation_policy": "always"  # หรือ "never" หรือ "selective"
    }],
    # ข้อความระบบที่กำหนดเองเพื่อความปลอดภัย
    system_message="""คุณกำลังใช้งานคอมพิวเตอร์ ปฏิบัติตามกฎความปลอดภัยเหล่านี้:
    1. ห้ามป้อนข้อมูลรับรองโดยไม่ได้รับการยืนยันจากผู้ใช้
    2. ถามก่อนที่จะลบไฟล์หรือข้อมูล
    3. ยืนยันก่อนส่งอีเมลหรือข้อความ
    4. รายงานข้อผิดพลาดหรือสถานะที่ไม่คาดคิดทันที
    """
)

ตัวอย่างระบบอัตโนมัติของเบราว์เซอร์

ทำให้งานของเบราว์เซอร์เป็นไปโดยอัตโนมัติด้วยการรวม Playwright:

from playwright.sync_api import sync_playwright

def browser_automation_workflow():
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=False)
        page = browser.new_page()

        # นำทางไปยังหน้าเว็บ
        page.goto("https://example.com")

        # รับภาพหน้าจอสำหรับ GPT-5.4
        screenshot = page.screenshot()
        screenshot_b64 = base64.b64encode(screenshot).decode('utf-8')

        messages = [{
            "role": "user",
            "content": [
                {"type": "text", "text": "ค้นหาแบบฟอร์มเข้าสู่ระบบและกรอกข้อมูล"}
                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{screenshot_b64}"}}
            ]
        }]

        # รับคำสั่งคอมพิวเตอร์จาก GPT-5.4
        response = client.chat.completions.create(
            model="gpt-5.4",
            messages=messages,
            tools=[{"type": "computer"}],
            tool_choice="required"
        )

        # แยกวิเคราะห์และดำเนินการคำสั่งบนเบราว์เซอร์
        for tool_call in response.choices[0].message.tool_calls:
            if tool_call.type == "computer":
                command = json.loads(tool_call.function.arguments)

                if command.get('action') == 'click':
                    x, y = command.get('coordinate', [0, 0])
                    page.mouse.click(x, y)
                elif command.get('action') == 'type':
                    page.keyboard.type(command.get('text', ''))

                # รับภาพหน้าจอใหม่และดำเนินการต่อ
                new_screenshot = page.screenshot()
                # ... ดำเนินการวนซ้ำต่อ

ระบบอัตโนมัติสำหรับอีเมลและปฏิทิน

ตัวอย่างจริง: ประมวลผลอีเมลและกำหนดการนัดหมาย:

def process_email_and_schedule_meeting():
    """
    เวิร์กโฟลว์: อ่านอีเมลที่ยังไม่ได้อ่าน, แยกคำขอประชุม,
    ตรวจสอบปฏิทินว่าง, และส่งคำเชิญปฏิทิน
    """

    workflow_prompt = """
    ทำเวิร์กโฟลว์นี้ให้สมบูรณ์:
    1. เปิด Gmail และค้นหาอีเมลที่ยังไม่ได้อ่านในช่วง 24 ชั่วโมงที่ผ่านมา
    2. ระบุคำขอประชุมหรือคำถามเกี่ยวกับการกำหนดตารางเวลา
    3. สำหรับแต่ละคำขอประชุม:
       - แยกวันที่/เวลาที่เสนอ
       - บันทึกผู้เข้าร่วมและวัตถุประสงค์ของการประชุม
    4. เปิด Google Calendar และตรวจสอบความพร้อม
    5. ส่งคำเชิญปฏิทินสำหรับการประชุมที่ยืนยันแล้ว
    6. ตอบกลับอีเมลเพื่อยืนยันเวลาที่กำหนด

    รายงานสรุปสิ่งที่ทำได้
    """

    # เริ่มต้นด้วยภาพหน้าจอของกล่องจดหมาย
    screenshot = take_screenshot()

    messages = [{
        "role": "user",
        "content": [
            {"type": "text", "text": workflow_prompt},
            {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{screenshot}"}}
        ]
    }]

    # ดำเนินการเวิร์กโฟลว์การใช้งานคอมพิวเตอร์แบบหลายรอบ
    for turn in range(10):  # จำกัดรอบเพื่อป้องกันการวนซ้ำไม่สิ้นสุด
        response = client.chat.completions.create(
            model="gpt-5.4",
            messages=messages,
            tools=[{"type": "computer"}],
            tool_choice="required"
        )

        # ตรวจสอบว่างานเสร็จสมบูรณ์หรือไม่
        if "complete" in response.choices[0].message.content.lower():
            print(f"เวิร์กโฟลว์เสร็จสมบูรณ์ใน {turn + 1} รอบ")
            break

        # ดำเนินการคำสั่งคอมพิวเตอร์และรับภาพหน้าจอใหม่
        # ... (ตรรกะการดำเนินการคำสั่งจากตัวอย่างก่อนหน้า)

การเพิ่มประสิทธิภาพ

ผลลัพธ์ของ Mainstay ที่ประมวลผลพอร์ทัลภาษีทรัพย์สิน 30,000 แห่ง:

อัตราความสำเร็จในการลองครั้งแรก 95%
เร็วกว่ารุ่นก่อนหน้า 3 เท่า
ใช้โทเค็นน้อยลง 70% ต่อเซสชัน

เคล็ดลับสำหรับการเพิ่มประสิทธิภาพ:

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

การค้นหาและรวมเครื่องมือ

การค้นหาเครื่องมือช่วยลดการใช้โทเค็นได้ 47% พร้อมทั้งช่วยให้ทำงานร่วมกับระบบนิเวศของเครื่องมือขนาดใหญ่ได้

การทำงานของการค้นหาเครื่องมือ

แทนที่จะโหลดคำจำกัดความเครื่องมือทั้งหมดล่วงหน้า โมเดลจะได้รับรายการที่มีน้ำหนักเบาและค้นหาคำจำกัดความเมื่อจำเป็น

การตั้งค่าการค้นหาเครื่องมือพื้นฐาน

# กำหนดเครื่องมือที่ใช้งานได้ (รายการที่มีน้ำหนักเบา)
available_tools = [
    {
        "name": "get_weather",
        "description": "รับสภาพอากาศปัจจุบันสำหรับสถานที่"
    },
    {
        "name": "send_email",
        "description": "ส่งอีเมลถึงผู้รับ"
    },
    {
        "name": "calendar_search",
        "description": "ค้นหาปฏิทินสำหรับกิจกรรม"
    },
    # ... เครื่องมืออื่นๆ อีกหลายร้อยรายการ
]

# คำขอเริ่มต้น - โมเดลเห็นรายการเครื่องมือ ไม่ใช่คำจำกัดความเต็ม
response = client.chat.completions.create(
    model="gpt-5.4",
    messages=[
        {"role": "user", "content": "สภาพอากาศในโตเกียวเป็นอย่างไร และส่งให้ทีมของฉันด้วย"}
    ],
    tools=available_tools,
    tool_choice="auto"
)

# หากโมเดลต้องการใช้เครื่องมือ จะร้องขอคำจำกัดความ
# แอปพลิเคชันของคุณจะให้คำจำกัดความเต็มในเวลานั้น

การรวมเซิร์ฟเวอร์ MCP

เกณฑ์มาตรฐาน MCP Atlas ของ Scale แสดงให้เห็นว่าการค้นหาเครื่องมือช่วยลดโทเค็นได้ 47%

# เซิร์ฟเวอร์ MCP พร้อมเครื่องมือมากมาย
mcp_servers = [
    {
        "name": "filesystem",
        "description": "การดำเนินการกับระบบไฟล์",
        "tool_count": 12
    },
    {
        "name": "database",
        "description": "การดำเนินการสอบถามฐานข้อมูล",
        "tool_count": 8
    },
    {
        "name": "web-search",
        "description": "การค้นหาและดึงข้อมูลจากเว็บ",
        "tool_count": 15
    }
    # ... 36 เซิร์ฟเวอร์ MCP ในเกณฑ์มาตรฐาน
]

# การกำหนดค่าการค้นหาเครื่องมือ
response = client.chat.completions.create(
    model="gpt-5.4",
    messages=[
        {"role": "user", "content": "ค้นหาไฟล์ Python ทั้งหมดที่แก้ไขวันนี้ และค้นหาความคิดเห็น TODO"}
    ],
    tools=mcp_servers,
    # การค้นหาเครื่องมือเปิดใช้งานโดยอัตโนมัติเมื่อใช้รูปแบบนี้
    parallel_tool_calls=True
)

# โมเดลจะร้องขอคำจำกัดความเครื่องมือเมื่อจำเป็น
# การประหยัดโทเค็น: 47% เทียบกับการโหลดคำจำกัดความทั้งหมดล่วงหน้า

เวิร์กโฟลว์หลายขั้นตอนสไตล์ Toolathlon

Toolathlon ทดสอบเวิร์กโฟลว์เครื่องมือแบบหลายขั้นตอนที่ซับซ้อน:

def grade_assignments_workflow():
    """
    เวิร์กโฟลว์ที่ซับซ้อน: อ่านอีเมลพร้อมไฟล์แนบ,
    อัปโหลดไปยังระบบการให้คะแนน, ให้คะแนนงาน,
    บันทึกผลลัพธ์ลงในสเปรดชีต
    """

    workflow_steps = """
    1. อ่านอีเมลจากนักเรียนพร้อมไฟล์แนบงาน
    2. ดาวน์โหลดไฟล์แนบแต่ละไฟล์
    3. อัปโหลดไปยังพอร์ทัลการให้คะแนน
    4. ให้คะแนนงานแต่ละชิ้นโดยใช้เกณฑ์การให้คะแนน
    5. บันทึกเกรดลงในสเปรดชีต
    6. ส่งอีเมลยืนยันไปยังนักเรียน
    """

    tools = [
        {"name": "email_read", "description": "อ่านอีเมลจากกล่องจดหมาย"},
        {"name": "email_send", "description": "ส่งอีเมล"},
        {"name": "file_download", "description": "ดาวน์โหลดไฟล์แนบ"},
        {"name": "file_upload", "description": "อัปโหลดไฟล์ไปยังเว็บพอร์ทัล"},
        {"name": "web_form_fill", "description": "กรอกและส่งแบบฟอร์มบนเว็บ"},
        {"name": "spreadsheet_write", "description": "เขียนข้อมูลลงในสเปรดชีต"},
        {"name": "rubric_evaluate", "description": "ประเมินงานเทียบกับเกณฑ์การให้คะแนน"}
    ]

    response = client.chat.completions.create(
        model="gpt-5.4",
        messages=[
            {"role": "user", "content": workflow_steps}
        ],
        tools=tools,
        parallel_tool_calls=True  # เปิดใช้งานการดำเนินการเครื่องมือแบบขนาน
    )

    # GPT-5.4 ทำคะแนนได้ 54.6% ใน Toolathlon เทียบกับ 45.7% สำหรับ GPT-5.2
    # หัวใจสำคัญ: การเลือกเครื่องมือที่ดีขึ้นและจำนวนรอบที่น้อยลง

การประมวลผลวิสัยทัศน์และรูปภาพ

GPT-5.4 รองรับการรับรู้ภาพที่ได้รับการปรับปรุงด้วยรายละเอียดภาพต้นฉบับสูงสุด 10.24M พิกเซล

ระดับรายละเอียดของภาพ

# รายละเอียดต้นฉบับ - ความคมชัดสูงสุด (10.24M พิกเซล, ขนาดสูงสุด 6000px)
response = client.chat.completions.create(
    model="gpt-5.4",
    messages=[{
        "role": "user",
        "content": [
            {
                "type": "image_url",
                "image_url": {
                    "url": "https://example.com/high-res-image.jpg",
                    "detail": "original"  # หรือ "high" หรือ "low"
                }
            },
            {"type": "text", "text": "วิเคราะห์แผนผังทางเทคนิคนี้"}
        ]
    }]
)

# รายละเอียดสูง - 2.56M พิกเซล, ขนาดสูงสุด 2048px
# รายละเอียดต่ำ - การประมวลผลที่เร็วที่สุด, ความแม่นยำต่ำกว่า

ตัวอย่างการแยกวิเคราะห์เอกสาร

OmniDocBench: อัตราข้อผิดพลาด 0.109 (เทียบกับ 0.140 สำหรับ GPT-5.2)

def parse_complex_document(pdf_path):
    """แยกวิเคราะห์ PDF หลายหน้าพร้อมตารางและรูปภาพ"""

    # แปลงหน้า PDF เป็นรูปภาพ
    from pdf2image import convert_from_path
    pages = convert_from_path(pdf_path, dpi=300)

    messages = [{"role": "user", "content": []}]

    for i, page in enumerate(pages[:5]):  # 5 หน้าแรก
        import io, base64
        buffer = io.BytesIO()
        page.save(buffer, format='PNG')
        img_b64 = base64.b64encode(buffer.getvalue()).decode()

        messages[0]["content"].append({
            "type": "image_url",
            "image_url": {
                "url": f"data:image/png;base64,{img_b64}",
                "detail": "high"
            }
        })

    messages[0]["content"].append({
        "type": "text",
        "text": """
        แยกข้อมูลทั้งหมดจากเอกสารนี้:
        1. ตารางพร้อมส่วนหัวแถว/คอลัมน์
        2. ตัวเลขสำคัญและคำอธิบายภาพ
        3. สรุปสถิติที่กล่าวถึงในข้อความ
        ส่งคืนเป็น JSON ที่มีโครงสร้าง
        """
    })

    response = client.chat.completions.create(
        model="gpt-5.4",
        messages=messages
    )

    return response.choices[0].message.content

การวิเคราะห์ภาพหน้าจอ UI

def analyze_ui_screenshot(screenshot_path):
    """วิเคราะห์ภาพหน้าจอ UI สำหรับปัญหาการเข้าถึง"""

    with open(screenshot_path, 'rb') as f:
        img_b64 = base64.b64encode(f.read()).decode()

    response = client.chat.completions.create(
        model="gpt-5.4",
        messages=[{
            "role": "user",
            "content": [
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/png;base64,{img_b64}",
                        "detail": "original"
                    }
                },
                {
                    "type": "text",
                    "text": """
                    ตรวจสอบภาพหน้าจอ UI นี้สำหรับปัญหาการเข้าถึง:
                    1. ปัญหาความเปรียบต่างของสี
                    2. ป้ายกำกับที่ขาดหายไปหรือตัวบ่งชี้ข้อความสำรอง
                    3. ปัญหาการนำทางด้วยคีย์บอร์ด (สถานะโฟกัสที่มองเห็นได้)
                    4. ขนาดตัวอักษรและการอ่านได้
                    5. ข้อกังวลเกี่ยวกับความเข้ากันได้กับโปรแกรมอ่านหน้าจอ

                    แสดงรายการปัญหาพร้อมตำแหน่งและความรุนแรงที่เฉพาะเจาะจง
                    """
                }
            ]
        }]
    )

    return response.choices[0].message.content

เวิร์กโฟลว์บริบทขนาดยาว

GPT-5.4 รองรับหน้าต่างบริบทสูงสุด 1M โทเค็น (ทดลอง)

บริบทมาตรฐาน (272K โทเค็น)

# โหลดไฟล์โค้ดเบสขนาดใหญ่
with open('large_codebase.py', 'r') as f:
    code = f.read()

response = client.chat.completions.create(
    model="gpt-5.4",
    messages=[
        {"role": "system", "content": "คุณคือผู้ช่วยในการตรวจสอบโค้ด"},
        {"role": "user", "content": f"""
        ตรวจสอบโค้ดเบสนี้สำหรับ:
        1. ช่องโหว่ด้านความปลอดภัย
        2. ปัญหาด้านประสิทธิภาพ
        3. ความไม่สอดคล้องกันของสไตล์โค้ด
        4. การจัดการข้อผิดพลาดที่ขาดหายไป

        โค้ด:
        {code}
        """}
    ],
    max_tokens=4000
)

บริบทเพิ่มเติม (1M โทเค็น)

กำหนดค่าผ่านพารามิเตอร์ API:

response = client.chat.completions.create(
    model="gpt-5.4",
    messages=[
        {"role": "user", "content": large_document}
    ],
    # การกำหนดค่าบริบทเพิ่มเติม
    extra_body={
        "model_context_window": 1048576,  # 1M โทเค็น
        "model_auto_compact_token_limit": 272000  # จัดเก็บอัตโนมัติหลังจาก 272K
    }
)

# หมายเหตุ: คำขอที่เกิน 272K จะนับในอัตราการใช้งาน 2 เท่า

การวิเคราะห์เอกสารหลายฉบับ

def analyze_multiple_documents(documents):
    """วิเคราะห์เอกสารมากกว่า 10 ฉบับในบริบทเดียว"""

    content_parts = []

    for i, doc in enumerate(documents):
        content_parts.append(f"=== เอกสารที่ {i+1}: {doc['title']} ===\n")
        content_parts.append(doc['content'][:50000])  # ตัดทอนหากจำเป็น
        content_parts.append("\n\n")

    combined_content = "".join(content_parts)

    response = client.chat.completions.create(
        model="gpt-5.4",
        messages=[{
            "role": "user",
            "content": f"""
            วิเคราะห์เอกสารเหล่านี้และให้:
            1. สรุปประเด็นสำคัญในทุกเอกสาร
            2. ความขัดแย้งหรือไม่สอดคล้องกันระหว่างเอกสาร
            3. รายการการดำเนินการที่กล่าวถึงในเอกสารใดๆ
            4. ไทม์ไลน์ของเหตุการณ์หากมี

            {combined_content}
            """
        }],
        max_tokens=8000
    )

    return response.choices[0].message.content

เวิร์กโฟลว์การเขียนโค้ดและการพัฒนา

GPT-5.4 ตรงกับ GPT-5.3-Codex ใน SWE-Bench Pro (57.7%) พร้อมความสามารถในการใช้งานคอมพิวเตอร์ที่เพิ่มเข้ามา

การสร้างส่วนหน้า

def generate_frontend_component(spec):
    """สร้างส่วนประกอบ React ที่สมบูรณ์พร้อมการจัดรูปแบบ"""

    prompt = f"""
    สร้างส่วนประกอบ React ที่สมบูรณ์ตามข้อกำหนดนี้:

    {spec}

    ข้อกำหนด:
    1. ส่วนประกอบฟังก์ชันพร้อม hooks
    2. ประเภท TypeScript สำหรับ props และ state ทั้งหมด
    3. Tailwind CSS สำหรับการจัดรูปแบบ
    4. การออกแบบที่ตอบสนอง (มือถือ, แท็บเล็ต, เดสก์ท็อป)
    5. การเข้าถึง (ป้ายกำกับ ARIA, การนำทางด้วยคีย์บอร์ด)
    6. การทดสอบหน่วยด้วย Jest/React Testing Library

    ส่งคืนโค้ดที่สมบูรณ์สำหรับ:
    - ไฟล์ส่วนประกอบ (.tsx)
    - สไตล์ (ถ้าไม่ใช่ Tailwind)
    - ไฟล์ทดสอบ (.test.tsx)
    """

    response = client.chat.completions.create(
        model="gpt-5.4",
        messages=[{"role": "user", "content": prompt}],
        max_tokens=6000
    )

    return response.choices[0].message.content

# ตัวอย่าง: การจำลองสวนสนุก (จากตัวอย่างของ OpenAI)
theme_park_spec = """
สร้างเกมจำลองสวนสนุกไอโซเมตริกแบบโต้ตอบ:
- การวางเส้นทางแบบกระเบื้อง
- การสร้างเครื่องเล่นและทิวทัศน์
- การหาเส้นทางและการเข้าคิวของแขก
- เมตริกสวนสนุก (เงิน, แขก, ความสุข, ความสะอาด)
- สามารถเล่นได้ในเบราว์เซอร์ด้วยการทดสอบ Playwright
- สินทรัพย์ไอโซเมตริกที่สร้างขึ้น
"""

component_code = generate_frontend_component(theme_park_spec)

การดีบักปัญหาที่ซับซ้อน

def debug_with_full_context(error_logs, codebase_files, stack_trace):
    """ดีบักโดยใช้บริบทเต็มของบันทึก, โค้ด และ stack trace"""

    context = f"""
    บันทึกข้อผิดพลาด (ERROR LOGS):
    {error_logs}

    STACK TRACE:
    {stack_trace}

    ไฟล์โค้ดที่เกี่ยวข้อง (RELEVANT CODE FILES):
    {codebase_files}

    งาน: ระบุสาเหตุหลักและเสนอวิธีแก้ไข
    พิจารณา:
    1. Race conditions หรือปัญหาเวลา
    2. Memory leaks หรือการใช้ทรัพยากรหมด
    3. ข้อสันนิษฐานที่ไม่ถูกต้องเกี่ยวกับกระแสข้อมูล
    4. กรณีพิเศษที่ไม่ได้รับการจัดการ
    5. ปัญหาการพึ่งพิงภายนอก

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

    response = client.chat.completions.create(
        model="gpt-5.4",
        messages=[{"role": "user", "content": context}],
        max_tokens=4000
    )

    return response.choices[0].message.content

การทดสอบแบบโต้ตอบด้วย Playwright

ทักษะ Codex ทดลองสำหรับการทดสอบการเล่นในเบราว์เซอร์:

def playwright_interactive_debug():
    """
    ใช้ Playwright Interactive สำหรับการทดสอบการเล่นในเบราว์เซอร์
    GPT-5.4 สามารถทดสอบแอปพลิเคชันได้ในขณะที่กำลังสร้าง
    """

    prompt = """
    สร้างแอปพลิเคชันเว็บ todo และทดสอบในขณะที่กำลังสร้าง:

    1. สร้างโครงสร้าง HTML
    2. เพิ่มสไตล์ CSS
    3. ใช้ฟังก์ชัน JavaScript
    4. หลังจากแต่ละฟีเจอร์ ให้ใช้ Playwright เพื่อ:
       - ตรวจสอบการมองเห็นขององค์ประกอบ
       - ทดสอบการโต้ตอบของผู้ใช้
       - ตรวจสอบความคงทนของสถานะ
       - ตรวจสอบกรณีพิเศษ

    รายงานปัญหาที่พบระหว่างการทดสอบและแก้ไข
    """

    response = client.chat.completions.create(
        model="gpt-5.4",
        messages=[{"role": "user", "content": prompt}],
        tools=[{"type": "playwright_interactive"}],
        max_tokens=8000
    )

    return response.choices[0].message.content

การตอบสนองแบบสตรีมมิ่ง

การสตรีมช่วยลดความล่าช้าที่รับรู้ได้สำหรับการตอบสนองที่ยาวนาน

การสตรีม Python

from openai import OpenAI

client = OpenAI()

stream = client.chat.completions.create(
    model="gpt-5.4",
    messages=[{"role": "user", "content": "เขียนคำอธิบายโดยละเอียดเกี่ยวกับการประมวลผลเชิงควอนตัม"}],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

การสตรีม Node.js

const stream = await client.chat.completions.create({
    model: 'gpt-5.4',
    messages: [{ role: 'user', content: 'เขียนคำอธิบายโดยละเอียดเกี่ยวกับการประมวลผลเชิงควอนตัม' }],
    stream: true
});

for await (const chunk of stream) {
    if (chunk.choices[0].delta.content) {
        process.stdout.write(chunk.choices[0].delta.content);
    }
}

การสตรีมพร้อมการนับโทเค็น

def stream_with_usage(stream):
    """ติดตามการใช้โทเค็นขณะสตรีม"""
    total_tokens = 0

    for chunk in stream:
        if chunk.choices[0].delta.content:
            content = chunk.choices[0].delta.content
            print(content, end="", flush=True)
            total_tokens += len(content) // 4  # ประมาณการคร่าวๆ

        if chunk.usage:
            print(f"\n\nการใช้งาน: {chunk.usage.total_tokens} โทเค็น")

    return total_tokens

การจัดการข้อผิดพลาดและตรรกะการลองใหม่

โค้ดที่ใช้งานจริงจำเป็นต้องมีการจัดการข้อผิดพลาดที่แข็งแกร่ง

การจัดการข้อผิดพลาดที่ครอบคลุม

from openai import OpenAI, RateLimitError, APIError, AuthenticationError
import time

client = OpenAI()

def make_request_with_retry(messages, max_retries=3):
    """สร้างคำขอด้วยตรรกะการลองใหม่แบบ exponential backoff"""

    for attempt in range(max_retries):
        try:
            response = client.chat.completions.create(
                model="gpt-5.4",
                messages=messages,
                max_tokens=2000,
                temperature=0.7
            )
            return response

        except RateLimitError as e:
            if attempt == max_retries - 1:
                raise

            wait_time = 2 ** attempt  # 1s, 2s, 4s
            print(f"ถูกจำกัดอัตราการใช้งาน กำลังรอ {wait_time} วินาที...")
            time.sleep(wait_time)

        except APIError as e:
            if e.status_code >= 500:  # ข้อผิดพลาดเซิร์ฟเวอร์, ลองใหม่
                if attempt == max_retries - 1:
                    raise
                wait_time = 2 ** attempt
                time.sleep(wait_time)
            else:
                raise  # ข้อผิดพลาดไคลเอนต์, ไม่ต้องลองใหม่

        except AuthenticationError:
            print("API key ไม่ถูกต้อง โปรดตรวจสอบข้อมูลรับรองของคุณ")
            raise

        except Exception as e:
            print(f"ข้อผิดพลาดที่ไม่คาดคิด: {e}")
            raise

    raise Exception("เกินจำนวนการลองใหม่สูงสุด")

# การใช้งาน
try:
    response = make_request_with_retry([
        {"role": "user", "content": "สวัสดี, GPT-5.4!"}
    ])
    print(response.choices[0].message.content)
except Exception as e:
    print(f"คำขอล้มเหลว: {e}")

การจัดการการหมดเวลา

import httpx

# กำหนดค่าการหมดเวลา
client = OpenAI(
    timeout=httpx.Timeout(60.0, connect=10.0)  # รวม 60 วินาที, เชื่อมต่อ 10 วินาที
)

try:
    response = client.chat.completions.create(
        model="gpt-5.4",
        messages=[{"role": "user", "content": "งานที่ใช้เวลานาน..."}]
    )
except httpx.TimeoutException:
    print("คำขอหมดเวลา พิจารณาใช้การสตรีมหรือลดความซับซ้อน")

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

การใช้ Apidog สำหรับเวิร์กโฟลว์ API ในการใช้งานจริง

ก่อนที่จะปรับใช้การรวม GPT-5.4 ในการใช้งานจริง ให้สร้างเวิร์กโฟลว์การทดสอบและการตรวจสอบที่แข็งแกร่ง:

ไปป์ไลน์การทดสอบ API:

ใช้ Apidog เพื่อสร้างชุดการทดสอบที่ครอบคลุมทั้งกรณีที่สำเร็จและผิดพลาด
ทำให้การทดสอบ API เป็นไปโดยอัตโนมัติในไปป์ไลน์ CI/CD เพื่อตรวจจับการเปลี่ยนแปลงที่ทำให้เกิดข้อผิดพลาด
จำลองการตอบสนอง GPT-5.4 สำหรับการทดสอบการรวมระบบเพื่อหลีกเลี่ยงค่าใช้จ่ายโทเค็น
สร้างเอกสารประกอบ API โดยอัตโนมัติจากคำขอที่ผ่านการทดสอบ

การทำงานร่วมกันเป็นทีม:

แชร์คอลเลกชัน API กับสมาชิกในทีมเพื่อรูปแบบการรวมระบบที่สอดคล้องกัน
ใช้ตัวแปรสภาพแวดล้อมเพื่อจัดการ API keys ที่แตกต่างกัน (dev/staging/production)
เพิ่มเอกสารประกอบคำขอที่อธิบายพฤติกรรมที่คาดหวังและกรณีพิเศษ

รูปแบบการรวมระบบ:

กลยุทธ์การเพิ่มประสิทธิภาพต้นทุน

การเพิ่มประสิทธิภาพ Prompt

# ไม่ดี: Prompt ที่ยาวเกินไป
bad_prompt = """
สวัสดี! หวังว่าคุณจะสบายดีนะคะ ฉันสงสัยว่าคุณพอจะช่วยฉันได้ไหมคะ
ฉันมีโค้ดนี้และไม่แน่ใจว่ามันทำอะไร ช่วยอธิบายให้ฉันฟังหน่อยได้ไหมคะ? นี่คือโค้ด:
""" + code

# ดี: Prompt โดยตรง
good_prompt = f"อธิบายว่าโค้ดนี้ทำอะไร:\n{code}"

# การประหยัดโทเค็น: ~50 โทเค็น = $0.000125 ต่อคำขอ
# ที่ 1 ล้านคำขอ/เดือน: ประหยัด $125

การควบคุมความยาวการตอบสนอง

# ตั้งค่า max_tokens อย่างเหมาะสม
response = client.chat.completions.create(
    model="gpt-5.4",
    messages=[{"role": "user", "content": "สรุปบทความนี้"}],
    max_tokens=200  # อย่าปล่อยให้มันพูดพล่าม
)

# ใช้ stop sequences
response = client.chat.completions.create(
    model="gpt-5.4",
    messages=[{"role": "user", "content": "แสดงรายการ 5 รายการ"}],
    stop=["\n\n", "6."]  # หยุดหลังจากรายการ
)

การประมวลผลแบบแบตช์

# ใช้ Batch API เพื่อรับส่วนลด 50%
from openai import OpenAI

client = OpenAI()

# สร้างไฟล์แบตช์
batch_requests = []
for article in articles:
    batch_requests.append({
        "custom_id": article["id"],
        "method": "POST",
        "url": "/v1/chat/completions",
        "body": {
            "model": "gpt-5.4",
            "messages": [{"role": "user", "content": article["content"]}]
        }
    })

# อัปโหลดและประมวลผล
batch_file = client.files.create(
    file=json.dumps(batch_requests),
    purpose="batch"
)

batch = client.batches.create(
    input_file_id=batch_file.id,
    endpoint="/v1/chat/completions",
    completion_window="24h"
)

# ประหยัดค่าใช้จ่าย 50% สำหรับเวิร์กโหลดที่ไม่ต้องใช้เวลาจริง

การแคชคำขอซ้ำๆ

import hashlib
import json

class ResponseCache:
    """แคชการตอบสนอง API ที่เหมือนกัน"""

    def __init__(self):
        self.cache = {}

    def _get_key(self, messages):
        return hashlib.md5(json.dumps(messages).encode()).hexdigest()

    def get_or_create(self, client, messages, **kwargs):
        key = self._get_key(messages)

        if key in self.cache:
            return self.cache[key]

        response = client.chat.completions.create(
            model="gpt-5.4",
            messages=messages,
            **kwargs
        )

        self.cache[key] = response
        return response

# การใช้งาน
cache = ResponseCache()
response = cache.get_or_create(client, messages)

สรุป

GPT-5.4 เปิดโอกาสใหม่ๆ สำหรับแอปพลิเคชันที่ขับเคลื่อนด้วย AI การใช้งานคอมพิวเตอร์แบบเนทีฟช่วยให้เกิดระบบอัตโนมัติของเบราว์เซอร์และเวิร์กโฟลว์ข้ามแอปพลิเคชัน การค้นหาเครื่องมือช่วยลดต้นทุนได้ 47% ขณะที่รองรับระบบนิเวศเครื่องมือขนาดใหญ่ วิสัยทัศน์ที่ได้รับการปรับปรุงจัดการการแยกวิเคราะห์เอกสารที่ซับซ้อน และหน้าต่างบริบท 1M ประมวลผลโค้ดเบสทั้งหมดได้

การสร้างแอปพลิเคชันที่ใช้งานจริงด้วย GPT-5.4 ต้องการการทดสอบ API ที่แข็งแกร่ง การดีบัก และเวิร์กโฟลว์การจัดทำเอกสาร Apidog เป็นแพลตฟอร์มแบบรวมสำหรับวงจรชีวิต API ที่สมบูรณ์

button

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

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

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

ฉันจะใช้คุณสมบัติการใช้งานคอมพิวเตอร์ของ GPT-5.4 ได้อย่างไร?

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

Tool search คืออะไรและฉันจะเปิดใช้งานได้อย่างไร?

Tool search โหลดคำจำกัดความของเครื่องมือตามความต้องการแทนที่จะโหลดล่วงหน้า ซึ่งช่วยลดการใช้โทเค็นได้ 47% เปิดใช้งานโดยการให้รายการเครื่องมือที่มีน้ำหนักเบาในคำขอ โมเดลจะร้องขอคำจำกัดความเต็มเมื่อจำเป็น ใช้งานได้โดยอัตโนมัติกับเซิร์ฟเวอร์ MCP

ฉันจะใช้หน้าต่างบริบท 1M โทเค็นได้อย่างไร?

กำหนดค่าผ่านพารามิเตอร์ extra_body: model_context_window: 1048576 และ model_auto_compact_token_limit: 272000 หมายเหตุ: คำขอที่เกิน 272K โทเค็นจะนับในอัตราการใช้งาน 2 เท่า มีให้ทดลองใน Codex

GPT-5.4 และ GPT-5.4-Pro แตกต่างกันอย่างไร?

GPT-5.4 Pro ให้ความแม่นยำสูงกว่าในการให้เหตุผลที่ซับซ้อน (89.3% เทียบกับ 82.7% ใน BrowseComp) แต่มีค่าใช้จ่ายมากกว่า 12 เท่า ($30/$180 เทียบกับ $2.50/$15) ใช้รุ่นมาตรฐานสำหรับงานส่วนใหญ่ และรุ่น Pro สำหรับงานที่ต้องการความแม่นยำสูงสุด

ฉันจะลดค่าใช้จ่าย GPT-5.4 API ได้อย่างไร?

ใช้ข้อมูลอินพุตที่แคชไว้ (ประหยัดได้ 90%), เพิ่มประสิทธิภาพความยาวของพรอมต์, กำหนดขีดจำกัด max_tokens, ใช้ Batch API (ส่วนลด 50%), ใช้การแคชการตอบสนอง และเลือกระดับรายละเอียดที่เหมาะสมสำหรับรูปภาพ

GPT-5.4 สามารถประมวลผลหลายรูปภาพในคำขอเดียวได้หรือไม่?

ได้ รวมส่วนเนื้อหา image_url หลายรายการในข้อความเดียว มีประโยชน์สำหรับเอกสารหลายหน้า งานเปรียบเทียบ หรือภาพหน้าจอตามลำดับ

ฉันจะจัดการ Rate Limit ในการใช้งานจริงได้อย่างไร?

ใช้ตรรกะการลองใหม่แบบ exponential backoff (หน่วงเวลา 1s, 2s, 4s), ใช้ Batch API สำหรับการประมวลผลจำนวนมาก, กระจายคำขอในช่วงเวลาหนึ่ง และร้องขอการเพิ่มขีดจำกัดสำหรับการใช้งานที่มีปริมาณมาก

GPT-5.4 รองรับภาษาโปรแกรมใดได้ดีที่สุด?

GPT-5.4 เก่งใน Python, JavaScript/TypeScript, React, Node.js และเทคโนโลยีเว็บทั่วไป และยังเก่งใน Java, Go, Rust และ SQL ตรงกับประสิทธิภาพของ GPT-5.3-Codex (57.7% SWE-Bench Pro)

ฉันจะสตรีมการตอบสนอง GPT-5.4 ได้อย่างไร?

ตั้งค่า stream=True ในคำขอ API วนซ้ำผ่าน chunk และประมวลผลแต่ละ delta ช่วยลดความล่าช้าที่รับรู้ได้สำหรับการตอบสนองที่ยาวนาน

GPT-5.4 เหมาะสำหรับเวิร์กโหลดการใช้งานจริงหรือไม่?

ใช่ GPT-5.4 มีข้อผิดพลาดด้านข้อเท็จจริงน้อยกว่า GPT-5.2 ถึง 33%, ใช้โทเค็นได้อย่างมีประสิทธิภาพมากขึ้น และมีการจัดการข้อผิดพลาดที่แข็งแกร่ง ใช้ตรรกะการลองใหม่ การตรวจสอบ และการติดตามต้นทุนสำหรับการปรับใช้ในการใช้งานจริง