Bfloat16 फ़्लोटिंग-पॉइंट प्रारूप: Difference between revisions

Revision as of 22:10, 18 July 2023

Bfloat16 (मस्तिष्क फ़्लोटिंग पॉइंट)^[1]^[2] फ़्लोटिंग-पॉइंट प्रारूप एक कंप्यूटर नंबर प्रारूप है जो स्मृति में 16-बिट रखता है; यह तैरनेवाला स्थल का उपयोग करके संख्यात्मक मानों की एक विस्तृत गतिशील श्रृंखला का प्रतिनिधित्व करता है। यह प्रारूप हार्डवेयर एक्सिलरेशन यंत्र अधिगम और बुद्धिमान सेंसर के इरादे से 32-बिट एकल-परिशुद्धता फ़्लोटिंग-पॉइंट प्रारूप Iआईईईई 754 सिंगल-प्रिसिजन फ्लोटिंग-पॉइंट फॉर्मेट (बाइनरी 32) का एक छोटा (16-बिट) संस्करण है। सेंसर कंप्यूटिंग.^[3] यह 8 एक्सपोनेंट पूर्वाग्रह को बनाए रखते हुए 32-बिट फ्लोटिंग-पॉइंट नंबरों की अनुमानित गतिशील रेंज को संरक्षित करता है, लेकिन बाइनरी32 प्रारूप के 24-बिट महत्व के बजाय केवल 8-बिट परिशुद्धता का समर्थन करता है। एकल-परिशुद्धता 32-बिट फ़्लोटिंग-पॉइंट संख्याओं से अधिक, bfloat16 संख्याएँ पूर्णांक गणना के लिए अनुपयुक्त हैं, लेकिन यह उनका इच्छित उपयोग नहीं है। Bfloat16 का उपयोग भंडारण आवश्यकताओं को कम करने और मशीन लर्निंग एल्गोरिदम की गणना गति को बढ़ाने के लिए किया जाता है।^[4]

Bfloat16 प्रारूप गूगल ब्रेन द्वारा विकसित किया गया था, जो गूगल का एक कृत्रिम बुद्धिमत्ता अनुसंधान समूह है। इसका उपयोग Intel AI त्वरक में किया जाता है, जैसे नर्वाना सिस्टम्स NNP-L1000, Xeon प्रोसेसर (AVX-512 BF16 एक्सटेंशन), और Intel FPGAs,^[5]^[6]^[7] गूगल क्लाउड टेन्सर प्रोसेसिंग इकाइयाँ,^[8]^[9]^[10] और TensorFlow।^[10]^[11] ARM आर्किटेक्चर#ARMv8.6-A|ARMv8.6-A, रेफरी>"Armv8-A के लिए BFloat16 एक्सटेंशन". community.arm.com (in English). Retrieved 2019-08-30.</ref> AMD OpenCL#ओपन सोर्स कार्यान्वयन, रेफरी>"आरओसीएम संस्करण इतिहास". github.com (in English). Retrieved 2019-10-23.</ref> सीयूडीए, रेफरी>"CUDA लाइब्रेरी ब्लोट16 इंट्रिनिक्स".</ref> Apple का Apple M2 रेफरी>"AArch64: नए Apple CPUs के लिए समर्थन जोड़ें · llvm/llvm-project@677da09". GitHub (in English). Retrieved 2023-05-08.</ref> और इसलिए Apple A15 चिप्स और बाद में, bfloat16 प्रारूप का भी समर्थन करते हैं। इन प्लेटफार्मों पर, bfloat16 का उपयोग मिश्रित-सटीक अंकगणित में भी किया जा सकता है, जहां bfloat16 संख्याओं को संचालित किया जा सकता है और व्यापक डेटा प्रकारों तक विस्तारित किया जा सकता है।

bfloat16 फ़्लोटिंग-पॉइंट प्रारूप

bfloat16 में निम्नलिखित प्रारूप है:

साइन बिट: 1 बिट
घातांक चौड़ाई: 8 बिट्स
महत्वपूर्ण परिशुद्धता (अंकगणित): 8 बिट्स (7 स्पष्ट रूप से संग्रहीत, एक अंतर्निहित अग्रणी बिट के साथ), शास्त्रीय एकल-परिशुद्धता फ़्लोटिंग-पॉइंट प्रारूप में 24 बिट्स के विपरीत

Bfloat16 प्रारूप, एक छोटा एकल-परिशुद्धता फ़्लोटिंग-पॉइंट प्रारूप है | आईईईई 754 एकल-परिशुद्धता 32-बिट फ़्लोट, आईईईई 754 एकल-परिशुद्धता 32-बिट फ़्लोट से तेज़ प्रकार के रूपांतरण की अनुमति देता है; Bfloat16 प्रारूप में रूपांतरण में, घातांक बिट्स को संरक्षित किया जाता है, जबकि NaN विशेष मामले को अनदेखा करते हुए महत्व क्षेत्र को काट-छाँट (इस प्रकार आईईईई 754#राउंडिंग नियमों के अनुरूप) द्वारा कम किया जा सकता है। प्रतिपादक बिट्स को संरक्षित करने से 32-बिट फ्लोट की रेंज ≈ 10 बनी रहती है⁻³⁸ से ≈ 3 × 10³⁸.^[12]

बिट्स को इस प्रकार रखा गया है:

आईईईई आधा परिशुद्धता 16-बिट फ्लोट
sign		exponent (5 बिट)					fraction (10 बिट)
┃		┌───────┐					┌─────────────────┐
	0	0	1	1	0	0	0	1	0	0	0	0	0	0	0	0
	15	14				10	9									0

आईईईई 754 एकल परिशुद्धता 32-बिट फ्लोट
sign		exponent (8 बिट)								fraction (23 बिट)
┃		┌─────────────┐								┌───────────────────────────────────────────┐
	0	0	1	1	1	1	1	0	0	0	1	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
	31	30							23	22																						0

bfloat16
sign		exponent (8 बिट)								fraction (7 बिट)
┃		┌─────────────┐								┌───────────┐
	0	0	1	1	1	1	1	0	0	0	1	0	0	0	0	0
	15	14							7	6						0

NVidia's TensorFloat
sign		exponent (8 बिट)								fraction (10 बिट)
┃		┌─────────────┐								┌─────────────────┐
	0	0	1	1	1	1	1	0	0	0	1	0	0	0	0	0	0	0	0
	18	17							10	9									0

AMD's fp24 format
sign		exponent (7 बिट)							fraction (16 बिट)
┃		┌───────────┐							┌─────────────────────────────┐
	0	0	1	1	1	1	0	0	0	1	0	0	0	0	0	0	0	0	0	0	0	0	0	0
	23	22						16	15															0

Pixar's PXR24 format
sign		exponent (8 बिट)								fraction (15 बिट)
┃		┌─────────────┐								┌───────────────────────────┐
	0	0	1	1	1	1	0	0	0	1	0	0	0	0	0	0	0	0	0	0	0	0	0	0
	23	22							15	14														0

bfloat16 और एकल परिशुद्धता के साथ तुलना करें

S	E	E	E	E	E	E	E	E	F	F	F	F	F	F	F	f	f	f	f	f	f	f	f	f	f	f	f	f	f	f	f

किंवदंती

S: sign
E: exponent
एफ: अंश (दोनों प्रारूपों में महत्वपूर्ण से पीछे)।
एफ: 32-बिट में अंश (अनुगामी महत्व) एकल परिशुद्धता (तुलनात्मक)

घातांक एन्कोडिंग

Bfloat16 बाइनरी फ्लोटिंग-पॉइंट एक्सपोनेंट को ऑफसेट बाइनरी | ऑफसेट-बाइनरी प्रतिनिधित्व का उपयोग करके एन्कोड किया गया है, जिसमें शून्य ऑफसेट 127 है; आईईईई 754 मानक में प्रतिपादक पूर्वाग्रह के रूप में भी जाना जाता है।

इ_min = 01_H−7F_H = −126
और_max = एफई_H−7F_H = 127
घातांक पूर्वाग्रह = 7F_H = 127

इस प्रकार, ऑफसेट-बाइनरी प्रतिनिधित्व द्वारा परिभाषित वास्तविक प्रतिपादक प्राप्त करने के लिए, 127 के ऑफसेट को प्रतिपादक क्षेत्र के मूल्य से घटाना होगा।

घातांक फ़ील्ड का न्यूनतम और अधिकतम मान (00)_H और एफएफ_H) की विशेष रूप से व्याख्या की जाती है, जैसे आईईईई 754 मानक प्रारूपों में।

प्रतिपादक	महत्व शून्य	सार्थकतथा गैर-शून्य	समीकरण
00_H	zero, −0	असामान्य संख्याएँ	(−1)^{signबिट}×2⁻¹²⁶× 0.significandबिटs
01_H, ..., FE_H	सामान्यीकृत मूल्य		(−1)^{signबिट}×2^{exponentबिटs−127}× 1.significandबिटs
FF_H	±infinity	NaN (शांत, संकेत)

न्यूनतम सकारात्मक सामान्य मान 2 है⁻¹²⁶ ≈ 1.18 × 10⁻³⁸ और न्यूनतम सकारात्मक (असामान्य) मान 2 है⁻¹²⁶⁻⁷ = 2⁻¹³³ ≈9.2 × 10⁻⁴¹.

विशेष मानों का एन्कोडिंग

सकारात्मक और नकारात्मक अनंत

जैसे आईईईई 754 में, सकारात्मक और नकारात्मक अनंत को उनके संबंधित साइन बिट्स के साथ दर्शाया जाता है, सभी 8 एक्सपोनेंट बिट्स सेट (एफएफ)_hex) और सभी महत्वपूर्ण बिट्स शून्य। स्पष्ट रूप से,

val    s_exponent_signcnd
+inf = 0_11111111_0000000
-inf = 1_11111111_0000000

कोई संख्या नहीं

