फ़्लोटिंग-पॉइंट प्रतिनिधित्व:

एफपी16 (आधा परिशुद्धता): एफपी16 में, एक फ्लोटिंग-पॉइंट संख्या को 16 बिट्स का उपयोग करके दर्शाया जाता है। इसमें 1 साइन बिट, घातांक के लिए 5 बिट और अंश (मेंटिसा) के लिए 10 बिट होते हैं। यह प्रारूप अपनी सीमा के भीतर भिन्नात्मक मानों का प्रतिनिधित्व करने के लिए उच्च परिशुद्धता प्रदान करता है।

बीएफ16 (बीफ्लोट16): बीएफ16 भी 16 बिट्स का उपयोग करता है, लेकिन एक अलग वितरण के साथ। इसमें 1 साइन बिट, एक्सपोनेंट के लिए 8 बिट और मंटिसा के लिए 7 बिट हैं। यह प्रारूप घातांकों की एक विस्तृत श्रृंखला को समायोजित करने के लिए भिन्नात्मक भाग में कुछ परिशुद्धता का त्याग करता है।

संख्यात्मक रेंज:

एफपी16 की रेंज छोटी है लेकिन 10-बिट मंटिसा के कारण उस रेंज के भीतर उच्च परिशुद्धता है।
बीएफ16 की रेंज व्यापक है लेकिन इसके 8-बिट एक्सपोनेंट और 7-बिट मंटिसा के कारण भिन्नात्मक मानों के लिए कम परिशुद्धता है।

उदाहरण:

आइए 3 उदाहरण मामलों के साथ एफपी16 और बीएफ16 के बीच अंतर को स्पष्ट करने के लिए उदाहरणों का उपयोग करें। TensorFlow का उपयोग नीचे साझा किए गए परीक्षण और कोड बनाने के लिए किया जाता है:

मूल मान: 0.0001 - दोनों विधियां प्रतिनिधित्व कर सकती हैं
FP16: 0.00010001659393 (बाइनरी: 0|00001110, हेक्स: 068ई) - 10 मंटिसा और 5 घातांक
बीएफ16: 0.00010013580322 (बाइनरी: 0|01110001|1010010, हेक्स: 38डी2) - 7 मंटिसा और 8 घातांक

जैसा कि आप देख सकते हैं कि उनके पास अलग-अलग घातांक और मंटिसा हैं और इस प्रकार वे अलग-अलग प्रतिनिधित्व करने में सक्षम हैं। लेकिन हम देख सकते हैं कि एफपी16 ने इसे अधिक करीबी मूल्य के साथ अधिक सटीक रूप से दर्शाया है।

मूल मान: 1e-08 (0.0000001)
FP16: 0.000000000000000 (बाइनरी: 0|00000|000000000, हेक्स: 0000)
BF16: 0.00000010011 72 (बाइनरी: 0|01100100| 0101100, हेक्स: 322सी)

यह एक बहुत ही दिलचस्प मामला है। FP16 विफल रहता है और परिणाम 0 बनाता है लेकिन BF16 इसे एक विशेष स्वरूपण के साथ प्रस्तुत करने में सक्षम है।

मूल मूल्य: 100000.00001
FP16: inf (बाइनरी: 0|111111|000000000, हेक्स: 7C00)
BF16: 99840.0000000000 (बाइनरी: 0|100011 11|1000011, हेक्स: 47सी3 )

उपरोक्त मामले में, FP16 विफल रहता है क्योंकि सभी घातांक बिट पूर्ण हो जाते हैं और मूल्य का प्रतिनिधित्व करने के लिए पर्याप्त नहीं होते हैं। हालाँकि BF16 काम करता है

उपयोग मामले:

FP16 का उपयोग आमतौर पर गहन शिक्षण प्रशिक्षण और अनुमान में किया जाता है, विशेष रूप से उन कार्यों के लिए जिनमें एक सीमित सीमा के भीतर छोटे भिन्नात्मक मूल्यों का प्रतिनिधित्व करने में उच्च परिशुद्धता की आवश्यकता होती है।

बीएफ16 मशीन लर्निंग कार्यों के लिए डिज़ाइन किए गए हार्डवेयर आर्किटेक्चर में लोकप्रिय हो रहा है, जो आंशिक भाग में कुछ सटीकता की कीमत पर भी, प्रतिनिधित्व योग्य मूल्यों की एक विस्तृत श्रृंखला से लाभान्वित होता है। यह विशेष रूप से तब उपयोगी होता है जब बड़े ग्रेडिएंट से निपटते समय या जब एक विस्तृत श्रृंखला में संख्यात्मक स्थिरता छोटे मानों की सटीकता से अधिक महत्वपूर्ण होती है।

सारांश

FP16 छोटी सीमा के भीतर भिन्नात्मक मानों के लिए उच्च परिशुद्धता प्रदान करता है, जिससे यह उन कार्यों के लिए उपयुक्त हो जाता है जिनके लिए छोटी संख्याओं के सटीक प्रतिनिधित्व की आवश्यकता होती है। दूसरी ओर, बीएफ16 कुछ परिशुद्धता की कीमत पर एक व्यापक रेंज प्रदान करता है, जिससे यह उन कार्यों के लिए फायदेमंद हो जाता है जिनमें मूल्यों का व्यापक स्पेक्ट्रम शामिल होता है या जहां विस्तृत श्रृंखला में संख्यात्मक स्थिरता महत्वपूर्ण होती है। एफपी16 और बीएफ16 के बीच का चुनाव मशीन सीखने के कार्य की विशिष्ट आवश्यकताओं पर निर्भर करता है।

अंतिम निष्कर्ष

उपरोक्त सभी कारणों से, स्टेबल डिफ्यूजन एक्सएल (एसडीएक्सएल) प्रशिक्षण करते समय, एफपी16 और बीएफ16 को थोड़ी अलग सीखने की दर की आवश्यकता होती है और मुझे लगता है कि बीएफ16 बेहतर काम करता है।

उपरोक्त उदाहरण उत्पन्न करने के लिए प्रयुक्त कोड

import tensorflow as tf
import struct

def float_to_binary(f):
    return ''.join(f'{b:08b}' for b in struct.pack('>f', f))

def display_fp16(value):
    fp16 = tf.cast(tf.constant(value, dtype=tf.float32), tf.float16)
    fp32 = tf.cast(fp16, tf.float32)
    binary = format(int.from_bytes(fp16.numpy().tobytes(), 'big'), '016b')
    sign = binary[0]
    exponent = binary[1:6]
    fraction = binary[6:]
    return f"FP16: {fp32.numpy():14.14f} (Binary: {sign}|{exponent}|{fraction}, Hex: {fp16.numpy().view('uint16'):04X})"

def display_bf16(value):
    bf16 = tf.cast(tf.constant(value, dtype=tf.float32), tf.bfloat16)
    bf32 = tf.cast(bf16, tf.float32)
    binary = format(int.from_bytes(bf16.numpy().tobytes(), 'big'), '016b')
    sign = binary[0]
    exponent = binary[1:9]
    fraction = binary[9:]
    return f"BF16: {bf32.numpy():14.14f} (Binary: {sign}|{exponent}|{fraction}, Hex: {bf16.numpy().view('uint16'):04X})"

values = [0.0001, 0.00000001, 100000.00001]

for value in values:
    print(f"\nOriginal value: {value}")
    print(display_fp16(value))
    print(display_bf16(value))