Add application file

best_multimodal.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bbe394b179a6b5f334f17725961b971ee50342e2d1d7867da43d51a64cbc45b7
+size 19924917

gladio_webapp.py

@@ -0,0 +1,637 @@
+# -*- coding: utf-8 -*-
+"""Gladio-webapp.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/11rgLJIwe-BYZs3NcVMFz4hnq6XIzxfsv
+"""
+
+
+
+import gradio as gr
+
+import matplotlib.pyplot as plt
+import numpy as np
+import os
+import PIL
+from PIL import Image
+import pandas as pd
+import torch
+import torch.nn as nn
+import torchvision.models as models
+from torchvision import transforms
+from torchvision.models import EfficientNet_B0_Weights
+
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+
+class ImageEncoder(nn.Module):
+    def __init__(self, backbone="efficientnet_b0", embed_dim=512, pretrained=True, train_backbone=False):
+        super().__init__()
+        if backbone == "resnet50":
+            base = models.resnet50(weights=models.ResNet50_Weights.IMAGENET1K_V2 if pretrained else None)
+            feat_dim = base.fc.in_features
+            base.fc = nn.Identity()
+            self.backbone = base
+        else:
+            base = models.efficientnet_b0(weights=models.EfficientNet_B0_Weights.IMAGENET1K_V1 if pretrained else None)
+            feat_dim = base.classifier[1].in_features
+            base.classifier = nn.Identity()
+            self.backbone = base
+
+        for p in self.backbone.parameters():
+            p.requires_grad = train_backbone
+
+        self.proj = nn.Sequential(
+            nn.Linear(feat_dim, embed_dim),
+            nn.ReLU(inplace=True),
+            nn.BatchNorm1d(embed_dim),
+            nn.Dropout(0.2),
+        )
+
+    def forward(self, x):
+        f = self.backbone(x)          # (B, feat_dim)
+        f = self.proj(f)              # (B, embed_dim)
+        return f
+
+class TabularEncoder(nn.Module):
+    def __init__(self, in_dim, out_dim=128):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.BatchNorm1d(in_dim),
+            nn.Linear(in_dim, 256), nn.ReLU(inplace=True),
+            nn.Dropout(0.2),
+            nn.Linear(256, out_dim), nn.ReLU(inplace=True),
+        )
+    def forward(self, x):
+        return self.net(x)
+
+class MultimodalNet(nn.Module):
+    def __init__(self, tab_in_dim, num_classes=4, img_embed_dim=512, tab_embed_dim=128,
+                 backbone="efficientnet_b0", pretrained=True, train_backbone=False):
+        super().__init__()
+        self.img_enc = ImageEncoder(backbone=backbone, embed_dim=img_embed_dim,
+                                    pretrained=pretrained, train_backbone=train_backbone)
+        self.tab_enc = TabularEncoder(in_dim=tab_in_dim, out_dim=tab_embed_dim)
+        self.head = nn.Sequential(
+            nn.Linear(img_embed_dim + tab_embed_dim, 256),
+            nn.ReLU(inplace=True),
+            nn.BatchNorm1d(256),
+            nn.Dropout(0.4),
+            nn.Linear(256, 128),
+            nn.ReLU(inplace=True),
+            nn.Dropout(0.3),
+            nn.Linear(128, num_classes)
+        )
+
+    def forward(self, front_img, back_img, tab_x):
+        f_front = self.img_enc(front_img)
+        f_back  = self.img_enc(back_img)
+        f_img   = 0.5 * (f_front + f_back)           # average two views
+        f_tab   = self.tab_enc(tab_x)
+        fused   = torch.cat([f_img, f_tab], dim=1)
+        logits  = self.head(fused)
+        return logits
+
+# ===== Force tabular dim to 38 no matter what's inside ckpt =====
+FORCE_TAB_DIM = 38
+FORCE_NUM_CLASSES = None   # ตั้งเป็นเลขจริงถ้าอยากบังคับ, หรือปล่อย None ให้ดึงจาก ckpt/ดีฟอลต์
+
+CKPT_PATH = "/content/best_multimodal.pt"  # <-- แก้เป็น path ของคุณ
+ckpt = torch.load(CKPT_PATH, map_location=DEVICE)
+
+# อย่าอ่าน tab_in_dim จาก ckpt แล้วเผลอได้ 14 มาอีก
+tab_in_dim = FORCE_TAB_DIM
+num_classes = int(ckpt.get("num_classes", 4) if FORCE_NUM_CLASSES is None else FORCE_NUM_CLASSES)
+
+print("[INFO] FORCE tab_in_dim:", tab_in_dim, "| num_classes:", num_classes)
+
+# สร้างโมเดลใหม่ให้รองรับ 38 ช่อง
+model = MultimodalNet(
+    tab_in_dim,
+    num_classes=num_classes,
+    backbone="efficientnet_b0",
+    pretrained=False,         # ไม่โหลด imagenet เมื่อมี ckpt เอง
+    train_backbone=False
+).to(DEVICE)
+
+# โหลดเฉพาะพารามิเตอร์ที่ 'เข้ากัน' และ *ตัด* ของ tab_enc (เพราะ shape ไม่ตรง)
+raw_state = ckpt.get("model", ckpt)
+# กรองทิ้งทั้งหมดที่ขึ้นต้นด้วย 'tab_enc.' เพื่อกันการโหลด buffer/พารามิเตอร์ 14 ช่อง
+state = {k: v for k, v in raw_state.items() if not k.startswith("tab_enc.")}
+missing, unexpected = model.load_state_dict(state, strict=False)
+print("[load_state_dict] Missing:", missing)
+print("[load_state_dict] Unexpected:", unexpected)
+
+# ตรว��สอบว่า TabularEncoder เป็น 38 จริง (ต้องเห็น BatchNorm1d(38), Linear(in=38 -> 256))
+print("[VERIFY] model.tab_enc.net =", model.tab_enc.net)
+
+model.eval()
+
+# base 14 ฟีเจอร์ที่ใช้ตอนเทรน
+BASE_14 = [
+    "pilling","condition","pattern","stains","holes",
+    "damage_count","damage_severity",
+    "brand","type","size","season","category","main_color","usage"
+]
+NUM_COLS_BASE = ["pilling","condition","damage_count"]
+
+CUT_CATEGORIES = ['collar','v-collar','tight','loose','regular','turtle-neck','cropped','long']
+
+MATERIAL_CATEGORIES = [
+    'cotton','polyester','viscose','acrylic','nylon',
+    'elastane','wool','rayon','silk','linen','spandex',
+    'lycra','bamboo','alpaca','lyocell','cashmere'
+]
+
+# ล็อก scheme เป็น 38
+SCHEME = {"use_cut": True, "use_mat_vec": True, "use_mat_count": False}
+tab_in_dim = 38
+
+def encode_material_rows(flat_vals):
+    """
+    flat_vals: ลิสต์เรียงเป็น [p1, m1, p2, m2, ...]
+    คืนเวกเตอร์ยาว 16 ตาม MATERIAL_CATEGORIES
+    """
+    agg = {k: 0.0 for k in MATERIAL_CATEGORIES}
+    it = iter(flat_vals)
+    for p, mat in zip(it, it):  # เดินทีละคู่
+        try:
+            pct = float(p) if p is not None else 0.0
+        except:
+            pct = 0.0
+        if mat in agg:
+            agg[mat] += max(0.0, pct)
+    return [agg[k] for k in MATERIAL_CATEGORIES]
+
+# ---------- 1) เลือกสคีมาฟีเจอร์ตาม tab_in_dim ----------
+def get_feature_scheme(tab_in_dim):
+    """
+    - 14: base 14
+    - 23: base 14 + cut(8) + material_count(1)
+    - 30: base 14 + material_vector(16)
+    - 38: base 14 + cut(8) + material_vector(16)
+    """
+    if tab_in_dim == 14:
+        return {"use_base": True, "use_cut": False, "use_mat_vec": False, "use_mat_count": False}
+    if tab_in_dim == 23:
+        return {"use_base": True, "use_cut": True,  "use_mat_vec": False, "use_mat_count": True}
+    if tab_in_dim == 30:
+        return {"use_base": True, "use_cut": False, "use_mat_vec": True,  "use_mat_count": False}
+    if tab_in_dim == 38:
+        return {"use_base": True, "use_cut": True,  "use_mat_vec": True,  "use_mat_count": False}
+    raise ValueError(f"ไม่รู้จัก tab_in_dim={tab_in_dim} (รองรับ 14/23/30/38)")
+
+SCHEME = get_feature_scheme(tab_in_dim)
+
+# ---------- 2) ฟีเจอร์ฐาน 14 ตัว (ของคุณ) ----------
+BASE_14 = [
+    "pilling","condition","pattern","stains","holes",
+    "damage_count","damage_severity",
+    "brand","type","size","season","category","main_color","usage"
+]
+NUM_COLS_BASE = ["pilling","condition","damage_count"]
+
+# (ตรงนี้วาง cat_maps ทั้งชุดของคุณ: brand/type/size/pattern/stains/holes/damage_severity/usage/main_color/season/category)
+
+# ---------- 3) CUT & MATERIAL utilities (จากที่คุณส่งมา) ----------
+import re
+
+CUT_CATEGORIES = ['collar','v-collar','tight','loose','regular','turtle-neck','cropped','long']
+
+def clean_cut(cut_list):
+    if isinstance(cut_list, str):
+        try:
+            cut_list = eval(cut_list) if cut_list.strip().startswith("[") else cut_list.split(',')
+        except Exception:
+            cut_list = [cut_list]
+    cut_list = [c.strip().lower() for c in cut_list if c]
+    mapping = {
+        'c-collar':'collar', 'c collar':'collar', 'collar':'collar',
+        'v-collar':'v-collar', 'v collar':'v-collar',
+        'tight':'tight', 'loose':'loose', 'oversize':'loose',
+        'regular':'regular',
+        'turtle neck':'turtle-neck', 'turtleneck':'turtle-neck',
+        'cropped':'cropped', 'long':'long'
+    }
+    cleaned = set(mapping.get(x, x) for x in cut_list)
+    return [c for c in cleaned if c in CUT_CATEGORIES]
+
+def cuts_to_multihot(cuts):
+    return [1 if cat in (cuts or []) else 0 for cat in CUT_CATEGORIES]
+
+MATERIAL_CATEGORIES = [
+    'cotton','polyester','viscose','acrylic','nylon',
+    'elastane','wool','rayon','silk','linen','spandex',
+    'lycra','bamboo','alpaca','lyocell','cashmere'
+]
+
+def parse_material(text):
+    if text is None:
+        return {}
+    text = str(text).strip().lower()
+    if text in ['not available','unknown','','scanner can not read material.']:
+        return {}
+    comps = re.findall(r'(\d+)\s*%\s*([a-z]+)', text)
+    out = {}
+    for pct, mat in comps:
+        try:
+            out[mat] = int(pct)
+        except:
+            pass
+    return out
+
+def material_to_vector(mat_dict):
+    return [mat_dict.get(cat, 0) for cat in MATERIAL_CATEGORIES]
+
+def material_count_from_dict(mat_dict):
+    return sum(1 for v in mat_dict.values() if float(v) > 0)
+
+# ---------- 4) encoder แบบ “dynamic” ให้ตรงกับโมเดล ----------
+def encode_tab_from_form(base_vals, cut_selected=None, mat_count_val=None, mat_text_val=None):
+    # 4.1 base 14
+    vec = []
+    for col, v in zip(BASE_14, base_vals):
+        if col in NUM_COLS_BASE:
+            vec.append(float(v))
+        else:
+            m = cat_maps[col]
+            idx = m.get(v, list(m.values())[0])  # fallback
+            vec.append(float(idx))
+
+    # 4.2 cut (8)
+    if SCHEME["use_cut"]:
+        cleaned = clean_cut(cut_selected) if cut_selected else []
+        vec.extend(cuts_to_multihot(cleaned))
+
+    # 4.3 material
+    if SCHEME["use_mat_count"]:
+        val = 0 if mat_count_val is None else float(mat_count_val)
+        vec.append(val)
+
+    if SCHEME["use_mat_vec"]:
+        mdict = parse_material(mat_text_val)
+        vec.extend(material_to_vector(mdict))
+
+    x = torch.tensor([vec], dtype=torch.float32, device=DEVICE)
+    assert x.shape[1] == tab_in_dim, f"Encoded dim {x.shape[1]} != tab_in_dim {tab_in_dim}"
+    return x
+
+import re
+
+# ----- CUT -----
+CUT_CATEGORIES = ['collar', 'v-collar', 'tight', 'loose', 'regular', 'turtle-neck', 'cropped', 'long']
+
+def clean_cut(cut_list):
+    # รองรับทั้ง list และ string
+    if isinstance(cut_list, str):
+        try:
+            cut_list = eval(cut_list) if cut_list.strip().startswith("[") else cut_list.split(',')
+        except Exception:
+            cut_list = [cut_list]
+    cut_list = [c.strip().lower() for c in cut_list if c]
+
+    mapping = {
+        'c-collar': 'collar', 'c collar': 'collar', 'collar': 'collar',
+        'v-collar': 'v-collar', 'v collar': 'v-collar',
+        'tight': 'tight', 'loose': 'loose', 'oversize': 'loose',
+        'regular': 'regular',
+        'turtle neck': 'turtle-neck', 'turtleneck': 'turtle-neck',
+        'cropped': 'cropped', 'long': 'long'
+    }
+    cleaned = set()
+    for item in cut_list:
+        key = item.strip().lower()
+        cleaned.add(mapping.get(key, key))
+    return [c for c in cleaned if c in CUT_CATEGORIES]
+
+def cuts_to_multihot(cuts):
+    return [1 if cat in cuts else 0 for cat in CUT_CATEGORIES]
+
+# ----- MATERIAL -----
+MATERIAL_CATEGORIES = [
+    'cotton','polyester','viscose','acrylic','nylon',
+    'elastane','wool','rayon','silk','linen','spandex',
+    'lycra','bamboo','alpaca','lyocell','cashmere'
+]
+
+def parse_material(text):
+    """
+    รับสตริงแบบ '60% cotton 40% polyester' หรือกรณีไม่พร้อมใช้งาน
+    คืน dict เช่น {'cotton':60, 'polyester':40}
+    """
+    if text is None:
+        return {}
+    text = str(text).strip().lower()
+    if text in ['not available','unknown','','scanner can not read material.']:
+        return {}
+    comps = re.findall(r'(\d+)\s*%\s*([a-z]+)', text)
+    out = {}
+    for pct, mat in comps:
+        try:
+            out[mat] = int(pct)
+        except Exception:
+            pass
+    return out
+
+def material_to_vector(mat_dict):
+    """เวกเตอร์ยาว 16 ตาม MATERIAL_CATEGORIES (ค่าร้อยละ 0..100)"""
+    return [mat_dict.get(cat, 0) for cat in MATERIAL_CATEGORIES]
+
+def material_count_from_dict(mat_dict):
+    """นับชนิดวัสดุที่มีสัดส่วน > 0 เพื่อใช้กับเคส 23 มิติ"""
+    return sum(1 for v in mat_dict.values() if float(v) > 0)
+
+def get_feature_scheme(tab_in_dim):
+    """
+    คืน dict ที่อธิบายว่าโมเดลต้องการฟีเจอร์อะไรบ้าง
+    - 14: base 14
+    - 23: base 14 + cut(8) + material_count(1)
+    - 30: base 14 + material_vector(16)
+    - 38: base 14 + cut(8) + material_vector(16)
+    """
+    if tab_in_dim == 14:
+        return {"use_base": True, "use_cut": False, "use_mat_vec": False, "use_mat_count": False}
+    if tab_in_dim == 23:
+        return {"use_base": True, "use_cut": True,  "use_mat_vec": False, "use_mat_count": True}
+    if tab_in_dim == 30:
+        return {"use_base": True, "use_cut": False, "use_mat_vec": True,  "use_mat_count": False}
+    if tab_in_dim == 38:
+        return {"use_base": True, "use_cut": True,  "use_mat_vec": True,  "use_mat_count": False}
+    raise ValueError(f"ไม่รู้จัก tab_in_dim={tab_in_dim} (รองรับ 14/23/30/38)")
+
+weights = EfficientNet_B0_Weights.IMAGENET1K_V1
+img_tf = transforms.Compose([
+    transforms.Resize(256),
+    transforms.CenterCrop(224),
+    transforms.ToTensor(),
+    transforms.Normalize(mean=weights.transforms().mean, std=weights.transforms().std),
+])
+
+def preprocess_image(pil_img: Image.Image):
+    return img_tf(pil_img.convert("RGB")).unsqueeze(0).to(DEVICE)  # (1,3,224,224)
+
+# ===== ใช้ลำดับฟีเจอร์ 14 ช่อง ตามที่คุณเทรน =====
+TAB_FEATS = [
+    "pilling","condition","pattern","stains","holes",
+    "damage_count","damage_severity",
+    "brand","type","size","season","category","main_color","usage"
+]
+
+# ===== mapping จริงจากโน้ตบุ๊ก (เรียง index ให้ตรงกับที่ map ในไฟล์) =====
+cat_maps = {
+    "brand": {
+        "Non-Brand": 0,
+        "Fast Fashion & High Street Retailers": 1,
+        "Other Brands": 2,
+        "Store Brands": 3,
+        "Niche Brands": 4,
+        "Premium & Designer": 5,
+        "Sportswear & Outdoor": 6,
+    },
+    "pattern": {
+        "Solid": 0,
+        "Printed": 1,
+        "Texture_Embellishment": 2,
+        "Other": 3,
+    },
+    "type": {
+        "topwear": 0,
+        "dresswear": 1,
+        "bottomwear": 2,
+        "outerwear": 3,
+        "other": 4,
+        "sleepwear": 5,
+    },
+    "size": {
+        "unknown": 0,
+        "xs": 1,
+        "s": 2,
+        "m": 3,
+        "l": 4,
+        "xl": 5,
+        "xxl": 6,
+        "kids": 7,
+        "onesize": 8,
+    },
+    "season": {
+        "All": 0, "Summer": 1, "Spring": 2, "Autumn": 3, "None": 4, "Winter": 5
+    },
+    "category": {
+        "Ladies": 0, "Men": 1, "Children": 2, "Unisex": 3
+    },
+    "main_color": {
+        "black": 0, "white": 1, "blue": 2, "multicolor": 3, "pink": 4,
+        "grey": 5, "beige": 6, "red": 7, "green": 8, "purple": 9,
+        "brown": 10, "yellow": 11, "orange": 12, "turquoise": 13, "none": 14
+    },
+    "usage": {
+        "export": 0, "reuse": 1, "recycle": 2, "repair": 3
+    },
+    "stains": {"No": 0, "Yes": 1},
+    "holes": {"None": 0, "Minor": 1, "Major": 2},
+    "damage_severity": {
+        "No Damage": 0, "Minor Damage": 1, "Moderate Damage": 2, "Severe Damage": 3
+    },
+}
+
+# ===== สเปกอินพุตสำหรับสร้าง UI ใน Gradio =====
+FEATURE_SPECS = {
+    # numeric (ใช้ค่าเดิม)
+    "pilling": {"kind":"number","min":0,"max":5,"step":1,"default":3},
+    "condition":{"kind":"number","min":0,"max":5,"step":1,"default":2},
+    "damage_count":{"kind":"number","min":0,"max":20,"step":1,"default":0},
+
+    # categorical (choices = list(cat_maps[col].keys()))
+    "pattern":{"kind":"cat","choices":list(cat_maps["pattern"].keys()),"default":"Solid"},
+    "stains":{"kind":"cat","choices":list(cat_maps["stains"].keys()),"default":"No"},
+    "holes":{"kind":"cat","choices":list(cat_maps["holes"].keys()),"default":"None"},
+    "damage_severity":{"kind":"cat","choices":list(cat_maps["damage_severity"].keys()),"default":"No Damage"},
+
+    "brand":{"kind":"cat","choices":list(cat_maps["brand"].keys()),"default":"Non-Brand"},
+    "type":{"kind":"cat","choices":list(cat_maps["type"].keys()),"default":"topwear"},
+    "size":{"kind":"cat","choices":list(cat_maps["size"].keys()),"default":"m"},
+    "season":{"kind":"cat","choices":list(cat_maps["season"].keys()),"default":"All"},
+    "category":{"kind":"cat","choices":list(cat_maps["category"].keys()),"default":"Ladies"},
+    "main_color":{"kind":"cat","choices":list(cat_maps["main_color"].keys()),"default":"black"},
+    "usage":{"kind":"cat","choices":list(cat_maps["usage"].keys()),"default":"reuse"},
+}
+
+NUM_COLS = ["pilling","condition","damage_count"]
+CAT_COLS = [c for c in TAB_FEATS if c not in NUM_COLS]
+
+def encode_tab(tab_dict):
+    """
+    แปลงค่าจากฟอร์ม → เวกเตอร์ตามลำดับ TAB_FEATS
+    - number: ใช้ค่า float ตรง ๆ (ไม่มี scaler ตามไฟล์เทรนของคุณ)
+    - categorical: map ชื่อ → index ตาม cat_maps (unknown → index 0 ของคอลัมน์นั้น)
+    """
+    vec = []
+    for col in TAB_FEATS:
+        if col in NUM_COLS:
+            vec.append(float(tab_dict[col]))
+        else:
+            m = cat_maps[col]
+            # ถ้าผู้ใช้ส่งค่าที่ไม่มีใน mapping ให้ fallback เป็นตัวแรก
+            idx = m.get(tab_dict[col], list(m.values())[0])
+            vec.append(float(idx))
+    return torch.tensor([vec], dtype=torch.float32, device=DEVICE)
+
+FX_RATE = 3.4   # 1 SEK ≈ 3.4 บาท (เปลี่ยนได้)
+CLASS_NAMES = ["<50", "50-100", "100-150", "150+"]   # ตัวอย่าง 4 คลาส
+
+import re
+def convert_label_sek_to_thb(label, rate=FX_RATE):
+    """
+    label: สตริงช่วงราคาเป็น SEK เช่น "<50", "50-100", "150+"
+    คืนค่า: สตริงช่วงราคาเป็นบาท เช่น "<170 บาท", "170-340 บาท", "510+ บาท"
+    """
+    s = str(label).strip().lower()
+    nums = [int(x) for x in re.findall(r"\d+", s)]
+    if not nums:
+        return label
+
+    if s.startswith("<"):
+        return f"<{int(round(nums[0]*rate))} บาท"
+    if s.endswith("+"):
+        return f"{int(round(nums[0]*rate))}+ บาท"
+    if "-" in s and len(nums) == 2:
+        a, b = nums
+        return f"{int(round(a*rate))}-{int(round(b*rate))} บาท"
+    return f"{int(round(nums[0]*rate))} บาท"
+
+
+def predict(front_img, back_img, *vals):
+    try:
+        if front_img is None or back_img is None:
+            return "กรุณาอัปโหลดร��ปทั้งสองภาพ", None
+
+        base_count = len(BASE_14)
+        i = 0
+        base_vals = list(vals[i:i+base_count]); i += base_count
+
+        # cut (CheckboxGroup)
+        cut_selected = vals[i]; i += 1
+
+        # material vector: N คู่ (percent, type) — ต้องเท่ากับ MAX_MATS ใน cell 16
+        MAX_MATS = 5
+        flat = []
+        for _ in range(MAX_MATS):
+            p = vals[i];   i += 1
+            m = vals[i];   i += 1
+            flat.extend([p, m])
+
+        # ---------- encode ----------
+        vec = []
+        # 1) base 14
+        for col, v in zip(BASE_14, base_vals):
+            if col in NUM_COLS_BASE:
+                vec.append(float(v))
+            else:
+                m = cat_maps[col]
+                idx = m.get(v, list(m.values())[0])  # fallback
+                vec.append(float(idx))
+
+        # 2) cut → multihot 8
+        cleaned = clean_cut(cut_selected) if cut_selected else []
+        vec.extend(cuts_to_multihot(cleaned))
+
+        # 3) material vector → 16
+        mvec = encode_material_rows(flat)  # รวมเปอร์เซ็นต์ตามชนิด → ลิสต์ 16 ช่อง
+        vec.extend(mvec)
+
+        xt = torch.tensor([vec], dtype=torch.float32, device=DEVICE)
+        assert xt.shape[1] == tab_in_dim, f"Encoded dim {xt.shape[1]} != tab_in_dim {tab_in_dim}"
+
+        # ---------- infer ----------
+        with torch.no_grad():
+            x1 = preprocess_image(front_img)
+            x2 = preprocess_image(back_img)
+            logits = model(x1, x2, xt)
+            probs = torch.softmax(logits, dim=1).cpu().numpy()[0]
+
+        top_idx = int(np.argmax(probs))
+        top_name_sek = str(CLASS_NAMES[top_idx])          # เช่น "<50"
+        top_name_thb = convert_label_sek_to_thb(top_name_sek)
+
+        import pandas as pd
+        rows = []
+        for name, p in zip(CLASS_NAMES, probs.tolist()):
+            thb = convert_label_sek_to_thb(str(name))
+            rows.append([thb, round(float(p), 4)])
+
+        df = pd.DataFrame(rows, columns=["class_THB", "probability"])
+
+        return f"ผลทำนาย: {top_name_thb}", df
+
+    except Exception as e:
+        import traceback
+        return f"Error: {type(e).__name__} - {e}\n" + traceback.format_exc(), None
+
+def encode_material_rows(flat_vals):
+    """
+    flat_vals: ลิสต์เรียงเป็น [p1, m1, p2, m2, ...] ที่มากับ *vals ใน predict()
+    คืนเวกเตอร์ยาว 16 ตรงตาม MATERIAL_CATEGORIES (ค่าร้อยละรวมกันตามชนิด)
+    """
+    # รวมเปอร์เซ็นต์ตามชนิด
+    agg = {k: 0.0 for k in MATERIAL_CATEGORIES}
+    it = iter(flat_vals)
+    for p, mat in zip(it, it):  # เดินทีละคู่
+        try:
+            pct = float(p) if p is not None else 0.0
+        except:
+            pct = 0.0
+        if mat in agg:
+            agg[mat] += max(0.0, pct)  # กันค่าติดลบ
+    # เติมเป็นลิสต์ตามลำดับคงที่
+    return [agg[k] for k in MATERIAL_CATEGORIES]
+
+with gr.Blocks(title="Multimodal (2 Images + Tabular)") as demo:
+    gr.Markdown("### โมเดลจำแนกด้วย 2 รูป + คุณลักษณะตาราง")
+
+    with gr.Row():
+        img_front = gr.Image(type="pil", label="รูปด้านหน้า")
+        img_back  = gr.Image(type="pil", label="รูปด้านหลัง")
+
+    # อินพุต base 14
+    tab_inputs = []
+    with gr.Row():
+        for k in BASE_14:
+            spec = FEATURE_SPECS[k]   # ต้องมี FEATURE_SPECS ตาม mapping ที่คุณใส่ไว้
+            if spec["kind"] == "number":
+                tab_inputs.append(gr.Slider(minimum=spec["min"], maximum=spec["max"],
+                                            step=spec["step"], value=spec["default"], label=k))
+            else:
+                tab_inputs.append(gr.Dropdown(choices=spec["choices"],
+                                              value=spec["default"], label=k))
+
+    # CUT
+    cut_input = gr.CheckboxGroup(label="cut (เลือกได้หลายค่า)",
+                                 choices=CUT_CATEGORIES, value=[])
+
+    # MATERIAL_VECTOR — ให้กรอกได้สูงสุด 5 ชนิด
+    MAX_MATS = 5
+    material_pairs = []
+    gr.Markdown("**วัสดุ (เปอร์เซ็นต์ + ชนิด)** เช่น 60% cotton, 40% polyester")
+    with gr.Column():
+        for i in range(MAX_MATS):
+            with gr.Row():
+                p = gr.Number(value=0, label=f"material_{i+1}_percent")
+                m = gr.Dropdown(choices=MATERIAL_CATEGORIES, value=MATERIAL_CATEGORIES[0],
+                                label=f"material_{i+1}_type")
+                material_pairs.append((p, m))
+
+    # รวมอินพุตทั้งหมด
+    predict_inputs = [img_front, img_back] + tab_inputs + [cut_input]
+    for p, m in material_pairs:
+        predict_inputs.extend([p, m])
+
+    # ปุ่ม + เอาต์พุต
+    btn = gr.Button("ทำนาย")
+    out_txt = gr.Textbox(label="สรุปผล")
+    out_tbl = gr.Dataframe(headers=["class","probability"],
+                           datatype=["str","number"], label="ความน่าจะเป็น")
+
+    btn.click(predict, inputs=predict_inputs, outputs=[out_txt, out_tbl])
+
+demo.launch()