जैसे आईईईई 754 में, NaN मानों को या तो साइन बिट के साथ दर्शाया जाता है, सभी 8 एक्सपोनेंट बिट्स सेट (एफएफ)_hex) और सभी महत्वपूर्ण बिट्स शून्य नहीं हैं। स्पष्ट रूप से,

val    s_exponent_signcnd
+NaN = 0_11111111_klmnopq
-NaN = 1_11111111_klmnopq

जहां k, l, m, n, o, p, या q में से कम से कम एक 1 है। आईईईई 754 की तरह, NaN मान शांत या सिग्नलिंग हो सकते हैं, हालांकि सितंबर 2018 तक bfloat16 NaNs सिग्नलिंग का कोई ज्ञात उपयोग नहीं है।

सीमा और परिशुद्धता

Bfloat16 को 32-बिट सिंगल-प्रिसिजन फ़्लोटिंग-पॉइंट फॉर्मेट | आईईईई 754 सिंगल-प्रिसिजन फ़्लोटिंग-पॉइंट फॉर्मेट (बाइनरी 32) से संख्या सीमा बनाए रखने के लिए डिज़ाइन किया गया है, जबकि परिशुद्धता को 24 बिट्स से घटाकर 8 बिट्स किया गया है। इसका मतलब है कि परिशुद्धता दो और तीन दशमलव अंकों के बीच है, और bfloat16 लगभग 3.4 × 10 तक परिमित मानों का प्रतिनिधित्व कर सकता है³⁸.

उदाहरण

ये उदाहरण फ्लोटिंग-पॉइंट मान के हेक्साडेसिमल और बाइनरी संख्या में बिट प्रतिनिधित्व में दिए गए हैं। इसमें संकेत, (पक्षपातपूर्ण) प्रतिपादक और महत्व शामिल हैं।

3f80 = 0 01111111 0000000 = 1
c000 = 1 10000000 0000000 = −2

7f7f = 0 11111110 1111111 = (2⁸ − 1)×2⁻⁷×2¹²⁷ ≈ 3.38953139 × 10³⁸ (bfloat16 परिशुद्धता में अधिकतम परिमित सकारात्मक मान)
0080 = 0 00000001 000000 = 2⁻¹²⁶ ≈ 1.175494351 × 10⁻³⁸ (bfloat16 परिशुद्धता और एकल-परिशुद्धता फ़्लोटिंग बिंदु में न्यूनतम सामान्यीकृत सकारात्मक मान)

एक सामान्य bfloat16 संख्या का अधिकतम सकारात्मक परिमित मान 3.38953139 × 10 है³⁸, थोड़ा नीचे (2²⁴ − 1)×2⁻²³×2¹²⁷ = 3.402823466 × 10³⁸, एकल परिशुद्धता में दर्शाने योग्य अधिकतम परिमित सकारात्मक मान।

शून्य और अनंत

0000 = 0 00000000 0000000 = 0
8000 = 1 00000000 0000000 = −0

7f80 = 0 11111111 0000000 = अनंत
एफएफ80 = 1 11111111 0000000 = −अनंत

विशेष मान

4049 = 0 100000000 1001001 = 3.140625 ≈ π (पीआई)
3ईएबी = 0 01111101 0101011 = 0.333984375 ≈ 1/3

NaNs

एफएफसी1 = x 11111111 1000001 => qNaN
ff81 = x 11111111 0000001 => sNaN

यह भी देखें

अर्ध-परिशुद्धता फ़्लोटिंग-पॉइंट प्रारूप: 16-बिट फ़्लोट w/1-बिट साइन, 5-बिट एक्सपोनेंट, और 11-बिट महत्व, जैसा कि आईईईई 754 द्वारा परिभाषित किया गया है
आईएसओ/आईईसी 10967, भाषा स्वतंत्र अंकगणित
आदिम डेटा प्रकार
मिनीफ्लोट
गूगल ब्रेन

संदर्भ

↑ Teich, Paul (2018-05-10). "Tearing Apart Google's TPU 3.0 AI Coprocessor". The Next Platform. Retrieved 2020-08-11. Google invented its own internal floating point format called "bfloat" for "brain floating point" (after Google Brain).
↑ Wang, Shibo; Kanwar, Pankaj (2019-08-23). "BFloat16: The secret to high performance on Cloud TPUs". Google Cloud. Retrieved 2020-08-11. This custom floating point format is called "Brain Floating Point Format," or "bfloat16" for short. The name flows from "Google Brain", which is an artificial intelligence research group at Google where the idea for this format was conceived.
↑ Tagliavini, Giuseppe; Mach, Stefan; Rossi, Davide; Marongiu, Andrea; Benin, Luca (2018). "A transprecision floating-point platform for ultra-low power computing". 2018 Design, Automation & Test in Europe Conference & Exhibition (DATE). pp. 1051–1056. arXiv:1711.10374. doi:10.23919/DATE.2018.8342167. ISBN 978-3-9819263-0-9. S2CID 5067903.
↑ Dr. Ian Cutress (2020-03-17). "Intel': Cooper lake Plans: Why is BF16 Important?". Retrieved 2020-05-12. The bfloat16 standard is a targeted way of representing numbers that give the range of a full 32-bit number, but in the data size of a 16-bit number, keeping the accuracy close to zero but being a bit more loose with the accuracy near the limits of the standard. The bfloat16 standard has a lot of uses inside machine learning algorithms, by offering better accuracy of values inside the algorithm while affording double the data in any given dataset (or doubling the speed in those calculation sections).
↑ Khari Johnson (2018-05-23). "इंटेल ने त्वरित एआई प्रशिक्षण के लिए नर्वाना न्यूरल नेट एल-1000 का अनावरण किया". VentureBeat. Retrieved 2018-05-23. ...इंटेल हमारे AI उत्पाद श्रृंखलाओं में bfloat16 समर्थन का विस्तार करेगा, जिसमें Intel Xeon प्रोसेसर और Intel FPGAs शामिल हैं।
↑ Michael Feldman (2018-05-23). "इंटेल ने एआई पोर्टफोलियो के लिए नया रोडमैप पेश किया". TOP500 Supercomputer Sites. Retrieved 2018-05-23. इंटेल ने Xeon और FPGA लाइनों सहित अपने सभी AI उत्पादों में इस प्रारूप का समर्थन करने की योजना बनाई है
↑ Lucian Armasu (2018-05-23). "इंटेल 2019 में अपना पहला न्यूरल नेटवर्क प्रोसेसर स्प्रिंग क्रेस्ट लॉन्च करेगा". Tom's Hardware. Retrieved 2018-05-23. इंटेल ने कहा कि एनएनपी-एल1000 बीफ्लोट16 को भी सपोर्ट करेगा, जो एक संख्यात्मक प्रारूप है जिसे तंत्रिका नेटवर्क के लिए सभी एमएल उद्योग खिलाड़ियों द्वारा अपनाया जा रहा है। कंपनी अपने FPGAs, Xeons और अन्य ML उत्पादों में bfloat16 का भी समर्थन करेगी। नर्वाना एनएनपी-एल1000 2019 में रिलीज के लिए निर्धारित है।
↑ "उपलब्ध TensorFlow ऑप्स | क्लाउड TPU | Google क्लाउड". Google Cloud. Retrieved 2018-05-23. यह पृष्ठ क्लाउड टीपीयू पर उपलब्ध टेन्सरफ्लो पायथन एपीआई और ग्राफ़ ऑपरेटरों को सूचीबद्ध करता है।
↑ Elmar Haußmann (2018-04-26). "ResNet-50 पर Google के TPUv2 की Nvidia के V100 से तुलना करना". RiseML Blog. Archived from the original on 2018-04-26. Retrieved 2018-05-23. क्लाउड टीपीयू के लिए, Google ने अनुशंसा की है कि हम TensorFlow 1.7.0 के साथ आधिकारिक TPU रिपॉजिटरी से bfloat16 कार्यान्वयन का उपयोग करें। टीपीयू और जीपीयू दोनों कार्यान्वयन संबंधित आर्किटेक्चर पर मिश्रित-सटीक गणना का उपयोग करते हैं और अधिकांश टेंसर को आधी-सटीकता के साथ संग्रहीत करते हैं।
↑ ^10.0 ^10.1 Tensorflow Authors (2018-07-23). "ResNet-50 TPU पर BFloat16 का उपयोग कर रहा है". Google. Retrieved 2018-11-06.
↑ Joshua V. Dillon, Ian Langmore, Dustin Tran, Eugene Brevdo, Srinivas Vasudevan, Dave Moore, Brian Patton, Alex Alemi, Matt Hoffman, Rif A. Saurous (2017-11-28). टेंसरफ़्लो वितरण (Report). arXiv:1711.10604. Bibcode:2017arXiv171110604D. Accessed 2018-05-23. All operations in टेंसरफ़्लो वितरणare numerically stable across half, single, and double floating-point precisions (as TensorFlow dtypes: tf.bfloat16 (truncated floating point), tf.float16, tf.float32, tf.float64). Class constructors have a validate_args flag for numerical asserts{{cite report}}: CS1 maint: multiple names: authors list (link)
↑ "Livestream Day 1: Stage 8 (Google I/O '18) - YouTube". Google. 2018-05-08. Retrieved 2018-05-23. In many models this is a drop-in replacement for float-32

[1] Teich, Paul (2018-05-10). "Tearing Apart Google's TPU 3.0 AI Coprocessor". The Next Platform. Retrieved 2020-08-11. Google invented its own internal floating point format called "bfloat" for "brain floating point" (after Google Brain).

[2] Wang, Shibo; Kanwar, Pankaj (2019-08-23). "BFloat16: The secret to high performance on Cloud TPUs". Google Cloud. Retrieved 2020-08-11. This custom floating point format is called "Brain Floating Point Format," or "bfloat16" for short. The name flows from "Google Brain", which is an artificial intelligence research group at Google where the idea for this format was conceived.

