สร้าง Vision AI Agent ออฟไลน์ 100% ด้วย Ollama + Gemma 3 Vision และ Llama 4 Scout สำหรับโรงงานไทย

ทำไมโรงงานไทยควรมี Vision AI Agent ของตัวเอง

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

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

บทความนี้จะพาสร้าง Vision AI Agent ที่ทำงานออฟไลน์ 100% ด้วย Ollama เป็นเครื่องมือหลัก ผสานกับ Gemma 3 Vision สำหรับการมองเห็น และ Llama 4 Scout สำหรับการให้เหตุผลและตัดสินใจ

ภาพรวมสถาปัตยกรรม

ระบบนี้แบ่งเป็น 3 ส่วนหลัก:

• Vision Model (Gemma 3 Vision): รับภาพเข้ามา ทำความเข้าใจเนื้อหา อ่านข้อความ และบอกได้ว่าในภาพมีอะไรบ้าง
• Reasoning Model (Llama 4 Scout): รับคำอธิบายจาก Vision Model มาวิเคราะห์เชิงลึก ตัดสินใจว่าเป็นของเสียหรือไม่ และรายงานผล
• Orchestrator (Python): สคริปต์กลางที่ประสานงานระหว่างสองโมเดล จัดการคิวภาพ และส่งผลไปยังระบบแจ้งเตือน

ข้อดีของการแยกโมเดลคือแต่ละตัวทำหน้าที่ที่ตัวเองเก่งที่สุด Gemma 3 Vision เก่งเรื่องการมองเห็นและ OCR ส่วน Llama 4 Scout เก่งเรื่องการให้เหตุผลแบบเป็นขั้นตอน

สิ่งที่ต้องเตรียม

ฮาร์ดแวร์

สำหรับการรันโมเดลเหล่านี้ออฟไลน์ แนะนำสเปกขั้นต่ำดังนี้:

• GPU: NVIDIA RTX 4090 24GB หรือ RTX 3090 24GB (รันได้พร้อมกัน 2 โมเดล)
• RAM: 32GB ขึ้นไป
• พื้นที่ดิสก์: 50GB สำหรับโมเดลและข้อมูลชั่วคราว

ถ้าไม่มี GPU ระดับนั้น สามารถรันบน Mac Studio ที่มี Unified Memory 64GB ขึ้นไปได้เช่นกัน ผ่าน Metal acceleration ของ Ollama

ซอฟต์แวร์

# ติดตั้ง Ollama (macOS / Linux)
curl -fsSL https://ollama.com/install.sh | sh

# ดึงโมเดลที่ต้องใช้
ollama pull gemma3:4b        # Gemma 3 Vision (เวอร์ชัน 4B น้ำหนักเบา)
ollama pull llama4-scout     # Llama 4 Scout สำหรับ reasoning

# ตรวจสอบว่าโมเดลพร้อมใช้งาน
ollama list

สำหรับ Windows สามารถดาวน์โหลดตัวติดตั้งได้จากเว็บ ollama.com โดยตรง

ขั้นที่ 1: ทดสอบ Gemma 3 Vision กับภาพจริง

ก่อนเขียนโค้ดเชื่อมโมเดล ลองทดสอบว่า Gemma 3 Vision อ่านภาพได้แม่นยำแค่ไหน เริ่มจากภาพง่าย ๆ ก่อน

# ส่งภาพให้ Gemma 3 Vision อธิบายสิ่งที่เห็น
ollama run gemma3:4b "อธิบายสิ่งที่เห็นในภาพนี้เป็นภาษาไทย" ./test_circuit_board.jpg

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

ลองทดสอบกับเอกสารด้วย:

ollama run gemma3:4b "อ่านข้อความทั้งหมดในเอกสารนี้และสรุปเป็น bullet points" ./invoice_sample.jpg

Gemma 3 Vision ทำ OCR ได้ดีมาก แม้กับเอกสารไทยที่มีฟอนต์หลายขนาดผสมกัน

ขั้นที่ 2: เขียน Orchestrator ด้วย Python

สร้างไฟล์ vision_agent.py สำหรับประสานงานระหว่างสองโมเดล:

import base64
import json
import requests
from pathlib import Path
from datetime import datetime

