सहायता Kaggle पर TensorFlow साथ ग्रेट बैरियर रीफ की रक्षा चैलेंज में शामिल हों

टेंसरफ़्लो :: टेन्सर

#include <tensor.h>

मूल्यों के एक एन-आयामी सरणी का प्रतिनिधित्व करता है।

सारांश

कंस्ट्रक्टर और डिस्ट्रक्टर्स

Tensor ()
1-आयामी, 0-तत्व फ्लोट टेंसर बनाता है।
Tensor (DataType type, const TensorShape & shape)
दिए गए type और shape का एक सेंसर बनाता है।
Tensor (Allocator *a, DataType type, const TensorShape & shape)
इनपुट के साथ एक टेन्सर बनाता है type और shape , संभाजक का उपयोग कर a अंतर्निहित बफर आवंटित करने के लिए।
Tensor (Allocator *a, DataType type, const TensorShape & shape, const AllocationAttributes & allocation_attr)
इनपुट के साथ एक टेन्सर बनाता है type और shape , संभाजक का उपयोग कर a और निर्दिष्ट "allocation_attr" आवंटित करने के लिए अंतर्निहित बफर।
Tensor (DataType type, const TensorShape & shape, TensorBuffer *buf)
इनपुट डेटाटाइप, आकृति और buf के साथ एक टेंसर बनाता है।
Tensor (DataType type)
दिए गए डेटा प्रकार का एक खाली सेंसर बनाता है।
Tensor (float scalar_value)
Tensor (double scalar_value)
Tensor (int32 scalar_value)
Tensor (uint32 scalar_value)
Tensor (uint16 scalar_value)
Tensor (uint8 scalar_value)
Tensor (int16 scalar_value)
Tensor (int8 scalar_value)
Tensor (tstring scalar_value)
Tensor (complex64 scalar_value)
Tensor (complex128 scalar_value)
Tensor (int64 scalar_value)
Tensor (uint64 scalar_value)
Tensor (bool scalar_value)
Tensor (qint8 scalar_value)
Tensor (quint8 scalar_value)
Tensor (qint16 scalar_value)
Tensor (quint16 scalar_value)
Tensor (qint32 scalar_value)
Tensor (bfloat16 scalar_value)
Tensor (Eigen::half scalar_value)
Tensor (ResourceHandle scalar_value)
Tensor (const char *scalar_value)
Tensor (const Tensor & other)
कंस्ट्रक्टर को कॉपी करें।
Tensor ( Tensor && other)
कंस्ट्रक्टर को स्थानांतरित करें।
~Tensor ()

सार्वजनिक कार्य