[3] Tagliavini, Giuseppe; Mach, Stefan; Rossi, Davide; Marongiu, Andrea; Benin, Luca (2018). "A transprecision floating-point platform for ultra-low power computing". 2018 Design, Automation & Test in Europe Conference & Exhibition (DATE). pp. 1051–1056. arXiv:1711.10374. doi:10.23919/DATE.2018.8342167. ISBN 978-3-9819263-0-9. S2CID 5067903.

[Why-4] Dr. Ian Cutress (2020-03-17). "Intel': Cooper lake Plans: Why is BF16 Important?". Retrieved 2020-05-12. The bfloat16 standard is a targeted way of representing numbers that give the range of a full 32-bit number, but in the data size of a 16-bit number, keeping the accuracy close to zero but being a bit more loose with the accuracy near the limits of the standard. The bfloat16 standard has a lot of uses inside machine learning algorithms, by offering better accuracy of values inside the algorithm while affording double the data in any given dataset (or doubling the speed in those calculation sections).

[vent_Inte-5] Khari Johnson (2018-05-23). "इंटेल ने त्वरित एआई प्रशिक्षण के लिए नर्वाना न्यूरल नेट एल-1000 का अनावरण किया". VentureBeat. Retrieved 2018-05-23. ...इंटेल हमारे AI उत्पाद श्रृंखलाओं में bfloat16 समर्थन का विस्तार करेगा, जिसमें Intel Xeon प्रोसेसर और Intel FPGAs शामिल हैं।

[top5_Inte-6] Michael Feldman (2018-05-23). "इंटेल ने एआई पोर्टफोलियो के लिए नया रोडमैप पेश किया". TOP500 Supercomputer Sites. Retrieved 2018-05-23. इंटेल ने Xeon और FPGA लाइनों सहित अपने सभी AI उत्पादों में इस प्रारूप का समर्थन करने की योजना बनाई है

[toms_Inte-7] Lucian Armasu (2018-05-23). "इंटेल 2019 में अपना पहला न्यूरल नेटवर्क प्रोसेसर स्प्रिंग क्रेस्ट लॉन्च करेगा". Tom's Hardware. Retrieved 2018-05-23. इंटेल ने कहा कि एनएनपी-एल1000 बीफ्लोट16 को भी सपोर्ट करेगा, जो एक संख्यात्मक प्रारूप है जिसे तंत्रिका नेटवर्क के लिए सभी एमएल उद्योग खिलाड़ियों द्वारा अपनाया जा रहा है। कंपनी अपने FPGAs, Xeons और अन्य ML उत्पादों में bfloat16 का भी समर्थन करेगी। नर्वाना एनएनपी-एल1000 2019 में रिलीज के लिए निर्धारित है।

[clou_Avai-8] "उपलब्ध TensorFlow ऑप्स | क्लाउड TPU | Google क्लाउड". Google Cloud. Retrieved 2018-05-23. यह पृष्ठ क्लाउड टीपीयू पर उपलब्ध टेन्सरफ्लो पायथन एपीआई और ग्राफ़ ऑपरेटरों को सूचीबद्ध करता है।

[blog_Comp-9] Elmar Haußmann (2018-04-26). "ResNet-50 पर Google के TPUv2 की Nvidia के V100 से तुलना करना". RiseML Blog. Archived from the original on 2018-04-26. Retrieved 2018-05-23. क्लाउड टीपीयू के लिए, Google ने अनुशंसा की है कि हम TensorFlow 1.7.0 के साथ आधिकारिक TPU रिपॉजिटरी से bfloat16 कार्यान्वयन का उपयोग करें। टीपीयू और जीपीयू दोनों कार्यान्वयन संबंधित आर्किटेक्चर पर मिश्रित-सटीक गणना का उपयोग करते हैं और अधिकांश टेंसर को आधी-सटीकता के साथ संग्रहीत करते हैं।

[gith_tens-10] 10.0 ^10.1 Tensorflow Authors (2018-07-23). "ResNet-50 TPU पर BFloat16 का उपयोग कर रहा है". Google. Retrieved 2018-11-06.

[arxiv_1711.10604-11] Joshua V. Dillon, Ian Langmore, Dustin Tran, Eugene Brevdo, Srinivas Vasudevan, Dave Moore, Brian Patton, Alex Alemi, Matt Hoffman, Rif A. Saurous (2017-11-28). टेंसरफ़्लो वितरण (Report). arXiv:1711.10604. Bibcode:2017arXiv171110604D. Accessed 2018-05-23. All operations in टेंसरफ़्लो वितरणare numerically stable across half, single, and double floating-point precisions (as TensorFlow dtypes: tf.bfloat16 (truncated floating point), tf.float16, tf.float32, tf.float64). Class constructors have a validate_args flag for numerical asserts{{cite report}}: CS1 maint: multiple names: authors list (link)

[googleio18-day1-time2575-12] "Livestream Day 1: Stage 8 (Google I/O '18) - YouTube". Google. 2018-05-08. Retrieved 2018-05-23. In many models this is a drop-in replacement for float-32

[1]

[2]

[3]

[4]

[5]

[6]

[7]

[8]

[9]

[10]

[11]

[12]

@@ Line 1: / Line 1: @@
-{{Confuse|text = [[Half-precision floating-point format|binary16]], a different 16-bit floating-point format}}
+{{Confuse|text = [[अर्ध-परिशुद्धता फ़्लोटिंग-पॉइंट प्रारूप|बाइनरी16]], एक अलग 16-बिट फ़्लोटिंग-पॉइंट प्रारूप}}
 {{Short description|Floating-point number format used in computer processors}}
-{{lowercase title}}
 {{Floating-point}}
