วิธีรัน Gemma 4 แบบ Local ด้วย Ollama: คู่มือฉบับสมบูรณ์

สรุปย่อ (TL;DR)

Gemma 4 เปิดตัวเมื่อวันที่ 3 เมษายน 2026 และ Ollama v0.20.0 ได้เพิ่มการรองรับในวันเดียวกัน คุณสามารถดึงและรันโมเดลเริ่มต้น gemma4:e4b ได้ด้วยคำสั่งเพียงสองคำสั่ง คู่มือนี้จะแนะนำคุณเกี่ยวกับการตั้งค่า การเลือกโมเดล การใช้งาน API และวิธีทดสอบ Gemma 4 endpoints ในเครื่องของคุณด้วย Apidog

บทนำ

Google ได้เปิดตัว Gemma 4 เมื่อวันที่ 2 เมษายน 2026 ภายใน 24 ชั่วโมง Ollama ได้ออกเวอร์ชัน v0.20.0 พร้อมการรองรับเต็มรูปแบบสำหรับโมเดลทั้งสี่รูปแบบ

สำหรับนักพัฒนา สิ่งนี้มีความสำคัญ Gemma 4 ไม่ใช่การอัปเดตเล็กน้อย มันทำคะแนนได้ 89.2% ใน AIME 2026 เทียบกับ Gemma 3 ที่ทำได้ 20.8% คะแนนการประเมินการเขียนโค้ดเพิ่มขึ้นจาก 110 ELO เป็น 2150 บน Codeforces คุณได้รับการเรียกใช้ฟังก์ชันแบบเนทีฟ โหมดการคิดที่กำหนดค่าได้ และหน้าต่างบริบท (context window) ขนาด 256K ในเวอร์ชันที่ใหญ่กว่า ทั้งหมดนี้ทำงานบนฮาร์ดแวร์ของคุณเอง

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

คู่มือนี้ครอบคลุมทุกอย่างตั้งแต่การติดตั้งไปจนถึงการเรียกใช้ API ในเครื่องครั้งแรกของคุณ

มีอะไรใหม่ใน Gemma 4

Gemma 4 มาพร้อมโมเดลสี่รุ่นที่มีความสามารถแตกต่างกันอย่างมีความหมาย

นี่คือสิ่งที่ทำให้แตกต่างจาก Gemma 3:

การให้เหตุผลและการเขียนโค้ด โมเดล 31B ทำคะแนนได้ 80% ใน LiveCodeBench v6 ในขณะที่ Gemma 3 27B รุ่นก่อนหน้าทำได้ 29.1% ช่องว่างนี้ไม่ใช่การปรับปรุงแบบค่อยเป็นค่อยไป; มันคือประสิทธิภาพในระดับที่แตกต่างกัน

สถาปัตยกรรม Mixture-of-Experts รุ่น 26B ใช้ MoE โดยมีพารามิเตอร์ที่ใช้งานอยู่เพียง 4 พันล้านพารามิเตอร์ระหว่างการอนุมาน คุณจะได้รับคุณภาพเกือบจะเทียบเท่าเรือธงด้วยต้นทุนการประมวลผลที่น้อยลงมาก

บริบทที่ยาวขึ้น โมเดล edge E2B และ E4B รองรับ 128K โทเค็น โมเดล 26B และ 31B ขยายขีดจำกัดเป็น 256K ซึ่งเพียงพอที่จะรองรับฐานโค้ดขนาดใหญ่หรือไฟล์ข้อกำหนด API ในพรอมต์เดียว

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

อินพุตเสียงและรูปภาพ โมเดล E2B และ E4B รับอินพุตเสียงและรูปภาพที่มีความละเอียดแปรผันพร้อมกับข้อความ

โหมดการคิด คุณสามารถเปิดหรือปิดการให้เหตุผลแบบ chain-of-thought ของโมเดลต่อคำขอได้ สำหรับการค้นหาง่ายๆ ให้ข้ามไป สำหรับปัญหาการเขียนโค้ดหรือคณิตศาสตร์ที่ซับซ้อน ให้เปิดใช้งาน

คำอธิบายโมเดล Gemma 4 รุ่นต่างๆ

ก่อนที่คุณจะดึงอะไร ให้เลือกรุ่นที่เหมาะสมสำหรับฮาร์ดแวร์ของคุณ:

