tensorflow:: מוֹתֵחַ

#include <tensor.h>

מייצג מערך n-ממדי של ערכים.

תַקצִיר

בנאים והורסים
Tensor () יוצר טנזור צף חד מימדי בעל 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 , תוך שימוש ב-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 ()

תפקידים ציבוריים
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	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 אם יש צורך, האם Tensor זה אותחל?
IsSameSize (const Tensor & b) const	bool
NumElements () const	int64 אביזר נוחות לצורת הטנזור.
SharesBufferWith (const Tensor & b) const	bool
Slice (int64 dim0_start, int64 dim0_limit) const	Tensor פורסים את הטנזור לאורך הממד הראשון.
SubSlice (int64 index) const	Tensor בחר תת-פרוסה מהטנזור הזה לאורך הממד הראשון.
SummarizeValue (int64 max_entries, bool print_v2) const	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 שצוין.
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 החזר את נתוני Tensor בתור TensorMap בגודל קבוע 1: 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 גרסאות קונסט של כל השיטות לעיל.

תפקידים ציבוריים

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

string DebugString(
  int num_values
) const 

תקציר קריא אנושי של הטנזור המתאים לניפוי באגים.

DebugString

string DebugString() const 

DeviceSafeDebugString

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 

אביזר נוחות לצורת הטנזור.

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 <= dim0_start < dim_size(0)

SummarizeValue

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
)

יוצר טנסור type shape הנתונים.

אם LogMemory::IsEnabled() ההקצאה מתועדת כמגיעה מגרעין ומשלב לא ידועים. קריאה לבנאי Tensor ישירות מתוך Op מבוטלת: השתמש בשיטות OpKernelConstruction/OpKernelContext allocate_* כדי להקצות טנסור חדש, המתעד את הליבה והשלב.

המאגר הבסיסי מוקצה באמצעות CPUAllocator .

מוֹתֵחַ

 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(
  const Tensor & other
)

עותק בנאי.

מוֹתֵחַ

 Tensor(
  Tensor && other
)

העבר בנאי.

לאחר השיחה הזו, ניתן להרוס בבטחה וניתן להקצות אליו, אך קריאות אחרות עליו (למשל מניפולציה של צורה) אינן תקפות.

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 מותר.

עמום_גודל

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()

מחזיר את הנתונים כ-Eigen::Tensor עם ממדי NDIMS, מכווץ את כל ממדי Tensor אבל את ה-NDIMS-1 האחרון לממד הראשון של התוצאה.

אם NDIMS > dims() אזי מידות מובילות בגודל 1 יתווספו כדי להפוך את הפלט לדרגת NDIMS.

שטוח_מעומעם_פנימי

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()

מחזיר את הנתונים כ-Eigen::Tensor עם ממדי NDIMS, מכווץ את כל ממדי Tensor אבל את ה-NDIMS-1 הראשון לממד האחרון של התוצאה.

אם NDIMS > dims() אזי מידות נגררות בגודל 1 יתווספו כדי להפוך את הפלט לדירוג NDIMS.

שטוח_חיצוני_עמומים

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
)

מפעיל העברה. ראה בנאי העברה לפרטים.

לפרש מחדש_ממד_אחרון

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()

החזר את נתוני Tensor בתור TensorMap בגודל קבוע 1: TensorMap > TensorMap > .

שימוש ב- 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()