โมเดล AI เบาๆ บน Edge Device: TensorFlow Lite ช่วยได้จริงดิ?

ทีมงาน devdog

17 ก.พ. 2026 — 1 min read

เคยไหม ที่แบบว่า เทรนโมเดล AI มาอย่างดิบดีเลย แต่พอจะเอาไปรันบนพวกมือถือ หรือว่าบอร์ดเล็กๆ อย่าง Raspberry Pi, Jetson Nano งี้... ก็ดันรันไม่ไหวบ้าง แหละเมมเต็มบ้าง หรือไม่ก็กินแบตยังกับน้ำเปล่า

ปัญหานี้แหละ ที่ทำให้เราต้องหันมามองอะไรที่มัน 'เบา' ลงมาหน่อย ซึ่งหนึ่งในพระเอกของงานนี้ก็คือ TensorFlow Lite ของ Google นี่แหละครับ

ทำไมต้อง TensorFlow Lite?

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

TensorFlow Lite เข้ามาช่วยตรงนี้แหละ โดยหลักๆ มันจะทำ Quantization ซึ่งก็คือการลดความละเอียดของตัวเลขจาก float32 ให้เป็น int8 (หรือแบบอื่นๆ) คิดง่ายๆ เหมือนลดจำนวนสีในรูปภาพอะครับ จากเป็นล้านสีให้เหลือแค่ 256 สีงี้ มันก็จะเล็ก และประหยัดแรงประมวลผลขึ้นเยอะเลย

ลองแปลงโมเดลเล็กๆ เป็น TFLite

มาดูโค้ดกันเลยดีกว่า ลองทำโมเดลเล็กๆ แล้วแปลงเป็น TFLite พร้อม Quantization แบบง่ายๆ

ก่อนอื่นก็ install tensorflow ก่อนนะ ถ้ายังไม่มี

pip install tensorflow

จากนั้นก็เขียนโค้ด Python แบบนี้

import tensorflow as tf
import numpy as np
import os

# 1. สร้างโมเดลแบบง่ายๆ
# อันนี้ใช้ Keras API สร้างโมเดล Linear Regression แบบกากๆ เพื่อทดสอบนะ
print("\n--- สร้างโมเดลง่ายๆ ---")
model = tf.keras.Sequential([
    tf.keras.layers.Dense(units=1, input_shape=[1])
])

# ลอง compile กับ train ดูหน่อย
model.compile(optimizer='sgd', loss='mean_squared_error')

# สร้างข้อมูลเทรนแบบ fakeๆ
x_train = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], dtype=float)
y_train = np.array([1.0, 1.5, 2.0, 2.5, 3.0, 3.5], dtype=float)

model.fit(x_train, y_train, epochs=500, verbose=0) # verbose=0 จะได้ไม่รกหน้าจอ

print(f"ทำนายค่า 10.0: {model.predict([10.0])[0][0]:.2f}")

# 2. แปลงโมเดลเป็น TensorFlow Lite
print("\n--- แปลงโมเดลเป็น TFLite ---")
converter = tf.lite.TFLiteConverter.from_keras_model(model)

# *** Quantization ตรงนี้แหละสำคัญ! ***
# ทำให้โมเดลเล็กลง และประหยัดพลังงาน
converter.optimizations = [tf.lite.Optimize.DEFAULT]

# ถ้าอยากให้มัน quantize แบบละเอียดขึ้น ต้องใช้ Representative Dataset
# converter.representative_dataset = tf.lite.RepresentativeDataset(lambda: ([x] for x in x_train))
# converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
# converter.inference_input_type = tf.uint8  # หรือ tf.int8
# converter.inference_output_type = tf.uint8 # หรือ tf.int8


tflite_model = converter.convert()

# 3. เซฟโมเดล TFLite
model_name = "linear_model.tflite"
with open(model_name, "wb") as f:
    f.write(tflite_model)

print(f"โมเดล TFLite บันทึกที่: {model_name}")
print(f"ขนาดโมเดล: {os.path.getsize(model_name) / 1024:.2f} KB")

