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

תעתיק מ

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 בגודל אוטומטי לגדלים של הטנסור. בדיקת היישום נכשלת אם הסוג או הגדלים אינם תואמים.

דוגמא:

l10n-placeholder89

l10n-placeholder90

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

~טנזור

l10n-placeholder91