דף זה תורגם על ידי Cloud Translation API.

זרימת טנזור:: טנזור

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

תפקידים ציבוריים
`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` אם יש צורך, האם טנזור זה אותחל?
`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, תוך כיווץ כל ממדי הטנזור מלבד ה-NDIMS-1 האחרון לתוך הממד הראשון של התוצאה.
`flat_inner_dims () const`	`TTypes< T, NDIMS >::ConstTensor`
`flat_inner_outer_dims (int64 begin)`	`TTypes< T, NDIMS >:: Tensor` מחזירה את הנתונים כ-Eigen::Tensor עם ממדי NDIMS, תוך כיווץ ממדי הטנזור 'begin' הראשונים לתוך הממד הראשון של התוצאה ואת ממדי הטנזור של ה- dims() - 'begin' - NDIMS האחרונים לתוך הממד האחרון של התוצאה.
`flat_inner_outer_dims (int64 begin) const`	`TTypes< T, NDIMS >::ConstTensor`
`flat_outer_dims ()`	`TTypes< T, NDIMS >:: Tensor` מחזירה את הנתונים כ-Eigen::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)`	`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` החזר את נתוני הטנזור כ- `TensorMap` בגודל קבוע 1: `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` גרסאות Const של כל השיטות לעיל.

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

בתים שהוקצו

size_t AllocatedBytes() const

AsProtoField

void AsProtoField(
  TensorProto *proto
) const

ממלא את proto עם התוכן של טנזור *this .

AsProtoField() ממלאת את השדה החוזר עבור proto.dtype() , בעוד ש- AsProtoTensorContent() מקודדת את התוכן ב- proto.tensor_content() בצורה קומפקטית.

תוכן פרוטו-טנזור

void AsProtoTensorContent(
  TensorProto *proto
) const

Bitcast מאת

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

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

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

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

ספציפית:

shape.num_elements() * גודל סוג נתונים (סוג)

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

other.num_elements() * גודל סוג נתונים(other.dtype())

בנוסף, פונקציה זו דורשת:

גודלסוגData(אחר.dtype()) != 0
גודלסוג נתונים (סוג) != 0

אם אחת מהדרישות אינה מתקיימת, מוחזר errors::InvalidArgument.

העתק מ

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

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

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

ניפוי באגים

string DebugString(
  int num_values
) const

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

ניפוי באגים

string DebugString() const

DeviceSafeDeviceSafeDebugString

string DeviceSafeDebugString() const

מילוי תיאור

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

מיושר

bool IsAligned() const

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

אותחל

bool IsInitialized() const

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

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

אותו גודל

bool IsSameSize(
  const Tensor & b
) const

מספר אלמנטים

int64 NumElements() const

גישה נוחה לצורת הטנזור.

שיתוף מאגר עם

bool SharesBufferWith(
  const Tensor & b
) const

פְּרוּסָה

Tensor Slice(
  int64 dim0_start,
  int64 dim0_limit
) const

פרסו את הטנזור הזה לאורך המימד הראשון.

כלומר, הטנזור המוחזר מקיים את return[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 הממדים האחרונים של טנזור הקלט.

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

סיכום ערך

string SummarizeValue(
  int64 max_entries,
  bool print_v2
) const

עבדו את הערכים הראשונים max_entries ב- *this למחרוזת.

מוֹתֵחַ

 Tensor()

יוצר טנזור צף חד-ממדי בעל 0 אלמנטים.

הטנזור המוחזר אינו סקלרי (shape {}), אלא טנזור חד-ממדי ריק (shape {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 כדי להקצות את המאגר הבסיסי.

a לשרוד את חייו של טנזור זה.

מוֹתֵחַ

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

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

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

a לשרוד את חייו של טנזור זה.

מוֹתֵחַ

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

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

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

מוֹתֵחַ

 Tensor(
  DataType type
)

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

כמו 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
)

בנאי העברה.

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

סך כל הבייטים

size_t TotalBytes() const

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

העתקה לא בטוחהמפנימית

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

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

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

בצורת_יצוק_bit

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

החזר את נתוני הטנזור ל- Eigen::Tensor עם הצורה החדשה שצוינה ב- new_sizes והפוך ל- dtype חדש T

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

בצורת_יצוק_bit

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

החזר את נתוני הטנזור ל- Eigen::Tensor עם הצורה החדשה שצוינה ב- new_sizes והפוך ל- dtype חדש T

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

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 .

סוג-די

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<T, 2>({4, 15});
    // CHECK fails, bad num elements:
    auto outer = my_ten.shaped<T, 2>({4, 8});
    // 3D Eigen::Tensor 6 x 5 x 2:
    auto weird = my_ten.shaped<T, 3>({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, תוך כיווץ כל ממדי הטנזור מלבד ה-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, תוך כיווץ ממדי הטנזור 'begin' הראשונים לתוך הממד הראשון של התוצאה ואת ממדי הטנזור של ה- dims() - 'begin' - NDIMS האחרונים לתוך הממד האחרון של התוצאה.

אם 'begin' < 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, תוך כיווץ כל ממדי הטנזור מלבד ה-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) צריך להיות שווה לגודל האלמנטים המקוריים מסוג * num בממד האחרון המקורי. NDIMS צריך להיות קטן ב-1 ממספר הממדים המקורי.

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

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

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

סקלרי

TTypes< T >::Scalar scalar()

החזר את נתוני הטנזור כ- TensorMap בגודל קבוע 1: 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

נתוני_טנזור

StringPiece tensor_data() const

מחזירה StringPiece הממפה את המאגר של הטנזור הנוכחי.

ייתכן 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

וקטור

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<T, 2>(); // 2D Eigen::Tensor, 3 x 5.
    auto vec = my_mat.vec();       // CHECK fails as my_mat is 2D.
    auto vec = my_mat.tensor<T, 3>(); // CHECK fails as my_mat is 2D.
    auto mat = my_mat.matrix();// CHECK fails as type mismatch.

vec

TTypes< T >::ConstVec vec() const

גרסאות Const של כל השיטות לעיל.

~טנזור

 ~Tensor()

זרימת טנזור:: טנזור

תַקצִיר

בנאים והורסים

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

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

בתים שהוקצו

AsProtoField

תוכן פרוטו-טנזור

Bitcast מאת

העתק מ

ניפוי באגים

ניפוי באגים

DeviceSafeDeviceSafeDebugString

מילוי תיאור

מפרוטו

מפרוטו

מיושר

אותחל

אותו גודל

מספר אלמנטים

שיתוף מאגר עם

פְּרוּסָה

תת-פרוסה

סיכום ערך

מוֹתֵחַ

Tensor

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

סך כל הבייטים

העתקה לא בטוחהמפנימית

בצורת_יצוק_bit

בצורת_יצוק_bit

bit_casted_tensor

bit_casted_tensor

גודל_עמום

מעמעם

סוג-די

שָׁטוּחַ

flat

שטוח_פנימי_מידות

שטוח_פנימי_מידות

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

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

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

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

מַטרִיצָה

מַטרִיצָה

אופרטור=

אופרטור=

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

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

סקלרי

סקלרי