รูปแบบ SafeTensors: คู่มือการซีเรียไลซ์โมเดล ML อย่างปลอดภัย

รูปแบบนี้ยังเข้ากับไปป์ไลน์ ML สมัยใหม่ได้อย่างเป็นธรรมชาติ เพราะมุ่งเน้นสิ่งที่เช็คพอยต์ส่วนใหญ่มีอยู่แล้ว: 

• เทนเซอร์
• รูปร่าง (shape)
• ชนิดข้อมูล (datatype)
• ค่าเวท

แทนที่จะทำตัวเป็นระบบซีเรียไลซ์ Python อเนกประสงค์ SafeTensors ทำหน้าที่เป็นเลเยอร์จัดเก็บสำหรับพารามิเตอร์ของโมเดลโดยเฉพาะ

แม้ว่า Hugging Face จะเป็นผู้พัฒนา SafeTensors ในตอนแรกเพื่อนิเวศของตนเอง แต่ตัวรูปแบบนั้นไม่ยึดติดกับเฟรมเวิร์กใด ๆ โดยเฉพาะ รูปแบบนี้เพิ่งเข้าร่วม PyTorch Foundation (ในเดือนเมษายน 2026) และรองรับทั้ง PyTorch, TensorFlow, JAX, Flax, NumPy และเฟรมเวิร์ก ML อื่น ๆ

ปัญหา Pickle: เหตุใดจึงต้องมีรูปแบบใหม่

รูปแบบ Pickle ของ Python ถูกสร้างมาสำหรับแอปพลิเคชัน Python ทั่วไป ที่ซึ่งนักพัฒนามักต้องการบันทึกและกู้คืนออบเจ็กต์ทั้งตัวพร้อมสถานะภายใน เมธอด และตรรกะในการสร้างกลับ

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

แต่ไฟล์ .pkl ทำมากกว่าการเก็บข้อมูล มันยังสามารถมีคำสั่งให้ Python สร้างออบเจ็กต์ขึ้นใหม่ระหว่างการโหลดได้ นั่นหมายความว่าการดีซีเรียไลซ์ไม่ได้เป็นเพียงการอ่านแบบพาสซีฟ; มันสามารถรันโค้ดได้ และถ้าโค้ดนั้นเป็นอันตราย ก็จะกลายเป็นปัญหาด้านความปลอดภัยที่ร้ายแรง 

pickle เปิดทางให้รันโค้ดตามอำเภอใจได้อย่างไร

Python สร้างออบเจ็กต์ขึ้นใหม่ระหว่างการดีซีเรียไลซ์ pickle โดยใช้เมธอดพิเศษอย่าง __reduce__() คลาสสามารถกำหนดเมธอดนี้เพื่อบอก pickle ว่าควรสร้างออบเจ็กต์ขึ้นใหม่อย่างไรเมื่อมีการโหลดกลับเข้าหน่วยความจำ

ตัวอย่างเช่น __reduce__() สามารถคืนฟังก์ชันที่เรียกได้พร้อมอาร์กิวเมนต์ของฟังก์ชันนั้น ระหว่างการดีซีเรียไลซ์ Python จะรันฟังก์ชันนั้นเพื่อสร้างออบเจ็กต์ ตัวอย่างโค้ด:

import pickle
import os

class Demo:
    def __reduce__(self):
        return (os.system, ("echo 'Code executed during deserialization'",))

payload = pickle.dumps(Demo())

pickle.loads(payload)

เมื่อรัน pickle.loads() Python จะรันฟังก์ชันที่คืนค่าจาก __reduce__() ในตัวอย่างนี้ การดีซีเรียไลซ์จะเรียกคำสั่งเชลล์ผ่าน os.system()

