MLOps สำหรับ SME ไทย: วิธีนำ AI ที่เทรนเองไปใช้จริงในระบบ ERP โดยไม่ต้องมีทีม Data Scientist

MLOps หรือ Machine Learning Operations คือชุดแนวทางและเครื่องมือที่ช่วยให้ธุรกิจสามารถนำโมเดล AI ที่พัฒนาไว้ไปใช้งานจริงได้อย่างมีระบบ โดยเฉพาะสำหรับ SME ไทยที่เริ่มพัฒนาโมเดลพยากรณ์ยอดขายหรือตรวจจับ fraud แต่ติดปัญหาตอน deploy จริง MLOps ช่วยแก้ปัญหานี้ด้วยการสร้าง pipeline อัตโนมัติตั้งแต่การเทรนโมเดล การทดสอบ การ deploy ไปจนถึงการติดตามประสิทธิภาพ โดยใช้เครื่องมือโอเพนซอร์สที่ต้นทุนต่ำอย่าง MLflow, Docker และ GitHub Actions ซึ่งทั้งหมดนี้ SME ที่มีทีม IT เพียง 1-2 คนก็สามารถทำได้โดยไม่ต้องพึ่งพา Data Scientist ขนาดใหญ่

ทำไม SME ไทยต้องสนใจ MLOps

ปัญหาหลักที่ SME ไทยพบเมื่อพัฒนาโมเดล AI คือช่องว่างระหว่างการพัฒนาในห้องแล็บ (development environment) กับการนำไปใช้งานจริง (production environment) หลายบริษัทใช้เวลาหลายเดือนในการเทรนโมเดลให้มีความแม่นยำสูงใน Jupyter Notebook แต่เมื่อถึงเวลา deploy จริงกลับพบว่าโมเดลทำงานช้า ข้อมูลจริงแตกต่างจากข้อมูลที่ใช้เทรน หรือไม่สามารถเชื่อมต่อกับระบบ ERP ที่มีอยู่ได้

ตัวอย่างจริงจากธุรกิจ SME ขายปลีกแห่งหนึ่งในกรุงเทพฯ ที่ใช้ Odoo เป็นระบบ ERP หลัก ทีม IT ของบริษัทได้พัฒนาโมเดล XGBoost สำหรับพยากรณ์สต็อกสินค้าที่อาจขาดมือ โดยใช้ข้อมูลยอดขายย้อนหลัง 2 ปี โมเดลให้ accuracy สูงถึง 92% ในช่วงทดสอบ แต่เมื่อลองเชื่อมต่อกับ Odoo Inventory Module กลับพบว่า:

• โมเดลที่เทรนไว้เสื่อมประสิทธิภาพลงเรื่อยๆ เพราะพฤติกรรมผู้ซื้อเปลี่ยนไปตามฤดูกาล
• การ deploy แต่ละครั้งต้องใช้เวลา 2-3 วันเพราะต้อง manually export model และเขียน integration ใหม่ทุกครั้ง
• ไม่มีระบบแจ้งเตือนเมื่อโมเดลเริ่มทำงานผิดพลาด

ด้วย MLOps ปัญหาเหล่านี้ได้รับการแก้ไขภายใน 2 เดือน โดยใช้เครื่องมือที่เราจะแนะนำในบทความนี้ และที่สำคัญคือบริษัทดังกล่าวเห็น ROI (Return on Investment) ภายใน 3 เดือน หลัง deploy เนื่องจากลดสต็อกขาดมือได้ 65% และลดสต็อกเกินความจำเป็นได้ 40% (ตัวเลขจากผลจริงของบริษัท)

MLOps ทำงานอย่างไรสำหรับ SME ไทย

หัวใจของ MLOps สำหรับ SME ไทยคือการเลือกใช้เครื่องมือที่เหมาะสมกับทรัพยากรที่มี โดยไม่จำเป็นต้องมี infrastructure แพงๆ หรือทีมงานขนาดใหญ่ ระบบที่แนะนำประกอบด้วยองค์ประกอบหลัก 4 ส่วน:

