SafeTensors फ़ॉर्मेट: सुरक्षित ML मॉडल सीरियलाइज़ेशन के लिए एक मार्गदर्शक

यह फ़ॉर्मेट आधुनिक ML पाइपलाइनों में स्वाभाविक रूप से फिट बैठता है क्योंकि यह उसी पर केंद्रित है जो अधिकांश चेकपॉइंट्स में पहले से होता है: 

• टेंसर
• शेप्स
• डेटाटाइप्स
• वेट वैल्यूज़

एक सामान्य-उद्देश्य Python सीरियलाइज़ेशन सिस्टम की तरह काम करने के बजाय, SafeTensors मॉडल पैरामीटर्स के लिए समर्पित स्टोरेज लेयर की तरह काम करता है।

हालाँकि Hugging Face ने मूलरूप से अपने इकोसिस्टम के लिए SafeTensors विकसित किया था, फ़ॉर्मेट स्वयं फ्रेमवर्क-अज्ञेय है। यह हाल ही में (अप्रैल 2026 में) PyTorch Foundation में शामिल हुआ और PyTorch, TensorFlow, JAX, Flax, NumPy और अन्य ML फ्रेमवर्क्स का समर्थन करता है।

पिक्ल की समस्या: नया फ़ॉर्मेट क्यों ज़रूरी था

Python का Pickle फ़ॉर्मेट सामान्य Python अनुप्रयोगों के लिए बनाया गया था, जहाँ डेवलपर्स अक्सर संपूर्ण Python ऑब्जेक्ट्स को उनके आंतरिक स्टेट, मेथड्स और पुनर्निर्माण लॉजिक सहित सेव और रिस्टोर करने की आवश्यकता होती है।

मशीन लर्निंग चेकपॉइंट्स को आमतौर पर उस स्तर के स्टोरेज की आवश्यकता नहीं होती। अधिकांश मॉडल फ़ाइलें मुख्य रूप से टेंसर स्टोर करती हैं: वेट मैट्रिसेज़, एम्बेडिंग्स, बायस, और अन्य संख्यात्मक पैरामीटर्स। व्यवहार में, इसका मतलब है कि चेकपॉइंट ज्यादातर संरचित संख्यात्मक डेटा ही होता है।

लेकिन एक .pkl फ़ाइल केवल डेटा स्टोर करने से अधिक करती है। इसमें लोडिंग के दौरान Python को यह बताने के निर्देश भी हो सकते हैं कि ऑब्जेक्ट्स को कैसे दोबारा बनाया जाए। यानी डीसिरियलाइज़ेशन एक निष्क्रिय रीड ऑपरेशन नहीं है; यह कोड चला सकता है। और यदि कोड मैलिशियस है, तो यह एक गंभीर सुरक्षा समस्या बन जाती है। 

पिक्ल कैसे मनमाना कोड निष्पादन सक्षम करता है

Python पिक्ल डीसिरियलाइज़ेशन के दौरान __reduce__() जैसे विशेष मेथड्स का उपयोग करके ऑब्जेक्ट्स का पुनर्निर्माण करता है। क्लासेज़ इस मेथड को परिभाषित कर सकती हैं ताकि पिक्ल को ठीक-ठीक बताया जा सके कि जब कोई ऑब्जेक्ट को मेमोरी में वापस लोड करे तो उसे कैसे पुनर्निर्मित किया जाए।

उदाहरण के लिए, __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__() किसी भी कॉलएबल को लॉजिक के आधार पर मनमाने आर्ग्युमेंट्स के साथ लौटा सकता है। इसका मतलब है कि एक पिक्ल फ़ाइल अन्य फ़ंक्शन्स को कॉल कर सकती है, फ़ाइलें डाउनलोड कर सकती है, एन्वायरनमेंट में परिवर्तन कर सकती है, या लोडिंग के दौरान मैलिशियस कोड निष्पादित कर सकती है। यही कारण है कि Python का प्रलेखन अनविश्वसनीय स्रोतों से पिक्ल डेटा लोड करने के खिलाफ स्पष्ट रूप से चेतावनी देता है।

मॉडल-शेयरिंग युग में जोखिम