ปัญหาไม่ใช่ตัวคำสั่งเชลล์เอง __reduce__() สามารถคืนค่า callable ใด ๆ พร้อมอาร์กิวเมนต์ตามตรรกะได้ นั่นหมายความว่าไฟล์ Pickle สามารถเรียกฟังก์ชันอื่น ดาวน์โหลดไฟล์ แก้ไขสภาพแวดล้อม หรือรันโค้ดอันตรายระหว่างการโหลดได้ นั่นจึงเป็นเหตุผลที่เอกสารของ Python เตือนอย่างชัดเจนว่าไม่ควรโหลดข้อมูล pickle จากแหล่งที่ไม่น่าเชื่อถือ

ความเสี่ยงในยุคแห่งการแบ่งปันโมเดล

แพลตฟอร์มอย่าง Hugging Face Hub ตอนนี้โฮสต์โมเดลมากกว่าล้านรายการที่แชร์โดยนักวิจัย สตาร์ทอัป ผู้หลงใหล และผู้มีส่วนร่วมแบบไม่เปิดเผยตัว ระบบนิเวศเติบโตเร็วเพราะนักพัฒนาสามารถดาวน์โหลดและทดสอบโมเดลได้ทันที แต่เช็คพอยต์ส่วนใหญ่ที่อัปโหลดไม่ได้ผ่านการตรวจสอบรายตัวก่อนเผยแพร่

เช็คพอยต์ PyTorch จำนวนมากยังคงพึ่งพาการซีเรียไลซ์แบบ pickle ผ่านรูปแบบอย่าง .pt หรือ .bin เมื่อมีการโหลดไฟล์เหล่านั้น Python อาจรันตรรกะการดีซีเรียไลซ์ที่ฝังอยู่ในเช็คพอยต์ หากเช็คพอยต์เป็นอันตราย ตรรกะนั้นอาจขโมยข้อมูลรับรอง อ่านตัวแปรแวดล้อม ดาวน์โหลดเพย์โหลด หรือรันโค้ดจากระยะไกลระหว่างการโหลด

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

รูปแบบ SafeTensors ทำงานอย่างไร

ตอนนี้เรารู้แล้วว่า SafeTensors คืออะไรและมีไว้ทำไม มาดูโครงสร้างและการทำงานของมันกัน

โครงสร้างส่วนหัว-ข้อมูล

ไฟล์ SafeTensors มีสองส่วน: ส่วนหัว JSON ตามด้วยข้อมูลเทนเซอร์ดิบ

ส่วนหัวเก็บเมตาดาตาสำหรับแต่ละเทนเซอร์ รวมถึง 

• ชื่อตัวเทนเซอร์
• รูปร่าง (shape)
• ชนิดข้อมูล (datatype)
• ออฟเซ็ตของไบต์

หลังส่วนหัวไฟล์จะจัดเก็บไบต์ของเทนเซอร์ดิบแบบเรียงต่อเนื่อง

ส่วนหัวทำหน้าที่เหมือนสารบัญ ชี้ให้ตัวโหลดรู้ว่ามีเทนเซอร์ใดบ้างและอยู่ตรงไหนในไฟล์ คล้ายดัชนีฐานข้อมูลที่ชี้ไปยังระเบียนที่จัดเก็บ SafeTensors จำกัดขนาดส่วนหัวไว้ที่ 100MB เพื่อป้องกันเมตาดาตาที่ใหญ่เกินความจำเป็น

การโหลดแบบ zero-copy และ memory-mapped

SafeTensors เพิ่มความเร็วในการโหลดผ่านการทำ memory-mapped แทนที่จะสร้างออบเจ็กต์ Python ใหม่ระหว่างการดีซีเรียไลซ์ เฟรมเวิร์กสามารถแมปข้อมูลเทนเซอร์จากดิสก์เข้าสู่หน่วยความจำโดยตรง ลดการคัดลอกหน่วยความจำที่ไม่จำเป็นและลดภาระ CPU ระหว่างการโหลด

ตาม การทดสอบของ Hugging Face SafeTensors โหลดเวทได้เร็วกว่า PyTorch บน CPU ประมาณ 76 เท่า และเร็วขึ้นประมาณ 2 เท่าบนงาน GPU แน่นอนว่าอัตราเร่งจริงยังขึ้นกับฮาร์ดแวร์และขนาดเช็คพอยต์ แต่การหลีกเลี่ยงการดีซีเรียไลซ์ของ Python จะช่วยให้ประสิทธิภาพการโหลดดีขึ้นอย่างสม่ำเสมอ