# 4. โหลดและรันโมเดล TFLite
print("\n--- ทดสอบรัน TFLite โมเดล ---")
interpreter = tf.lite.Interpreter(model_path=model_name)
interpreter.allocate_tensors()

# ดึง input และ output details
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()

# ลองทำนายค่าเดิม
input_data = np.array([[10.0]], dtype=np.float32)
interpreter.set_tensor(input_details[0]['index'], input_data)

interpreter.invoke()

output_data = interpreter.get_tensor(output_details[0]['index'])
print(f"ทำนายค่า 10.0 ด้วย TFLite: {output_data[0][0]:.2f}")

# ลองลบไฟล์ที่สร้างทิ้งไป เพื่อความสะอาด
# os.remove(model_name)

ลองรันโค้ดข้างบนดูนะ จะเห็นว่าไฟล์ .tflite มันเล็กจิ๋วเลย แล้วผลลัพธ์ก็ใกล้เคียงกันด้วย (ถ้าโมเดลไม่ซับซ้อนมาก).

ปัญหาที่อาจจะเจอ (ประสบการณ์ส่วนตัว)

ใช่ว่ามันจะง่ายไปซะหมดหรอกนะ บางทีก็เจอเรื่องปวดหัวเหมือนกันแหละ

ความแม่นยำตกวูบ: ไอ้เรื่อง Quantization เนี่ย บางทีพอแปลงเป็น int8 แล้ว ความแม่นยำของโมเดลมันตกลงเยอะแบบน่าใจหายเลยนะ ยิ่งถ้าโมเดลซับซ้อนๆ หรือเป็นพวกโมเดลที่ต้องการความละเอียดสูงๆ เช่นพวก Medical Imaging งี้... อาจจะต้องคิดดีๆ เลย ต้องมีกระบวนการ calibrate เพิ่มเติม หรือไม่ก็ต้องใช้ quantization แบบอื่น เช่น float16 แทน
Unsupported Operations: บางทีตอน converter.convert() แล้วมันบ่นว่า Unsupported op: 'tf.raw_ops.SomeExoticOp' นี่อย่างเซ็งเลยนะ ต้องมานั่งไล่ดูว่าใช้ layer อะไรแปลกๆ ไปรึเปล่า หรือว่ามี operation ไหนที่ TFLite มันยังไม่รองรับรึเปล่า บางทีก็ต้องปรับแก้โครงสร้างโมเดลกันเลยทีเดียว
การ Deploy จริงๆ ไม่ได้ง่าย: ไอ้ที่รันบน Python ในเครื่องเราเนี่ย มันก็ง่ายอยู่หรอก แต่พอจะเอาไปลงบน Embedded device จริงๆ อย่าง Raspberry Pi หรือพวก Android/iOS app เนี่ย มันก็จะมีเรื่องของการคอมไพล์โค้ดสำหรับแต่ละแพลตฟอร์ม การจัดการ dependencies หรือบางทีก็ต้องเขียนโค้ดภาษา C++/Java/Kotlin/Swift เพื่อเรียกใช้ Interpreter อีก มันไม่ใช่แค่ copy ไฟล์ไปวางแล้วจบนะ

สรุป

TensorFlow Lite นี่โคตรมีประโยชน์เลยนะ ถ้างานของเราคือการเอาโมเดล AI ไปรันบนอุปกรณ์ที่มีทรัพยากรจำกัด หรือต้องการความเร็วในการประมวลผลสูงๆ พร้อมกับกินพลังงานน้อยๆ อย่างพวก Computer Vision บนโดรน หรือ Voice Recognition บน Smart Speaker เล็กๆ

มันไม่ได้มาแทนที่ TensorFlow ตัวเต็มนะ แต่เป็นการเสริมกันมากกว่า สำหรับงานที่ต้องการประสิทธิภาพ และขนาดไฟล์ที่เล็กมากๆ

หวังว่าบทความนี้จะพอเป็นไกด์ไลน์ให้ลองเล่น TensorFlow Lite กันดูนะฮะ เจอกันบทความหน้าจ้า