Hugging Face Hub जैसे प्लेटफ़ॉर्म अब शोधकर्ताओं, स्टार्टअप्स, हॉबीस्ट्स और अनाम योगदानकर्ताओं द्वारा साझा किए गए एक मिलियन से अधिक मॉडल होस्ट करते हैं। इकोसिस्टम तेज़ी से आगे बढ़ता है क्योंकि डेवलपर्स तुरंत मॉडल डाउनलोड और टेस्ट कर सकते हैं। लेकिन वितरित होने से पहले अधिकांश अपलोडेड चेकपॉइंट्स का अलग से ऑडिट नहीं होता।

कई PyTorch चेकपॉइंट्स अभी भी .pt या .bin जैसे फ़ॉर्मेट्स के माध्यम से पिक्ल-आधारित सीरियलाइज़ेशन पर निर्भर करते हैं। जब कोई उन फ़ाइलों में से एक को लोड करता है, तो Python चेकपॉइंट के अंदर एम्बेडेड डीसिरियलाइज़ेशन लॉजिक को चला सकता है। यदि चेकपॉइंट मैलिशियस है, तो वह लॉजिक क्रेडेंशियल्स चुरा सकता है, एन्वायरनमेंट वेरिएबल्स पढ़ सकता है, पेलोड्स डाउनलोड कर सकता है, या लोडिंग के दौरान रिमोट कोड चला सकता है।

यही सटीक समस्या SafeTensors को हल करने के लिए बनाया गया था। मनमाने Python ऑब्जेक्ट्स को सीरियलाइज़ करने के बजाय, यह केवल उन टेंसरों का डेटा और उन्हें सही ढंग से लोड करने के लिए आवश्यक मेटाडेटा स्टोर करता है। एक .safetensors फ़ाइल लोड करने के लिए Python के पुनर्निर्माण लॉजिक को निष्पादित करने की आवश्यकता नहीं होती, जिससे अटैक सरफेस में उल्लेखनीय कमी आती है।

SafeTensors फ़ॉर्मेट कैसे काम करता है

अब जब हमें पता है कि SafeTensors क्या हैं और क्यों मौजूद हैं, तो आइए उनकी संरचना और काम करने के तरीके पर नज़र डालते हैं।

हेडर-डेटा संरचना

एक SafeTensors फ़ाइल में दो भाग होते हैं: एक JSON हेडर और उसके बाद कच्चा टेंसर डेटा।

यह हेडर प्रत्येक टेंसर के लिए मेटाडेटा स्टोर करता है, जिसमें शामिल हैं 

• टेंसर नाम
• शेप्स
• डेटाटाइप्स
• बाइट ऑफ़सेट्स

हेडर के बाद, फ़ाइल कच्चे टेंसर बाइट्स को लगातार स्टोर करती है।

हेडर एक विषय-सूची की तरह काम करता है। यह लोडर को बताता है कि कौन-कौन से टेंसर मौजूद हैं और फ़ाइल में वे कहाँ स्थित हैं, जैसे कोई डेटाबेस इंडेक्स स्टोर्ड रिकॉर्ड्स की ओर इशारा करता है। SafeTensors इस हेडर के आकार को 100MB तक सीमित करता है ताकि अत्यधिक बड़े मेटाडेटा पेलोड्स से बचा जा सके।

ज़ीरो-कॉपी और मेमोरी-मैप्ड लोडिंग

SafeTensors मेमोरी-मैप्ड लोडिंग के माध्यम से लोडिंग गति में सुधार करता है। डीसिरियलाइज़ेशन के दौरान Python ऑब्जेक्ट्स को फिर से बनाने के बजाय, फ्रेमवर्क्स टेंसर डेटा को सीधे डिस्क से मेमोरी में मैप कर सकते हैं। इससे अनावश्यक मेमोरी कॉपीज़ कम होती हैं और लोडिंग के दौरान CPU ओवरहेड घटता है।

