Bitcast

डेटा को कॉपी किए बिना एक टेंसर को एक प्रकार से दूसरे प्रकार में बिटकास्ट करता है।

एक टेंसर `इनपुट` को देखते हुए, यह ऑपरेशन एक टेंसर लौटाता है जिसमें डेटाटाइप `प्रकार` के साथ `इनपुट` के समान बफर डेटा होता है।

यदि इनपुट डेटाटाइप `T` आउटपुट डेटाटाइप `टाइप` से बड़ा है तो आकार [...] से [..., sizeof(`T`)/sizeof(`type`)] में बदल जाता है।

यदि `T` `प्रकार` से छोटा है, तो ऑपरेटर के लिए आवश्यक है कि सबसे दाहिना आयाम sizeof(`type`)/sizeof(`T`) के बराबर हो। फिर आकार [..., sizeof(`type`)/sizeof(`T`)] से [...] तक चला जाता है।

जब वास्तविक dtype को एक जटिल dtype (जैसे tf.complex64 या tf.complex128) के रूप में डाला जाता है तो tf.bitcast() और tf.cast() अलग-अलग काम करते हैं क्योंकि tf.cast() काल्पनिक भाग 0 बनाते हैं जबकि tf.bitcast() मॉड्यूल देता है गलती। उदाहरण के लिए,

उदाहरण 1:

>>> a = [1., 2., 3.] >>> समानता_बिटकास्ट = tf.bitcast(a, tf.complex128) ट्रेसबैक (सबसे हालिया कॉल अंतिम): ... अमान्यArgumentError: 1 से 18 तक बिटकास्ट नहीं किया जा सकता [ ऑप: बिटकास्ट] >>> समानता_कास्ट = tf.cast(a, tf.complex128) >>> प्रिंट(equality_cast) tf.Tensor([1.+0.j 2.+0.j 3.+0.j] , आकार=(3,), dtype=complex128)

उदाहरण 2:

>>> tf.bitcast(tf.constant(0xffffffff, dtype=tf.uint32), tf.uint8)

उदाहरण 3:

>>> x = [1., 2., 3.] >>> y = [0., 2., 3.] >>> समानता = tf.equal(x,y) >>> समानता_कास्ट = tf. कास्ट (समानता, tf.float32) >>> समानता_बिटकास्ट = tf.bitcast (equality_cast, tf.uint8) >>> प्रिंट (समानता) tf.Tensor ([झूठा सच सच], आकार = (3,), dtype = bool ) >>> प्रिंट(equality_cast) tf.Tensor([0. 1. 1.], आकार=(3,), dtype=float32) >>> प्रिंट(equality_bitcast) tf.Tensor( [[ 0 0 0 0] [ 0 0 128 63] [ 0 0 128 63]], आकार=(3, 4), dtype=uint8)

ध्यान दें : बिटकास्ट को निम्न-स्तरीय कास्ट के रूप में कार्यान्वित किया जाता है, इसलिए विभिन्न एंडियन ऑर्डर वाली मशीनें अलग-अलग परिणाम देंगी।