class OfflineVisionAgent:
    def __init__(self, ollama_host="http://localhost:11434"):
        self.host = ollama_host
        self.vision_model = "gemma3:4b"
        self.reasoning_model = "llama4-scout"
        
    def encode_image(self, image_path):
        with open(image_path, "rb") as f:
            return base64.b64encode(f.read()).decode()
    
    def describe_image(self, image_path, prompt):
        """ส่งภาพให้ Gemma 3 Vision อธิบาย"""
        img_b64 = self.encode_image(image_path)
        
        payload = {
            "model": self.vision_model,
            "prompt": prompt,
            "images": [img_b64],
            "stream": False,
            "options": {
                "temperature": 0.1,  # ต่ำเพื่อความสม่ำเสมอ
                "top_p": 0.9
            }
        }
        
        resp = requests.post(
            f"{self.host}/api/generate",
            json=payload
        )
        return resp.json()["response"]
    
    def analyze_defect(self, description):
        """ส่งคำอธิบายให้ Llama 4 Scout วิเคราะห์"""
        system_prompt = f"""คุณเป็นผู้เชี่ยวชาญด้านการตรวจสอบคุณภาพในโรงงาน
        
        ข้อมูลจากการตรวจสอบภาพ:
        {description}
        
        กรุณาวิเคราะห์ว่า:
        1. ชิ้นงานนี้เป็นของเสียหรือไม่
        2. ถ้าเป็นของเสีย ระบุประเภทและตำแหน่ง
        3 ระดับความรุนแรง (ต่ำ/กลาง/สูง)
        4. ข้อแนะนำเบื้องต้น
        
        ตอบเป็น JSON เท่านั้น"""
        
        payload = {
            "model": self.reasoning_model,
            "prompt": system_prompt,
            "stream": False,
            "format": "json",
            "options": {
                "temperature": 0.2
            }
        }
        
        resp = requests.post(
            f"{self.host}/api/generate",
            json=payload
        )
        return resp.json()["response"]
    
    def run(self, image_path):
        timestamp = datetime.now().isoformat()
        
        # Step 1: Vision model อธิบายภาพ
        vision_prompt = """คุณเป็นผู้ตรวจสอบคุณภาพชิ้นงาน
        อธิบายสิ่งที่เห็นในภาพโดยละเอียด ระบุ:
        - ประเภทของชิ้นงาน
        - สีและพื้นผิว
        - ตำแหน่งที่ดูผิดปกติ (รอย รอยบัดกรี สีไม่สม่ำเสมอ ฯลฯ)
        - ขนาดโดยประมาณ"""
        
        description = self.describe_image(image_path, vision_prompt)
        
        # Step 2: Reasoning model วิเคราะห์
        analysis = self.analyze_defect(description)
        
        return {
            "timestamp": timestamp,
            "image": str(image_path),
            "vision_description": description,
            "defect_analysis": json.loads(analysis)
        }

# ใช้งาน
agent = OfflineVisionAgent()
result = agent.run("./production_line_sample.jpg")
print(json.dumps(result, ensure_ascii=False, indent=2))

โค้ดนี้ทำงานเป็นสองขั้นตอนชัดเจน ขั้นแรกให้ Gemma 3 Vision บอกว่าเห็นอะไร ขั้นที่สองส่งคำอธิบายนั้นให้ Llama 4 Scout ตัดสินใจ

ขั้นที่ 3: ปรับแต่ง Prompt ให้เหมาะกับงานจริง

Prompt เป็นหัวใจสำคัญที่ทำให้ระบบทำงานได้แม่นยำ นี่คือตัวอย่าง prompt ที่ใช้จริงในโรงงานผลิตชิ้นส่วนพลาสติก:

# Prompt สำหรับตรวจจับรอยบนพื้นผิวพลาสติก
SURFACE_DEFECT_PROMPT = """ตรวจสอบพื้นผิวชิ้นพลาสติกในภาพนี้

ระบบคุณภาพของเรากำหนดว่าของเสียคือ:
- รอยขีดข่วนความยาวเกิน 2 มม.
- รอยบุ๋มหรือรอยนูนเส้นผ่านศูนย์กลางเกิน 1 มม.
- สีไม่สม่ำเสมอหรือมีจุดด่าง
- รอยไหม้จากกระบวนการฉีด

อธิบายสิ่งที่เห็นโดยเน้นที่ลักษณะที่อาจเป็นของเสีย
ระบุตำแหน่งโดยใช้ระบบพิกัด (ซ้ายบน = 0,0)"""

# Prompt สำหรับอ่านเอกสารใบรับส่งสินค้า
DOCUMENT_OCR_PROMPT = """อ่านข้อมูลจากเอกสารนี้และสร้างโครงสร้าง JSON ตามรูปแบบ:
{
  "เลขที่เอกสาร": "",
  "วันที่": "",
  "ผู้ส่ง": "",
  "ผู้รับ": "",
  "รายการ": [
    {"ชื่อ": "", "จำนวน": 0, "หน่วย": ""}
  ],
  "หมายเหตุ": ""
}
ถ้าฟิลด์ไหนอ่านไม่ได้ ใส่ค่าว่าง"""

ยิ่ง prompt ระบุเกณฑ์ชัดเจนเท่าไหร่ ผลที่ได้ยิ่งแม่นยำขึ้นเท่านั้น

ขั้นที่ 4: เชื่อมต่อกับระบบแจ้งเตือน