AllocatedBytes () const
size_t
AsProtoField (TensorProto *proto) const
void
*this टेंसर की सामग्री के साथ *this proto में भरता है।
AsProtoTensorContent (TensorProto *proto) const
void
BitcastFrom (const Tensor & other, DataType dtype, const TensorShape & shape)
अन्य टेंसर को इस टेंसर में कॉपी करें, इसे रीशैप करें और बफ़र के डेटाटाइप की पुनर्व्याख्या करें।
CopyFrom (const Tensor & other, const TensorShape & shape) TF_MUST_USE_RESULT
bool
इस टेंसर में दूसरे टेंसर को कॉपी करें और उसे रीशैप करें।
DebugString (int num_values) const
string
डिबगिंग के लिए उपयुक्त टेंसर का मानव-पठनीय सारांश।
DebugString () const
string
DeviceSafeDebugString () const
string
FillDescription (TensorDescription *description) const
void
TensorDescription प्रोटो में मेटाडेटा के साथ भरें टेंसर के बारे में जो निगरानी और डीबगिंग के लिए उपयोगी है।
FromProto (const TensorProto & other) TF_MUST_USE_RESULT
bool
other पार्स करें और टेंसर का निर्माण करें।
FromProto (Allocator *a, const TensorProto & other) TF_MUST_USE_RESULT
bool
IsAligned () const
bool
यदि यह टेनर संरेखित है तो सही है।
IsInitialized () const
bool
यदि आवश्यक हो, तो क्या इस सेंसर को आरंभीकृत किया गया है?
IsSameSize (const Tensor & b) const
bool
NumElements () const
int64
टेंसर आकार के लिए सुविधा अभिगमकर्ता।
SharesBufferWith (const Tensor & b) const
bool
Slice (int64 dim0_start, int64 dim0_limit) const
1 आयाम के साथ इस टेंसर को स्लाइस करें।
SubSlice (int64 index) const
1 आयाम के साथ इस तन्यता से एक उप-प्रजाति चुनें।
SummarizeValue (int64 max_entries, bool print_v2) const
string
*this एक स्ट्रिंग में *this में max_entries मूल्यों को प्रस्तुत करना।
TotalBytes () const
size_t
इस टेंसर के अनुमानित स्मृति उपयोग को लौटाता है।
UnsafeCopyFromInternal (const Tensor & other, DataType dtype, const TensorShape & shape)
void
बिटकास्टफ्रॉम की तरह, लेकिन किसी भी पूर्व शर्त को पूरा नहीं करने पर CHECK विफल हो जाता है।
bit_casted_shaped (gtl::ArraySlice< int64 > new_sizes)
TTypes< T, NDIMS >:: Tensor
new_sizes डेटा को एक Eigen::Tensor लौटें नए आकार में निर्दिष्ट नए आकार के साथ और एक नए dtype T कास्ट करें।
bit_casted_shaped (gtl::ArraySlice< int64 > new_sizes) const
TTypes< T, NDIMS >::ConstTensor
new_sizes डेटा को एक Eigen::Tensor लौटें नए आकार के साथ new_sizes और एक नए dtype T में निर्दिष्ट करें।
bit_casted_tensor ()
TTypes< T, NDIMS >:: Tensor
टेंसर डेटा को Eigen::Tensor पर समान आकार के साथ लौटाएं लेकिन निर्दिष्ट dtype T लिए एक बिटवाइज़ कास्ट।
bit_casted_tensor () const
TTypes< T, NDIMS >::ConstTensor
टेंसर डेटा को Eigen::Tensor पर समान आकार के साथ लौटाएं लेकिन निर्दिष्ट dtype T लिए एक बिटवाइज़ कास्ट।
dim_size (int d) const
int64
टेंसर आकार के लिए सुविधा अभिगमकर्ता।
dims () const
int
टेंसर आकार के लिए सुविधा अभिगमकर्ता।
dtype () const
DataType
डेटा प्रकार लौटाता है।
flat ()
TTypes< T >::Flat
एक Eigen::Tensor डेटा प्रकार और एक निर्दिष्ट आकार के Eigen::Tensor के रूप में टेंसर डेटा लौटाएं।
flat () const
TTypes< T >::ConstFlat
flat_inner_dims ()
TTypes< T, NDIMS >:: Tensor
डेटा को Eigen के रूप में लौटाता है :: NDIMS आयामों के साथ Tensor, सभी Tensor आयामों को ध्वस्त करता है लेकिन अंतिम NDIMS-1 परिणाम के पहले आयाम में।
flat_inner_dims () const
TTypes< T, NDIMS >::ConstTensor
flat_inner_outer_dims (int64 begin)
TTypes< T, NDIMS >:: Tensor
डेटा को एक Eigen के रूप में लौटाता है :: NDIMS आयामों वाला Tensor , परिणाम के पहले आयाम में 'शुरुआती' Tensor आयामों को ढहाने और अंतिम dims () - 'start' - Tensor आयामों के ND आयाम को अंतिम आयाम में परिणाम।
flat_inner_outer_dims (int64 begin) const
TTypes< T, NDIMS >::ConstTensor
flat_outer_dims ()
TTypes< T, NDIMS >:: Tensor
डेटा को Eigen के रूप में लौटाता है :: NDIMS आयामों के साथ Tensor, सभी Tensor आयामों को ध्वस्त करता है लेकिन परिणाम के अंतिम आयाम में पहला NDIMS-1।
flat_outer_dims () const
TTypes< T, NDIMS >::ConstTensor
matrix ()
TTypes< T >::Matrix
matrix () const
TTypes< T >::ConstMatrix
operator= (const Tensor & other)
संचालक का कार्यभार सौंपें। यह टेंसर अन्य अंतर्निहित भंडारण को साझा करता है।
operator= ( Tensor && other)
ऑपरेटर को स्थानांतरित करें। विवरण के लिए मूव कंस्ट्रक्टर देखें।
reinterpret_last_dimension ()
TTypes< T, NDIMS >:: Tensor
दसवें डेटा को एक Eigen::Tensor लौटें Eigen::Tensor एक बड़े प्रकार के एकल तत्वों में परिवर्तित अंतिम आयाम तत्वों के साथ सेंसर।
reinterpret_last_dimension () const
TTypes< T, NDIMS >::ConstTensor
दसवें डेटा को एक Eigen::Tensor लौटें Eigen::Tensor एक बड़े प्रकार के एकल तत्वों में परिवर्तित अंतिम आयाम तत्वों के साथ सेंसर।
scalar ()
TTypes< T >::Scalar
Tensor डेटा को निश्चित आकार 1 के TensorMap के रूप में TensorMap : TensorMap > TensorMap >
scalar () const
TTypes< T >::ConstScalar
shape () const
const TensorShape &
टेंसर का आकार देता है।
shaped (gtl::ArraySlice< int64 > new_sizes)
TTypes< T, NDIMS >:: Tensor
shaped (gtl::ArraySlice< int64 > new_sizes) const
TTypes< T, NDIMS >::ConstTensor
tensor ()
TTypes< T, NDIMS >:: Tensor
tensor () const
TTypes< T, NDIMS >::ConstTensor
tensor_data () const
StringPiece
वर्तमान टेंसर के बफर को मैप करते हुए एक StringPiece लौटाता है।
unaligned_flat ()
TTypes< T >::UnalignedFlat
unaligned_flat () const
TTypes< T >::UnalignedConstFlat
unaligned_shaped (gtl::ArraySlice< int64 > new_sizes)
TTypes< T, NDIMS >::UnalignedTensor
unaligned_shaped (gtl::ArraySlice< int64 > new_sizes) const
TTypes< T, NDIMS >::UnalignedConstTensor
vec ()
TTypes< T >::Vec
टेंसर डेटा को एक Eigen::Tensor के प्रकार और इस Tensor आकार के साथ लौटाएं।
vec () const
TTypes< T >::ConstVec
उपरोक्त सभी विधियों के कॉन्स्टेंट संस्करण।