โมเดล e4b เป็นค่าเริ่มต้นเมื่อคุณรัน ollama run gemma4 สามารถติดตั้งบน GPU ผู้ใช้ทั่วไปส่วนใหญ่ที่มี VRAM 10+ GB และทำงานได้ค่อนข้างเร็วบนหน่วยความจำรวมของ Apple Silicon

รุ่น 26b MoE เป็นตัวเลือกที่น่าสนใจ เนื่องจากมีพารามิเตอร์เพียง 4 พันล้านพารามิเตอร์ที่เปิดใช้งานต่อโทเค็น การอนุมานจึงมีความเร็วใกล้เคียงกับโมเดล 4B ในขณะที่คุณภาพใกล้เคียงกับโมเดล 13B หากคุณมี RAM 20+ GB นี่คือสิ่งที่ควรลอง

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

คุณต้องใช้ Ollama v0.20.0 หรือใหม่กว่า เวอร์ชันก่อนหน้านี้ไม่รองรับ Gemma 4

ตรวจสอบเวอร์ชันปัจจุบันของคุณ:

ollama --version

หากคุณใช้เวอร์ชันเก่ากว่า ให้อัปเดต:

# macOS
brew upgrade ollama

# Linux
curl -fsSL https://ollama.com/install.sh | sh

บน Windows ให้ดาวน์โหลดตัวติดตั้งล่าสุดจาก ollama.com

ข้อกำหนดฮาร์ดแวร์:

• gemma4:e2b: RAM ขั้นต่ำ 8 GB (แนะนำ 16 GB)
• gemma4:e4b: VRAM 10 GB หรือหน่วยความจำรวม 16 GB
• gemma4:26b: RAM หรือหน่วยความจำรวม 20+ GB
• gemma4:31b: VRAM 24 GB หรือหน่วยความจำรวม 32 GB

การติดตั้งและรัน Gemma 4

ดึงและรันโมเดล e4b เริ่มต้น:

ollama run gemma4

สิ่งนี้จะดาวน์โหลดประมาณ 9.6 GB ในการรันครั้งแรก จากนั้นจะพาคุณเข้าสู่เซสชันแบบโต้ตอบ พิมพ์ข้อความเพื่อทดสอบ:

>>> รหัสสถานะ HTTP สำหรับข้อผิดพลาดของไคลเอ็นต์คืออะไร?

หากต้องการรันรุ่นเฉพาะ:

# โมเดล Edge, ขนาดเล็กกว่า
ollama run gemma4:e2b

# โมเดล MoE, อัตราคุณภาพต่อขนาดที่ดีที่สุด
ollama run gemma4:26b

# รุ่นเรือธงเต็มรูปแบบ
ollama run gemma4:31b

หากต้องการดึงโดยไม่ต้องรันทันที:

ollama pull gemma4
ollama pull gemma4:26b

ตรวจสอบว่าคุณมีโมเดลใดบ้าง:

ollama list

การใช้ Gemma 4 API ในเครื่อง

Ollama แสดง API REST ในเครื่องที่ http://localhost:11434 เมื่อดึงโมเดลแล้ว คุณสามารถเรียกใช้ได้จากไคลเอ็นต์ HTTP ใดๆ โดยไม่ต้องเริ่ม CLI แบบโต้ตอบ

สร้างการเติมข้อความ (completion)

curl http://localhost:11434/api/generate \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemma4",
    "prompt": "เขียนการตอบสนอง JSON สำหรับ API endpoint โปรไฟล์ผู้ใช้",
    "stream": false
  }'

การเติมข้อความแชท (endpoint ที่เข้ากันได้กับ OpenAI)

Ollama ยังรองรับรูปแบบแชทของ OpenAI:

curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemma4",
    "messages": [
      {
        "role": "user",
        "content": "สร้าง mock JSON ที่สมจริงสำหรับการตอบสนอง API คำสั่งซื้ออีคอมเมิร์ซ"
      }
    ]
  }'

ไคลเอ็นต์ Python

import requests

def ask_gemma4(prompt: str, model: str = "gemma4") -> str:
    response = requests.post(
        "http://localhost:11434/api/generate",
        json={
            "model": model,
            "prompt": prompt,
            "stream": False
        }
    )
    response.raise_for_status()
    return response.json()["response"]

result = ask_gemma4("แสดงรายการฟิลด์ที่การตอบสนอง API การชำระเงินควรรวมถึง")
print(result)

การใช้ OpenAI Python SDK