Hugging Face बेंचमार्क्स के अनुसार, SafeTensors ने CPU पर PyTorch की तुलना में लगभग 76x तेज़ और GPU वर्कलोड्स पर लगभग 2x तेज़ वेट्स लोड किए। बेशक, वास्तविक स्पीडअप हार्डवेयर और चेकपॉइंट आकार पर निर्भर करता है, लेकिन Python डीसिरियलाइज़ेशन से बचना लगातार लोड परफ़ॉर्मेंस को बेहतर करता है।

लेज़ी लोडिंग और आंशिक डीसिरियलाइज़ेशन

SafeTensors पूरे चेकपॉइंट को एक साथ मेमोरी में पढ़ने के बजाय नाम से विशिष्ट टेंसर लोड करता है।

यह कई GPUs पर चल रहे बड़े वितरित मॉडलों के साथ उपयोगी है। उदाहरण के लिए BLOOM का 176B पैरामीटर मॉडल लें। मानक PyTorch चेकपॉइंट्स के साथ, सिस्टम को पहले पूरे मॉडल वेट्स को डीसिरियलाइज़ करना पड़ता था और फिर उन्हें डिवाइसों में विभाजित करना पड़ता था, जिसमें लगभग 10 मिनट लगते थे। 

SafeTensors के साथ, प्रत्येक GPU ने केवल वही टेंसर शार्ड्स लोड किए जिनकी उसे वास्तव में आवश्यकता थी। इससे 8 GPU पर मॉडल स्टार्टअप समय लगभग 45 सेकंड तक कम हो गया।

SafeTensors बनाम अन्य सीरियलाइज़ेशन फ़ॉर्मेट्स

SafeTensors मॉडल वेट्स को सुरक्षित और कुशलतापूर्वक स्टोर और लोड करने के लिए अच्छा काम करता है, लेकिन इसका मतलब यह नहीं है कि यह हर फ़ॉर्मेट का सार्वभौमिक विकल्प है। सही चुनाव इस पर निर्भर करता है कि आप क्या स्टोर कर रहे हैं और मॉडल पाइपलाइन में कहाँ है।

हम पिक्ल के बारे में काफी बात कर चुके हैं, इसलिए मैं अलग फ़ॉर्मेट्स पर ध्यान केंद्रित करूँगा।

SafeTensors बनाम GGUF

SafeTensors और GGUF अलग समस्याएँ हल करते हैं। 

GGUF, जिसका अर्थ GGML Unified Format है, को llama.cpp जैसे रनटाइम्स में क्वांटाइज़्ड इन्फ़रेंस वर्कलोड्स के लिए बनाया गया था। यह फ़ॉर्मेट विशेष रूप से CPU इन्फ़रेंस और एज डिवाइसों के लिए कंप्रेस्ड मॉडलों की कुशल तैनाती पर केंद्रित है। 

SafeTensors पाइपलाइन में पहले आता है। अधिकांश SafeTensors चेकपॉइंट्स फुल-प्रिसीजन या ट्रेनिंग-रेडी टेंसर स्टोर करते हैं, जिनका उपयोग ट्रेनिंग, फाइन-ट्यूनिंग, मर्जिंग या डिस्ट्रीब्यूटेड इन्फ़रेंस वर्कफ़्लोज़ में होता है। यह फ़ॉर्मेट सुरक्षित लोडिंग, PyTorch जैसे फ्रेमवर्क्स के साथ अनुकूलता, और ट्रेनिंग व सर्विंग के दौरान कुशल टेंसर एक्सेस को प्राथमिकता देता है।

ये एक-दूसरे से सीधे प्रतिस्पर्धा करने के बजाय एक-दूसरे के पूरक हो सकते हैं। उदाहरण वर्कफ़्लो: 

• PyTorch और SafeTensors चेकपॉइंट्स का उपयोग करके मॉडल को ट्रेन या फाइन-ट्यून करें
• अंतिम मॉडल को क्वांटाइज़ करें
• तैनाती के लिए इसे llama.cpp या एज इन्फ़रेंस रनटाइम्स में GGUF में एक्सपोर्ट करें

SafeTensors बनाम ONNX