सार्वजनिक कार्य

आवंटित की गई

size_t AllocatedBytes() const 
है

AsProtoField

void AsProtoField(
  TensorProto *proto
) const 

*this टेंसर की सामग्री के साथ *this proto में भरता है।

AsProtoField() के लिए आवर्ती फ़ील्ड में भर जाता है proto.dtype() है, जबकि AsProtoTensorContent() में सामग्री को कूटबद्ध proto.tensor_content() एक कॉम्पैक्ट रूप में।

AsProtoTensorContent

void AsProtoTensorContent(
  TensorProto *proto
) const 

बिटकास्टफ्रॉम

Status BitcastFrom(
  const Tensor & other,
  DataType dtype,
  const TensorShape & shape
)

अन्य टेंसर को इस टेंसर में कॉपी करें, इसे रीशैप करें और बफ़र के डेटाटाइप की पुनर्व्याख्या करें।

यदि स्थिति :: OK () वापस आ गई है, तो दो टेनर्स अब उसी अंतर्निहित संग्रहण को साझा करते हैं।

इस कॉल के लिए आवश्यक है कि other टेंसर और दिए गए प्रकार और आकार "संगत" हों (यानी वे समान संख्या में बाइट्स पर कब्जा कर लेते हैं)।

विशेष रूप से:

shape.num_elements () * DataTypeSize (प्रकार)

बराबर होना चाहिए

other.num_elements () * DataTypeSize (other.dtype ())

इसके अलावा, इस फ़ंक्शन की आवश्यकता है:

  • DataTypeSize (other.dtype ())! = 0
  • DataTypeSize (प्रकार)! = 0

यदि कोई आवश्यकताएं पूरी नहीं हुई हैं, तो त्रुटियाँ :: InvalidArgument वापस आ गई है।

से प्रतिलिपि बनाएँ

bool CopyFrom(
  const Tensor & other,
  const TensorShape & shape
) TF_MUST_USE_RESULT

इस टेंसर में दूसरे टेंसर को कॉपी करें और उसे रीशैप करें।

यह टेंसर अन्य अंतर्निहित भंडारण को साझा करता है। अन्य other.shape() दिए गए shape के तत्वों की समान संख्या other.shape() true

डिबगस्ट्रिंग

string DebugString(
  int num_values
) const 

डीबगिंग के लिए उपयुक्त टेंसर का मानव-पठनीय सारांश।

डिबगस्ट्रिंग

string DebugString() const 

DeviceSafeDebugString

string DeviceSafeDebugString() const 

FillDescription

void FillDescription(
  TensorDescription *description
) const 