-Bfloat16 (मस्तिष्क फ़्लोटिंग पॉइंट)<ref>{{cite web |url=https://www.nextplatform.com/2018/05/10/tearing-apart-googles-tpu-3-0-ai-coprocessor/ |title=Tearing Apart Google's TPU 3.0 AI Coprocessor |last=Teich |first=Paul |date=2018-05-10 |website=The Next Platform |access-date=2020-08-11 |quote=Google invented its own internal floating point format called “bfloat” for “brain floating point” (after Google Brain).}}</ref><ref>{{cite web |url=https://cloud.google.com/blog/products/ai-machine-learning/bfloat16-the-secret-to-high-performance-on-cloud-tpus |title=BFloat16: The secret to high performance on Cloud TPUs |last1=Wang |first1=Shibo |last2=Kanwar |first2=Pankaj |date=2019-08-23 |website=Google Cloud |access-date=2020-08-11 |quote=This custom floating point format is called “Brain Floating Point Format,” or “bfloat16” for short. The name flows from “Google Brain”, which is an artificial intelligence research group at Google where the idea for this format was conceived.}}</ref> फ़्लोटिंग-पॉइंट प्रारूप एक [[कंप्यूटर नंबर प्रारूप]] है जो [[ स्मृति ]] में [[16-बिट]] रखता है; यह [[तैरनेवाला स्थल]] का उपयोग करके संख्यात्मक मानों की एक विस्तृत गतिशील श्रृंखला का प्रतिनिधित्व करता है। यह प्रारूप [[ हार्डवेयर एक्सिलरेशन ]] [[ यंत्र अधिगम ]] और [[ बुद्धिमान सेंसर ]] के इरादे से 32-बिट [[ एकल-परिशुद्धता फ़्लोटिंग-पॉइंट प्रारूप ]] IIEEE 754 सिंगल-प्रिसिजन फ्लोटिंग-पॉइंट फॉर्मेट (बाइनरी 32) का एक छोटा (16-बिट) संस्करण है। सेंसर कंप्यूटिंग.<ref>{{Cite book |doi=10.23919/DATE.2018.8342167|chapter=A transprecision floating-point platform for ultra-low power computing|title=2018 Design, Automation & Test in Europe Conference & Exhibition (DATE)|pages=1051–1056|year=2018|last1=Tagliavini|first1=Giuseppe|last2=Mach|first2=Stefan|last3=Rossi|first3=Davide|last4=Marongiu|first4=Andrea|last5=Benin|first5=Luca|isbn=978-3-9819263-0-9|arxiv=1711.10374|s2cid=5067903}}</ref> यह 8 एक्सपोनेंट पूर्वाग्रह को बनाए रखते हुए 32-बिट फ्लोटिंग-पॉइंट नंबरों की अनुमानित गतिशील रेंज को संरक्षित करता है, लेकिन बाइनरी32 प्रारूप के 24-बिट [[महत्व]] के बजाय केवल 8-बिट परिशुद्धता का समर्थन करता है। एकल-परिशुद्धता 32-बिट फ़्लोटिंग-पॉइंट संख्याओं से अधिक, bfloat16 संख्याएँ पूर्णांक गणना के लिए अनुपयुक्त हैं, लेकिन यह उनका इच्छित उपयोग नहीं है। Bfloat16 का उपयोग भंडारण आवश्यकताओं को कम करने और मशीन लर्निंग एल्गोरिदम की गणना गति को बढ़ाने के लिए किया जाता है।<ref name="Why">{{Cite web | title = Intel': Cooper lake Plans: Why is BF16 Important? | author = Dr. Ian Cutress | date = 2020-03-17 | access-date = 2020-05-12 | url = https://www.anandtech.com/show/15631/intels-cooper-lake-plans-the-chip-that-wasnt-meant-to-exist-dies-for-you | quote = The bfloat16 standard is a targeted way of representing numbers that give the range of a full 32-bit number, but in the data size of a 16-bit number, keeping the accuracy close to zero but being a bit more loose with the accuracy near the limits of the standard. The bfloat16 standard has a lot of uses inside machine learning algorithms, by offering better accuracy of values inside the algorithm while affording double the data in any given dataset (or doubling the speed in those calculation sections). }}</ref>
+Bfloat16 (मस्तिष्क फ़्लोटिंग पॉइंट)<ref>{{cite web |url=https://www.nextplatform.com/2018/05/10/tearing-apart-googles-tpu-3-0-ai-coprocessor/ |title=Tearing Apart Google's TPU 3.0 AI Coprocessor |last=Teich |first=Paul |date=2018-05-10 |website=The Next Platform |access-date=2020-08-11 |quote=Google invented its own internal floating point format called “bfloat” for “brain floating point” (after Google Brain).}}</ref><ref>{{cite web |url=https://cloud.google.com/blog/products/ai-machine-learning/bfloat16-the-secret-to-high-performance-on-cloud-tpus |title=BFloat16: The secret to high performance on Cloud TPUs |last1=Wang |first1=Shibo |last2=Kanwar |first2=Pankaj |date=2019-08-23 |website=Google Cloud |access-date=2020-08-11 |quote=This custom floating point format is called “Brain Floating Point Format,” or “bfloat16” for short. The name flows from “Google Brain”, which is an artificial intelligence research group at Google where the idea for this format was conceived.}}</ref> '''फ़्लोटिंग-पॉइंट प्रारूप''' एक [[कंप्यूटर नंबर प्रारूप]] है जो [[ स्मृति ]] में [[16-बिट]] रखता है; यह [[तैरनेवाला स्थल]] का उपयोग करके संख्यात्मक मानों की एक विस्तृत गतिशील श्रृंखला का प्रतिनिधित्व करता है। यह प्रारूप [[ हार्डवेयर एक्सिलरेशन ]] [[ यंत्र अधिगम ]] और [[ बुद्धिमान सेंसर ]] के इरादे से 32-बिट [[ एकल-परिशुद्धता फ़्लोटिंग-पॉइंट प्रारूप ]] Iआईईईई 754 सिंगल-प्रिसिजन फ्लोटिंग-पॉइंट फॉर्मेट (बाइनरी 32) का एक छोटा (16-बिट) संस्करण है। सेंसर कंप्यूटिंग.<ref>{{Cite book |doi=10.23919/DATE.2018.8342167|chapter=A transprecision floating-point platform for ultra-low power computing|title=2018 Design, Automation & Test in Europe Conference & Exhibition (DATE)|pages=1051–1056|year=2018|last1=Tagliavini|first1=Giuseppe|last2=Mach|first2=Stefan|last3=Rossi|first3=Davide|last4=Marongiu|first4=Andrea|last5=Benin|first5=Luca|isbn=978-3-9819263-0-9|arxiv=1711.10374|s2cid=5067903}}</ref> यह 8 एक्सपोनेंट पूर्वाग्रह को बनाए रखते हुए 32-बिट फ्लोटिंग-पॉइंट नंबरों की अनुमानित गतिशील रेंज को संरक्षित करता है, लेकिन बाइनरी32 प्रारूप के 24-बिट [[महत्व]] के बजाय केवल 8-बिट परिशुद्धता का समर्थन करता है। एकल-परिशुद्धता 32-बिट फ़्लोटिंग-पॉइंट संख्याओं से अधिक, bfloat16 संख्याएँ पूर्णांक गणना के लिए अनुपयुक्त हैं, लेकिन यह उनका इच्छित उपयोग नहीं है। Bfloat16 का उपयोग भंडारण आवश्यकताओं को कम करने और मशीन लर्निंग एल्गोरिदम की गणना गति को बढ़ाने के लिए किया जाता है।<ref name="Why">{{Cite web | title = Intel': Cooper lake Plans: Why is BF16 Important? | author = Dr. Ian Cutress | date = 2020-03-17 | access-date = 2020-05-12 | url = https://www.anandtech.com/show/15631/intels-cooper-lake-plans-the-chip-that-wasnt-meant-to-exist-dies-for-you | quote = The bfloat16 standard is a targeted way of representing numbers that give the range of a full 32-bit number, but in the data size of a 16-bit number, keeping the accuracy close to zero but being a bit more loose with the accuracy near the limits of the standard. The bfloat16 standard has a lot of uses inside machine learning algorithms, by offering better accuracy of values inside the algorithm while affording double the data in any given dataset (or doubling the speed in those calculation sections). }}</ref>
-Bfloat16 प्रारूप Google ब्रेन द्वारा विकसित किया गया था, जो Google का एक कृत्रिम बुद्धिमत्ता अनुसंधान समूह है। इसका उपयोग Intel AI त्वरक में किया जाता है, जैसे [[Nervana Systems]] NNP-L1000, [[Xeon]] प्रोसेसर ([[AVX-512]] BF16 एक्सटेंशन), और Intel [[FPGA]]s,<ref name="vent_Inte">{{Cite web | title = इंटेल ने त्वरित एआई प्रशिक्षण के लिए नर्वाना न्यूरल नेट एल-1000 का अनावरण किया| author = Khari Johnson | work = VentureBeat | date = 2018-05-23 | access-date = 2018-05-23 | url = https://venturebeat.com/2018/05/23/intel-unveils-nervana-neural-net-l-1000-for-accelerated-ai-training/ |quote = ...इंटेल हमारे AI उत्पाद श्रृंखलाओं में bfloat16 समर्थन का विस्तार करेगा, जिसमें Intel Xeon प्रोसेसर और Intel FPGAs शामिल हैं।}}</ref><ref name="top5_Inte">{{Cite web | title = इंटेल ने एआई पोर्टफोलियो के लिए नया रोडमैप पेश किया| author = Michael Feldman | work = TOP500 Supercomputer Sites | date = 2018-05-23 | access-date = 2018-05-23 | url = https://www.top500.org/news/intel-lays-out-new-roadmap-for-ai-portfolio/ | quote = इंटेल ने Xeon और FPGA लाइनों सहित अपने सभी AI उत्पादों में इस प्रारूप का समर्थन करने की योजना बनाई है}}</ref><ref name="toms_Inte">{{Cite web | title = इंटेल 2019 में अपना पहला न्यूरल नेटवर्क प्रोसेसर स्प्रिंग क्रेस्ट लॉन्च करेगा| author = Lucian Armasu | work = Tom's Hardware | date = 2018-05-23 | access-date = 2018-05-23 | url = https://www.tomshardware.com/news/intel-neural-network-processor-lake-crest,37105.html | quote = इंटेल ने कहा कि एनएनपी-एल1000 बीफ्लोट16 को भी सपोर्ट करेगा, जो एक संख्यात्मक प्रारूप है जिसे तंत्रिका नेटवर्क के लिए सभी एमएल उद्योग खिलाड़ियों द्वारा अपनाया जा रहा है। कंपनी अपने FPGAs, Xeons और अन्य ML उत्पादों में bfloat16 का भी समर्थन करेगी। नर्वाना एनएनपी-एल1000 2019 में रिलीज के लिए निर्धारित है।}}</ref> Google क्लाउड टेन्सर प्रोसेसिंग इकाइयाँ,<ref name="clou_Avai">{{Cite web | title = उपलब्ध TensorFlow ऑप्स {{!}} क्लाउड TPU {{!}} Google क्लाउड| work = Google Cloud | access-date = 2018-05-23 | url = https://cloud.google.com/tpu/docs/tensorflow-ops | quote = यह पृष्ठ क्लाउड टीपीयू पर उपलब्ध टेन्सरफ्लो पायथन एपीआई और ग्राफ़ ऑपरेटरों को सूचीबद्ध करता है।}}</ref><ref name="blog_Comp">{{Cite web | title = ResNet-50 पर Google के TPUv2 की Nvidia के V100 से तुलना करना| author = Elmar Haußmann | work = RiseML Blog | date = 2018-04-26 | access-date = 2018-05-23 | url = https://blog.riseml.com/comparing-google-tpuv2-against-nvidia-v100-on-resnet-50-c2bbb6a51e5e | quote = क्लाउड टीपीयू के लिए, Google ने अनुशंसा की है कि हम TensorFlow 1.7.0 के साथ आधिकारिक TPU रिपॉजिटरी से bfloat16 कार्यान्वयन का उपयोग करें। टीपीयू और जीपीयू दोनों कार्यान्वयन संबंधित आर्किटेक्चर पर मिश्रित-सटीक गणना का उपयोग करते हैं और अधिकांश टेंसर को आधी-सटीकता के साथ संग्रहीत करते हैं।| archive-url = https://web.archive.org/web/20180426200043/https://blog.riseml.com/comparing-google-tpuv2-against-nvidia-v100-on-resnet-50-c2bbb6a51e5e | archive-date = 2018-04-26 | url-status = dead }}</ref><ref name="gith_tens">{{Cite web | title = ResNet-50 TPU पर BFloat16 का उपयोग कर रहा है| author = Tensorflow Authors | work = Google | date = 2018-07-23 | access-date = 2018-11-06 | url = https://github.com/tensorflow/tpu/tree/0ece10f6f4e523eab79aba0247b513fe57d38ae6/models/experimental/resnet_bfloat16 }}</ref> और [[TensorFlow]]।<ref name="gith_tens"/><ref name="arxiv_1711.10604">{{cite report |title= टेंसरफ़्लो वितरण|author= Joshua V. Dillon, Ian Langmore, Dustin Tran, Eugene Brevdo, Srinivas Vasudevan, Dave Moore, Brian Patton, Alex Alemi, Matt Hoffman, Rif A. Saurous |date= 2017-11-28 |id= Accessed 2018-05-23 |arxiv= 1711.10604 |quote= All operations in टेंसरफ़्लो वितरणare numerically stable across half, single, and double floating-point precisions (as TensorFlow dtypes: tf.bfloat16 (truncated floating point), tf.float16, tf.float32, tf.float64). Class constructors have a validate_args flag for numerical asserts |bibcode= 2017arXiv171110604D }}</ref> ARM आर्किटेक्चर#ARMv8.6-A|ARMv8.6-A, रेफरी>{{Cite web|url=https://community.arm.com/developer/ip-products/processors/b/ml-ip-blog/posts/bfloat16-processing-for-neural-networks-on-armv8_2d00_a|title=Armv8-A के लिए BFloat16 एक्सटेंशन|website=community.arm.com|language=en|access-date=2019-08-30}}</ref> [[AMD]] OpenCL#ओपन सोर्स कार्यान्वयन, रेफरी>{{Cite web|url=https://github.com/RadeonOpenCompute/ROCm/blob/8bd9a527405cb466d45b3b343a33434e79b1d387/version_history.md#miopen-20|title=आरओसीएम संस्करण इतिहास|website=github.com|language=en|access-date=2019-10-23}}</ref> सीयूडीए, रेफरी>{{Cite web| url=https://docs.nvidia.com/cuda/cuda-math-api/group__CUDA__MATH__INTRINSIC__BFLOAT16.html#group__CUDA__MATH__INTRINSIC__BFLOAT16|title=CUDA लाइब्रेरी ब्लोट16 इंट्रिनिक्स}}</ref> Apple का [[Apple M2]] रेफरी>{{Cite web |title=AArch64: नए Apple CPUs के लिए समर्थन जोड़ें · llvm/llvm-project@677da09|url=https://github.com/llvm/llvm-project/commit/677da09d0259d7530d32e85cb561bee15f0066e2 |access-date=2023-05-08 |website=GitHub |language=en}}</ref> और इसलिए [[Apple A15]] चिप्स और बाद में, bfloat16 प्रारूप का भी समर्थन करते हैं। इन प्लेटफार्मों पर, bfloat16 का उपयोग मिश्रित-सटीक अंकगणित में भी किया जा सकता है, जहां bfloat16 संख्याओं को संचालित किया जा सकता है और व्यापक डेटा प्रकारों तक विस्तारित किया जा सकता है।
+Bfloat16 प्रारूप गूगल ब्रेन द्वारा विकसित किया गया था, जो गूगल का एक कृत्रिम बुद्धिमत्ता अनुसंधान समूह है। इसका उपयोग Intel AI त्वरक में किया जाता है, जैसे [[Nervana Systems|नर्वाना सिस्टम्स]] NNP-L1000, [[Xeon]] प्रोसेसर ([[AVX-512]] BF16 एक्सटेंशन), और Intel [[FPGA]]s,<ref name="vent_Inte">{{Cite web | title = इंटेल ने त्वरित एआई प्रशिक्षण के लिए नर्वाना न्यूरल नेट एल-1000 का अनावरण किया| author = Khari Johnson | work = VentureBeat | date = 2018-05-23 | access-date = 2018-05-23 | url = https://venturebeat.com/2018/05/23/intel-unveils-nervana-neural-net-l-1000-for-accelerated-ai-training/ |quote = ...इंटेल हमारे AI उत्पाद श्रृंखलाओं में bfloat16 समर्थन का विस्तार करेगा, जिसमें Intel Xeon प्रोसेसर और Intel FPGAs शामिल हैं।}}</ref><ref name="top5_Inte">{{Cite web | title = इंटेल ने एआई पोर्टफोलियो के लिए नया रोडमैप पेश किया| author = Michael Feldman | work = TOP500 Supercomputer Sites | date = 2018-05-23 | access-date = 2018-05-23 | url = https://www.top500.org/news/intel-lays-out-new-roadmap-for-ai-portfolio/ | quote = इंटेल ने Xeon और FPGA लाइनों सहित अपने सभी AI उत्पादों में इस प्रारूप का समर्थन करने की योजना बनाई है}}</ref><ref name="toms_Inte">{{Cite web | title = इंटेल 2019 में अपना पहला न्यूरल नेटवर्क प्रोसेसर स्प्रिंग क्रेस्ट लॉन्च करेगा| author = Lucian Armasu | work = Tom's Hardware | date = 2018-05-23 | access-date = 2018-05-23 | url = https://www.tomshardware.com/news/intel-neural-network-processor-lake-crest,37105.html | quote = इंटेल ने कहा कि एनएनपी-एल1000 बीफ्लोट16 को भी सपोर्ट करेगा, जो एक संख्यात्मक प्रारूप है जिसे तंत्रिका नेटवर्क के लिए सभी एमएल उद्योग खिलाड़ियों द्वारा अपनाया जा रहा है। कंपनी अपने FPGAs, Xeons और अन्य ML उत्पादों में bfloat16 का भी समर्थन करेगी। नर्वाना एनएनपी-एल1000 2019 में रिलीज के लिए निर्धारित है।}}</ref> गूगल क्लाउड टेन्सर प्रोसेसिंग इकाइयाँ,<ref name="clou_Avai">{{Cite web | title = उपलब्ध TensorFlow ऑप्स {{!}} क्लाउड TPU {{!}} Google क्लाउड| work = Google Cloud | access-date = 2018-05-23 | url = https://cloud.google.com/tpu/docs/tensorflow-ops | quote = यह पृष्ठ क्लाउड टीपीयू पर उपलब्ध टेन्सरफ्लो पायथन एपीआई और ग्राफ़ ऑपरेटरों को सूचीबद्ध करता है।}}</ref><ref name="blog_Comp">{{Cite web | title = ResNet-50 पर Google के TPUv2 की Nvidia के V100 से तुलना करना| author = Elmar Haußmann | work = RiseML Blog | date = 2018-04-26 | access-date = 2018-05-23 | url = https://blog.riseml.com/comparing-google-tpuv2-against-nvidia-v100-on-resnet-50-c2bbb6a51e5e | quote = क्लाउड टीपीयू के लिए, Google ने अनुशंसा की है कि हम TensorFlow 1.7.0 के साथ आधिकारिक TPU रिपॉजिटरी से bfloat16 कार्यान्वयन का उपयोग करें। टीपीयू और जीपीयू दोनों कार्यान्वयन संबंधित आर्किटेक्चर पर मिश्रित-सटीक गणना का उपयोग करते हैं और अधिकांश टेंसर को आधी-सटीकता के साथ संग्रहीत करते हैं।| archive-url = https://web.archive.org/web/20180426200043/https://blog.riseml.com/comparing-google-tpuv2-against-nvidia-v100-on-resnet-50-c2bbb6a51e5e | archive-date = 2018-04-26 | url-status = dead }}</ref><ref name="gith_tens">{{Cite web | title = ResNet-50 TPU पर BFloat16 का उपयोग कर रहा है| author = Tensorflow Authors | work = Google | date = 2018-07-23 | access-date = 2018-11-06 | url = https://github.com/tensorflow/tpu/tree/0ece10f6f4e523eab79aba0247b513fe57d38ae6/models/experimental/resnet_bfloat16 }}</ref> और [[TensorFlow]]।<ref name="gith_tens" /><ref name="arxiv_1711.10604">{{cite report |title= टेंसरफ़्लो वितरण|author= Joshua V. Dillon, Ian Langmore, Dustin Tran, Eugene Brevdo, Srinivas Vasudevan, Dave Moore, Brian Patton, Alex Alemi, Matt Hoffman, Rif A. Saurous |date= 2017-11-28 |id= Accessed 2018-05-23 |arxiv= 1711.10604 |quote= All operations in टेंसरफ़्लो वितरणare numerically stable across half, single, and double floating-point precisions (as TensorFlow dtypes: tf.bfloat16 (truncated floating point), tf.float16, tf.float32, tf.float64). Class constructors have a validate_args flag for numerical asserts |bibcode= 2017arXiv171110604D }}</ref> ARM आर्किटेक्चर#ARMv8.6-A|ARMv8.6-A, रेफरी>{{Cite web|url=https://community.arm.com/developer/ip-products/processors/b/ml-ip-blog/posts/bfloat16-processing-for-neural-networks-on-armv8_2d00_a|title=Armv8-A के लिए BFloat16 एक्सटेंशन|website=community.arm.com|language=en|access-date=2019-08-30}}<nowiki></ref></nowiki> [[AMD]] OpenCL#ओपन सोर्स कार्यान्वयन, रेफरी>{{Cite web|url=https://github.com/RadeonOpenCompute/ROCm/blob/8bd9a527405cb466d45b3b343a33434e79b1d387/version_history.md#miopen-20|title=आरओसीएम संस्करण इतिहास|website=github.com|language=en|access-date=2019-10-23}}<nowiki></ref></nowiki> सीयूडीए, रेफरी>{{Cite web| url=https://docs.nvidia.com/cuda/cuda-math-api/group__CUDA__MATH__INTRINSIC__BFLOAT16.html#group__CUDA__MATH__INTRINSIC__BFLOAT16|title=CUDA लाइब्रेरी ब्लोट16 इंट्रिनिक्स}}<nowiki></ref></nowiki> Apple का [[Apple M2]] रेफरी>{{Cite web |title=AArch64: नए Apple CPUs के लिए समर्थन जोड़ें · llvm/llvm-project@677da09|url=https://github.com/llvm/llvm-project/commit/677da09d0259d7530d32e85cb561bee15f0066e2 |access-date=2023-05-08 |website=GitHub |language=en}}<nowiki></ref></nowiki> और इसलिए [[Apple A15]] चिप्स और बाद में, bfloat16 प्रारूप का भी समर्थन करते हैं। इन प्लेटफार्मों पर, bfloat16 का उपयोग मिश्रित-सटीक अंकगणित में भी किया जा सकता है, जहां bfloat16 संख्याओं को संचालित किया जा सकता है और व्यापक डेटा प्रकारों तक विस्तारित किया जा सकता है।
 == bfloat16 फ़्लोटिंग-पॉइंट प्रारूप ==
@@ Line 14: / Line 15: @@
 * महत्वपूर्ण [[परिशुद्धता (अंकगणित)]]: 8 बिट्स (7 स्पष्ट रूप से संग्रहीत, एक [[अंतर्निहित अग्रणी बिट]] के साथ), शास्त्रीय एकल-परिशुद्धता फ़्लोटिंग-पॉइंट प्रारूप में 24 बिट्स के विपरीत
-Bfloat16 प्रारूप, एक छोटा एकल-परिशुद्धता फ़्लोटिंग-पॉइंट प्रारूप है | IEEE 754 एकल-परिशुद्धता 32-बिट फ़्लोट, IEEE 754 एकल-परिशुद्धता 32-बिट फ़्लोट से तेज़ प्रकार के रूपांतरण की अनुमति देता है; Bfloat16 प्रारूप में रूपांतरण में, घातांक बिट्स को संरक्षित किया जाता है, जबकि [[NaN]] विशेष मामले को अनदेखा करते हुए महत्व क्षेत्र को काट-छाँट (इस प्रकार IEEE 754#राउंडिंग नियमों के अनुरूप) द्वारा कम किया जा सकता है। [[ प्रतिपादक ]] बिट्स को संरक्षित करने से 32-बिट फ्लोट की रेंज ≈ 10 बनी रहती है<sup>−38</sup> से ≈ 3 × 10<sup>38</sup>.<ref name="googleio18-day1-time2575">{{Cite web | title = Livestream Day 1: Stage 8 (Google I/O '18) - YouTube | work = Google | date = 2018-05-08 | access-date = 2018-05-23 | url = https://www.youtube.com/watch?v=vm67WcLzfvc&t=2555 | quote = In many models this is a drop-in replacement for float-32 }}</ref>
+Bfloat16 प्रारूप, एक छोटा एकल-परिशुद्धता फ़्लोटिंग-पॉइंट प्रारूप है | आईईईई 754 एकल-परिशुद्धता 32-बिट फ़्लोट, आईईईई 754 एकल-परिशुद्धता 32-बिट फ़्लोट से तेज़ प्रकार के रूपांतरण की अनुमति देता है; Bfloat16 प्रारूप में रूपांतरण में, घातांक बिट्स को संरक्षित किया जाता है, जबकि [[NaN]] विशेष मामले को अनदेखा करते हुए महत्व क्षेत्र को काट-छाँट (इस प्रकार आईईईई 754#राउंडिंग नियमों के अनुरूप) द्वारा कम किया जा सकता है। [[ प्रतिपादक ]] बिट्स को संरक्षित करने से 32-बिट फ्लोट की रेंज ≈ 10 बनी रहती है<sup>−38</sup> से ≈ 3 × 10<sup>38</sup>.<ref name="googleio18-day1-time2575">{{Cite web | title = Livestream Day 1: Stage 8 (Google I/O '18) - YouTube | work = Google | date = 2018-05-08 | access-date = 2018-05-23 | url = https://www.youtube.com/watch?v=vm67WcLzfvc&t=2555 | quote = In many models this is a drop-in replacement for float-32 }}</ref>
 बिट्स को इस प्रकार रखा गया है:
 {| class="wikitable" style="text-align:center; border-width:0;"
-|+ [[Half-precision floating-point format|IEEE half-precision]] 16-bit float
+|+ [[Half-precision floating-point format|आईईईई आधा परिशुद्धता]] 16-बिट फ्लोट
 |- style="line-height:70%;"
-| style="border-width:0; background:#FFFFFF;" colspan="2" | sign
+| colspan="2" style="border-width:0; background:#FFFFFF;" | sign
-| style="border-width:0; background:#FFFFFF;" colspan="5" | exponent (5 bit)
+| colspan="5" style="border-width:0; background:#FFFFFF;" | exponent (5 बिट)
-| style="border-width:0; background:#FFFFFF;" colspan="10"| fraction (10 bit)
+| colspan="10" style="border-width:0; background:#FFFFFF;" | fraction (10 बिट)
 |- style="line-height:70%;"
-| style="border-width:0; background:#FFFFFF;" colspan="2" | &nbsp;&nbsp;┃
+| colspan="2" style="border-width:0; background:#FFFFFF;" | &nbsp;&nbsp;┃
-| style="border-width:0; background:#FFFFFF;" colspan="5" | ┌───────┐
+| colspan="5" style="border-width:0; background:#FFFFFF;" | ┌───────┐
-| style="border-width:0; background:#FFFFFF;" colspan="10"| ┌─────────────────┐
+| colspan="10" style="border-width:0; background:#FFFFFF;" | ┌─────────────────┐
 |- style="font-size:9pt;"
 | style="border-width:0; background:#FFFFFF;" | || style="background:#C4FCFF;" | &nbsp;0&nbsp; || style="background:#9FFFAC;" | &nbsp;0&nbsp; || style="background:#9FFFAC;" | &nbsp;1&nbsp; || style="background:#9FFFAC;" | &nbsp;1&nbsp; || style="background:#9FFFAC;" | &nbsp;0&nbsp; || style="background:#9FFFAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;1&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp;
 |-
-| style="border-width:0; background:#FFFFFF;" | || style="border-width:0; background:#FFFFFF;" | 15 || style="border-width:0; background:#FFFFFF;" | 14 || style="border-width:0; background:#FFFFFF;" colspan="3" | || style="border-width:0; background:#FFFFFF;" | 10 || style="border-width:0; background:#FFFFFF;" | 9 || style="border-width:0; background:#FFFFFF;" colspan="8" | || style="border-width:0; background:#FFFFFF;" | 0
+| style="border-width:0; background:#FFFFFF;" | || style="border-width:0; background:#FFFFFF;" | 15 || style="border-width:0; background:#FFFFFF;" | 14 || colspan="3" style="border-width:0; background:#FFFFFF;" | || style="border-width:0; background:#FFFFFF;" | 10 || style="border-width:0; background:#FFFFFF;" | 9 || colspan="8" style="border-width:0; background:#FFFFFF;" | || style="border-width:0; background:#FFFFFF;" | 0
 |}
 {| class="wikitable" style="text-align:center; border-width:0;"
-|+ [[Single-precision floating-point format|IEEE 754 single-precision]] 32-bit float
+|+ [[Single-precision floating-point format|आईईईई 754 एकल परिशुद्धता]] 32-बिट फ्लोट
 |- style="line-height:70%;"
-| style="border-width:0; background:#FFFFFF;" colspan="2" | sign
+| colspan="2" style="border-width:0; background:#FFFFFF;" | sign
-| style="border-width:0; background:#FFFFFF;" colspan="8" | exponent (8 bit)
+| colspan="8" style="border-width:0; background:#FFFFFF;" | exponent (8 बिट)
-| style="border-width:0; background:#FFFFFF;" colspan="23"| fraction (23 bit)
+| colspan="23" style="border-width:0; background:#FFFFFF;" | fraction (23 बिट)
 |- style="line-height:70%;"
-| style="border-width:0; background:#FFFFFF;" colspan="2" | &nbsp;&nbsp;┃
+| colspan="2" style="border-width:0; background:#FFFFFF;" | &nbsp;&nbsp;┃
-| style="border-width:0; background:#FFFFFF;" colspan="8" | ┌─────────────┐
+| colspan="8" style="border-width:0; background:#FFFFFF;" | ┌─────────────┐
-| style="border-width:0; background:#FFFFFF;" colspan="23"| ┌───────────────────────────────────────────┐
+| colspan="23" style="border-width:0; background:#FFFFFF;" | ┌───────────────────────────────────────────┐
 |- style="font-size:9pt;"
 | style="border-width:0; background:#FFFFFF;" | || style="background:#C4FCFF;" | &nbsp;0&nbsp; || style="background:#9FFFAC;" | &nbsp;0&nbsp; || style="background:#9FFFAC;" | &nbsp;1&nbsp; || style="background:#9FFFAC;" | &nbsp;1&nbsp; || style="background:#9FFFAC;" | &nbsp;1&nbsp; || style="background:#9FFFAC;" | &nbsp;1&nbsp; || style="background:#9FFFAC;" | &nbsp;1&nbsp; || style="background:#9FFFAC;" | &nbsp;0&nbsp; || style="background:#9FFFAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;1&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp;
 |-
-| style="border-width:0; background:#FFFFFF;" | || style="border-width:0; background:#FFFFFF;" | 31 || style="border-width:0; background:#FFFFFF;" | 30 || style="border-width:0; background:#FFFFFF;" colspan="6" | || style="border-width:0; background:#FFFFFF;" | 23 || style="border-width:0; background:#FFFFFF;" | 22 || style="border-width:0; background:#FFFFFF;" colspan="21" | || style="border-width:0; background:#FFFFFF;" | 0
+| style="border-width:0; background:#FFFFFF;" | || style="border-width:0; background:#FFFFFF;" | 31 || style="border-width:0; background:#FFFFFF;" | 30 || colspan="6" style="border-width:0; background:#FFFFFF;" | || style="border-width:0; background:#FFFFFF;" | 23 || style="border-width:0; background:#FFFFFF;" | 22 || colspan="21" style="border-width:0; background:#FFFFFF;" | || style="border-width:0; background:#FFFFFF;" | 0
 |}
@@ Line 52: / Line 54: @@
 |+ bfloat16
 |- style="line-height:70%;"
-| style="border-width:0; background:#FFFFFF;" colspan="2" | sign
+| colspan="2" style="border-width:0; background:#FFFFFF;" | sign
-| style="border-width:0; background:#FFFFFF;" colspan="8" | exponent (8 bit)
+| colspan="8" style="border-width:0; background:#FFFFFF;" | exponent (8 बिट)
-| style="border-width:0; background:#FFFFFF;" colspan="7" | fraction (7 bit)
+| colspan="7" style="border-width:0; background:#FFFFFF;" | fraction (7 बिट)
 |- style="line-height:70%;"
-| style="border-width:0; background:#FFFFFF;" colspan="2" | &nbsp;&nbsp;┃
+| colspan="2" style="border-width:0; background:#FFFFFF;" | &nbsp;&nbsp;┃
-| style="border-width:0; background:#FFFFFF;" colspan="8" | ┌─────────────┐
+| colspan="8" style="border-width:0; background:#FFFFFF;" | ┌─────────────┐
-| style="border-width:0; background:#FFFFFF;" colspan="7" | ┌───────────┐
+| colspan="7" style="border-width:0; background:#FFFFFF;" | ┌───────────┐
 |- style="font-size:9pt;"
 | style="border-width:0; background:#FFFFFF;" | || style="background:#C4FCFF;" | &nbsp;0&nbsp; || style="background:#9FFFAC;" | &nbsp;0&nbsp; || style="background:#9FFFAC;" | &nbsp;1&nbsp; || style="background:#9FFFAC;" | &nbsp;1&nbsp; || style="background:#9FFFAC;" | &nbsp;1&nbsp; || style="background:#9FFFAC;" | &nbsp;1&nbsp; || style="background:#9FFFAC;" | &nbsp;1&nbsp; || style="background:#9FFFAC;" | &nbsp;0&nbsp; || style="background:#9FFFAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;1&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp;
 |-
-| style="border-width:0; background:#FFFFFF;" | || style="border-width:0; background:#FFFFFF;" | 15 || style="border-width:0; background:#FFFFFF;" | 14 || style="border-width:0; background:#FFFFFF;" colspan="6" | || style="border-width:0; background:#FFFFFF;" | 7 || style="border-width:0; background:#FFFFFF;" | 6 || style="border-width:0; background:#FFFFFF;" colspan="5" | || style="border-width:0; background:#FFFFFF;" | 0
+| style="border-width:0; background:#FFFFFF;" | || style="border-width:0; background:#FFFFFF;" | 15 || style="border-width:0; background:#FFFFFF;" | 14 || colspan="6" style="border-width:0; background:#FFFFFF;" | || style="border-width:0; background:#FFFFFF;" | 7 || style="border-width:0; background:#FFFFFF;" | 6 || colspan="5" style="border-width:0; background:#FFFFFF;" | || style="border-width:0; background:#FFFFFF;" | 0
 |}
@@ Line 68: / Line 70: @@
 |+ NVidia's TensorFloat
 |- style="line-height:70%;"
-| style="border-width:0; background:#FFFFFF;" colspan="2" | sign
+| colspan="2" style="border-width:0; background:#FFFFFF;" | sign
-| style="border-width:0; background:#FFFFFF;" colspan="8" | exponent (8 bit)
+| colspan="8" style="border-width:0; background:#FFFFFF;" | exponent (8 बिट)
-| style="border-width:0; background:#FFFFFF;" colspan="10"| fraction (10 bit)
+| colspan="10" style="border-width:0; background:#FFFFFF;" | fraction (10 बिट)
 |- style="line-height:70%;"
-| style="border-width:0; background:#FFFFFF;" colspan="2" | &nbsp;&nbsp;┃
+| colspan="2" style="border-width:0; background:#FFFFFF;" | &nbsp;&nbsp;┃
-| style="border-width:0; background:#FFFFFF;" colspan="8" | ┌─────────────┐
+| colspan="8" style="border-width:0; background:#FFFFFF;" | ┌─────────────┐
-| style="border-width:0; background:#FFFFFF;" colspan="10"| ┌─────────────────┐
+| colspan="10" style="border-width:0; background:#FFFFFF;" | ┌─────────────────┐
 |- style="font-size:9pt;"
 | style="border-width:0; background:#FFFFFF;" | || style="background:#C4FCFF;" | &nbsp;0&nbsp; || style="background:#9FFFAC;" | &nbsp;0&nbsp; || style="background:#9FFFAC;" | &nbsp;1&nbsp; || style="background:#9FFFAC;" | &nbsp;1&nbsp; || style="background:#9FFFAC;" | &nbsp;1&nbsp; || style="background:#9FFFAC;" | &nbsp;1&nbsp; || style="background:#9FFFAC;" | &nbsp;1&nbsp; || style="background:#9FFFAC;" | &nbsp;0&nbsp; || style="background:#9FFFAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;1&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp;
 |-
-| style="border-width:0; background:#FFFFFF;" | || style="border-width:0; background:#FFFFFF;" | 18 || style="border-width:0; background:#FFFFFF;" | 17 || style="border-width:0; background:#FFFFFF;" colspan="6" | || style="border-width:0; background:#FFFFFF;" | 10 || style="border-width:0; background:#FFFFFF;" | 9 || style="border-width:0; background:#FFFFFF;" colspan="8" | || style="border-width:0; background:#FFFFFF;" | 0
+| style="border-width:0; background:#FFFFFF;" | || style="border-width:0; background:#FFFFFF;" | 18 || style="border-width:0; background:#FFFFFF;" | 17 || colspan="6" style="border-width:0; background:#FFFFFF;" | || style="border-width:0; background:#FFFFFF;" | 10 || style="border-width:0; background:#FFFFFF;" | 9 || colspan="8" style="border-width:0; background:#FFFFFF;" | || style="border-width:0; background:#FFFFFF;" | 0
 |}
@@ Line 84: / Line 86: @@
 |+ AMD's fp24 format
 |- style="line-height:70%;"
-| style="border-width:0; background:#FFFFFF;" colspan="2" | sign
+| colspan="2" style="border-width:0; background:#FFFFFF;" | sign
-| style="border-width:0; background:#FFFFFF;" colspan="7" | exponent (7 bit)
+| colspan="7" style="border-width:0; background:#FFFFFF;" | exponent (7 बिट)
-| style="border-width:0; background:#FFFFFF;" colspan="16"| fraction (16 bit)
+| colspan="16" style="border-width:0; background:#FFFFFF;" | fraction (16 बिट)
 |- style="line-height:70%;"
-| style="border-width:0; background:#FFFFFF;" colspan="2" | &nbsp;&nbsp;┃
+| colspan="2" style="border-width:0; background:#FFFFFF;" | &nbsp;&nbsp;┃
-| style="border-width:0; background:#FFFFFF;" colspan="7" | ┌───────────┐
+| colspan="7" style="border-width:0; background:#FFFFFF;" | ┌───────────┐
-| style="border-width:0; background:#FFFFFF;" colspan="16"| ┌─────────────────────────────┐
+| colspan="16" style="border-width:0; background:#FFFFFF;" | ┌─────────────────────────────┐
 |- style="font-size:9pt;"
 | style="border-width:0; background:#FFFFFF;" | || style="background:#C4FCFF;" | &nbsp;0&nbsp; || style="background:#9FFFAC;" | &nbsp;0&nbsp; || style="background:#9FFFAC;" | &nbsp;1&nbsp; || style="background:#9FFFAC;" | &nbsp;1&nbsp; || style="background:#9FFFAC;" | &nbsp;1&nbsp; || style="background:#9FFFAC;" | &nbsp;1&nbsp; || style="background:#9FFFAC;" | &nbsp;0&nbsp; || style="background:#9FFFAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;1&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp;
 |-
-| style="border-width:0; background:#FFFFFF;" | || style="border-width:0; background:#FFFFFF;" | 23 || style="border-width:0; background:#FFFFFF;" | 22 || style="border-width:0; background:#FFFFFF;" colspan="5" | || style="border-width:0; background:#FFFFFF;" | 16 || style="border-width:0; background:#FFFFFF;" | 15 || style="border-width:0; background:#FFFFFF;" colspan="14" | || style="border-width:0; background:#FFFFFF;" | 0
+| style="border-width:0; background:#FFFFFF;" | || style="border-width:0; background:#FFFFFF;" | 23 || style="border-width:0; background:#FFFFFF;" | 22 || colspan="5" style="border-width:0; background:#FFFFFF;" | || style="border-width:0; background:#FFFFFF;" | 16 || style="border-width:0; background:#FFFFFF;" | 15 || colspan="14" style="border-width:0; background:#FFFFFF;" | || style="border-width:0; background:#FFFFFF;" | 0
 |}
@@ Line 100: / Line 102: @@
 |+ Pixar's PXR24 format
 |- style="line-height:70%;"
-| style="border-width:0; background:#FFFFFF;" colspan="2" | sign
+| colspan="2" style="border-width:0; background:#FFFFFF;" | sign
-| style="border-width:0; background:#FFFFFF;" colspan="8" | exponent (8 bit)
+| colspan="8" style="border-width:0; background:#FFFFFF;" | exponent (8 बिट)
-| style="border-width:0; background:#FFFFFF;" colspan="15"| fraction (15 bit)
+| colspan="15" style="border-width:0; background:#FFFFFF;" | fraction (15 बिट)
 |- style="line-height:70%;"
-| style="border-width:0; background:#FFFFFF;" colspan="2" | &nbsp;&nbsp;┃
+| colspan="2" style="border-width:0; background:#FFFFFF;" | &nbsp;&nbsp;┃
-| style="border-width:0; background:#FFFFFF;" colspan="8" | ┌─────────────┐
+| colspan="8" style="border-width:0; background:#FFFFFF;" | ┌─────────────┐
-| style="border-width:0; background:#FFFFFF;" colspan="15"| ┌───────────────────────────┐
+| colspan="15" style="border-width:0; background:#FFFFFF;" | ┌───────────────────────────┐
 |- style="font-size:9pt;"
 | style="border-width:0; background:#FFFFFF;" | || style="background:#C4FCFF;" | &nbsp;0&nbsp; || style="background:#9FFFAC;" | &nbsp;0&nbsp; || style="background:#9FFFAC;" | &nbsp;1&nbsp; || style="background:#9FFFAC;" | &nbsp;1&nbsp; || style="background:#9FFFAC;" | &nbsp;1&nbsp; || style="background:#9FFFAC;" | &nbsp;1&nbsp; || style="background:#9FFFAC;" | &nbsp;0&nbsp; || style="background:#9FFFAC;" | &nbsp;0&nbsp; || style="background:#9FFFAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;1&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp; || style="background:#FFACAC;" | &nbsp;0&nbsp;
 |-
-| style="border-width:0; background:#FFFFFF;" | || style="border-width:0; background:#FFFFFF;" | 23 || style="border-width:0; background:#FFFFFF;" | 22 || style="border-width:0; background:#FFFFFF;" colspan="6" | || style="border-width:0; background:#FFFFFF;" | 15 || style="border-width:0; background:#FFFFFF;" | 14 || style="border-width:0; background:#FFFFFF;" colspan="13" | || style="border-width:0; background:#FFFFFF;" | 0
+| style="border-width:0; background:#FFFFFF;" | || style="border-width:0; background:#FFFFFF;" | 23 || style="border-width:0; background:#FFFFFF;" | 22 || colspan="6" style="border-width:0; background:#FFFFFF;" | || style="border-width:0; background:#FFFFFF;" | 15 || style="border-width:0; background:#FFFFFF;" | 14 || colspan="13" style="border-width:0; background:#FFFFFF;" | || style="border-width:0; background:#FFFFFF;" | 0
 |}
 ===bfloat16 और एकल परिशुद्धता के साथ तुलना करें===
 {| class="wikitable" style="color: black; background: black; text-align: center;"
@@ Line 150: / Line 150: @@
 | style="background: #ccc; width: 16pt;" | f
 |}
 ====किंवदंती====
 * {{Legend|#f99|S: [[sign bit|sign]]}}
 * {{Legend|#9f9|E: [[exponent]]}}
-* {{Legend|#99f|F: fraction (trailing [[significand]]) in both formats}}
+* {{Legend|#99f|एफ: अंश (दोनों प्रारूपों में [[महत्वपूर्ण]] से पीछे)।}}
-* {{Legend|#ccc|f: fraction (trailing significand) in 32-bit [[single precision]] (comparative)}}
+* {{Legend|#ccc|एफ: 32-बिट में अंश (अनुगामी महत्व) [[एकल परिशुद्धता]] (तुलनात्मक)}}
 === घातांक एन्कोडिंग ===
-Bfloat16 बाइनरी फ्लोटिंग-पॉइंट एक्सपोनेंट को [[ऑफसेट बाइनरी]] | ऑफसेट-बाइनरी प्रतिनिधित्व का उपयोग करके एन्कोड किया गया है, जिसमें शून्य ऑफसेट 127 है; IEEE 754 मानक में प्रतिपादक पूर्वाग्रह के रूप में भी जाना जाता है।
+Bfloat16 बाइनरी फ्लोटिंग-पॉइंट एक्सपोनेंट को [[ऑफसेट बाइनरी]] | ऑफसेट-बाइनरी प्रतिनिधित्व का उपयोग करके एन्कोड किया गया है, जिसमें शून्य ऑफसेट 127 है; आईईईई 754 मानक में प्रतिपादक पूर्वाग्रह के रूप में भी जाना जाता है।
 * इ<sub>min</sub> = 01<sub>H</sub>−7F<sub>H</sub> = −126
 * और<sub>max</sub> = एफई<sub>H</sub>−7F<sub>H</sub> = 127
@@ Line 166: / Line 164: @@
 इस प्रकार, ऑफसेट-बाइनरी प्रतिनिधित्व द्वारा परिभाषित वास्तविक प्रतिपादक प्राप्त करने के लिए, 127 के ऑफसेट को प्रतिपादक क्षेत्र के मूल्य से घटाना होगा।
-घातांक फ़ील्ड का न्यूनतम और अधिकतम मान (00)<sub>H</sub> और एफएफ<sub>H</sub>) की विशेष रूप से व्याख्या की जाती है, जैसे IEEE 754 मानक प्रारूपों में।
+घातांक फ़ील्ड का न्यूनतम और अधिकतम मान (00)<sub>H</sub> और एफएफ<sub>H</sub>) की विशेष रूप से व्याख्या की जाती है, जैसे आईईईई 754 मानक प्रारूपों में।
 {| class="wikitable" style="text-align:center"
-!Exponent
+!प्रतिपादक
-!Significand zero
+!महत्व शून्य
-!Significand non-zero
+!सार्थकतथा गैर-शून्य
-!Equation
+!समीकरण
 |-
 |00<sub>H</sub>
 |[[0 (number)|zero]], [[−0]]
-|[[subnormal number]]s
+|[[subnormal number|असामान्य संख्याएँ]]
-|(−1)<sup>signbit</sup>×2<sup>−126</sup>× 0.significandbits
+|(−1)<sup>signबिट</sup>×2<sup>−126</sup>× 0.significandबिटs
 |-
 |01<sub>H</sub>, ..., FE<sub>H</sub>
-| colspan="2" |normalized value
+| colspan="2" |सामान्यीकृत मूल्य
-|(−1)<sup>signbit</sup>×2<sup>exponentbits−127</sup>× 1.significandbits
+|(−1)<sup>signबिट</sup>×2<sup>exponentबिटs−127</sup>× 1.significandबिटs
 |-
 |FF<sub>H</sub>
 |±[[infinity]]
-|[[NaN]] (quiet, signaling)
+|[[NaN]] (शांत, संकेत)
 |
 |}
@@ Line 192: / Line 190: @@
 === सकारात्मक और नकारात्मक अनंत ===
-जैसे [[IEEE 754]] में, सकारात्मक और नकारात्मक अनंत को उनके संबंधित साइन बिट्स के साथ दर्शाया जाता है, सभी 8 एक्सपोनेंट बिट्स सेट (एफएफ)<sub>hex</sub>) और सभी महत्वपूर्ण बिट्स शून्य। स्पष्ट रूप से,<syntaxhighlight lang="text">
+जैसे [[IEEE 754|आईईईई 754]] में, सकारात्मक और नकारात्मक अनंत को उनके संबंधित साइन बिट्स के साथ दर्शाया जाता है, सभी 8 एक्सपोनेंट बिट्स सेट (एफएफ)<sub>hex</sub>) और सभी महत्वपूर्ण बिट्स शून्य। स्पष्ट रूप से,<syntaxhighlight lang="text">
 val    s_exponent_signcnd
 +inf = 0_11111111_0000000
 -inf = 1_11111111_0000000
 </syntaxhighlight>
 === कोई संख्या नहीं ===
-जैसे IEEE 754 में, NaN मानों को या तो साइन बिट के साथ दर्शाया जाता है, सभी 8 एक्सपोनेंट बिट्स सेट (एफएफ)<sub>hex</sub>) और सभी महत्वपूर्ण बिट्स शून्य नहीं हैं। स्पष्ट रूप से,<syntaxhighlight lang="text">
+जैसे आईईईई 754 में, NaN मानों को या तो साइन बिट के साथ दर्शाया जाता है, सभी 8 एक्सपोनेंट बिट्स सेट (एफएफ)<sub>hex</sub>) और सभी महत्वपूर्ण बिट्स शून्य नहीं हैं। स्पष्ट रूप से,<syntaxhighlight lang="text">
 val    s_exponent_signcnd
 +NaN = 0_11111111_klmnopq
 -NaN = 1_11111111_klmnopq
-</syntaxhighlight>जहां k, l, m, n, o, p, या q में से कम से कम एक 1 है। IEEE 754 की तरह, NaN मान शांत या सिग्नलिंग हो सकते हैं, हालांकि सितंबर 2018 तक bfloat16 NaNs सिग्नलिंग का कोई ज्ञात उपयोग नहीं है।
+</syntaxhighlight>जहां k, l, m, n, o, p, या q में से कम से कम एक 1 है। आईईईई 754 की तरह, NaN मान शांत या सिग्नलिंग हो सकते हैं, हालांकि सितंबर 2018 तक bfloat16 NaNs सिग्नलिंग का कोई ज्ञात उपयोग नहीं है।
 == सीमा और परिशुद्धता ==
-Bfloat16 को 32-बिट सिंगल-प्रिसिजन फ़्लोटिंग-पॉइंट फॉर्मेट | IEEE 754 सिंगल-प्रिसिजन फ़्लोटिंग-पॉइंट फॉर्मेट (बाइनरी 32) से संख्या सीमा बनाए रखने के लिए डिज़ाइन किया गया है, जबकि परिशुद्धता को 24 बिट्स से घटाकर 8 बिट्स किया गया है। इसका मतलब है कि परिशुद्धता दो और तीन दशमलव अंकों के बीच है, और bfloat16 लगभग 3.4 × 10 तक परिमित मानों का प्रतिनिधित्व कर सकता है<sup>38</sup>.
+Bfloat16 को 32-बिट सिंगल-प्रिसिजन फ़्लोटिंग-पॉइंट फॉर्मेट | आईईईई 754 सिंगल-प्रिसिजन फ़्लोटिंग-पॉइंट फॉर्मेट (बाइनरी 32) से संख्या सीमा बनाए रखने के लिए डिज़ाइन किया गया है, जबकि परिशुद्धता को 24 बिट्स से घटाकर 8 बिट्स किया गया है। इसका मतलब है कि परिशुद्धता दो और तीन दशमलव अंकों के बीच है, और bfloat16 लगभग 3.4 × 10 तक परिमित मानों का प्रतिनिधित्व कर सकता है<sup>38</sup>.
 == उदाहरण ==
@@ Line 236: / Line 232: @@
 == यह भी देखें ==
-* [[अर्ध-परिशुद्धता फ़्लोटिंग-पॉइंट प्रारूप]]: 16-बिट फ़्लोट w/1-बिट साइन, 5-बिट एक्सपोनेंट, और 11-बिट महत्व, जैसा कि IEEE 754 द्वारा परिभाषित किया गया है
+* [[अर्ध-परिशुद्धता फ़्लोटिंग-पॉइंट प्रारूप]]: 16-बिट फ़्लोट w/1-बिट साइन, 5-बिट एक्सपोनेंट, और 11-बिट महत्व, जैसा कि आईईईई 754 द्वारा परिभाषित किया गया है
 * आईएसओ/आईईसी 10967, भाषा स्वतंत्र अंकगणित
 * [[आदिम डेटा प्रकार]]
@@ Line 244: / Line 240: @@
 ==संदर्भ==
 {{Reflist}}
-{{data types}}
 {{DEFAULTSORT:bfloat16 floating-point format}}[[Category: बाइनरी अंकगणित]] [[Category: फ़्लोटिंग पॉइंट प्रकार]]

Anonymous

Search

Bfloat16 फ़्लोटिंग-पॉइंट प्रारूप: Difference between revisions

Namespaces

More

Page actions

Revision as of 22:10, 18 July 2023

Contents