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

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 האחרונות של טנזור הקלט.

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

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

סקלרי

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

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

~טנזור

 ~Tensor()

tensorflow:: מוֹתֵחַ

תַקצִיר

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

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

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

AllocatedBytes

AsProtoField

AsProtoTensorContent

BitcastFrom

CopyFrom

DebugString

DebugString

DeviceSafeDebugString

מילוי תיאור

FromProto

FromProto

IsAligned

הוא אתחול

IsSameSize

NumElements

SharesBufferWith

פְּרוּסָה

תת פרוסה

SummarizeValue

מוֹתֵחַ

Tensor

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

מוֹתֵחַ

TotalBytes

UnsafeCopyFromInternal

bit_casted_shaped

bit_casted_shaped

bit_casted_tensor

bit_casted_tensor

עמום_גודל

מתעמעם

dtype

שָׁטוּחַ

flat

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

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

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

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

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

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

מַטרִיצָה

מַטרִיצָה

מפעיל=

מפעיל=

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

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

סקלרי

סקלרי