การโหลดแบบขี้เกียจและดีซีเรียไลซ์บางส่วน

SafeTensors โหลดเทนเซอร์เฉพาะตามชื่อ แทนการอ่านเช็คพอยต์ทั้งก้อนเข้าหน่วยความจำในครั้งเดียว

สิ่งนี้มีประโยชน์กับโมเดลขนาดใหญ่แบบกระจายที่รันบนหลาย GPU ยกตัวอย่างโมเดล BLOOM ที่มีพารามิเตอร์ 176B ด้วยเช็คพอยต์มาตรฐานของ PyTorch ระบบต้องดีซีเรียไลซ์เวททั้งโมเดลก่อนแล้วค่อยกระจายลงอุปกรณ์ ใช้เวลาราว 10 นาที 

ด้วย SafeTensors แต่ละ GPU จะโหลดเฉพาะชาร์ดเทนเซอร์ที่จำเป็นจริง ๆ ซึ่งลดเวลาเริ่มต้นโมเดลเหลือประมาณ 45 วินาทีบน 8 GPU

SafeTensors เทียบกับรูปแบบซีเรียไลซ์อื่น

SafeTensors เหมาะสำหรับการจัดเก็บและโหลดเวทของโมเดลอย่างปลอดภัยและมีประสิทธิภาพ แต่ไม่ได้หมายความว่าจะทดแทนรูปแบบอื่นได้เสมอไป ทางเลือกที่เหมาะสมขึ้นกับสิ่งที่จัดเก็บและตำแหน่งของโมเดลในไปป์ไลน์

เราพูดถึง pickle พอสมควรแล้ว ต่อไปจะเน้นที่รูปแบบอื่น

SafeTensors เทียบกับ GGUF

SafeTensors และ GGUF แก้ปัญหาคนละแบบกัน 

GGUF ย่อมาจาก GGML Unified Format ถูกสร้างมาสำหรับงานอินเฟอเรนซ์แบบควอนไทซ์ในรันไทม์อย่าง llama.cpp รูปแบนี้มุ่งเน้นการดีพลอยโมเดลที่บีบอัดอย่างมีประสิทธิภาพ โดยเฉพาะสำหรับอินเฟอเรนซ์บน CPU และอุปกรณ์ปลายทาง

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

ทั้งสองอย่างจึงเกื้อหนุนกันได้แทนที่จะต้องแข่งขัน ตัวอย่างเวิร์กโฟลว์: 

• เทรนหรือไฟน์จูนโมเดลด้วย PyTorch และเช็คพอยต์ SafeTensors
• ควอนไทซ์โมเดลขั้นสุดท้าย
• ส่งออกเป็น GGUF เพื่อดีพลอยใน llama.cpp หรือรันไทม์อินเฟอเรนซ์บนอุปกรณ์ปลายทาง

SafeTensors เทียบกับ ONNX

SafeTensors มุ่งเน้นการจัดเก็บเวทของโมเดลอย่างปลอดภัยและโหลดอย่างมีประสิทธิภาพภายในเฟรมเวิร์กอย่าง PyTorch มันเก็บเฉพาะเทนเซอร์และเมตาดาตา จึงมีน้ำหนักเบาและรวดเร็วสำหรับการแชร์เช็คพอยต์ ไฟน์จูน และเวิร์กโฟลว์การเทรน

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

ตัวอย่างเช่น ทีมที่เทรนและไฟน์จูน LLM ด้วย PyTorch มักจะชอบเช็คพอยต์ SafeTensors เพราะโหลดได้เร็วและผสานเข้ากับเวิร์กโฟลว์ที่มีอยู่ได้โดยตรง แต่หากทีมเดียวกันต้องดีพลอยโมเดลไปยัง TensorRT, ONNX Runtime หรือเอนจินอินเฟอเรนซ์บนอุปกรณ์ปลายทาง การส่งออกเป็น ONNX จะสมเหตุสมผลกว่า