SafeTensors फ्रेमवर्क्स जैसे PyTorch के अंदर मॉडल वेट्स को सुरक्षित रूप से स्टोर करने और कुशलतापूर्वक लोड करने पर केंद्रित है। यह केवल टेंसर और मेटाडेटा स्टोर करता है, जो इसे चेकपॉइंट शेयरिंग, फाइन-ट्यूनिंग और ट्रेनिंग वर्कफ़्लोज़ के लिए हल्का और तेज़ बनाता है।

ONNX एक व्यापक दृष्टिकोण अपनाता है। यह मॉडल पैरामीटर्स के साथ पूर्ण कम्प्यूटेशन ग्राफ़ को स्टोर करता है। जब आप एक फ्रेमवर्क से मॉडल एक्सपोर्ट करके कहीं और चलाना चाहते हैं, तो ONNX उपयोगी है।

उदाहरण के लिए, टीमें जो PyTorch का उपयोग करके LLMs को ट्रेन और फाइन-ट्यून करती हैं, वे आमतौर पर SafeTensors चेकपॉइंट्स को प्राथमिकता देंगी क्योंकि वे जल्दी लोड होते हैं और मौजूदा वर्कफ़्लोज़ में सीधे एकीकृत हो जाते हैं। लेकिन यदि वही टीम मॉडल को TensorRT, ONNX Runtime या किसी एज इन्फ़रेंस इंजन में तैनात करना चाहती है, तो मॉडल को ONNX में एक्सपोर्ट करना अधिक समझदारी है।

व्यवहार में SafeTensors का उपयोग

SafeTensors के PyTorch इकोसिस्टम में तेजी से फैलने का एक कारण यह है कि API परिचित लगता है। आप अब भी स्टेट डिक्शनरीज़ और टेंसर के साथ वैसे ही काम करते हैं जैसे सामान्यतः करते हैं।

टेंसर सेव और लोड करना

बेसिक वर्कफ़्लो मानक 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. स्टेट डिक्शनरी निकालें
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 इंटरफ़ेस के माध्यम से होस्टेड मॉडलों के लिए बिल्ट-इन चेकपॉइंट कन्वर्ज़न सपोर्ट प्रदान करता है।

सीरियलाइज़ेशन फ़ॉर्मेट्स: तुलना सारणी

2026 में SafeTensors: PyTorch Foundation और आगे की राह

अप्रैल 2026 में, Hugging Face ने SafeTensors को Linux Foundation के अंतर्गत PyTorch Foundation को सौंप दिया। अब यह प्रोजेक्ट PyTorch, vLLM, DeepSpeed और Ray के साथ फाउंडेशन गवर्नेंस के अंतर्गत आता है।

यह कदम संकेत देता है कि SafeTensors अब केवल Hugging Face का प्रोजेक्ट नहीं है। यह ML इकोसिस्टम के लिए साझा अवसंरचना बनता जा रहा है। 

घोषणा में यह भी संकेत है कि आगे यह फ़ॉर्मेट किस दिशा में बढ़ रहा है।

डिवाइस-अवेयर लोडिंग

एक प्रमुख फोकस डिवाइस-अवेयर लोडिंग है। आज, कई वर्कफ़्लोज़ अभी भी टेंसर को CUDA या ROCm डिवाइसों पर ट्रांसफर करने से पहले CPU मेमोरी में लोड करते हैं। यह अतिरिक्त स्टेजिंग स्टेप स्टार्टअप लेटेंसी बढ़ाता है, खासकर बड़े डिस्ट्रीब्यूटेड सिस्टम्स के लिए। 

SafeTensors मेंटेनर्स ऐसे डायरेक्ट डिवाइस लोडिंग पाथ्स पर काम कर रहे हैं जो अनावश्यक CPU कॉपीज़ को कम करें और टेंसर को सीधे एक्सेलेरेटर्स पर ले जाएँ। 

डिस्ट्रीब्यूटेड लोडिंग

डिस्ट्रीब्यूटेड लोडिंग सपोर्ट भी विकसित हो रहा है। आधुनिक इन्फ़रेंस सिस्टम अब शायद ही किसी एकल GPU पर मॉडल चलाते हैं। टेंसर पैरेललिज़्म और पाइपलाइन पैरेललिज़्म बड़े मॉडलों के लिए मानक डिप्लॉयमेंट पैटर्न बन चुके हैं, लेकिन फ्रेमवर्क्स में चेकपॉइंट लोडिंग API अभी भी विखंडित हैं। 

