tensorflow:: מוֹתֵחַ
#include <tensor.h>
מייצג מערך n-ממדי של ערכים.
תַקצִיר
בנאים והורסים | |
---|---|
Tensor () יוצר טנזור צף חד מימדי בעל 0 אלמנטים. | |
Tensor (DataType type, const TensorShape & 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 , תוך שימוש ב-alocator a וב-"allocation_attr" שצוין כדי להקצות את המאגר הבסיסי. | |
Tensor (DataType type, const TensorShape & shape, TensorBuffer *buf) יוצר טנזור עם סוג הנתונים הקלט, צורה ו-buff. | |
Tensor (DataType type) יוצר Tensor ריק מסוג הנתונים הנתון. | |
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 (T *t) | |
~Tensor () |
תפקידים ציבוריים | |
---|---|
AllocatedBytes () const | size_t |
AsProtoField (TensorProto *proto) const | void ממלא proto עם *this . |
AsProtoTensorContent (TensorProto *proto) const | void |
BitcastFrom (const Tensor & other, DataType dtype, const TensorShape & shape) | Status העתק את הטנזור השני לטנזור זה, עצב אותו מחדש ופרש מחדש את סוג הנתונים של המאגר. |
CopyFrom (const Tensor & other, const TensorShape & shape) TF_MUST_USE_RESULT | bool העתיקו את הטנזור השני לטנזור הזה ועצבו אותו מחדש. |
DebugString (int num_values) const | std::string תקציר קריא אנושי של הטנזור המתאים לניפוי באגים. |
DebugString () const | std::string |
DeviceSafeDebugString () const | std::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 אם יש צורך, האם Tensor זה אותחל? |
IsSameSize (const Tensor & b) const | bool |
NumElements () const | int64 אביזר נוחות לצורת הטנזור. |
RefCountIsOne () const | bool |
SharesBufferWith (const Tensor & b) const | bool |
Slice (int64 dim0_start, int64 dim0_limit) const | פורסים את הטנזור הזה לאורך הממד הראשון. |
SubSlice (int64 index) const | בחר תת-פרוסה מהטנזור הזה לאורך הממד הראשון. |
SummarizeValue (int64 max_entries, bool print_v2) const | std::string עבד את ערכי max_entries הראשונים ב- *this למחרוזת. |
TotalBytes () const | size_t מחזירה את השימוש המשוער בזיכרון של טנזור זה. |
UnsafeCopyFromInternal (const Tensor & other, DataType dtype, const TensorShape & shape) | void כמו BitcastFrom, אבל CHECK נכשל אם תנאים מוקדמים לא מתקיימים. |
bit_casted_shaped (gtl::ArraySlice< int64 > new_sizes) | TTypes< T, NDIMS >:: Tensor החזר את נתוני הטנסור ל- Eigen::Tensor עם הצורה החדשה שצוינה ב- new_sizes והוצק ל-dtype T חדש. |
bit_casted_shaped (gtl::ArraySlice< int64 > new_sizes) const | TTypes< T, NDIMS >::ConstTensor החזר את נתוני הטנסור ל- 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 שצוין. |
data () const | void * |
dim_size (int d) const | int64 אביזר נוחות לצורת הטנזור. |
dims () const | int אביזר נוחות לצורת הטנזור. |
dtype () const | DataType מחזירה את סוג הנתונים. |
flat () | TTypes< T >::Flat החזר את נתוני הטנזור כ- Eigen::Tensor מסוג הנתונים וצורה שצוינה. |
flat () const | TTypes< T >::ConstFlat |
flat_inner_dims () | TTypes< T, NDIMS >:: Tensor מחזיר את הנתונים כ-Eigen::Tensor עם ממדי NDIMS, מכווץ את כל ממדי Tensor אבל את ה-NDIMS-1 האחרון לממד הראשון של התוצאה. |
flat_inner_dims () const | TTypes< T, NDIMS >::ConstTensor |
flat_inner_outer_dims (int64 begin) | TTypes< T, NDIMS >:: Tensor מחזיר את הנתונים כ-Eigen::Tensor עם ממדי NDIMS, מכווץ את ממדי ה-Tensor 'ההתחלה' הראשונים לממד הראשון של התוצאה ואת מימדי ה-Tensor של העמעומים האחרונים() - 'begin' - NDIMS לממד האחרון של ה- תוֹצָאָה. |
flat_inner_outer_dims (int64 begin) const | TTypes< T, NDIMS >::ConstTensor |
flat_outer_dims () | TTypes< T, NDIMS >:: Tensor מחזיר את הנתונים כ-Eigen::Tensor עם ממדי NDIMS, מכווץ את כל ממדי Tensor אבל את ה-NDIMS-1 הראשון לממד האחרון של התוצאה. |
flat_outer_dims () const | TTypes< T, NDIMS >::ConstTensor |
matrix () | TTypes< T >::Matrix |
matrix () const | TTypes< T >::ConstMatrix |
operator= (const Tensor & other) | Tensor & הקצה מפעיל. טנזור זה חולק את האחסון הבסיסי של אחרים. |
operator= ( Tensor && other) | Tensor & מפעיל העברה. לפרטים, ראה בנאי העברה. |
reinterpret_last_dimension () | TTypes< T, NDIMS >:: Tensor החזר את נתוני הטנזור ל- Eigen::Tensor עם רכיבי הממד האחרון שהומרו לאלמנטים בודדים מסוג גדול יותר. |
reinterpret_last_dimension () const | TTypes< T, NDIMS >::ConstTensor החזר את נתוני הטנזור ל- Eigen::Tensor עם רכיבי הממד האחרון שהומרו לאלמנטים בודדים מסוג גדול יותר. |
scalar () | TTypes< T >::Scalar |
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 גרסאות קונסט של כל השיטות לעיל. |
תפקידים ציבוריים
AllocatedBytes
size_t AllocatedBytes() const
AsProtoField
void AsProtoField( TensorProto *proto ) const
ממלא proto
עם *this
.
AsProtoField()
ממלא את השדה החוזר עבור proto.dtype()
, בעוד AsProtoTensorContent()
מקודד את התוכן ב- proto.tensor_content()
בצורה קומפקטית.
AsProtoTensorContent
void AsProtoTensorContent( TensorProto *proto ) const
BitcastFrom
Status BitcastFrom( const Tensor & other, DataType dtype, const TensorShape & shape )
העתיקו את הטנזור השני לטנזור הזה, עצבו אותו מחדש ותפרשו מחדש את סוג הנתונים של המאגר.
אם Status::OK() מוחזר, שני הטנסורים חולקים כעת את אותו האחסון הבסיסי.
קריאה זו דורשת שהטנזור other
והסוג והצורה הנתונים יהיו "תואמים" (כלומר הם תופסים את אותו מספר בתים).
ספציפית:
shape.num_elements() * DataTypeSize(type)
חייב להיות שווה
other.num_elements() * DataTypeSize(other.dtype())
בנוסף, פונקציה זו דורשת:
- DataTypeSize(other.dtype()) != 0
- DataTypeSize(type) != 0
אם אחת מהדרישות לא מתקיימת, שגיאות::InvalidArgument מוחזרות.
CopyFrom
bool CopyFrom( const Tensor & other, const TensorShape & shape ) TF_MUST_USE_RESULT
העתיקו את הטנזור השני לטנזור הזה ועצבו אותו מחדש.
טנזור זה חולק את האחסון הבסיסי של אחרים. מחזירה true
אם other.shape()
יש אותו מספר אלמנטים של shape
הנתונה.
DebugString
std::string DebugString( int num_values ) const
סיכום קריא על ידי אדם של הטנזור המתאים לניפוי באגים.
DebugString
std::string DebugString() const
DeviceSafeDebugString
std::string DeviceSafeDebugString() const
מילוי תיאור
void FillDescription( TensorDescription *description ) const
מלא את פרוטו TensorDescription
עם מטא נתונים על הטנזור שימושי לניטור וניפוי באגים.
FromProto
bool FromProto( const TensorProto & other ) TF_MUST_USE_RESULT
נתח other
ובנה את הטנזור.
מחזירה true
אם הניתוח יצליח. אם הניתוח נכשל, המצב של *this
לא ישתנה.
FromProto
bool FromProto( Allocator *a, const TensorProto & other ) TF_MUST_USE_RESULT
IsAligned
bool IsAligned() const
מחזירה אמת אם טנזור זה מיושר.
הוא אתחול
bool IsInitialized() const
אם יש צורך, האם Tensor זה אותחל?
Tensors אפס אלמנטים נחשבים תמיד לאתחלים, גם אם מעולם לא הוקצו אליהם ואין להם זיכרון שהוקצה להם.
IsSameSize
bool IsSameSize( const Tensor & b ) const
NumElements
int64 NumElements() const
אביזר נוחות לצורת הטנזור.
RefCountIsOne
bool RefCountIsOne() const
SharesBufferWith
bool SharesBufferWith( const Tensor & b ) const
פְּרוּסָה
Tensor Slice( int64 dim0_start, int64 dim0_limit ) const
פורסים את הטנזור הזה לאורך הממד הראשון.
כלומר, הטנזור המוחזר עונה על המוחזר[i, ...] == this[dim0_start + i, ...]. הטנזור המוחזר חולק את חיץ הטנזור הבסיסי עם טנזור זה.
הערה: ייתכן שהטנזור המוחזר לא יעמוד באותה דרישת יישור כמו הטנזור הזה, בהתאם לצורה. המתקשר חייב לבדוק את היישור של הטנזור המוחזר לפני שיקרא לשיטות מסוימות שיש להן דרישת יישור (למשל, flat()
, tensor()
).
הערה: כאשר מוזנים עם טנזור N-ממדי, שיטה זו מחזירה טנזור גם עם N ממדים. אם ברצונך לבחור תת-טנזור, ראה SubSlice.
דורש: dims()
>= 1 דורש: 0 <= dim0_start <= dim0_limit <= dim_size(0)
תת פרוסה
Tensor SubSlice( int64 index ) const
בחר תת-פרוסה מהטנזור הזה לאורך הממד הראשון.
כאשר מוזנים עם טנזור N-ממדי, שיטה זו מחזירה טנזור עם ממדי N-1, כאשר הטנזור המוחזר הוא תת-פריסה של טנזור הקלט לאורך הממד הראשון. מידות ה-N-1 של הטנזור המוחזר הן מידות ה-N-1 האחרונות של טנזור הקלט.
הערה: ייתכן שהטנזור המוחזר לא יעמוד באותה דרישת יישור כמו הטנזור הזה, בהתאם לצורה. המתקשר חייב לבדוק את היישור של הטנזור המוחזר לפני שיקרא לשיטות מסוימות שיש להן דרישת יישור (למשל, flat()
, tensor()
).
דורש: dims()
>= 1 דורש: 0 <= index < dim_size(0)
SummarizeValue
std::string SummarizeValue( int64 max_entries, bool print_v2 ) const
עבד את ערכי max_entries
הראשונים ב- *this
למחרוזת.
מוֹתֵחַ
Tensor()
יוצר טנזור צף חד מימדי בעל 0 אלמנטים.
הטנסור המוחזר אינו סקלרי (צורה {}), אלא הוא טנסור חד-ממדי ריק (צורה {0}, NumElements() == 0). מכיוון שאין לו אלמנטים, אין צורך להקצות לו ערך והוא מאותחל כברירת מחדל ( IsInitialized() הוא true). אם זה לא רצוי, שקול ליצור סקלר של אלמנט אחד שאכן דורש אתחול:
Tensor(DT_FLOAT, TensorShape({}))
Tensor
Tensor( DataType type, const TensorShape & shape )
מוֹתֵחַ
Tensor( Allocator *a, DataType type, const TensorShape & shape )
יוצר טנזור עם type
הקלט shape
, תוך שימוש במקצה a
כדי להקצות את המאגר הבסיסי.
אם LogMemory::IsEnabled() ההקצאה מתועדת כמגיעה מגרעין ומשלב לא ידועים. קריאה לבנאי Tensor ישירות מתוך Op מבוטלת: השתמש בשיטות OpKernelConstruction/OpKernelContext allocate_* כדי להקצות טנסור חדש, המתעד את הליבה והשלב.
a
לחיות את חייו של הטנסור הזה.
מוֹתֵחַ
Tensor( Allocator *a, DataType type, const TensorShape & shape, const AllocationAttributes & allocation_attr )
יוצר טנזור עם type
הקלט shape
, תוך שימוש ב-alocator a
וב-"allocation_attr" שצוין כדי להקצות את המאגר הבסיסי.
אם הליבה והשלב ידועים, יש להגדיר allocation_attr.allocation_will_be_logged ל-true ויש לקרוא ל-LogMemory::RecordTensorAllocation לאחר בניית הטנסור. קריאה לבנאי Tensor ישירות מתוך Op מבוטלת: השתמש בשיטות OpKernelConstruction/OpKernelContext allocate_* כדי להקצות טנסור חדש, המתעד את הליבה והשלב.
a
לחיות את חייו של הטנסור הזה.
מוֹתֵחַ
Tensor( DataType type, const TensorShape & shape, TensorBuffer *buf )
יוצר טנזור עם סוג הנתונים הקלט, צורה ו-buff.
רוכש שופט ב-buff ששייך לטנסור הזה.
מוֹתֵחַ
Tensor( DataType type )
יוצר Tensor ריק מסוג הנתונים הנתון.
בדומה ל-Tensor() , מחזיר Tensor חד-ממדי, 0-אלמנט, כאשר IsInitialized() מחזיר True. עיין בתיעוד Tensor() לפרטים.
מוֹתֵחַ
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( Tensor && other )
העבר בנאי.
לאחר השיחה הזו,
מוֹתֵחַ
Tensor( T *t )=delete
TotalBytes
size_t TotalBytes() const
מחזירה את השימוש המשוער בזיכרון של טנזור זה.
UnsafeCopyFromInternal
void UnsafeCopyFromInternal( const Tensor & other, DataType dtype, const TensorShape & shape )
כמו BitcastFrom, אבל CHECK נכשל אם תנאים מוקדמים לא מתקיימים.
הוצא משימוש. השתמש ב-BitcastFrom במקום זאת ובדוק את הסטטוס שהוחזר.
bit_casted_shaped
TTypes< T, NDIMS >::Tensor bit_casted_shaped( gtl::ArraySlice< int64 > new_sizes )
החזר את נתוני הטנזור ל- Eigen::Tensor
עם הצורה החדשה שצוינה ב- new_sizes
והוצק ל-dtype T
חדש.
שימוש ב-bitcast שימושי לפעולות העברה והעתקה. ה-bitcast המותר הוא ההבדל היחיד מ- shaped()
.
bit_casted_shaped
TTypes< T, NDIMS >::ConstTensor bit_casted_shaped( gtl::ArraySlice< int64 > new_sizes ) const
החזר את נתוני הטנזור ל- Eigen::Tensor
עם הצורה החדשה שצוינה ב- new_sizes
והוצק ל-dtype T
חדש.
שימוש ב-bitcast שימושי לפעולות העברה והעתקה. ה-bitcast המותר הוא ההבדל היחיד מ- shaped()
.
bit_casted_tensor
TTypes< T, NDIMS >::Tensor bit_casted_tensor()
החזר את נתוני הטנסור ל- Eigen::Tensor
באותו גודל אך יציקה סיבית ל-dtype T
שצוין.
שימוש ב-bitcast שימושי לפעולות העברה והעתקה. הערה: זה זהה ל- tensor()
פרט ל-bitcast מותר.
bit_casted_tensor
TTypes< T, NDIMS >::ConstTensor bit_casted_tensor() const
החזר את נתוני הטנזור ל- Eigen::Tensor
באותו גודל אך יציקה בכיוון סיביות ל-dtype T
שצוין.
שימוש ב-bitcast שימושי לפעולות העברה והעתקה. הערה: זה זהה ל- tensor()
פרט ל-bitcast מותר.
נְתוּנִים
void * data() const
עמום_גודל
int64 dim_size( int d ) const
אביזר נוחות לצורת הטנזור.
מתעמעם
int dims() const
אביזר נוחות לצורת הטנזור.
לכל אביזרי הצורה, ראה הערות לשיטות רלוונטיות של TensorShape
ב- tensor_shape.h
.
dtype
DataType dtype() const
מחזירה את סוג הנתונים.
שָׁטוּחַ
TTypes< T >::Flat flat()
החזר את נתוני הטנזור כ- 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
שטוח_מעומעם_פנימי
TTypes< T, NDIMS >::Tensor flat_inner_dims()
שטוח_מעומעם_פנימי
TTypes< T, NDIMS >::ConstTensor flat_inner_dims() const
שטוחים_פנימיים_חיצוניים
TTypes< T, NDIMS >::Tensor flat_inner_outer_dims( int64 begin )
מחזיר את הנתונים כ-Eigen::Tensor עם ממדי NDIMS, מכווץ את ממדי ה-Tensor 'ההתחלה' הראשונים לממד הראשון של התוצאה ואת מימדי ה-Tensor של העמעומים האחרונים() - 'begin' - NDIMS לממד האחרון של ה- תוֹצָאָה.
אם 'התחלה' < 0 אז ה- |'begin'| מידות מובילות בגודל 1 יתווספו. אם 'begin' + NDIMS > dims() אזי 'begin' + NDIMS - dims() יתווספו מידות נגררות בגודל 1.
שטוחים_פנימיים_חיצוניים
TTypes< T, NDIMS >::ConstTensor flat_inner_outer_dims( int64 begin ) const
שטוח_חיצוני_עמעומים
TTypes< T, NDIMS >::Tensor 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 )
הקצה מפעיל. טנזור זה חולק את האחסון הבסיסי של אחרים.
לפרש מחדש_ממד_אחרון
TTypes< T, NDIMS >::Tensor reinterpret_last_dimension()
החזר את נתוני הטנזור ל- Eigen::Tensor
עם רכיבי הממד האחרון שהומרו לאלמנטים בודדים מסוג גדול יותר.
לדוגמה, זה שימושי עבור גרעינים שיכולים להתייחס לטנסור NCHW_VECT_C int8 כאל טנסור NCHW int32. ה-sizeof(T) צריך להיות שווה לגודל של סוג האלמנט המקורי * מספר אלמנטים בממד האחרון המקורי. NDIMS צריך להיות 1 פחות ממספר הממדים המקורי.
לפרש מחדש_ממד_אחרון
TTypes< T, NDIMS >::ConstTensor reinterpret_last_dimension() const
החזר את נתוני הטנזור ל- Eigen::Tensor
עם רכיבי הממד האחרון שהומרו לאלמנטים בודדים מסוג גדול יותר.
לדוגמה, זה שימושי עבור גרעינים שיכולים להתייחס לטנסור NCHW_VECT_C int8 כאל טנסור NCHW int32. ה-sizeof(T) צריך להיות שווה לגודל של סוג האלמנט המקורי * מספר אלמנטים בממד האחרון המקורי. NDIMS צריך להיות 1 פחות ממספר הממדים המקורי.
סקלרי
TTypes< T >::Scalar scalar()
סקלרי
TTypes< T >::ConstScalar scalar() const
צוּרָה
const TensorShape & shape() const
מחזירה את צורת הטנזור.
מְעוּצָב
TTypes< T, NDIMS >::Tensor shaped( gtl::ArraySlice< int64 > new_sizes )
מְעוּצָב
TTypes< T, NDIMS >::ConstTensor shaped( gtl::ArraySlice< int64 > new_sizes ) const
מוֹתֵחַ
TTypes< T, NDIMS >::Tensor tensor()
מוֹתֵחַ
TTypes< T, NDIMS >::ConstTensor tensor() const
tensor_data
StringPiece tensor_data() const
מחזירה StringPiece הממפה את המאגר של הטנזור הנוכחי.
ה-StringPiece המוחזר עשוי להצביע על מיקום זיכרון במכשירים שה-CPU לא יכול לפנות אליהם ישירות.
הערה: מאגר הטנזור הבסיסי נספר מחדש, כך שאורך החיים של התוכן הממופת על ידי StringPiece תואם את משך החיים של המאגר; המתקשרים צריכים לארגן כדי לוודא שהמאגר לא ייהרס בזמן שה-StringPiece עדיין בשימוש.
דורש: DataTypeCanUseMemcpy(dtype()) .
unaligned_flat
TTypes< T >::UnalignedFlat unaligned_flat()
unaligned_flat
TTypes< T >::UnalignedConstFlat unaligned_flat() const
unaligned_shaped
TTypes< T, NDIMS >::UnalignedTensor unaligned_shaped( gtl::ArraySlice< int64 > new_sizes )
unaligned_shaped
TTypes< T, NDIMS >::UnalignedConstTensor unaligned_shaped( gtl::ArraySlice< int64 > new_sizes ) const
vec
TTypes< T >::Vec vec()
החזר את נתוני הטנזור בתור Eigen::Tensor עם הסוג והגדלים של הטנסור הזה.
השתמש בשיטות אלה כאשר אתה יודע את סוג הנתונים ומספר הממדים של הטנסור ואתה רוצה Eigen::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()
אלא אם צוין אחרת, התוכן של דף זה הוא ברישיון Creative Commons Attribution 4.0 ודוגמאות הקוד הן ברישיון Apache 2.0. לפרטים, ניתן לעיין במדיניות האתר Google Developers. Java הוא סימן מסחרי רשום של חברת Oracle ו/או של השותפים העצמאיים שלה.
עדכון אחרון: 2024-11-30 (שעון UTC).