การใช้ SafeTensors ในทางปฏิบัติ

หนึ่งในเหตุผลที่ SafeTensors แพร่หลายอย่างรวดเร็วในระบบนิเวศของ PyTorch คือ API ให้ความรู้สึกคุ้นเคย ยังทำงานกับ state dictionary และเทนเซอร์แบบเดียวกับที่เคยทำ

การบันทึกและโหลดเทนเซอร์

เวิร์กโฟลว์พื้นฐานดูเหมือนการจัดการเช็คพอยต์ของ PyTorch มาตรฐานทุกประการ ตัวอย่าง:

import torch
from safetensors.torch import save_file, load_file

tensors = {
    "weights": torch.randn(2, 2),
    "bias": torch.zeros(2)
}

save_file(tensors, "model.safetensors")

loaded_tensors = load_file("model.safetensors")

print(loaded_tensors["weights"])

save_file() จะเขียนเทนเซอร์ลงในรูปแบบ .safetensors ขณะที่ load_file() โหลดกลับเข้าสู่หน่วยความจำ

SafeTensors ยังรองรับการโหลดแบบเลือกเฉพาะผ่าน safe_open() ซึ่งมีประโยชน์กับเช็คพอยต์ขนาดใหญ่ที่ต้องการเพียงบางเทนเซอร์

from safetensors import safe_open

with safe_open("model.safetensors", framework="pt") as f:
    weights = f.get_tensor("weights")

print(weights)

แทนการโหลดเช็คพอยต์ทั้งก้อน get_tensor() จะอ่านเฉพาะเทนเซอร์ที่ร้องขอ

การแปลงโมเดลที่มีอยู่ให้เป็น safetensors

แพตเทิร์นมาตรฐานคือ:

1. โหลดโมเดลที่มีอยู่
2. ดึง state dictionary ออกมา
3. บันทึกด้วย save_file()

from transformers import AutoModel
from safetensors.torch import save_file

model = AutoModel.from_pretrained("bert-base-uncased")

save_file(model.state_dict(), "model.safetensors")

state_dict() คืนเวทของโมเดลในรูปของเทนเซอร์ ซึ่ง SafeTensors จัดเก็บได้โดยตรง 

หากโมเดลมีอยู่บน Hugging Face Hub อยู่แล้ว อาจไม่ต้องมีโค้ดแปลงในเครื่องด้วยซ้ำ Hugging Face มีการรองรับการแปลงเช็คพอยต์อัตโนมัติสำหรับโมเดลที่โฮสต์อยู่จำนวนมากผ่านอินเทอร์เฟซของ Hub

รูปแบบซีเรียไลซ์: ตารางเปรียบเทียบ

SafeTensors ในปี 2026: PyTorch Foundation และก้าวต่อไป

ในเดือนเมษายน 2026 Hugging Face ได้มอบ SafeTensors ให้กับ PyTorch Foundation ภายใต้ Linux Foundation ตอนนี้โปรเจ็กต์อยู่เคียงข้าง PyTorch, vLLM, DeepSpeed และ Ray ภายใต้การกำกับดูแลของมูลนิธิ

ก้าวย่างนี้ส่งสัญญาณว่า SafeTensors ไม่ใช่แค่โปรเจ็กต์ของ Hugging Face อีกต่อไป แต่มุ่งสู่การเป็นโครงสร้างพื้นฐานร่วมของระบบนิเวศ ML 

ประกาศยังกล่าวถึงทิศทางต่อไปของรูปแบบนี้ด้วย

การโหลดที่รับรู้ถึงอุปกรณ์

หนึ่งในโฟกัสหลักคือการโหลดที่รับรู้ถึงอุปกรณ์ ทุกวันนี้ เวิร์กโฟลว์จำนวนมากยังโหลดเทนเซอร์เข้าสู่หน่วยความจำ CPU ก่อนย้ายไปยังอุปกรณ์ CUDA หรือ ROCm ขั้นตอนพักคอยนี้เพิ่มระยะเวลาเริ่มต้น โดยเฉพาะในระบบกระจายขนาดใหญ่ 