SafeTensors शार्ड-अवेयर लोडिंग और डिस्ट्रीब्यूटेड टेंसर लेआउट्स के लिए सपोर्ट का विस्तार कर रहा है, ताकि फ्रेमवर्क्स डिवाइसेज़ में चेकपॉइंट लोडिंग को अधिक कुशलता से समन्वयित कर सकें। 

आधुनिक क्वांटाइज़ेशन वर्कफ़्लोज़

यह फ़ॉर्मेट नए क्वांटाइज़ेशन वर्कफ़्लोज़ के अनुरूप भी हो रहा है। इन्फ़रेंस सिस्टम मेमोरी उपयोग घटाने और सर्विंग लागत कम करने के लिए FP8, GPTQ और AWQ फ़ॉर्मेट्स पर बढ़ती निर्भरता दिखा रहे हैं। 

फ्रेमवर्क्स को इन्हें कस्टम सीरियलाइज़ेशन लॉजिक के ज़रिए संभालने के लिए मजबूर करने के बजाय, SafeTensors सीधे फ़ॉर्मेट में ही लोअर-प्रिसीजन और ब्लॉक-क्वांटाइज़्ड टेंसर फ़ॉर्मेट्स के लिए औपचारिक सपोर्ट जोड़ रहा है। 

अभी, डेवलपर्स को सेव और लोड वर्कफ़्लोज़ के बीच स्विच करके SafeTensors में मैन्युअली ऑप्ट-इन करना पड़ता है। लेकिन PyTorch के नैटिव सीरियलाइज़ेशन सिस्टम के साथ गहरे एकीकरण पर काम जारी है। यदि वह अंततः आ जाता है, तो SafeTensors एक वैकल्पिक चेकपॉइंट फ़ॉर्मेट होने से आगे बढ़कर PyTorch द्वारा मॉडल स्टोर करने का डिफ़ॉल्ट तरीका बन सकता है।

अंतिम विचार

कई वर्षों तक, डेवलपर्स ऐसे सीरियलाइज़ेशन सिस्टम्स का उपयोग करके मॉडल चेकपॉइंट्स साझा करते रहे जो लोडिंग के दौरान मनमाना Python कोड चला सकते थे। जब सार्वजनिक मॉडल हब्स ने लाखों चेकपॉइंट्स होस्ट करना शुरू किया, तो सुरक्षा जोखिमों को नज़रअंदाज़ करना बहुत कठिन हो गया।

SafeTensors ने फ़ॉर्मेट के दायरे को सीमित करके इसे बदल दिया। संपूर्ण Python ऑब्जेक्ट्स को सीरियलाइज़ करने की कोशिश करने के बजाय, यह केवल टेंसर और उन्हें लोड करने के लिए आवश्यक मेटाडेटा को स्टोर करने पर ध्यान देता है। यह सरल डिज़ाइन पिक्ल-आधारित चेकपॉइंट्स के साथ आने वाले डीसिरियलाइज़ेशन जोखिमों को हटाता है और साथ ही लोडिंग गति और मेमोरी दक्षता में सुधार करता है।

तो जब आपको केवल मॉडल वेट्स की आवश्यकता हो, तब डीसिरियलाइज़ेशन के दौरान मनमाना कोड चलाने का कोई मतलब नहीं है—ऐसे मामलों में SafeTensors का उपयोग करना बेहतर है।

यदि आप आधुनिक ML टूलिंग, मॉडल फ़ॉर्मेट्स और Hugging Face वर्कफ़्लोज़ के साथ गहराई से काम करना चाहते हैं, तो हमारे Deep Learning in Python और Working with Hugging Face कोर्स अच्छे अगले कदम हैं। ये आज के AI इकोसिस्टम में उपयोग किए जाने वाले टूल्स के साथ मॉडल्स को ट्रेन, फाइन-ट्यून और डिप्लॉय करने के व्यावहारिक वर्कफ़्लोज़ को कवर करते हैं।