เนื่องจาก API ของ Ollama เข้ากันได้กับ OpenAI คุณสามารถชี้ SDK อย่างเป็นทางการไปยังอินสแตนซ์ในเครื่องของคุณ:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"  # จำเป็นโดย SDK แต่ไม่ได้ใช้โดย Ollama
)

response = client.chat.completions.create(
    model="gemma4",
    messages=[
        {
            "role": "system",
            "content": "คุณสร้างข้อมูลการตอบสนอง API ที่สมจริงในรูปแบบ JSON"
        },
        {
            "role": "user",
            "content": "สร้างตัวอย่างการตอบสนองสำหรับ endpoint GET /users/{id}"
        }
    ]
)

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

การใช้ Function Calling กับ Gemma 4

Gemma 4 รองรับการเรียกใช้ฟังก์ชันแบบเนทีฟ คุณกำหนดสคีมาเครื่องมือ และโมเดลจะส่งคืน JSON ที่มีโครงสร้างตรงกับลายเซ็นฟังก์ชันของคุณ

สิ่งนี้มีประโยชน์สำหรับการสร้างเอเจนต์ที่เรียกใช้ API ของคุณโดยโปรแกรม:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"
)

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_user",
            "description": "เรียกผู้ใช้ด้วย ID จาก API",
            "parameters": {
                "type": "object",
                "properties": {
                    "user_id": {
                        "type": "integer",
                        "description": "รหัสผู้ใช้ที่ไม่ซ้ำกัน"
                    },
                    "include_orders": {
                        "type": "boolean",
                        "description": "ว่าจะรวมประวัติคำสั่งซื้อหรือไม่"
                    }
                },
                "required": ["user_id"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="gemma4",
    messages=[
        {"role": "user", "content": "ดึงผู้ใช้ 42 พร้อมประวัติคำสั่งซื้อของเขา"}
    ],
    tools=tools,
    tool_choice="auto"
)

tool_call = response.choices[0].message.tool_calls[0]
print(tool_call.function.name)       # get_user
print(tool_call.function.arguments)  # {"user_id": 42, "include_orders": true}

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

การเปิดใช้งานโหมดการคิด

สำหรับงานที่ซับซ้อน เช่น การเขียนสถานการณ์การทดสอบหรือการวิเคราะห์ข้อกำหนด API คุณสามารถเปิดใช้งานการให้เหตุผลแบบ chain-of-thought ของ Gemma 4 ได้:

response = client.chat.completions.create(
    model="gemma4",
    messages=[
        {
            "role": "user",
            "content": "ออกแบบสถานการณ์การทดสอบที่สมบูรณ์สำหรับ API การประมวลผลการชำระเงินพร้อม edge cases"
        }
    ],
    extra_body={"think": True}
)

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

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

การทดสอบการตอบสนอง Gemma 4 API ด้วย Apidog

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

นำเข้าข้อกำหนด Ollama API เซิร์ฟเวอร์ในเครื่องของ Ollama แสดง endpoints REST มาตรฐาน สร้างโปรเจกต์ใหม่ใน Apidog และเพิ่ม URL พื้นฐาน http://localhost:11434

กำหนด endpoints ของคุณ เพิ่ม endpoints ที่คุณกำลังทดสอบ:

• POST /api/generate สำหรับการเติมข้อความแบบครั้งเดียว
• POST /v1/chat/completions สำหรับการแชทแบบหลายรอบ
• GET /api/tags เพื่อแสดงรายการโมเดลที่มีอยู่

ตั้งค่าสถานการณ์ทดสอบ ใน Apidog สถานการณ์ทดสอบจะเชื่อมโยงคำขอหลายรายการเข้าด้วยกันพร้อมการยืนยันระหว่างนั้น สำหรับการทดสอบ Gemma 4:

1. ขั้นตอนที่ 1: GET /api/tags เพื่อยืนยันว่า gemma4 ปรากฏในรายการโมเดล
2. ขั้นตอนที่ 2: POST /api/generate เพื่อส่งพรอมต์และยืนยันว่าฟิลด์ response ไม่ว่างเปล่า
3. ขั้นตอนที่ 3: POST /v1/chat/completions เพื่อส่งข้อความแชทและยืนยันว่าการตอบกลับตรงกับรูปแบบที่คุณคาดหวัง

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

ตรวจสอบสคีมาการตอบสนอง Contract Testing ของ Apidog ตรวจสอบการตอบสนอง API กับข้อกำหนด OpenAPI ของคุณ กำหนดรูปแบบการตอบสนองที่คาดหวังสำหรับแต่ละ Gemma 4 endpoint จากนั้นรันการทดสอบสัญญาหลังจากการอัปเดตโมเดลเพื่อตรวจจับการเปลี่ยนแปลงที่ทำให้เกิดความเสียหายในรูปแบบ API ของ Ollama

Smart Mock สำหรับการพัฒนาแบบขนาน หากแบ็คเอนด์ของคุณขึ้นอยู่กับการตอบสนองของ Gemma 4 แต่คุณต้องการให้ทีมฟรอนต์เอนด์ทำงานโดยไม่ต้องรอโมเดลในเครื่อง Smart Mock ของ Apidog จะสร้างการตอบสนองที่สอดคล้องกับสคีมาจากข้อกำหนด API ของคุณโดยอัตโนมัติ กำหนดว่าการตอบสนองของ Gemma 4 มีลักษณะอย่างไร และ Smart Mock จะให้บริการข้อมูลที่สมจริงตามความต้องการ

อินพุตแบบหลายโมดอลด้วย Gemma 4

โมเดล E2B และ E4B รับรูปภาพพร้อมกับข้อความ ส่งรูปภาพเป็นสตริงที่เข้ารหัสแบบ base64:

import base64

with open("api_diagram.png", "rb") as f:
    image_data = base64.b64encode(f.read()).decode()

response = client.chat.completions.create(
    model="gemma4:e4b",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/png;base64,{image_data}"
                    }
                },
                {
                    "type": "text",
                    "text": "อธิบายโฟลว์ API ที่แสดงในแผนภาพนี้และระบุเส้นทางข้อผิดพลาดที่อาจเกิดขึ้น"
                }
            ]
        }
    ]
)

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

