יום הקהילה ML הוא 9 בנובמבר! הצטרפו אלינו עדכונים מ- TensorFlow, JAX, ועוד למידע נוסף

זרימת טנסור :: מוֹתֵחַ

#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 , תוך שימוש בהקצאה 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 (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 עם מטא-נתונים אודות הטנסור היעיל לניטור 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
אביזר נוחות לצורת הטנסור.
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 הערכים 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 חדשים ויצוק לסוג d חדש T
bit_casted_shaped (gtl::ArraySlice< int64 > new_sizes) const
TTypes< T, NDIMS >::ConstTensor
החזר את נתוני הטנסור ל- Eigen::Tensor עם הצורה החדשה שצוינה new_sizes חדשים ויצוק לסוג d חדש 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
מחזיר את הנתונים כקובץ אייגן :: מותח עם ממדים NDIMS, קורסת כל מותח ממדים אך NDIMS-1 שעבר לתוך הממד הראשון של התוצאה.
flat_inner_dims () const
TTypes< T, NDIMS >::ConstTensor
flat_inner_outer_dims (int64 begin)
TTypes< T, NDIMS >:: Tensor
מחזיר את הנתונים כקובץ אייגן :: מותח עם ממדים NDIMS, קורסת הראשון "להתחיל" מותח מימדים למימד הראשון של התוצאה ואת מותח ממדי האחרון מעמעם () - "להתחיל" - NDIMS לתוך הממד האחרון של תוֹצָאָה.
flat_inner_outer_dims (int64 begin) const
TTypes< T, NDIMS >::ConstTensor
flat_outer_dims ()
TTypes< T, NDIMS >:: Tensor
מחזיר את הנתונים כקובץ אייגן :: מותח עם ממדים NDIMS, קורסת כל מותח ממדים אך 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 עם רכיבי הממד האחרון שהוסבו לאלמנטים בודדים מסוג גדול יותר.
reinterpret_last_dimension () const
TTypes< T, NDIMS >::ConstTensor
להחזיר את נתוני הטנזור ל- Eigen::Tensor עם רכיבי הממד האחרון שהוסבו לאלמנטים בודדים מסוג גדול יותר.
scalar ()
TTypes< T >::Scalar
החזר את טנסור נתונים כמו 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
)

העתק את הטנסור האחר לטנזור זה, עצב אותו מחדש ופרש מחדש את סוג הנתונים של המאגר.

אם מוחזר סטטוס :: אישור (), שני הטנזורים חולקים כעת את אותו האחסון הבסיסי.

קריאה זו דורשת שהטנסור other והסוג והצורה הנתונים יהיו "תואמים" (כלומר הם תופסים את אותו מספר בתים).

במיוחד:

shape.num_elements () * DataTypeSize (type)

חייב להיות שווה

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

העתק את הטנסור האחר לטנזור הזה ועצב אותו מחדש.

טנזור זה חולק את האחסון הבסיסי של אחרים. מחזירה true אם other.shape() מכיל את אותו מספר אלמנטים shape הנתונה.

DebugString

std::string DebugString(
  int num_values
) const 

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

DebugString

std::string DebugString() const 

DeviceSafeDebugString

std::string DeviceSafeDebugString() const 

FillDescription

void FillDescription(
  TensorDescription *description
) const 

מלא את הפרוטו של TensorDescription עם מטא-נתונים אודות הטנסור היעיל לניטור ולניפוי באגים.

מאת פרוטו

bool FromProto(
  const TensorProto & other
) TF_MUST_USE_RESULT

לנתח other ולבנות את הטנסור.

מחזירה true אם הניתוח מצליח. אם הניתוח נכשל, המצב של *this לא משתנה.

מאת פרוטו

bool FromProto(
  Allocator *a,
  const TensorProto & other
) TF_MUST_USE_RESULT

IsAligned

bool IsAligned() const 

מחזיר נכון אם טנזור זה מיושר.

יזם

bool IsInitialized() const 

אם יש צורך, האם טנזור זה בוצע אתחול?

טנזורי אפס-אלמנטים נחשבים תמיד לאתחילים, גם אם מעולם לא הוקצו להם ואין להם זיכרון מוקצה.

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, ...] == זה [dim0_start + i, ...]. הטנסור המוחזר חולק את מאגר הטנדרים הבסיסי עם הטנסור הזה.

הערה: ייתכן שהטנסור שהוחזר לא יעמוד באותה דרישת יישור כמו טנסור זה בהתאם לצורה. על המתקשר לבדוק את יישור הטנסור שהוחזר לפני שהוא קורא לשיטות מסוימות שיש להן דרישת יישור (למשל flat() , tensor() ).

הערה: כאשר מוזן עם טנסור ממדי N, שיטה זו מחזירה טנסור גם עם ממדי N. אם ברצונך לבחור תת-טנסור, ראה SubSlice.

דורש: dims() > = 1 דורש: 0 <= dim0_start <= dim0_limit <= dim_size(0)

SubSlice

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 הערכים max_entries הראשונים ב- *this למחרוזת.

מוֹתֵחַ

 Tensor()

יוצר טנסור צף חד ממדי, בעל 0 מרכיבים.

הטנסור שהוחזר אינו סקלרי (צורה {}), אלא הוא טנסור חד-ממדי ריק (צורה {0}, NumElements () == 0). מכיוון שאין בו אלמנטים, אין צורך להקצות לו ערך והוא מאותחל כברירת מחדל ( IsInitialized () נכון). אם זה לא רצוי, שקול ליצור סקלר של אלמנט אחד שדורש אתחול:

Tensor(DT_FLOAT, TensorShape({}))

      

Tensor

 Tensor(
  DataType type,
  const TensorShape & shape
)

יוצר טנסור type shape .

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

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