TensorDescription प्रोटो में मेटाडेटा के साथ भरें टेंसर के बारे में जो निगरानी और डिबगिंग के लिए उपयोगी है।

FromProto से

bool FromProto(
  const TensorProto & other
) TF_MUST_USE_RESULT

other पार्स करें और टेंसर का निर्माण करें।

यदि पार्सिंग सफल होता है तो true रिटर्न देता true । यदि पार्सिंग विफल रहता है, तो *this की स्थिति अपरिवर्तित है।

FromProto से

0a0a19790

अलग है

bool IsAligned() const 

यदि यह टेनर संरेखित है तो सही है।

इंसुलेटेड है

bool IsInitialized() const 

यदि आवश्यक हो, तो क्या इस सेंसर को आरंभीकृत किया गया है?

शून्य-तत्व सेंसर को हमेशा प्रारंभिक माना जाता है, भले ही उन्हें कभी भी आवंटित नहीं किया गया हो और कोई स्मृति आवंटित न हो।

IsSameSize

bool IsSameSize(
  const Tensor & b
) const 

संख्याएँ

int64 NumElements() const 

टेंसर आकार के लिए सुविधा अभिगमकर्ता।

शेयरबफ़रविथ

bool SharesBufferWith(
  const Tensor & b
) const 

टुकड़ा

Tensor Slice(
  int64 dim0_start,
  int64 dim0_limit
) const 

1 आयाम के साथ इस टेंसर को स्लाइस करें।

यानी, लौटे हुए टेंसर संतुष्ट होकर लौटे [i, ...] == यह [dim0_start + i, ...]। लौटे हुए टेंसर इस टेंसर के साथ अंतर्निहित टैंसर बफर को साझा करते हैं।

नोट: लौटा हुआ टेंसर आकार के आधार पर इस टेंसर के समान संरेखण की आवश्यकता को पूरा नहीं कर सकता है। कॉल करने वाले को कुछ तरीकों को कॉल करने से पहले लौटे हुए टैंसर के अलाइनमेंट की जांच करनी चाहिए, जिसमें एलाइनमेंट की आवश्यकता (जैसे, flat() , tensor() ) है।

नोट: जब एक एन-आयामी टेंसर के साथ खिलाया जाता है, तो यह विधि एक टेंसर को भी एन आयामों के साथ वापस करती है। यदि आप एक सब टेन्सर का चयन करना चाहते हैं, तो SubSlice देखें।

आवश्यकताएँ: dims() > = 1 आवश्यकताएँ: 0 <= dim0_start <= dim0_limit <= dim_size(0)

उपश्रेणी

Tensor SubSlice(
  int64 index
) const 

1 आयाम के साथ इस तन्यता से एक उप-प्रजाति चुनें।

जब एन-डायमेंशनल टेंसर के साथ फीड किया जाता है, तो यह पद्धति एन -1 आयामों के साथ एक टेंसर को लौटाती है, जहां लौटा हुआ टेंसर पहले आयाम के साथ इनपुट टेंसर का एक उप-प्रकार है। रिटर्न किए गए टेंसर का एन -1 आयाम इनपुट टेंसर के अंतिम एन -1 आयाम हैं।

नोट: लौटा हुआ टेंसर आकार के आधार पर इस टेंसर के समान संरेखण की आवश्यकता को पूरा नहीं कर सकता है। कॉल करने वाले को कुछ तरीकों को कॉल करने से पहले लौटे हुए टैंसर के अलाइनमेंट की जांच करनी चाहिए, जिसमें एलाइनमेंट की आवश्यकता (जैसे, flat() , tensor() ) है।

आवश्यकताएँ: dims() > = 1 आवश्यकताएँ: 0 <= dim0_start < dim_size(0)

संक्षेप

string SummarizeValue(
  int64 max_entries,
  bool print_v2
) const 

*this एक स्ट्रिंग में *this में पहले max_entries मूल्यों को प्रस्तुत करना।

टेन्सर

 Tensor()

1-आयामी, 0-तत्व फ्लोट टेंसर बनाता है।

लौटे टेन्सर एक अदिश (आकार {}) नहीं है, लेकिन बजाय एक खाली एक आयामी है टेन्सर (आकार {0}, NumElements () == 0)। चूंकि इसमें कोई तत्व नहीं है, इसलिए इसे एक मान निर्दिष्ट करने की आवश्यकता नहीं है और इसे डिफ़ॉल्ट रूप से प्रारंभ किया जाता है ( IsInitialized () सत्य है)। यदि यह अवांछनीय है, तो एक-तत्व स्केलर बनाने पर विचार करें, जिसे आरंभीकरण की आवश्यकता होती है:

Tensor(DT_FLOAT, TensorShape({}))

      

Tensor

 Tensor(
  DataType type,
  const TensorShape & shape
)

दिए गए type और shape का एक सेंसर बनाता है।

यदि LogMemory :: IsEnabled () आवंटन को अज्ञात कर्नेल और चरण से आने के रूप में लॉग किया जाता है। किसी ओपीन के भीतर से सीधे टेंसर कंस्ट्रक्टर को कॉल करने पर पदावनत किया जाता है: एक नए टेंसर को आवंटित करने के लिए ऑपकर्नेलकॉन्स्ट्रक्शन / ओपकर्नेल कॉन्टेक्स्ट__ तरीकों का उपयोग करें, जो कर्नेल और स्टेप को रिकॉर्ड करते हैं।

अंतर्निहित बफर को CPUAllocator का उपयोग करके आवंटित किया गया है।

टेन्सर

 Tensor(
  Allocator *a,
  DataType type,
  const TensorShape & shape
)

इनपुट के साथ एक टेन्सर बनाता है type और shape , संभाजक का उपयोग कर a अंतर्निहित बफर आवंटित करने के लिए।

यदि LogMemory :: IsEnabled () आवंटन को अज्ञात कर्नेल और चरण से आने के रूप में लॉग किया जाता है। किसी ओपीन के भीतर से सीधे टेंसर कंस्ट्रक्टर को कॉल करने पर पदावनत किया जाता है: एक नए टेंसर को आवंटित करने के लिए ऑपकर्नेलकॉन्स्ट्रक्शन / ओपकर्नेल कॉन्टेक्स्ट__ तरीकों का उपयोग करें, जो कर्नेल और स्टेप को रिकॉर्ड करते हैं।

a इस के जीवनकाल से अधिक जीवित करना होगा टेन्सर

टेन्सर

 Tensor(
  Allocator *a,
  DataType type,
  const TensorShape & shape,
  const AllocationAttributes & allocation_attr
)

इनपुट के साथ एक टेन्सर बनाता है type और shape , संभाजक का उपयोग कर a और निर्दिष्ट "allocation_attr" आवंटित करने के लिए अंतर्निहित बफर।

यदि कर्नेल और चरण ज्ञात हैं आवंटन_attr.allocation_will_be_logged को सही पर सेट किया जाना चाहिए और LogMemory :: RecordTensorAllocation को टेंसर के निर्माण के बाद बुलाया जाना चाहिए। किसी ओपीन के भीतर से सीधे टेंसर कंस्ट्रक्टर को कॉल करने पर पदावनत किया जाता है: एक नए टेंसर को आवंटित करने के लिए ऑपकर्नेलकॉन्स्ट्रक्शन / ओपकर्नेल कॉन्टेक्स्ट__ तरीकों का उपयोग करें, जो कर्नेल और स्टेप को रिकॉर्ड करते हैं।

a इस के जीवनकाल से अधिक जीवित करना होगा टेन्सर

टेन्सर

 Tensor(
  DataType type,
  const TensorShape & shape,
  TensorBuffer *buf
)

इनपुट डेटाटाइप, आकृति और buf के साथ एक टेंसर बनाता है।

Buf पर एक रेफरी प्राप्त करता है जो इस Tensor का है

टेन्सर

 Tensor(
  DataType type
)

दिए गए डेटा प्रकार का एक खाली सेंसर बनाता है।

Tensor () की तरह , एक 1-आयामी, 0-तत्व Tensor को IsInitialized () True लौटाता है। विवरण के लिए टेन्सर () प्रलेखन देखें।

टेन्सर

 Tensor(
  float scalar_value
)

टेन्सर

 Tensor(
  double scalar_value
)

टेन्सर

 Tensor(
  int32 scalar_value
)

टेन्सर

 Tensor(
  uint32 scalar_value
)

टेन्सर

 Tensor(
  uint16 scalar_value
)

टेन्सर

 Tensor(
  uint8 scalar_value
)

टेन्सर

 Tensor(
  int16 scalar_value
)

टेन्सर

 Tensor(
  int8 scalar_value
)

टेन्सर

 Tensor(
  tstring scalar_value
)

