AI कंप्यूट कनवर्टर

रूपांतरण

FLOPS/TOPS AI कंप्यूट इकाइयों के बीच रूपांतरण। FLOPS और TOPS भिन्न संक्रियाएँ मापते हैं और सीधे रूपांतरणीय नहीं हैं।

100% क्लाइंट-साइड कोई बैकएंड नहीं

FLOPS (फ़्लोटिंग-पॉइंट) और TOPS/OPS (पूर्णांक या मिश्रित) भिन्न संक्रिया प्रकार मापते हैं और सीधे रूपांतरणीय नहीं हैं। दोनों इकाइयाँ एक ही परिवार से चुनें।

मान

से तक

परिणाम —

सभी इकाइयाँ (एक ही परिवार)

इस पृष्ठ पर

AI कंप्यूट इकाई परिवर्तक क्या है?#

AI हार्डवेयर “operations per second” इकाइयों के दो समानांतर परिवारों में बिकता है, और वे परस्पर विनिमेय दिखते हैं किंतु हैं नहीं। FLOPS परिवार (FLOPS, kFLOPS, MFLOPS, GFLOPS, TFLOPS, PFLOPS, EFLOPS, ZFLOPS) प्रति सेकंड फ़्लोटिंग-पॉइंट संक्रियाएँ गिनता है — वैज्ञानिक कंप्यूटिंग, प्रशिक्षण थ्रूपुट और ग्राफ़िक्स के लिए पारंपरिक माप। OPS परिवार (OPS, kOPS, MOPS, GOPS, TOPS, POPS) प्रति सेकंड पूर्णांक या “मिश्रित” संक्रियाएँ गिनता है — वह आँकड़ा जो चिप विक्रेता INT8 अनुमान त्वरकों के लिए देते हैं। एक “100 TOPS” NPU और एक “100 TFLOPS” GPU को एक ही मापदंड से तुलना नहीं किया जा सकता, क्योंकि TOPS “संक्रिया” और FLOPS “संक्रिया” अलग-अलग चीज़ें मापते हैं।

यह पेज प्रत्येक परिवार के भीतर सटीक रूपांतरित करता है (हर इकाई अपने परिवार आधार का एक साफ़ 1000-की-घात गुणज है), और यह किसी अनुपात का आविष्कार करने के बजाय पारिवारिक-रूपांतरणों को अस्वीकार करता है। यह अस्वीकृति ही पूरा मतलब है: कोई भी एकल संख्या जो TFLOPS को TOPS में “रूपांतरित” करती है एक फ़र्जी है, क्योंकि विक्रेता तक यह तय नहीं है कि एक multiply-accumulate एक संक्रिया है या दो।

इसका उपयोग कैसे करें#

वह मान दर्ज करें जिसे आप रूपांतरित करना चाहते हैं।
समूहबद्ध ड्रॉपडाउन से से चुनें — इकाइयाँ दो optgroups, FLOPS और OPS के अंतर्गत सूचीबद्ध हैं, इसलिए परिवार सीमा पिकर में ही दृश्य है।
तक भी इसी तरह चुनें।
परिणाम पढ़ें। यदि दोनों इकाइयाँ एक ही परिवार में हैं तो आपको एक संख्या मिलती है; यदि आप परिवार पार कर गए तो आपको एक बनाई-गई संख्या के बजाय स्पष्ट क्रॉस-परिवार सूचना मिलती है।
सभी इकाइयाँ विस्तृत करें और अपना इनपुट एक ही परिवार की हर इकाई में एक बार में देखें, छह सार्थक अंकों तक राउंड किया गया। दूसरे परिवार की इकाइयाँ छोड़ दी जाती हैं क्योंकि वे रूपांतरणीय नहीं हैं।

मुख्य विशेषताएँ#

दो परिवार, कभी मिलाए नहीं। FLOPS और OPS अलग optgroups के रूप में दिखाए जाते हैं और कभी चुपचाप नहीं मिलाए जाते। एक परिवार के भीतर गणित सटीक है (value × fromFactor ÷ toFactor); परिवारों के बीच टूल इंकार कर देता है।
ईमानदार क्रॉस-परिवार अस्वीकृति। एक TFLOPS-से-TOPS अनुरोध एक स्पष्ट क्रॉस-परिवार त्रुटि लौटाता है, न कि एक प्रशंसनीय-दिखने वाली किंतु अर्थहीन संख्या। यही एक परिवर्तक और एक अनुमान के बीच का अंतर है।
ZFLOPS तक पूर्ण FLOPS श्रेणी। एकल-ops FLOPS से k, M, G, T, P, E और Z (10²¹) तक, एक एम्बेडेड MCU से लेकर एक काल्पनिक एक्सास्केल-से-अधिक सिस्टम तक सब कुछ कवर।
POPS तक पूर्ण OPS श्रेणी। OPS से k, M, G, T, P — वह श्रेणी जो विक्रेता स्पेक शीट वास्तव में INT8 अनुमान दावों के लिए उपयोग करते हैं।
छह-सार्थक-अंक राउंडिंग। परिणाम बाइनरी फ़्लोटिंग-पॉइंट शोर दबाने के लिए एप्सिलॉन सुधार के साथ राउंड किए जाते हैं, इसलिए 1 TFLOPS 999.9999999 के बजाय ठीक 1000 GFLOPS पढ़ा जाता है।
सभी-इकाइयाँ तालिका। एक इनपुट, हर समान-परिवार इकाई एक नज़र में — उपयोगी जब कोई स्पेक शीट TOPS देता है और आप वही थ्रूपुट GOPS और MOPS में भी देखना चाहते हैं।