ผู้ดูแล SafeTensors กำลังพัฒนาเส้นทางโหลดสู่ดีไวซ์โดยตรง เพื่อลดการคัดลอกผ่าน CPU ที่ไม่จำเป็นและย้ายเทนเซอร์เข้าสู่ตัวเร่งความเร็วโดยตรง 

การโหลดแบบกระจาย

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

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

เวิร์กโฟลว์ควอนไทซ์สมัยใหม่

รูปแบบนี้ยังปรับตัวรองรับเวิร์กโฟลว์ควอนไทซ์รุ่นใหม่ ระบบอินเฟอเรนซ์พึ่งพารูปแบบอย่าง FP8, GPTQ และ AWQ มากขึ้นเพื่อประหยัดหน่วยความจำและลดต้นทุนการเสิร์ฟ 

แทนที่จะบังคับให้เฟรมเวิร์กจัดการเรื่องนี้ผ่านตรรกะซีเรียไลซ์แบบกำหนดเอง SafeTensors กำลังเพิ่มการรองรับอย่างเป็นทางการสำหรับเทนเซอร์ความละเอียดต่ำและเทนเซอร์ควอนไทซ์แบบบล็อกลงในตัวรูปแบบ 

ตอนนี้นักพัฒนายังต้องเลือกใช้ SafeTensors ด้วยตนเองโดยสลับเวิร์กโฟลว์ save และ load แต่มีงานที่กำลังดำเนินการเพื่อผสานรวมกับระบบซีเรียไลซ์เนทีฟของ PyTorch ให้ลึกขึ้น หากสำเร็จ SafeTensors อาจเลิกเป็นเพียงรูปแบบเช็คพอยต์ทางเลือก และกลายเป็นวิธีเริ่มต้นที่ PyTorch ใช้จัดเก็บโมเดล

บทส่งท้าย

หลายปีที่ผ่านมานักพัฒนาแชร์เช็คพอยต์ของโมเดลด้วยระบบซีเรียไลซ์ที่สามารถรันโค้ด Python ตามอำเภอใจระหว่างการโหลด เมื่อคลังโมเดลสาธารณะเริ่มโฮสต์เช็คพอยต์นับล้าน ความเสี่ยงด้านความปลอดภัยจึงยิ่งยากจะมองข้าม

SafeTensors เปลี่ยนสิ่งนั้นด้วยการจำกัดขอบเขตของรูปแบบ แทนที่จะพยายามซีเรียไลซ์ออบเจ็กต์ Python ทั้งตัว มันโฟกัสเฉพาะการเก็บเทนเซอร์และเมตาดาตาที่ต้องใช้ในการโหลด การออกแบบที่เรียบง่ายกว่านี้กำจัดความเสี่ยงจากการดีซีเรียไลซ์ที่มาพร้อมเช็คพอยต์แบบ pickle พร้อมทั้งเพิ่มความเร็วในการโหลดและประสิทธิภาพการใช้หน่วยความจำ

ดังนั้นเมื่อจำเป็นแค่เวทของโมเดล ก็ไม่มีเหตุผลใดที่จะต้องรันโค้ดตามอำเภอใจระหว่างการดีซีเรียไลซ์ และควรใช้ SafeTensors ในกรณีเหล่านั้น

หากต้องการเจาะลึกการทำงานกับเครื่องมือ ML สมัยใหม่ รูปแบบโมเดล และเวิร์กโฟลว์ของ Hugging Face หลักสูตร Deep Learning in Python และ Working with Hugging Face ของเราคือก้าวต่อไปที่ดี ครอบคลุมเวิร์กโฟลว์เชิงปฏิบัติสำหรับการเทรน ไฟน์จูน และดีพลอยโมเดลด้วยเครื่องมือที่ใช้กันทั่วระบบนิเวศ AI ในปัจจุบัน