टेन्सर

 Tensor(
  complex64 scalar_value
)

टेन्सर

 Tensor(
  complex128 scalar_value
)

टेन्सर

 Tensor(
  int64 scalar_value
)

टेन्सर

 Tensor(
  uint64 scalar_value
)

टेन्सर

 Tensor(
  bool scalar_value
)

टेन्सर

 Tensor(
  qint8 scalar_value
)

टेन्सर

 Tensor(
  quint8 scalar_value
)

टेन्सर

 Tensor(
  qint16 scalar_value
)

टेन्सर

 Tensor(
  quint16 scalar_value
)

टेन्सर

 Tensor(
  qint32 scalar_value
)

टेन्सर

 Tensor(
  bfloat16 scalar_value
)

टेन्सर

 Tensor(
  Eigen::half scalar_value
)

टेन्सर

 Tensor(
  ResourceHandle scalar_value
)

टेन्सर

 Tensor(
  const char *scalar_value
)

टेन्सर

 Tensor(
  const Tensor & other
)

कंस्ट्रक्टर को कॉपी करें।

टेन्सर

 Tensor(
  Tensor && other
)

कंस्ट्रक्टर को स्थानांतरित करें।

इस कॉल के बाद, सुरक्षित रूप से विनाशकारी है और इसे सौंपा जा सकता है, लेकिन इस पर अन्य कॉल (जैसे आकार में हेरफेर) मान्य नहीं हैं।

TotalBytes

size_t TotalBytes() const 

इस टेंसर के अनुमानित स्मृति उपयोग को लौटाता है।

UnsafeCopyFromInternal

void UnsafeCopyFromInternal(
  const Tensor & other,
  DataType dtype,
  const TensorShape & shape
)

बिटकास्टफ्रॉम की तरह, लेकिन अगर कोई पूर्व शर्त पूरी नहीं हुई तो CHECK विफल हो जाती है।

पदावनत किया हुआ। इसके बजाय BitcastFrom का उपयोग करें और लौटे स्थिति की जाँच करें।

bit_casted_shaped

TTypes< T, NDIMS >::Tensor bit_casted_shaped(
  gtl::ArraySlice< int64 > new_sizes
)

new_sizes डेटा को एक Eigen::Tensor लौटें नए आकार में निर्दिष्ट नए आकार के साथ और एक नए dtype T कास्ट करें।

बिटकास्ट का उपयोग चाल और प्रतिलिपि कार्यों के लिए उपयोगी है। अनुमत बिटकास्ट shaped() से एकमात्र अंतर है।

bit_casted_shaped

TTypes< T, NDIMS >::ConstTensor bit_casted_shaped(
  gtl::ArraySlice< int64 > new_sizes
) const 

new_sizes डेटा को एक Eigen::Tensor लौटें नए आकार में निर्दिष्ट नए आकार के साथ और एक नए dtype T कास्ट करें।

बिटकास्ट का उपयोग चाल और प्रतिलिपि कार्यों के लिए उपयोगी है। अनुमत बिटकास्ट shaped() से एकमात्र अंतर है।

bit_casted_tensor

TTypes< T, NDIMS >::Tensor bit_casted_tensor()
है

एक प्रतिजन के लिए दसवाँ डेटा लौटाएँ Eigen::Tensor एक ही आकार के साथ सेंसर लेकिन निर्दिष्ट dtype T लिए एक बिटवाइज़ कास्ट।

बिटकास्ट का उपयोग चाल और प्रतिलिपि कार्यों के लिए उपयोगी है। ध्यान दें: यह एक बिटकास्ट को छोड़कर अनुमार्गण tensor() समान है।

bit_casted_tensor

TTypes< T, NDIMS >::ConstTensor bit_casted_tensor() const 

टेंसर डेटा को Eigen::Tensor पर समान आकार के साथ लौटाएं लेकिन निर्दिष्ट dtype T लिए एक बिटवाइज़ कास्ट।

बिटकास्ट का उपयोग चाल और प्रतिलिपि कार्यों के लिए उपयोगी है। नोट: यह एक बिटकास्ट को छोड़कर tensor() समान है।

dim_size

int64 dim_size(
  int d
) const 

टेंसर आकार के लिए सुविधा अभिगमकर्ता।

मंद

int dims() const 

टेंसर आकार के लिए सुविधा अभिगमकर्ता।

सभी आकार के TensorShape , tensor_shape.h प्रासंगिक तरीकों के लिए टिप्पणियों को TensorShape में tensor_shape.h