1. Model Registry และ Version Control ด้วย MLflow

MLflow เป็นเครื่องมือโอเพนซอร์สที่ช่วยจัดการวงจรชีวิตของโมเดล AI ตั้งแต่การบันทึกพารามิเตอร์การเทรน การเปรียบเทียบประสิทธิภาพระหว่างรุ่นต่างๆ ไปจนถึงการจัดเก็บโมเดลที่พร้อม deploy

การติดตั้งสำหรับ SME ไทย:

# docker-compose.yml สำหรับ MLflow + PostgreSQL
version: '3.8'
services:
  postgres:
    image: postgres:14
    environment:
      POSTGRES_DB: mlflow
      POSTGRES_USER: mlflow
      POSTGRES_PASSWORD: your_password
    volumes:
      - postgres_data:/var/lib/postgresql/data
  
  mlflow:
    image: ghcr.io/mlflow/mlflow:v2.3.0
    ports:
      - "5000:5000"
    command: >
      mlflow server
      --backend-store-uri postgresql://mlflow:your_password@postgres/mlflow
      --default-artifact-root /mlflow/artifacts
      --host 0.0.0.0
    volumes:
      - mlflow_artifacts:/mlflow/artifacts
    depends_on:
      - postgres

volumes:
  postgres_data:
  mlflow_artifacts:

การติดตั้งด้วย Docker แบบนี้มีค่าใช้จ่ายเพียงค่าบริการ VPS ขนาดเล็ก เดือนละประมาณ 1,000-2,000 บาท หรือจะรันบนเครื่องภายในสำนักงานก็ได้

2. Pipeline Training อัตโนมัติด้วย GitHub Actions

แทนที่จะให้ Data Scientist เทรนโมเดลด้วยมือทุกครั้ง เราสามารถสร้าง workflow ที่ทำงานโดยอัตโนมัติทุกเดือนหรือทุกครั้งที่ข้อมูลใน Odoo มีการเปลี่ยนแปลงมากพอ

ตัวอย่าง GitHub Actions workflow:

name: Monthly Model Training

on:
  schedule:
    - cron: '0 0 1 * *'  # ทุกวันที่ 1 ของเดือน
  workflow_dispatch:  # สามารถเรียก manual run ได้

jobs:
  train:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      
      - name: Set up Python
        uses: actions/setup-python@v4
        with:
          python-version: '3.9'
      
      - name: Install dependencies
        run: pip install -r requirements.txt
      
      - name: Fetch data from Odoo
        run: python scripts/fetch_odoo_data.py
        env:
          ODOO_URL: ${{ secrets.ODOO_URL }}
          ODOO_DB: ${{ secrets.ODOO_DB }}
          ODOO_USERNAME: ${{ secrets.ODOO_USERNAME }}
          ODOO_PASSWORD: ${{ secrets.ODOO_PASSWORD }}
      
      - name: Train model
        run: python scripts/train_model.py
      
      - name: Register model in MLflow
        run: python scripts/register_model.py
        env:
          MLFLOW_TRACKING_URI: ${{ secrets.MLFLOW_TRACKING_URI }}

วิธีนี้ทำให้การเทรนโมเดลเกิดขึ้นโดยอัตโนมัติโดยไม่ต้องใช้ทรัพยากรบุคคลมากนัก แถมยังบันทึกทุกอย่างไว้ใน MLflow ให้สามารถย้อนกลับไปดูได้เสมอ

3. Deploy Model ผ่าน REST API โดยไม่ต้องแก้ Core Odoo