เมื่อพบของเสีย ต้องแจ้งคนงานได้ทันที ตัวอย่างนี้ใช้ LINE Notify เพราะใช้งานง่ายและคนไทยคุ้นเคิน

import requests

def send_line_notify(token, message, image_path=None):
    url = "https://notify-api.line.me/api/notify"
    headers = {"Authorization": f"Bearer {token}"}
    
    data = {"message": message}
    files = {}
    
    if image_path and Path(image_path).exists():
        files["imageFile"] = open(image_path, "rb")
    
    resp = requests.post(url, headers=headers, data=data, files=files)
    return resp.status_code == 200

# ใช้ใน agent
if result["defect_analysis"]["is_defect"]:
    severity = result["defect_analysis"]["severity"]
    defect_type = result["defect_analysis"]["defect_type"]
    
    msg = f"\n⚠️ พบของเสีย\nประเภท: {defect_type}\nระดับ: {severity}\nเวลา: {result['timestamp']}"
    send_line_notify(LINE_TOKEN, msg, result["image"])

สำหรับโรงงานที่มีระบบ MES หรือ ERP อยู่แล้ว สามารถส่งผลเป็น webhook เข้าระบบได้โดยตรง

ขั้นที่ 5: วัดประสิทธิภาพและปรับแต่ง

หลังจากรันจริงสักพัก ควรเก็บสถิติเพื่อปรับปรุงระบบ ตัวชี้วัดที่ควรติดตาม:

• False Positive Rate: บอกว่าเป็นของเสียแต่จริง ๆ ไม่ใช่ (ควรต่ำกว่า 5%)
• False Negative Rate: บอกว่าไม่เสียแต่จริง ๆ เสีย (ควรต่ำกว่า 2%)
• เวลาประมวลผลต่อภาพ: ควรต่ำกว่า 3 วินาทีเพื่อให้ทันสายการผลิต

วิธีปรับแต่งเมื่อผลไม่ดี:

1. ถ้า False Positive สูง: ลด temperature ของ reasoning model ลงเป็น 0.05 หรือเพิ่มเกณฑ์ใน prompt ให้ชัดเจนขึ้น
2. ถ้า False Negative สูง: เพิ่มรายละเอียดใน vision prompt หรือลองใช้ Gemma 3 เวอร์ชัน 12B ที่แม่นยำกว่า
3. ถ้าช้าเกินไป: ลดขนาดภาพก่อนส่งเข้าโมเดล หรือใช้ quantization แบบ Q4

กรณีศึกษา: โรงงานผลิตชิ้นส่วนรถยนต์ในระยอง

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

ผลลัพธ์หลังทดลองใช้ 3 เดือน:

• อัตราของเสียลดจาก 3.2% เหลือ 0.8%
• ตรวจจับของเสียได้เร็วขึ้น 4 เท่า
• ประหยัดค่าแรงต่อเดือนประมาณ 60,000 บาท
• ค่าใช้จ่ายฮาร์ดแวร์ครั้งเดียวประมาณ 80,000 บาท (คืนทุนใน 2 เดือน)

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

ข้อควรระวังเมื่อใช้งานจริง

แสงและมุมกล้อง

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

อย่าพึ่ง AI 100% ในช่วงแรก

ระบบใหม่ควรรันคู่ขนานกับการตรวจของคนสัก 1-2 เดือน เก็บข้อมูลเปรียบเทียบ แล้วค่อย ๆ ปรับระดับความเชื่อมั่น

อัปเดตโมเดลเป็นระยะ

Ollama มีโมเดลใหม่ออกเรื่อย ๆ ควรติดตามและทดสอบเปรียบเทียบประสิทธิภาพเป็นระยะ แต่อย่าอัปเดตบนเครื่องที่ใช้งานจริงโดยไม่ทดสอบก่อน

สรุป

การสร้าง Vision AI Agent ออฟไลน์ไม่ใช่เรื่องยากอย่างที่คิด ด้วย Ollama + Gemma 3 Vision + Llama 4 Scout โรงงานขนาดกลางในไทยก็เข้าถึงเทคโนโลยีนี้ได้โดยไม่ต้องพึ่งคลาวด์ ความเป็นส่วนตัวของข้อมูลอยู่ในมือเรา และค่าใช้จ่ายควบคุมได้

ลองเริ่มจากภาพตัวอย่าง 5-10 ใบก่อน ปรับ prompt จนพอใจ แล้วค่อยขยายไปสายการผลิตจริง ถ้าทำตามขั้นตอมนี้ มีโอกาสคืนทุนภายใน 2-3 เดือน

อยากลองทำไหม? เริ่มจากติดตั้ง Ollama แล้วดึงโมเดล gemma3:4b มาทดสอบกับภาพแรกของคุณวันนี้เลย แล้วมาแชร์ผลกันในคอมเมนต์