dtype

DataType dtype() const 

डेटा प्रकार लौटाता है।

समतल

08 बी 1655020

टेंसर डेटा को एक Eigen::Tensor डेटा प्रकार और एक निर्दिष्ट आकार के सेंसर के रूप में लौटाएं।

ये विधियाँ आपको अपनी पसंद के आयामों और आकारों के साथ डेटा तक पहुँचने की अनुमति देती हैं। आपको उन्हें कॉल करने के लिए टेन्सर के आयामों की संख्या जानने की आवश्यकता नहीं है। हालाँकि, वे यह CHECK कि जिस प्रकार का मिलान होता है और जिन आयामों का अनुरोध किया जाता है, वे एक Eigen::Tensor को तत्वों की समान संख्या के साथ बनाते हैं।

उदाहरण:

  
    typedef float T;
    Tensor my_ten(...built with Shape{planes: 4, rows: 3, cols: 5}...);
    // 1D Eigen::Tensor, size 60:
    auto flat = my_ten.flat();
    // 2D Eigen::Tensor 12 x 5:
    auto inner = my_ten.flat_inner_dims();
    // 2D Eigen::Tensor 4 x 15:
    auto outer = my_ten.shaped({4, 15});
    // CHECK fails, bad num elements:
    auto outer = my_ten.shaped({4, 8});
    // 3D Eigen::Tensor 6 x 5 x 2:
    auto weird = my_ten.shaped({6, 5, 2});
    // CHECK fails, type mismatch:
    auto bad   = my_ten.flat();

      

flat

TTypes< T >::ConstFlat flat() const 

flat_inner_dims

TTypes< T, NDIMS >::Tensor flat_inner_dims()
है

डेटा को Eigen के रूप में लौटाता है :: NDIMS आयामों के साथ Tensor, सभी Tensor आयामों को ध्वस्त करता है लेकिन अंतिम NDIMS-1 परिणाम के पहले आयाम में।

अगर NDIMS> dims () है, तो आउटपुट रैंक NDIMS बनाने के लिए आकार 1 के प्रमुख आयामों को जोड़ा जाएगा।

flat_inner_dims

TTypes< T, NDIMS >::ConstTensor flat_inner_dims() const 

flat_inner_outer_dims

TTypes< T, NDIMS >::Tensor flat_inner_outer_dims(
  int64 begin
)

डेटा को एक Eigen के रूप में लौटाता है :: NDIMS आयामों वाला Tensor , परिणाम के पहले आयाम में 'शुरुआती' Tensor आयामों को ढहाने और अंतिम dims () - 'start' - Tensor आयामों के ND आयाम को अंतिम आयाम में परिणाम।

अगर 'शुरू' <0 तो | 'शुरू' | आकार 1 के अग्रणी आयाम जोड़े जाएंगे। यदि 'start' + NDIMS> dims () है तो 'start' + NDIMS - dims () आकार 1 के अनुगामी आयाम जोड़े जाएंगे।

flat_inner_outer_dims

TTypes< T, NDIMS >::ConstTensor flat_inner_outer_dims(
  int64 begin
) const 

flat_outer_dims

TTypes< T, NDIMS >::Tensor flat_outer_dims()

डेटा को Eigen के रूप में लौटाता है :: NDIMS आयामों के साथ Tensor, सभी Tensor आयामों को ध्वस्त करता है लेकिन परिणाम के अंतिम आयाम में पहला NDIMS-1।

यदि NDIMS> dims () है, तो आउटपुट रैंक NDIMS बनाने के लिए आकार 1 के अनुगामी आयाम जोड़े जाएंगे।

flat_outer_dims

TTypes< T, NDIMS >::ConstTensor flat_outer_dims() const 

आव्यूह

TTypes< T >::Matrix matrix()

आव्यूह

TTypes< T >::ConstMatrix matrix() const 

संचालक =

Tensor & operator=(
  const Tensor & other
)

संचालक का कार्यभार सौंपें। यह टेंसर अन्य अंतर्निहित भंडारण को साझा करता है।

संचालक =

Tensor & operator=(
  Tensor && other
)

ऑपरेटर को स्थानांतरित करें। विवरण के लिए मूव कंस्ट्रक्टर देखें।

reinterpret_last_dimension

TTypes< T, NDIMS >::Tensor reinterpret_last_dimension()