เทคนิคที่สำคัญที่สุดสำหรับ SME คือการ deploy โมเดลโดยไม่ต้องแก้ไข core code ของ Odoo ซึ่งอาจทำให้เกิดปัญหาในการอัปเกรดหรือ maintenance ในอนาคต วิธีที่แนะนำคือการสร้าง REST API แยกต่างหากด้วย FastAPI แล้วให้ Odoo เรียกใช้ผ่าน External API Integration

ตัวอย่างการสร้าง API ด้วย FastAPI:

# app.py
from fastapi import FastAPI
from pydantic import BaseModel
import mlflow.pyfunc
import pandas as pd
import numpy as np

app = FastAPI()

# โหลดโมเดลจาก MLflow Registry
model_name = "stock_forecast_model"
model_version = "latest"
model = mlflow.pyfunc.load_model(
    model_uri=f"models:/{model_name}/{model_version}"
)

class PredictionRequest(BaseModel):
    product_id: int
    sales_last_30_days: float
    stock_current: int
    lead_time_days: int
    seasonality_factor: float

class PredictionResponse(BaseModel):
    predicted_stock_needed: int
    confidence_score: float
    model_version: str
    timestamp: str

@app.post("/predict", response_model=PredictionResponse)
async def predict(request: PredictionRequest):
    # แปลง request เป็น DataFrame
    data = pd.DataFrame([request.dict()])
    
    # ทำนาย
    prediction = model.predict(data)
    confidence = model.predict_proba(data) if hasattr(model, 'predict_proba') else 0.85
    
    return PredictionResponse(
        predicted_stock_needed=int(prediction[0]),
        confidence_score=float(confidence),
        model_version=model_version,
        timestamp=pd.Timestamp.now().isoformat()
    )

@app.get("/health")
async def health_check():
    return {"status": "healthy", "model": f"{model_name}:{model_version}"}

จากนั้น containerize ด้วย Docker:

FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
CMD ["uvicorn", "app:main", "--host", "0.0.0.0", "--port", "8000"]

การเชื่อมต่อกับ Odoo: สร้าง Automated Action ใน Odoo ที่จะเรียก API นี้ทุกครั้งที่มีการขายสินค้าหรือมีการ update stock โดยใช้ external API connector ที่มีใน Odoo Enterprise หรือใช้ Odoo Studio สำหรับรุ่น Community

4. Model Drift Monitoring และ Alert

โมเดล AI ที่ deploy ไปแล้วอาจเสื่อมประสิทธิภาพลงเมื่อเวลาผ่านไป เนื่องจากข้อมูลจริงเปลี่ยนไปเรื่อยๆ ระบบ monitoring ที่ดีควรตรวจสอบ accuracy ของโมเดลโดยอัตโนมัติและแจ้งเตือนเมื่อพบปัญหา

ตัวอย่างการตรวจสอบ drift ด้วย Python และแจ้งเตือนทาง Line Notify:

# monitor_drift.py
import requests
import pandas as pd
import mlflow.pyfunc
from datetime import datetime, timedelta

# Configuration
LINE_NOTIFY_TOKEN = os.environ.get("LINE_NOTIFY_TOKEN")
ACCURACY_THRESHOLD = 0.80  # 80% accuracy threshold
ODOO_URL = os.environ.get("ODOO_URL")

def send_line_notify(message):
    headers = {
        "Authorization": f"Bearer {LINE_NOTIFY_TOKEN}",
        "Content-Type": "application/x-www-form-urlencoded"
    }
    payload = {"message": message}
    requests.post("https://notify-api.line.me/api/notify", 
                  headers=headers, data=payload)