מוֹתֵחַ

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

יוצר טנסור עם type הקלט shape , באמצעות המקצה a להקצאת המאגר הבסיסי.

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

חייב לגבור על זה כל החיים מותח .

מוֹתֵחַ

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

יוצר טנסור עם type הקלט shape , תוך שימוש בהקצאת a וב- "allocation_attr" שצוין להקצאת המאגר הבסיסי.

אם הגרעין והשלב ידועים, יש להגדיר את allocation_attr.allocation_will_be_logged ו- LogMemory :: RecordTensorAllocation צריך להיקרא לאחר בניית הטנסור. קריאה לבניית טנסור ישירות מתוך אופ אינה מוצלחת: השתמש בשיטות OpKernelConstruction / OpKernelContext allocate_ * להקצאת טנסור חדש, שתעד את הגרעין ואת הצעד.

חייב לגבור על זה כל החיים מותח .

מוֹתֵחַ

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

יוצר טנסור עם סוג הנתונים הקלט, הצורה וה- buf.

רוכש שופט על buf השייך לטנסור זה.

מוֹתֵחַ

 Tensor(
  DataType type
)

יוצר טנסור ריק מסוג הנתונים הנתון.

כמו טנסור () , ומחזירה 1-ממדי, 0 אלמנט מותח עם IsInitialized () חוזרים נכון. לפרטים, עיין בתיעוד 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
)=delete

TotalBytes

size_t TotalBytes() const 

מחזיר את צריכת הזיכרון המשוערת של טנזור זה.

UnsafeCopyFromInternal

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

כמו BitcastFrom, אך CHECK נכשל אם לא מתקיימים תנאים מוקדמים כלשהם.

הוצא משימוש. השתמש במקום זאת ב- BitcastFrom ובדוק את הסטטוס שהוחזר.

צורת_מוסרטת_ bit

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

החזר את נתוני הטנסור ל- Eigen::Tensor עם הצורה החדשה שצוינה new_sizes חדשים ויצק לסוג dtype T חדש.

שימוש ב- bitcast שימושי לפעולות העברה והעתקה. ה- bitcast המותר הוא ההבדל היחיד בין shaped() .

צורת_מוסרטת_ bit

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

החזר את נתוני הטנסור ל- Eigen::Tensor עם הצורה החדשה שצוינה new_sizes חדשים ויצוק לסוג d חדש T

שימוש ב- bitcast שימושי לפעולות העברה והעתקה. ה- bitcast המותר הוא ההבדל היחיד מ- shaped() .

טנסור bit_casted_

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

להחזיר את הנתונים מותח אל Eigen::Tensor עם אותו גודל אלא נטיית ביטים אל dtype שצוין T .

שימוש ב- bitcast שימושי לפעולות העברה והעתקה. הערה: זה זהה לטנסור tensor() למעט ביטקאסט מותר.

טנסור bit_casted_

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

להחזיר את הנתונים מותח אל Eigen::Tensor עם אותו גודל אלא נטיית ביטים אל dtype שצוין T .

שימוש ב- bitcast שימושי לפעולות העברה והעתקה. הערה: זה זהה לטנסור tensor() למעט ביטקאסט מותר.

נתונים

void * data() const 

dim_size

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

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

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

שטוחות_ארוחות_עמעימות

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

דימוי_אחד_במפלגות_אנשים

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

מחזיר את הנתונים כקובץ אייגן :: מותח עם ממדים NDIMS, קורסת הראשון "להתחיל" מותח מימדים למימד הראשון של התוצאה ואת מותח ממדי האחרון מעמעם () - "להתחיל" - NDIMS לתוך הממד האחרון של תוֹצָאָה.

אם 'התחל' <0 אז | 'התחל' | יתווספו מידות מובילות בגודל 1. אם 'התחל' + NDIMS> מעומעם () ואז יתווסף 'מתחיל' + NDIMS - מעומעם () מידות נגררות בגודל 1.

דימוי_ארוחת_הביתה

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

שטוח_אאוט_דימוי

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

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

אם NDIMS> מעמעם () , יתווספו מידות נגררות בגודל 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. גודל ה- (T) צריך להיות שווה לגודל סוג האלמנט המקורי * מספר האלמנטים בממד האחרון המקורי. NDIMS צריך להיות פחות ממספר הממדים המקורי.

לפרש מחדש את הממד האחרון

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

להחזיר את נתוני הטנזור ל- Eigen::Tensor עם רכיבי הממד האחרון שהומרו לאלמנטים בודדים מסוג גדול יותר.

לדוגמה, זה שימושי עבור גרעינים שיכולים להתייחס לנסרים NCHW_VECT_C int8 כאל טנסרים NCHW int32. גודל ה- (T) צריך להיות שווה לגודל סוג האלמנט המקורי * מספר האלמנטים בממד האחרון המקורי. NDIMS צריך להיות פחות ממספר הממדים המקורי.

סקלר

TTypes< T >::Scalar scalar()

החזר את טנסור נתונים כמו 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 שהוחזר עשוי להצביע על מיקום זיכרון בהתקנים שהמעבד אינו יכול לטפל בהם ישירות.

הערה: מאגר הטנסור הבסיסי נספר מחדש, כך שאורך החיים של התוכן הממופה על ידי StringPiece תואם את חיי המאגר; על המתקשרים לדאוג לוודא שהמאגר לא נהרס בזמן שמשתמשים במחרוזת.

דורש: DataTypeCanUseMemcpy (dtype ()).

לא מיושר_שטוח

TTypes< T >::UnalignedFlat unaligned_flat()

לא מיושר_שטוח

TTypes< T >::UnalignedConstFlat unaligned_flat() const 

לא מיושר_ בצורת

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

לא מיושר_ בצורת

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

vec

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