टेंसर डेटा को Eigen::Tensor लौटें अंतिम आयाम तत्वों के साथ एक बड़े प्रकार के एकल तत्वों में परिवर्तित।

उदाहरण के लिए, यह गुठली के लिए उपयोगी है जो NCHW_VECT_C int8 टेंसरों को NCHW इंटर्नल टेनसर्स के रूप में मान सकता है। आकार (T) मूल तत्व के आकार के बराबर होना चाहिए * मूल अंतिम आयाम में संख्या तत्व। NDIMS आयामों की मूल संख्या से 1 कम होना चाहिए।

reinterpret_last_dimension

TTypes< T, NDIMS >::ConstTensor reinterpret_last_dimension() const 

दसवें डेटा को एक Eigen::Tensor लौटें Eigen::Tensor एक बड़े प्रकार के एकल तत्वों में परिवर्तित अंतिम आयाम तत्वों के साथ सेंसर।

उदाहरण के लिए, यह गुठली के लिए उपयोगी है जो NCHW_VECT_C int8 टेंसरों को NCHW इंटर्नल टेनसर्स के रूप में मान सकता है। आकार (T) मूल तत्व के आकार के बराबर होना चाहिए * मूल अंतिम आयाम में संख्या तत्व। NDIMS आयामों की मूल संख्या से 1 कम होना चाहिए।

अदिश

TTypes< T >::Scalar scalar()

Tensor डेटा को निश्चित आकार 1 के TensorMap के रूप में TensorMap : TensorMap > TensorMap >

scalar() का उपयोग करने से कंपाइलर अनुकूलन करने की अनुमति देता है क्योंकि टैंसर का आकार संकलन समय पर जाना जाता है।

अदिश

TTypes< T >::ConstScalar scalar() const 

आकार

const TensorShape & shape() const 

टेंसर का आकार देता है।

आकार का

03000b8a0

आकार का

TTypes< T, NDIMS >::ConstTensor shaped(
  gtl::ArraySlice< int64 > new_sizes
) const 

टेन्सर

TTypes< T, NDIMS >::Tensor tensor()

टेन्सर

TTypes< T, NDIMS >::ConstTensor tensor() const 

टेंसर_डाटा

StringPiece tensor_data() const 

वर्तमान टेंसर के बफर को मैप करते हुए एक StringPiece लौटाता है।

वापस StringPiece गए StringPiece उन उपकरणों पर मेमोरी StringPiece को इंगित कर सकते हैं जिन्हें सीपीयू सीधे संबोधित नहीं कर सकता है।

नोट: अंतर्निहित टेंसर बफर को StringPiece किया गया है, StringPiece द्वारा मैप की गई सामग्री का जीवनकाल बफर के जीवनकाल से मेल खाता है; कॉल करने वालों को यह सुनिश्चित करने के लिए व्यवस्था करनी चाहिए कि बफर तबाह न हो, जबकि StringPiece का उपयोग अभी भी किया जाता है।

आवश्यकताएँ: DataTypeCanUseMemcpy(dtype())

unalign_flat

TTypes< T >::UnalignedFlat unaligned_flat()

unalign_flat

TTypes< T >::UnalignedConstFlat unaligned_flat() const 

unalign_shaped

TTypes< T, NDIMS >::UnalignedTensor unaligned_shaped(
  gtl::ArraySlice< int64 > new_sizes
)

unalign_shaped

TTypes< T, NDIMS >::UnalignedConstTensor unaligned_shaped(
  gtl::ArraySlice< int64 > new_sizes
) const 

वी.ई.सी

TTypes< T >::Vec vec()

टेंसर डेटा को एक Eigen :: Tensor के प्रकार और इस Tensor के आकार के साथ लौटाएं।

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

उदाहरण:

  
    typedef float T;
    Tensor my_mat(...built with Shape{rows: 3, cols: 5}...);
    auto mat = my_mat.matrix();    // 2D Eigen::Tensor, 3 x 5.
    auto mat = my_mat.tensor(); // 2D Eigen::Tensor, 3 x 5.
    auto vec = my_mat.vec();       // CHECK fails as my_mat is 2D.
    auto vec = my_mat.tensor(); // CHECK fails as my_mat is 2D.
    auto mat = my_mat.matrix();// CHECK fails as type mismatch.

      

vec

TTypes< T >::ConstVec vec() const 

उपरोक्त सभी विधियों के कॉन्स्टेंट संस्करण।

~ टेंसर

 ~Tensor()