विस्तृत उदाहरण#

एक GPU स्पेक शीट 1 TFLOPS FP16 थ्रूपुट का दावा करती है। इसे GFLOPS में व्यक्त करने के लिए, मान 1, से TFLOPS, तक GFLOPS सेट करें:

1 TFLOPS = 1000 GFLOPS

सभी इकाइयाँ विस्तृत करें और वही मान पूरा FLOPS परिवार भर देता है:

FLOPS:   1,000,000,000,000
kFLOPS:  1,000,000,000
MFLOPS:  1,000,000
GFLOPS:  1,000
TFLOPS:  1
PFLOPS:  0.001
EFLOPS:  1e-6
ZFLOPS:  1e-9

अब इसकी तुलना किसी TOPS में रेटेड NPU से करने का प्रयास करें: से TFLOPS, तक TOPS सेट करें। परिणाम कोई संख्या नहीं है — यह क्रॉस-परिवार सूचना है। कोई भौतिक रूप से सार्थक रूपांतरण नहीं है, क्योंकि TFLOPS फ़्लोटिंग-पॉइंट संक्रियाएँ मापता है (अपनी परिशुद्धता शब्दार्थ के साथ) और TOPS पूर्णांक/मिश्रित संक्रियाएँ मापता है (आमतौर पर INT8), और एक MAC कुछ विक्रेताओं के लिए एक संक्रिया और अन्य के लिए दो माना जाता है। ईमानदार उत्तर है “वे बिना अधिक जानकारी के तुलनीय नहीं हैं”, और यही टूल लौटाता है।

अक्सर पूछे जाने वाले प्रश्न#

मैं TFLOPS को TOPS में क्यों नहीं रूपांतरित कर सकता?#

क्योंकि वे अलग-अलग चीज़ें गिनते हैं। TFLOPS प्रति सेकंड फ़्लोटिंग-पॉइंट संक्रियाएँ हैं; TOPS प्रति सेकंड पूर्णांक (आमतौर पर INT8) संक्रियाएँ हैं, और दोनों संक्रिया प्रकारों का कोई नियत अनुपात नहीं है — यह चिप के डेटा पथों और इस पर निर्भर करता है कि एक multiply-accumulate एक या दो संक्रियाएँ गिना जाता है। कोई भी एकल रूपांतरण गुणांक एक अनुमान होगा। FLOPS के भीतर, या OPS के भीतर रूपांतरित करें, किंतु दोनों के बीच नहीं।

FLOPS परिवार वास्तव में क्या मापता है?#

प्रति सेकंड फ़्लोटिंग-पॉइंट संक्रियाएँ, जिस भी परिशुद्धता में स्पेक शीट परिभाषित करता है (FP64, FP32, FP16, INT8-as-float…)। निर्णायक रूप से, “1 TFLOPS FP16” और “1 TFLOPS FP32” एक ही काम की मात्रा नहीं हैं — एक चिप की TFLOPS रेटिंग इस बात पर निर्भर करती है कि आप किस परिशुद्धता को देते हैं। हमेशा संख्या के साथ परिशुद्धता पढ़ें; अकेली इकाई पर्याप्त नहीं है।

क्या kFLOPS, MFLOPS, GFLOPS सभी 1000 की घातें हैं?#

हाँ। एक परिवार के भीतर हर कदम ×1000 है: 1 kFLOPS = 1000 FLOPS, 1 MFLOPS = 1000 kFLOPS, 1 GFLOPS = 1000 MFLOPS, और इसी तरह ZFLOPS (10²¹) तक। यहाँ कोई बाइनरी/दशमलव अस्पष्टता नहीं है जैसी KiB बनाम KB के साथ होती है — कंप्यूट इकाइयाँ सार्वभौमिक रूप से दशमलव हैं।

सभी-इकाइयाँ तालिका दूसरे परिवार को क्यों छोड़ती है?#

क्योंकि वे इकाइयाँ आपके मान में रूपांतरणीय नहीं हैं। यदि आपने एक FLOPS मान दर्ज किया, तो तालिका हर FLOPS इकाई दिखाती है; OPS इकाइयाँ बनाई गई संख्याओं के साथ दिखाने के बजाय छोड़ दी जाती हैं। OPS समकक्ष देखने के लिए, अपने मान को एक OPS आँकड़े के रूप में पुनः दर्ज करें (किसी स्पेक शीट से जो वास्तव में OPS देती है) और तालिका OPS कॉलम भर देगी।