ปัญหาและการแก้ไขทั่วไป

Ollama แจ้งว่าไม่พบโมเดล รัน ollama pull gemma4 ก่อน หรือตรวจสอบด้วย ollama list

การอนุมานช้าบน CPU Gemma 4 ได้รับการปรับให้เหมาะสมสำหรับ GPU บนเครื่องที่ใช้ CPU เท่านั้น คาดว่าจะได้รับ 1-3 โทเค็นต่อวินาทีสำหรับโมเดล e4b ใช้ gemma4:e2b เพื่อประสิทธิภาพ CPU ที่ดีขึ้น

ข้อผิดพลาดหน่วยความจำไม่พอ ตรวจสอบ VRAM หรือหน่วยความจำรวมที่มีอยู่ของคุณด้วย ollama ps หากโมเดลมีขนาดใหญ่เกินไป ให้เปลี่ยนไปใช้ gemma4:e2b (7.2 GB)

โมเดลไม่โหลดบน Apple Silicon Ollama 0.20.0 เพิ่มการรองรับ MLX สำหรับ Apple Silicon ในเวอร์ชันพรีวิว หากคุณใช้ Ollama เวอร์ชันเก่ากว่า ให้อัปเดตก่อน

พอร์ตถูกใช้งานอยู่ หากมีสิ่งอื่นใช้พอร์ต 11434 ให้ตั้งค่าพอร์ตที่กำหนดเอง: OLLAMA_HOST=0.0.0.0:11435 ollama serve

การตอบกลับถูกตัดทอน เพิ่มหน้าต่างบริบทในคำขอของคุณ: เพิ่ม "options": {"num_ctx": 8192} ลงในเนื้อหา JSON ของคุณ

Gemma 4 เทียบกับโมเดลในเครื่องอื่นๆ

ข้อได้เปรียบของ Gemma 4 คือรุ่น MoE 26B ด้วยขนาด 18 GB มันให้คุณภาพเกือบเทียบเท่าเรือธงด้วยพารามิเตอร์ที่ใช้งานอยู่ 4B ณ เวลาอนุมาน ทำให้คุณได้โทเค็นต่อวินาทีที่ดีกว่าโมเดล dense ขนาดใหญ่ใดๆ ในรายการนี้

สำหรับงานเขียนโค้ดล้วนๆ โมเดล 31B สามารถแข่งขันกับโมเดลที่ใหญ่กว่ามากได้ สำหรับการติดตั้งบนอุปกรณ์ edge หรือแล็ปท็อป e2b ทำงานได้ในพื้นที่ไม่ถึง 8 GB