def check_model_drift():
    # ดึงข้อมูลจาก Odoo
    sales_data = fetch_recent_sales_from_odoo(ODOO_URL)
    
    # โหลดโมเดลล่าสุด
    model = mlflow.pyfunc.load_model("models:/stock_forecast_model/latest")
    
    # ทำนายย้อนหลัง
    predictions = model.predict(sales_data[features])
    
    # เปรียบเทียบกับ actual
    accuracy = calculate_accuracy(predictions, sales_data['actual_stock_needed'])
    
    if accuracy < ACCURACY_THRESHOLD:
        message = f"⚠️ โมเดล Stock Forecast มี accuracy: &#123;accuracy:.2%&#125;\n"
        message += f"ต่ำกว่า threshold (&#123;ACCURACY_THRESHOLD:.0%&#125;)\n"
        message += f"กรุณาตรวจสอบที่ MLflow Dashboard\n"
        message += f"เวลา: &#123;datetime.now().isoformat()&#125;"
        
        send_line_notify(message)
        
        # บันทึก drift event ลง MLflow
        log_drift_event(accuracy, datetime.now())
    
    return accuracy

if __name__ == "__main__":
    accuracy = check_model_drift()
    print(f"Model accuracy: &#123;accuracy:.2%&#125;")

ระบบนี้จะรันทุกวันผ่าน cron job ใน Docker container หรือ Kubernetes CronJob โดยส่งแจ้งเตือนตรงไปยัง Line ของทีม IT ทันทีที่พบความผิดปกติ

ขั้นตอนเริ่มต้นสำหรับ SME ไทย (1 เดือนแรก)

สัปดาห์ที่ 1: ตั้งค่า Infrastructure

• ติดตั้ง Docker บน VPS หรือเครื่องในสำนักงาน
• รัน docker-compose เพื่อติดตั้ง MLflow + PostgreSQL
• สร้าง GitHub repository สำหรับ project และตั้งค่า secrets

สัปดาห์ที่ 2: พัฒนา Model Pipeline

• เขียน script ดึงข้อมูลจาก Odoo ผ่าน API
• ปรับปรุงโมเดลที่มีอยู่ให้ใช้ MLflow tracking
• ทดสอบ pipeline การเทรนบน GitHub Actions

สัปดาห์ที่ 3: Deploy API และเชื่อมต่อ Odoo

• สร้าง FastAPI สำหรับ inference
• Containerize API ด้วย Docker
• สร้าง Automated Action ใน Odoo เพื่อเรียกใช้ API

สัปดาห์ที่ 4: ตั้งค่า Monitoring

• ติดตั้ง cron job สำหรับตรวจสอบ drift
• ตั้งค่า Line Notify หรือ Slack webhook
• ทดสอบระบบทั้งหมดด้วยข้อมูลจริง 1 สัปดาห์

สรุป: MLOps ไม่ใช่เรื่องไกลตัวของ SME ไทยอีกต่อไป

การนำ AI ที่เทรนเองไปใช้จริงในระบบ ERP ไม่จำเป็นต้องมีทีม Data Scientist ขนาดใหญ่หรืองบประมาณหลักล้าน ด้วยเครื่องมือโอเพนซอร์สอย่าง MLflow, Docker และ GitHub Actions SME ไทยสามารถสร้างระบบ MLOps ที่มีประสิทธิภาพได้ด้วยงบไม่เกิน 5,000 บาทต่อเดือน (ค่า VPS + ค่าเครื่องมือต่างๆ)

สิ่งสำคัญที่สุดคือการเริ่มต้นทีละขั้นตอน อย่าพยายามทำทุกอย่างในครั้งเดียว เริ่มจากการทำให้โมเดลเดี่ยวๆ ตัวหนึ่ง deploy และ monitor ได้ก่อน แล้วค่อยขยายไปยังโมเดลอื่นๆ ในอนาคต

ที่ Flowtica เรามีประสบการณ์ช่วย SME ไทยหลายราย deploy AI บน Odoo ด้วยวิธีที่อธิบายในบทความนี้ ผลลัพธ์ที่ได้คือการลดสต็อกขาดมือ ลดค่าใช้จ่ายในการดำเนินงาน และเพิ่มความสามารถในการแข่งขันในตลาด โดยไม่ต้องลงทุนบุคลากรเพิ่ม

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