สรุป

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

เริ่มต้นด้วย ollama run gemma4, ทดสอบ API ด้วย Apidog เพื่อให้แน่ใจว่า endpoints ของคุณทำงานได้ตามที่คาดหวัง จากนั้นเลือกรุ่นที่เหมาะสมสำหรับปริมาณงานของคุณโดยอิงจากตารางโมเดลด้านบน

สำหรับทีมที่กำลังสร้างฟังก์ชันที่ขับเคลื่อนด้วย API บน Gemma 4 การจับคู่การอนุมานในเครื่องกับ Smart Mock และ Test Scenarios ของ Apidog จะช่วยให้คุณมีวงจรการพัฒนาที่สมบูรณ์โดยไม่ต้องพึ่งพาทรัพยากรภายนอก

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

ฉันจะอัปเดต Gemma 4 ใน Ollama ได้อย่างไรเมื่อมีเวอร์ชันใหม่ออกมา?รัน ollama pull gemma4 อีกครั้ง Ollama จะตรวจสอบเวอร์ชันล่าสุดและดาวน์โหลดเฉพาะส่วนที่เปลี่ยนแปลง

ฉันสามารถรัน Gemma 4 บนเครื่องที่ไม่มี GPU ได้หรือไม่?ได้ แต่จะช้า คาดว่า 1-3 โทเค็นต่อวินาทีบน CPU โมเดล e2b เป็นตัวเลือกที่ใช้งานได้จริงที่สุดสำหรับเครื่องที่ใช้ CPU เท่านั้น

ความแตกต่างระหว่าง gemma4:e2b และ gemma4:e4b คืออะไร?ทั้งสองเป็นโมเดล "effective" แบบ dense ที่ปรับให้เหมาะสมสำหรับฮาร์ดแวร์ edge E4B มีพารามิเตอร์มากกว่าและจัดการการให้เหตุผลที่ซับซ้อนได้ดีกว่า E2B มีขนาดเล็กกว่าและรองรับอินพุตเสียง สำหรับงานข้อความส่วนใหญ่ e4b เป็นค่าเริ่มต้นที่ดีกว่า

Gemma 4 ใช้งานได้กับ LangChain และ LlamaIndex หรือไม่?ได้ ทั้งสองเฟรมเวิร์กรองรับ Ollama เป็นแบ็คเอนด์ ชี้ผู้ให้บริการ Ollama ไปที่ http://localhost:11434 และใช้ gemma4 เป็นชื่อโมเดล

Gemma 4 API ในเครื่องเข้ากันได้กับโค้ดที่เขียนสำหรับ OpenAI API หรือไม่?ส่วนใหญ่แล้ว ใช่ endpoint /v1/chat/completions ของ Ollama เป็นไปตามรูปแบบของ OpenAI เปลี่ยน base_url เป็น http://localhost:11434/v1 และ api_key เป็นสตริงที่ไม่ว่างเปล่า SDK ของ OpenAI ส่วนใหญ่ทำงานได้โดยไม่มีการเปลี่ยนแปลง

ฉันจะใช้โหมดการคิดของ Gemma 4 ได้อย่างไร?ส่ง "think": true ในพารามิเตอร์ extra_body เมื่อใช้ OpenAI SDK หรือเพิ่ม "think": true ลงในเนื้อหา JSON ระดับบนสุดในการเรียกใช้ API โดยตรง ปิดใช้งานสำหรับงานง่ายๆ เพื่อลดความหน่วง

ฉันสามารถให้บริการ Gemma 4 แก่เครื่องอื่นในเครือข่ายของฉันได้หรือไม่?ได้ เริ่ม Ollama ด้วย OLLAMA_HOST=0.0.0.0:11434 ollama serve และเครื่องอื่นสามารถเข้าถึงได้ที่ที่อยู่ IP ของคุณบนพอร์ต 11434

โมเดล Gemma 4 ใดดีที่สุดสำหรับงานพัฒนา API?สำหรับการสร้างข้อมูลจำลองและการเขียน test cases, e4b มีความสมดุลระหว่างความเร็วและคุณภาพที่ดี สำหรับการวิเคราะห์ข้อกำหนดที่ซับซ้อนหรือการตรวจสอบสถาปัตยกรรม โมเดล 26b MoE ให้ผลลัพธ์ที่ดีกว่าโดยไม่มีค่าใช้จ่ายเท่ากับ 31B เต็มรูปแบบ