'tfl' נִיב

הדיאלקט של TensorFlow Lite.

ניב זה ממפה לפעולות TensorFlow Lite.

אינוריאנטים:

  • כל הערכים הם מסוג Tensor (במיוחד, סקלרים מיוצגים באמצעות טנסורים אפס מימדיים);

פעולות

tfl.abs (TFL::AbsOp)

אופרטור ערך מוחלט

בהינתן טנסור x , פעולה זו מחזירה טנזור המכיל את הערך המוחלט של כל אלמנט ב- x . לדוגמה, אם x הוא אלמנט קלט ו-y הוא אלמנט פלט, פעולה זו מחשבת \(y = |x|\).

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
x טנסור של מספר שלם ללא סימן 16 סיביות או ערכים שלם ללא סימן של 32 סיביות או 32 סיביות צף או ערכים מסוג QI8 או QI16

תוצאות:

תוֹצָאָה תֵאוּר
y טנסור של מספר שלם ללא סימן 16 סיביות או ערכים שלם ללא סימן של 32 סיביות או 32 סיביות צף או ערכים מסוג QI8 או QI16

tfl.add (TFL::AddOp)

מפעיל הוספה

פעולת הוספת אלמנטים.

תכונות: ::mlir::OpTrait::TFLRuntimeOpTrait , AlwaysSpeculatableImplTrait , Commutative , QuantizableResult , ResultsBroadcastableShape

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflArithmeticCountOpInterface , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
fused_activation_function ::mlir::StringAttr תכונת מחרוזת שהערך שלה הוא NONE, או RELU, או RELU_N1_TO_1, או RELU6, או TANH, או SIGN_BIT

אופרנדים:

אופרנד תֵאוּר
lhs טנסור של מספר שלם ללא סימן של 32 סיביות או 16 סיביות ללא סימן או מספר שלם ללא סימן 32 סיביות או ערכי מספר שלם ללא סימן 64 סיביות או מסוג QI8 או מסוג QUI8 או מסוג QI16
rhs טנסור של מספר שלם ללא סימן של 32 סיביות או 16 סיביות ללא סימן או מספר שלם ללא סימן 32 סיביות או ערכי מספר שלם ללא סימן 64 סיביות או מסוג QI8 או מסוג QUI8 או מסוג QI16

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של מספר שלם ללא סימן של 32 סיביות או 16 סיביות ללא סימן או מספר שלם ללא סימן 32 סיביות או ערכי מספר שלם ללא סימן 64 סיביות או מסוג QI8 או מסוג QUI8 או מסוג QI16

tfl.add_n (TFL::AddNOp)

_הוסף אופרטור n

מוסיף את כל טנסור הקלט מבחינה אלמנטית.

תכונות: AlwaysSpeculatableImplTrait , Commutative

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflArithmeticCountOpInterface , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
inputs וריאדית של טנסור מכל סוג שהוא

תוצאות:

תוֹצָאָה תֵאוּר
sum טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות או 32 סיביות

tfl.arg_max (TFL::ArgMaxOp)

מפעיל ArgMax

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

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
output_type ::mlir::תכונה תכונה נגזרת

אופרנדים:

אופרנד תֵאוּר
input טנסור של מספר שלם ללא סימן 1 סיביות או 32 סיביות צף או מספר שלם ללא סימן 32 סיביות או מספר שלם ללא סימן 8 סיביות או ערכי מספר שלם ללא סימן 8 סיביות או מסוג QI8 או QUI8
dim טנסור של ערכי מספרים שלמים ללא סימן של 32/64 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של ערכי מספרים שלמים ללא סימן של 32/64 סיביות

tfl.arg_min (TFL::ArgMinOp)

מפעיל ArgMin

מחזירה את האינדקס עם הערך הקטן ביותר על פני מימדים של טנזור. a = [1, 10, 26.9, 2.8, 166.32, 62.3] b = tf.math.argmin(input = a) c = tf.keras.backend.eval(b)

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
output_type ::mlir::תכונה תכונה נגזרת

אופרנדים:

אופרנד תֵאוּר
input טנסור של מספר שלם ללא סימן 1 סיביות או 32 סיביות צף או מספר שלם ללא סימן 32 סיביות או מספר שלם ללא סימן 8 סיביות או ערכי מספר שלם ללא סימן 8 סיביות או מסוג QI8 או QUI8
dim טנסור של ערכי מספרים שלמים ללא סימן של 32/64 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של ערכי מספרים שלמים ללא סימן של 32/64 סיביות

tfl.assign_variable (TFL::AssignVariableOp)

מקצה ערך חדש למשתנה.

כל ReadVariableOp עם תלות בקרה על אופציה זו מובטחת להחזיר ערך זה או ערך חדש יותר עוקב של המשתנה.

ממשקים: TflRuntimeVerifyOpInterface

אופרנדים:

אופרנד תֵאוּר
resource_id טנסור של ערכי משאבים
value טנסור של צף 32 סיביות או 64 סיביות צף או מספר שלם ללא סימן 1 סיביות או מספר שלם ללא סימן 8 סיביות או מספר שלם ללא סימן 8 סיביות או מסוג QI8 או מסוג QUI8 או מספר שלם ללא סימן 32 סיביות או מספר שלם ללא סימן 64 סיביות או סוג QI16 או סוג מורכב עם רכיבי ציפה של 32 סיביות או סוג מורכב עם ערכי רכיבי ציפה של 64 סיביות

tfl.atan2 (TFL::Atan2Op)

מבצע Atan2

פעולת "atan2" מחשבת את ה-arctangent של y/x מבחינה אלמנט, תוך כיבוד סימני הארגומנטים.

תכונות: AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType , SameOperandsAndResultShape

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
y טנסור של ערכי ציפה של 32 סיביות או 64 סיביות
x טנסור של ערכי ציפה של 32 סיביות או 64 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של ערכי ציפה של 32 סיביות או 64 סיביות

tfl.average_pool_2d (TFL::AveragePool2DOp)

אופרטור _Average_pool 2d

מבצע פעולת איסוף ממוצע בקלט.

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflArithmeticCountOpInterface , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
filter_height ::mlir::IntegerAttr תכונת מספר שלם ללא סימנים של 32 סיביות
filter_width ::mlir::IntegerAttr תכונת מספר שלם ללא סימנים של 32 סיביות
padding ::mlir::StringAttr תכונת string שהערך שלה הוא SAME, או VALID
stride_h ::mlir::IntegerAttr תכונת מספר שלם ללא סימנים של 32 סיביות
stride_w ::mlir::IntegerAttr תכונת מספר שלם ללא סימנים של 32 סיביות
fused_activation_function ::mlir::StringAttr תכונת מחרוזת שהערך שלה הוא NONE, או RELU, או RELU_N1_TO_1, או RELU6, או TANH, או SIGN_BIT

אופרנדים:

אופרנד תֵאוּר
input טנסור של 32 סיביות ציפה או ערכים מסוג QI8 או מסוג QUI8 או QI16

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של 32 סיביות ציפה או ערכים מסוג QI8 או מסוג QUI8 או QI16

tfl.basic_lstm (TFL::BasicLSTMOp)

אופרטור lstm הבסיסי

מפעיל סלולרי LSTM בסיסי.

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
fused_activation_function ::mlir::StringAttr תכונת מחרוזת שהערך שלה הוא NONE, או RELU, או RELU_N1_TO_1, או RELU6, או TANH, או SIGN_BIT
cell_clip ::mlir::FloatAttr תכונת float של 32 סיביות שהערך שלה אינו שלילי
proj_clip ::mlir::FloatAttr תכונת float של 32 סיביות שהערך שלה אינו שלילי
kernel_type ::mlir::TFL::LSTMKernelTypeAttr lstm_kernel_type שהערך שלו הוא mlir::TFL::LSTMKernelType::BASIC

אופרנדים:

אופרנד תֵאוּר
data_input טנסור של 32 סיביות מסוג Float או QUI8
prev_activ_input טנסור של 32 סיביות מסוג Float או QUI8
weights_input טנסור של 32 סיביות מסוג Float או QUI8
biases_input טנסור של 32 סיביות מסוג Float או QI32
prev_state_input טנסור של 32 סיביות מסוג ציפה או ערכי QI16

תוצאות:

תוֹצָאָה תֵאוּר
activ_output טנסור דו מימדי מכל סוג שהוא
state_output טנסור דו מימדי מכל סוג שהוא
concat_temp טנסור דו מימדי מכל סוג שהוא
activ_temp טנסור דו מימדי מכל סוג שהוא

tfl.batch_matmul (TFL::BatchMatMulOp)

מפעיל מכפלת מטריקס אצווה

מבצע כפל מטריצה ​​אצווה בכניסות. עוקב אחר המוסכמות של TensorFlow BatchMatMulV2, עם תמיכה במידות לא ידועות במידות האצווה ובשידור.

Inputs:
  `inputs[0]`: required: input LHS
  `inputs[1]`: required: input RHS
  `adjoint_lhs`: optional: Transpose LHS (default false)
  `adjoint_lhs`: optional: Transpose LHS (default false)

תכונות: ::mlir::OpTrait::TFLRuntimeOpTrait , AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , DynamicRangeQuantizedOpInterface , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
adj_x ::mlir::BoolAttr תכונת bool
adj_y ::mlir::BoolAttr תכונת bool
asymmetric_quantize_inputs ::mlir::BoolAttr תכונת bool

אופרנדים:

אופרנד תֵאוּר
x טנסור של 32-bit float או מסוג QI8 או מסוג QI16 או 8-bit ערכי מספר שלם ללא סימן
y טנסור של 32-bit float או מסוג QI8 או מסוג QI16 או 8-bit ערכי מספר שלם ללא סימן

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של 32-bit float או מסוג QI8 או מסוג QI16 או 32-bit ערכי מספר שלם ללא סימן

tfl.batch_to_space_nd (TFL::BatchToSpaceNdOp)

מפעיל BatchToSpaceNd

פעולה זו מעצבת מחדש את מימד ה"אצווה" 0 למימדי שטח.

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
input טנסור של מספר שלם ללא סימן 32 סיביות או 8 סיביות ללא סימן או מספר שלם ללא סימן 32 סיביות או מספר שלם ללא סימן של 64 סיביות או ערכים של מספר שלם ללא סימן 8 סיביות או ערכים מסוג QI8 או מסוג QUI8 או QI16
block_shape טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות
indices טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של מספר שלם ללא סימן של 32 סיביות או 16 סיביות ללא סימן או מספר שלם ללא סימן 32 סיביות או מספר שלם ללא סימן 64 סיביות או ערכי מספר שלם ללא סימן 8 סיביות או מסוג QI8 או מסוג QUI8 או מסוג QI16

tfl.bidirectional_sequence_lstm (TFL::BidirectionalSequenceLSTMOp)

אופרטור lstm ברצף דו-כיווני

lstm דו-כיווני הוא בעצם שני lstms, אחד רץ קדימה והשני רץ אחורה. והפלט הוא השרשור של שני ה-lstms.

תכונות: QuantizableResult

ממשקים: DynamicRangeQuantizedOpInterface , TFL_StatefulOp , TflRuntimeVerifyOpInterface

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
fused_activation_function ::mlir::StringAttr תכונת מחרוזת שהערך שלה הוא NONE, או RELU, או RELU_N1_TO_1, או RELU6, או TANH, או SIGN_BIT
cell_clip ::mlir::FloatAttr תכונת float של 32 סיביות שהערך שלה אינו שלילי
proj_clip ::mlir::FloatAttr תכונת float של 32 סיביות שהערך שלה אינו שלילי
merge_outputs ::mlir::BoolAttr תכונת bool
time_major ::mlir::BoolAttr תכונת bool
asymmetric_quantize_inputs ::mlir::BoolAttr תכונת bool

אופרנדים:

אופרנד תֵאוּר
input טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות או 8 סיביות
fw_input_to_input_weights טנסור מכל סוג שהוא ערכי או שום סוג
fw_input_to_forget_weights טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות או 8 סיביות
fw_input_to_cell_weights טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות או 8 סיביות
fw_input_to_output_weights טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות או 8 סיביות
fw_recurrent_to_input_weights טנסור מכל סוג שהוא ערכי או שום סוג
fw_recurrent_to_forget_weights טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות או 8 סיביות
fw_recurrent_to_cell_weights טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות או 8 סיביות
fw_recurrent_to_output_weights טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות או 8 סיביות
fw_cell_to_input_weights טנסור מכל סוג שהוא ערכי או שום סוג
fw_cell_to_forget_weights טנסור מכל סוג שהוא ערכי או שום סוג
fw_cell_to_output_weights טנסור מכל סוג שהוא ערכי או שום סוג
fw_input_gate_bias טנסור מכל סוג שהוא ערכי או שום סוג
fw_forget_gate_bias טנסור של ערכי ציפה של 32 סיביות
fw_cell_bias טנסור של ערכי ציפה של 32 סיביות
fw_output_gate_bias טנסור של ערכי ציפה של 32 סיביות
fw_projection_weights טנסור מכל סוג שהוא ערכי או שום סוג
fw_projection_bias טנסור מכל סוג שהוא ערכי או שום סוג
bw_input_to_input_weights טנסור מכל סוג שהוא ערכי או שום סוג
bw_input_to_forget_weights טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות או 8 סיביות
bw_input_to_cell_weights טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות או 8 סיביות
bw_input_to_output_weights טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות או 8 סיביות
bw_recurrent_to_input_weights טנסור מכל סוג שהוא ערכי או שום סוג
bw_recurrent_to_forget_weights טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות או 8 סיביות
bw_recurrent_to_cell_weights טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות או 8 סיביות
bw_recurrent_to_output_weights טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות או 8 סיביות
bw_cell_to_input_weights טנסור מכל סוג שהוא ערכי או שום סוג
bw_cell_to_forget_weights טנסור מכל סוג שהוא ערכי או שום סוג
bw_cell_to_output_weights טנסור מכל סוג שהוא ערכי או שום סוג
bw_input_gate_bias טנסור מכל סוג שהוא ערכי או שום סוג
bw_forget_gate_bias טנסור של ערכי ציפה של 32 סיביות
bw_cell_bias טנסור של ערכי ציפה של 32 סיביות
bw_output_gate_bias טנסור של ערכי ציפה של 32 סיביות
bw_projection_weights טנסור מכל סוג שהוא ערכי או שום סוג
bw_projection_bias טנסור מכל סוג שהוא ערכי או שום סוג
fw_input_activation_state טנסור ממלכתי
fw_input_cell_state טנסור ממלכתי
bw_input_activation_state טנסור ממלכתי
bw_input_cell_state טנסור ממלכתי
aux_input טנסור מכל סוג שהוא ערכי או שום סוג
fw_aux_input_to_input_weights טנסור מכל סוג שהוא ערכי או שום סוג
fw_aux_input_to_forget_weights טנסור מכל סוג שהוא ערכי או שום סוג
fw_aux_input_to_cell_weights טנסור מכל סוג שהוא ערכי או שום סוג
fw_aux_input_to_output_weights טנסור מכל סוג שהוא ערכי או שום סוג
bw_aux_input_to_input_weights טנסור מכל סוג שהוא ערכי או שום סוג
bw_aux_input_to_forget_weights טנסור מכל סוג שהוא ערכי או שום סוג
bw_aux_input_to_cell_weights טנסור מכל סוג שהוא ערכי או שום סוג
bw_aux_input_to_output_weights טנסור מכל סוג שהוא ערכי או שום סוג

תוצאות:

תוֹצָאָה תֵאוּר
fw_output ערכי טנסור מכל סוג שהוא
bw_output ערכי טנסור מכל סוג שהוא

tfl.bitcast (TFL::BitcastOp)

מפעיל ביטקאסט

Bitcasts טנזור מסוג אחד לאחר.

תכונות: AlwaysSpeculatableImplTrait

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
input ערכי טנסור מכל סוג שהוא

תוצאות:

תוֹצָאָה תֵאוּר
output ערכי טנסור מכל סוג שהוא

tfl.bitwise_xor (TFL::BitwiseXorOp)

אופרטור Bitwise Xor

Elementwise מחשב את ה-XOR הביטבי של lhs ו- rhs .

תכונות: AlwaysSpeculatableImplTrait , Commutative , ResultsBroadcastableShape , SameOperandsAndResultElementType

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
lhs טנסור של מספר שלם ללא סימן 8 סיביות או 8 סיביות ללא סימן או מספר שלם ללא סימן 16 סיביות או מספר שלם ללא סימן 16 סיביות או ערכי מספר שלם ללא סימן 32 סיביות או 32 סיביות ללא סימן
rhs טנסור של מספר שלם ללא סימן 8 סיביות או 8 סיביות ללא סימן או מספר שלם ללא סימן 16 סיביות או מספר שלם ללא סימן 16 סיביות או ערכי מספר שלם ללא סימן 32 סיביות או 32 סיביות ללא סימן

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של מספר שלם ללא סימן 8 סיביות או 8 סיביות ללא סימן או מספר שלם ללא סימן 16 סיביות או מספר שלם ללא סימן 16 סיביות או ערכי מספר שלם ללא סימן 32 סיביות או 32 סיביות ללא סימן

tfl.broadcast_args (TFL::BroadcastArgsOp)

החזר את הצורה של s0 op s1 עם שידור.

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

תכונות: AlwaysSpeculatableImplTrait

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
s0 טנסור של ערכי מספרים שלמים ללא סימן של 32/64 סיביות
s1 טנסור של ערכי מספרים שלמים ללא סימן של 32/64 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
r0 טנסור של ערכי מספרים שלמים ללא סימן של 32/64 סיביות

tfl.broadcast_to (TFL::BroadcastToOp)

שדר מערך לקבלת צורה תואמת.

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

לְדוּגמָה,

x = tf.constant([1, 2, 3]) y = tf.broadcast_to(x, [3, 3]) print(y) tf.Tensor( [[1 2 3] [1 2 3] [1 2 3]], shape=(3, 3), dtype=int32)

בדוגמה שלמעלה, קלט Tensor עם הצורה של [1, 3] משודר לפלט Tensor עם הצורה של [3, 3] .

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

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

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
input טנסור של מספר שלם ללא סימן 32 סיביות או 32 סיביות ללא סימן או מספר שלם ללא סימן 1 סיביות או מספר שלם ללא סימן 4 סיביות או מספר שלם ללא סימן 8 סיביות או מסוג QI8 או מספר שלם ללא סימן 8 סיביות או מספר שלם ללא סימן 32 סיביות או מסוג QUI8 או 16 מספר שלם ללא סימנים או סוג QI16 או מספר שלם ללא סימן של 64 סיביות או סוג מורכב עם ערכי רכיבי ציפה של 32 סיביות
shape טנסור של ערכי מספרים שלמים ללא סימן של 32/64 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של מספר שלם ללא סימן 32 סיביות או 32 סיביות ללא סימן או מספר שלם ללא סימן 1 סיביות או מספר שלם ללא סימן 4 סיביות או מספר שלם ללא סימן 8 סיביות או מסוג QI8 או מספר שלם ללא סימן 8 סיביות או מספר שלם ללא סימן 32 סיביות או מסוג QUI8 או 16 מספר שלם ללא סימנים או סוג QI16 או מספר שלם ללא סימן של 64 סיביות או סוג מורכב עם ערכי רכיבי ציפה של 32 סיביות

tfl.bucketize (TFL::BucketizeOp)

מרכזת 'קלט' בהתבסס על 'גבולות'.

דוּגמָה:

אם הכניסות הן boundaries = [0, 10, 100] input = [[-5, 10000][150, 10][5, 100]] , אז הפלט יהיה output = [[0, 3][3, 2][1, 3]] .

תכונות: AlwaysSpeculatableImplTrait , SameOperandsAndResultShape

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
boundaries ::mlir::ArrayAttr תכונת מערך צף של 32 סיביות

אופרנדים:

אופרנד תֵאוּר
input טנסור של ערכי מספר שלם ללא סימן של 32 סיביות או 64 סיביות או מספר שלם ללא סימן או 64 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות

tfl.call_once (TFL::CallOnceOp)

מפעיל פונקציית אתחול

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

ממשקים: TflRuntimeVerifyOpInterface

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
session_init_function ::mlir::StringAttr תכונת מחרוזת

tfl.cast (TFL::CastOp)

מפעיל שחקנים

מעביר קלט מסוג קלט לסוג פלט.

תכונות: AlwaysSpeculatableImplTrait , SameOperandsAndResultShape

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
input טנסור מסוג 16-bit float או bfloat16 או 32-bit float או 64-bit float או 1-bit ללא סימן או מספר שלם ללא סימן 4-bit או 16-bit ללא סימן או מספר שלם ללא סימן 16-bit או 32-bit מספר שלם ללא סימן 32 סיביות או מספר שלם ללא סימן 64 סיביות או מסוג TFLite quint8 או מספר שלם ללא סימן 8 סיביות או מספר שלם ללא סימן 8 סיביות או סוג מורכב עם ערכי רכיבים צפים של 32 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור מסוג 16-bit float או bfloat16 או 32-bit float או 64-bit float או 1-bit ללא סימן או מספר שלם ללא סימן 16-bit או 16-bit ללא סימן או מספר שלם ללא סימן 32-bit או 32-bit. מספר שלם ללא סימן של 64 סיביות או מסוג TFLite quint8 או מספר שלם ללא סימן של 8 סיביות או מספר שלם ללא סימן של 8 סיביות או סוג מורכב עם ערכי רכיבי ציפה של 32 סיביות

tfl.ceil (TFL::CeilOp)

מפעיל תקרה

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

תכונות: AlwaysSpeculatableImplTrait , InferTensorType , TF::SameOperandsAndResultTypeResolveRef

ממשקים: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
x טנסור של ערכי ציפה של 32 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
y טנסור של ערכי ציפה של 32 סיביות

tfl.complex_abs (TFL::ComplexAbsOp)

מחשב את הערך המוחלט המורכב של טנזור.

בהינתן טנסור x של מספרים מרוכבים, פעולה זו מחזירה טנזור מסוג float או double שהוא הערך המוחלט של כל אלמנט ב- x . כל האלמנטים ב- x חייבים להיות מספרים מרוכבים של הצורה \(a + bj\). הערך המוחלט מחושב כ \( \sqrt{a^2 + b^2}\).

תכונות: AlwaysSpeculatableImplTrait , SameOperandsAndResultShape

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
input טנזור מסוג מורכב עם רכיבי ציפה של 32 סיביות או סוג מורכב עם ערכי רכיבי ציפה של 64 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של ערכי ציפה של 32 סיביות או 64 סיביות

tfl.concatenation (TFL::ConcatenationOp)

מפעיל שרשור

משרשרת טנסורים לאורך מימד אחד

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
axis ::mlir::IntegerAttr תכונת מספר שלם ללא סימנים של 32 סיביות
fused_activation_function ::mlir::StringAttr תכונת מחרוזת שהערך שלה הוא NONE, או RELU, או RELU_N1_TO_1, או RELU6, או TANH, או SIGN_BIT

אופרנדים:

אופרנד תֵאוּר
values וריאדית של טנסור מכל סוג שהוא

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של מספר שלם ללא סימן של 32 סיביות או 64 סיביות ללא סימן או מספר שלם ללא סימן 32 סיביות או מספר שלם ללא סימן 16 סיביות או מספר שלם ללא סימן 8 סיביות או מסוג QI8 או מסוג QUI8 או מספר שלם ללא סימן 8 סיביות או מספר שלם ללא סימן 32 סיביות או 1 ערכי מספר שלם ללא סימנים -bit

tfl.control_node (TFL::ControlNodeOp)

פעולת TFL.control_node עוטפת פעולות בלוק יחיד על מנת לצרף קצוות בקרה.

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

תכונות: HasParent<mlir::func::FuncOp> , RecursiveMemoryEffects , SingleBlockImplicitTerminator<YieldOp> , SingleBlock

אופרנדים:

אופרנד תֵאוּר
controlInputs משתנה של שליטה

תוצאות:

תוֹצָאָה תֵאוּר
outputs וריאדית של טנסור מכל סוג שהוא
control לִשְׁלוֹט

tfl.conv_2d (TFL::Conv2DOp)

מפעיל Convolution

מבצע פעולת קונבולציה בכניסות.

כניסות: inputs[0] : נדרשות: inputs[1] : נדרשות inputs[2] : אופציונלי: טנסור הטיה

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult , quant::AccumulatorUniformScale<2, 0, 1> , quant::AffineOpCoefficient<0, 1>

ממשקים: AffineQuantizedOpInterface , ConditionallySpeculatable , DynamicRangeQuantizedOpInterface TflRuntimeVerifyOpInterface InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface) , TFL_SparseOp , TflArithmeticCountOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
dilation_h_factor ::mlir::IntegerAttr תכונת מספר שלם ללא סימנים של 32 סיביות
dilation_w_factor ::mlir::IntegerAttr תכונת מספר שלם ללא סימנים של 32 סיביות
fused_activation_function ::mlir::StringAttr תכונת מחרוזת שהערך שלה הוא NONE, או RELU, או RELU_N1_TO_1, או RELU6, או TANH, או SIGN_BIT
padding ::mlir::StringAttr תכונת string שהערך שלה הוא SAME, או VALID
stride_h ::mlir::IntegerAttr תכונת מספר שלם ללא סימנים של 32 סיביות
stride_w ::mlir::IntegerAttr תכונת מספר שלם ללא סימנים של 32 סיביות

אופרנדים:

אופרנד תֵאוּר
input טנסור של 32 סיביות ציפה או ערכים מסוג QI8 או מסוג QUI8 או QI16
filter טנסור של 32 סיביות ציפה או ערכים מסוג QI4 או מסוג QI8 או QUI8
bias טנסור מכל סוג שהוא ערכי או שום סוג

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של 32 סיביות ציפה או ערכים מסוג QI8 או מסוג QUI8 או QI16

tfl.conv_3d (TFL::Conv3DOp)

מפעיל תלת מימד Convolution

מבצע פעולת קונבולציה בכניסות תלת מימדיות. כניסות: inputs[0] : נדרשות: inputs[1] : נדרשות inputs[2] : אופציונלי: טנסור הטיה

תכונות: AlwaysSpeculatableImplTrait , quant::AccumulatorUniformScale<2, 0, 1>

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
dilation_d_factor ::mlir::IntegerAttr תכונת מספר שלם ללא סימנים של 32 סיביות
dilation_h_factor ::mlir::IntegerAttr תכונת מספר שלם ללא סימנים של 32 סיביות
dilation_w_factor ::mlir::IntegerAttr תכונת מספר שלם ללא סימנים של 32 סיביות
fused_activation_function ::mlir::StringAttr תכונת מחרוזת שהערך שלה הוא NONE, או RELU, או RELU_N1_TO_1, או RELU6, או TANH, או SIGN_BIT
padding ::mlir::StringAttr תכונת string שהערך שלה הוא SAME, או VALID
stride_d ::mlir::IntegerAttr תכונת מספר שלם ללא סימנים של 32 סיביות
stride_h ::mlir::IntegerAttr תכונת מספר שלם ללא סימנים של 32 סיביות
stride_w ::mlir::IntegerAttr תכונת מספר שלם ללא סימנים של 32 סיביות

אופרנדים:

אופרנד תֵאוּר
input טנסור של ערכי ציפה של 32 סיביות
filter טנסור של ערכי ציפה של 32 סיביות
bias טנסור מכל סוג שהוא ערכי או שום סוג

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של ערכי ציפה של 32 סיביות

tfl.conv_3d_transpose (TFL::Conv3DTransposeOp)

מפעיל תלת מימד Transposed Convolution

מבצע פעולת קונבולוציית טרנספוזיציה בכניסות תלת מימדיות. כניסות: inputs[0] : נדרשות: צורת inputs[1] : נדרשות inputs[2] : נדרשות inputs[3] : אופציונלי: טנסור הטיה

תכונות: AlwaysSpeculatableImplTrait , quant::AccumulatorUniformScale<2, 0, 1>

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
dilation_d_factor ::mlir::IntegerAttr תכונת מספר שלם ללא סימנים של 32 סיביות
dilation_h_factor ::mlir::IntegerAttr תכונת מספר שלם ללא סימנים של 32 סיביות
dilation_w_factor ::mlir::IntegerAttr תכונת מספר שלם ללא סימנים של 32 סיביות
fused_activation_function ::mlir::StringAttr תכונת מחרוזת שהערך שלה הוא NONE, או RELU, או RELU_N1_TO_1, או RELU6, או TANH, או SIGN_BIT
padding ::mlir::StringAttr תכונת string שהערך שלה הוא SAME, או VALID
stride_d ::mlir::IntegerAttr תכונת מספר שלם ללא סימנים של 32 סיביות
stride_h ::mlir::IntegerAttr תכונת מספר שלם ללא סימנים של 32 סיביות
stride_w ::mlir::IntegerAttr תכונת מספר שלם ללא סימנים של 32 סיביות

אופרנדים:

אופרנד תֵאוּר
output_shape טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות
filter טנסור של ערכי ציפה של 32 סיביות
input טנסור של ערכי ציפה של 32 סיביות
bias טנסור מכל סוג שהוא ערכי או שום סוג

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של ערכי ציפה של 32 סיביות

tfl.cos (TFL::CosOp)

מפעיל קוסינוס

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

תכונות: AlwaysSpeculatableImplTrait , InferTensorType , TF::SameOperandsAndResultTypeResolveRef

ממשקים: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
x טנסור של ערכי ציפה של 32 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
y טנסור של ערכי ציפה של 32 סיביות

tfl.cumsum (TFL::CumsumOp)

מפעיל Cumsum

חשב את הסכום המצטבר של הטנזור x לאורך הציר.

תכונות: AlwaysSpeculatableImplTrait

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
exclusive ::mlir::BoolAttr תכונת bool
reverse ::mlir::BoolAttr תכונת bool

אופרנדים:

אופרנד תֵאוּר
input טנסור של ערכי מספר שלם ללא סימן של 32 סיביות או 32 סיביות או 64 סיביות
axis טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של ערכי מספר שלם ללא סימן של 32 סיביות או 32 סיביות או 64 סיביות

tfl.custom (TFL::CustomOp)

אופציה מותאמת אישית

אופציה גנרית לכל פעולה מותאמת אישית של TFLite.

קלט: רשימה של כניסות באופציה המקורית. custom_code: מחרוזת המשמשת כדי לזהות מה בדיוק המבצע הזה, התואם ל-operator_codes.custom_code ב-flatbuffer. custom_option: מחזיק לשמירת תכונות ה-op ב-bytes. פלט: רשימה של פלטים ב-op המקורי.

ממשקים: TflRuntimeVerifyOpInterface

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
custom_code ::mlir::StringAttr תכונת מחרוזת
custom_option ::mlir::TFL::ConstBytesAttr ייצוג תכונת מחרוזת של בתים מלוכדים

אופרנדים:

אופרנד תֵאוּר
input וריאדית של טנסור מכל סוג שהוא ערכי או שום סוג

תוצאות:

תוֹצָאָה תֵאוּר
output וריאדית של טנסור מכל סוג שהוא

tfl.custom_tf (TFL::CustomTfOp)

Wrapper Op for TF אופציות מותאמות אישית.

אופציה עטיפה סביב כל אופ TF Custom. אלה כוללים פעולות המוגדרות באמצעות custom_opdefs או מקושרות שאינן מוגדרות בניב TF. ה-Op הזה פשוט עוטף את ה-Op המותאם אישית בתוך אזור. הערה מס' 1, אופציה זו לא תכלול אופציות מותאמות אישית של TF Lite המוגדרות באמצעות CustomOp. הערה מס' 2, הפעולה הזו היא רק ייצוג פנימי בתוך הממיר ואינן נחשפות/יוצאות כאשר המודל מיוצא ל-Flatbuffer.

תכונות: IsolatedFromAbove , RecursiveMemoryEffects , SingleBlockImplicitTerminator<YieldOp> , SingleBlock

ממשקים: InferTypeOpInterface , TflRuntimeVerifyOpInterface

אופרנדים:

אופרנד תֵאוּר
input וריאדית של טנסור מכל סוג שהוא ערכי או שום סוג

תוצאות:

תוֹצָאָה תֵאוּר
output וריאדית של טנסור מכל סוג שהוא

tfl.densify (TFL::DensifyOp)

מפעיל צפוף

ממיר טנסור דליל לפורמט צפוף.

תכונות: AlwaysSpeculatableImplTrait

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
input טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות או 8 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות או 8 סיביות

tfl.depth_to_space (TFL::DepthToSpaceOp)

מפעיל DepthToSpace

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

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
block_size ::mlir::IntegerAttr תכונת מספר שלם ללא סימן של 32 סיביות שערכה חיובי

אופרנדים:

אופרנד תֵאוּר
input טנסור של מספר שלם ללא סימן 32 סיביות או 8 סיביות ללא סימן או מספר שלם ללא סימן 32 סיביות או מספר שלם ללא סימן 64 סיביות או ערכים מסוג TFLite quint8 או 8 סיביות ללא סימן או ערכים מסוג QI8 או QUI8

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של מספר שלם ללא סימן 32 סיביות או 8 סיביות ללא סימן או מספר שלם ללא סימן 32 סיביות או מספר שלם ללא סימן 64 סיביות או ערכים מסוג TFLite quint8 או 8 סיביות ללא סימן או ערכים מסוג QI8 או QUI8

tfl.depthwise_conv_2d (TFL::DepthwiseConv2DOp)

אופרטור פיתול הניתן להפרדה לעומק

מבצע פעולת קונבולציה בכניסות.

כניסות: inputs[0] : נדרשות: inputs[1] : נדרשות inputs[2] : אופציונלי: טנסור הטיה

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult , quant::AccumulatorUniformScale<2, 0, 1> , quant::AffineOpCoefficient<3, 1>

ממשקים: AffineQuantizedOpInterface , ConditionallySpeculatable , DynamicRangeQuantizedOpInterface , NoMemoryEffect (MemoryEffectOpInterface) , TFL_SparseOp , TflArithmeticCountOpInterface , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
dilation_h_factor ::mlir::IntegerAttr תכונת מספר שלם ללא סימנים של 32 סיביות
dilation_w_factor ::mlir::IntegerAttr תכונת מספר שלם ללא סימנים של 32 סיביות
fused_activation_function ::mlir::StringAttr תכונת מחרוזת שהערך שלה הוא NONE, או RELU, או RELU_N1_TO_1, או RELU6, או TANH, או SIGN_BIT
padding ::mlir::StringAttr תכונת string שהערך שלה הוא SAME, או VALID
stride_h ::mlir::IntegerAttr תכונת מספר שלם ללא סימנים של 32 סיביות
stride_w ::mlir::IntegerAttr תכונת מספר שלם ללא סימנים של 32 סיביות
depth_multiplier ::mlir::IntegerAttr תכונת מספר שלם ללא סימנים של 32 סיביות

אופרנדים:

אופרנד תֵאוּר
input טנסור של 32 סיביות ציפה או ערכים מסוג QI8 או מסוג QUI8 או QI16
filter טנסור של 32 סיביות ציפה או ערכים מסוג QI4 או מסוג QI8 או QUI8
bias טנסור מכל סוג שהוא ערכי או שום סוג

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של 32 סיביות ציפה או ערכים מסוג QI8 או מסוג QUI8 או QI16

tfl.dequantize (TFL::DequantizeOp)

אופרטור לנטרל

ממירה מערך כמותי של מספרים שלמים לנקודות צפה לפי פרמטרי הכימות.

ממשקים: NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
input טנסור מסוג QI4 או מסוג QI8 או מסוג QUI8 או מסוג QI16 או ערכי ציפה של 16 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של ערכי ציפה של 32 סיביות

tfl.dilate (TFL::DilateOp)

מפעיל הרחבה

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

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
input טנסור של מספר שלם ללא סימן 8 סיביות או מספר שלם ללא סימן 16 סיביות או מספר שלם ללא סימן 32 סיביות או מספר שלם ללא סימן 64 סיביות או מספר שלם ללא סימן 8 סיביות או מספר שלם ללא סימן 16 סיביות או 32 סיביות ללא סימן או מספר שלם ללא סימן 64 סיביות או ערכי ציפה של 32 סיביות או 64 סיביות
dilations טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות
padding_value 0D טנסור מכל סוג שהוא

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של מספר שלם ללא סימן 8 סיביות או מספר שלם ללא סימן 16 סיביות או מספר שלם ללא סימן 32 סיביות או מספר שלם ללא סימן 64 סיביות או מספר שלם ללא סימן 8 סיביות או מספר שלם ללא סימן 16 סיביות או 32 סיביות ללא סימן או מספר שלם ללא סימן 64 סיביות או ערכי ציפה של 32 סיביות או 64 סיביות

tfl.div (TFL::DivOp)

מפעיל חטיבה

פעולת חלוקת אלמנטים.

תכונות: ::mlir::OpTrait::TFLRuntimeOpTrait , AlwaysSpeculatableImplTrait , ResultsBroadcastableShape

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflArithmeticCountOpInterface , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
fused_activation_function ::mlir::StringAttr תכונת מחרוזת שהערך שלה הוא NONE, או RELU, או RELU_N1_TO_1, או RELU6, או TANH, או SIGN_BIT

אופרנדים:

אופרנד תֵאוּר
lhs טנסור של 32 סיביות ציפה או 32 סיביות חסרות סימנים או ערכי סוג QUI8
rhs טנסור של 32 סיביות ציפה או 32 סיביות חסרות סימנים או ערכי סוג QUI8

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של 32 סיביות ציפה או 32 סיביות חסרות סימנים או ערכי סוג QUI8

tfl.dynamic_update_slice (TFL::DynamicUpdateSliceOp)

DynamicUpdateSlice.

הפעלה של DynamicUpdateSlice שיש להם את אותה סמנטיקה עם XLA DynamicUpdateSlice. יוצר תוצאה שהיא הערך של אופרנד מערך הקלט, עם עדכון פרוסה שהוחלף ב-start_indices.

ראה https://www.tensorflow.org/xla/operation_semantics#dynamicupdateslice

תכונות: AlwaysSpeculatableImplTrait

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
operand טנסור של מספר שלם ללא סימן 1-bit או מספר שלם ללא סימן של 8-bit או ערכי מספר שלם ללא סימן של 32-bit או 64-bit ללא סימן או 32-bit ערכים
update טנסור של מספר שלם ללא סימן 1-bit או מספר שלם ללא סימן של 8-bit או ערכי מספר שלם ללא סימן של 32-bit או 64-bit ללא סימן או 32-bit ערכים
start_indices טנסור של ערכי מספרים שלמים ללא סימן של 32/64 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של מספר שלם ללא סימן 1-bit או מספר שלם ללא סימן של 8-bit או ערכי מספר שלם ללא סימן של 32-bit או 64-bit ללא סימן או 32-bit ערכים

tfl.elu (TFL::EluOp)

אופרטור יחידה לינארית אקספוננציאלית

מחשב את הערך הליניארי f(x) -> exp(x) - 1 עבור x < 0, x עבור x >= 0. מבחינה אלמנט.

תכונות: AlwaysSpeculatableImplTrait , SameOperandsAndResultShape

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
x טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות או 8 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
y טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות או 8 סיביות

tfl.embedding_lookup (TFL::EmbeddingLookupOp)

הטמעת מפעיל חיפוש

מחפש מזהים ברשימה של טנסורים מוטמעים.

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: AffineQuantizedOpInterface , ConditionallySpeculatable , DynamicRangeQuantizedOpInterface , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
lookup טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות
value טנסור של מספר שלם ללא סימן 32 סיביות או 8 סיביות חסר סימן או 8 סיביות ללא סימן או ערכי סוג QI8 או מסוג QUI8 או QI4

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של ערכי מספר שלם ללא סימן של 32 סיביות או 8 סיביות ללא סימן או 8 סיביות ללא סימן

tfl.equal (TFL::EqualOp)

מפעיל שווה

מחזירה את אלמנט האמת של x == y מבחינת אלמנט

תכונות: ::mlir::OpTrait::TFLRuntimeOpTrait , AlwaysSpeculatableImplTrait , Commutative , QuantizableResult , ResultsBroadcastableShape

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
x טנסור של מספר שלם ללא סימן 1 סיביות או 32 סיביות צף או מספר שלם ללא סימן 16 סיביות או מספר שלם ללא סימן 32 סיביות או מספר שלם ללא סימן 64 סיביות או ערכים מסוג QI8 או QUI8 או 8 סיביות ללא סימן או ערכי סוג מחרוזת TFLite
y טנסור של מספר שלם ללא סימן 1 סיביות או 32 סיביות צף או מספר שלם ללא סימן 16 סיביות או מספר שלם ללא סימן 32 סיביות או מספר שלם ללא סימן 64 סיביות או ערכים מסוג QI8 או QUI8 או 8 סיביות ללא סימן או ערכי סוג מחרוזת TFLite

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של ערכי מספר שלם ללא סימן של סיביות 1

tfl.exp (TFL::ExpOp)

אופרטור אקספוננציציה טבעית

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

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
x טנסור של 32 סיביות ציפה או ערכי QI8 או QI16

תוצאות:

תוֹצָאָה תֵאוּר
y טנסור של 32 סיביות ציפה או ערכי QI8 או QI16

tfl.expand_dims (TFL::ExpandDimsOp)

מכניס ממד של 1 לצורת טנזור.

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

פעולה זו שימושית אם ברצונך להוסיף ממד אצווה לרכיב בודד. לדוגמה, אם יש לך תמונה אחת של צורה [height, width, channels] , אתה יכול להפוך אותה לקבוצה של תמונה אחת עם expand_dims(image, 0) , מה שיהפוך את הצורה [1, height, width, channels] .

דוגמאות נוספות:

# 't' is a tensor of shape [2]
shape(expand_dims(t, 0)) ==> [1, 2]
shape(expand_dims(t, 1)) ==> [2, 1]
shape(expand_dims(t, -1)) ==> [2, 1]

# 't2' is a tensor of shape [2, 3, 5]
shape(expand_dims(t2, 0)) ==> [1, 2, 3, 5]
shape(expand_dims(t2, 2)) ==> [2, 3, 1, 5]
shape(expand_dims(t2, 3)) ==> [2, 3, 5, 1]

פעולה זו דורשת כי:

-1-input.dims() <= dim <= input.dims()

פעולה זו קשורה ל- squeeze() , אשר מסירה ממדים בגודל 1.

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
input ערכי טנסור מכל סוג שהוא
dim טנסור של ערכי מספרים שלמים ללא סימן של 32/64 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output ערכי טנסור מכל סוג שהוא

tfl.external_const (TFL::ExternalConstOp)

קונסט אופ.

External const op מחזיק buffer_index שמצביע על קבוע ב-flatbuffer.

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
buffer_index ::mlir::IntegerAttr תכונת מספר שלם ללא סימנים של 32 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output ערכי טנסור מכל סוג שהוא

tfl.fake_quant (TFL::FakeQuantOp)

אופרטור FakeQuant

בצע התאמה מזויפת של טנסור ה"כניסות" מסוג "צף" באמצעות סקלרים צפים, min ומקסימום לטנזור "פלטים" באותו צורה כמו קלט.

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
min ::mlir::FloatAttr תכונת ציפה של 32 סיביות
max ::mlir::FloatAttr תכונת ציפה של 32 סיביות
num_bits ::mlir::IntegerAttr תכונת מספר שלם ללא סימן של 32 סיביות שהערך המינימלי שלה הוא 2 שהערך המקסימלי שלה הוא 16
narrow_range ::mlir::BoolAttr תכונת bool שהערך שלה הוא false

אופרנדים:

אופרנד תֵאוּר
input טנסור של ערכי ציפה של 32 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של ערכי ציפה של 32 סיביות

tfl.fill (TFL::FillOp)

מלאו את הטנזור בערך נתון.

מלאו את הטנזור בערך נתון.

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
dims טנסור של ערכי מספרים שלמים ללא סימן של 32/64 סיביות
input טנסור של 32 סיביות צף או 16 סיביות צף או 32 סיביות ללא סימן או מספר שלם ללא סימן 64 סיביות או מספר שלם ללא סימן של 1 סיביות או ערכים מסוג QI8 או מסוג QI16 או TFLite

תוצאות:

תוֹצָאָה תֵאוּר
result טנסור של 32 סיביות צף או 16 סיביות צף או 32 סיביות ללא סימן או מספר שלם ללא סימן 64 סיביות או מספר שלם ללא סימן של 1 סיביות או ערכים מסוג QI8 או מסוג QI16 או TFLite

tfl.floor (TFL::FloorOp)

מפעיל קומה

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

תכונות: AlwaysSpeculatableImplTrait , InferTensorType , TF::SameOperandsAndResultTypeResolveRef

ממשקים: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
x טנסור של ערכי ציפה של 32 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
y טנסור של ערכי ציפה של 32 סיביות

tfl.floor_div (TFL::FloorDivOp)

מפעיל div קומה

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

תכונות: ::mlir::OpTrait::TFLRuntimeOpTrait , AlwaysSpeculatableImplTrait , ResultsBroadcastableShape

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
lhs טנסור של מספר שלם ללא סימן של 32 סיביות או 8 סיביות ללא סימן או מספר שלם ללא סימן של 16 סיביות או מספר שלם ללא סימן של 32 סיביות
rhs טנסור של מספר שלם ללא סימן של 32 סיביות או 8 סיביות ללא סימן או מספר שלם ללא סימן של 16 סיביות או מספר שלם ללא סימן של 32 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של מספר שלם ללא סימן של 32 סיביות או 8 סיביות ללא סימן או מספר שלם ללא סימן של 16 סיביות או מספר שלם ללא סימן של 32 סיביות

tfl.floor_mod (TFL::FloorModOp)

תזכורת חטיבה

פעולת תזכורת לחלוקה מבחינה יסודית.

תכונות: ::mlir::OpTrait::TFLRuntimeOpTrait , AlwaysSpeculatableImplTrait , ResultsBroadcastableShape

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
lhs טנסור של מספר שלם ללא סימן של 8 סיביות או מספר שלם ללא סימן של 16 סיביות או מספר שלם ללא סימן של 32 סיביות או ערכי מספר שלם ללא סימן של 64 סיביות או 32 סיביות
rhs טנסור של מספר שלם ללא סימן של 8 סיביות או מספר שלם ללא סימן של 16 סיביות או מספר שלם ללא סימן של 32 סיביות או ערכי מספר שלם ללא סימן של 64 סיביות או 32 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של מספר שלם ללא סימן של 8 סיביות או מספר שלם ללא סימן של 16 סיביות או מספר שלם ללא סימן של 32 סיביות או ערכי מספר שלם ללא סימן של 64 סיביות או 32 סיביות

tfl.fully_connected (TFL::FullyConnectedOp)

אופ. מחובר לחלוטין

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult , quant::AccumulatorUniformScale<2, 0, 1> , quant::AffineOpCoefficient<0, 1>

ממשקים: AffineQuantizedOpInterface , ConditionallySpeculatable , DynamicRangeQuantizedOpInterface , NoMemoryEffect (MemoryEffectOpInterface) , TFL_SparseOp , TflArithmeticCountOpInterface , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
fused_activation_function ::mlir::StringAttr תכונת מחרוזת שהערך שלה הוא NONE, או RELU, או RELU_N1_TO_1, או RELU6, או TANH, או SIGN_BIT
weights_format ::mlir::StringAttr תכונת מחרוזת שהערך שלה הוא DEFAULT, או SHUFFLED4x16INT8
keep_num_dims ::mlir::BoolAttr תכונת bool
asymmetric_quantize_inputs ::mlir::BoolAttr תכונת bool

אופרנדים:

אופרנד תֵאוּר
input טנסור מסוג 32-bit float או מסוג QI8 או מסוג QUI8 או מסוג QI16 או מסוג QUI16
filter טנסור מסוג ציפה של 32 סיביות או מסוג QI4 או מסוג QI8 או מסוג QUI8 או ערכים מסוג QI16
bias טנסור מכל סוג שהוא ערכי או שום סוג

תוצאות:

תוֹצָאָה תֵאוּר
output וריאדית של טנסור מכל סוג שהוא

tfl.gather (TFL::GatherOp)

מפעיל אסוף

אסוף פרוסות מציר axis params לפי indices .

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , DynamicRangeQuantizedOpInterface , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
axis ::mlir::IntegerAttr תכונת מספר שלם ללא סימנים של 32 סיביות
batch_dims ::mlir::IntegerAttr תכונת מספר שלם ללא סימנים של 32 סיביות

אופרנדים:

אופרנד תֵאוּר
params טנסור של מספר שלם ללא סימן 32 סיביות או 1 סיביות ללא סימן או מספר שלם ללא סימן 4 סיביות או מספר שלם ללא סימן 8 סיביות או מספר שלם ללא סימן 16 סיביות או מספר שלם ללא סימן 32 סיביות או מספר שלם ללא סימן 64 סיביות או סוג מחרוזת TFLite או 8 סיביות ערכי מספר שלם או מסוג QI8 או מסוג QUI8 או QI16 ללא סימן
indices טנסור של מספר שלם ללא סימן של 16 סיביות או ערכי מספר שלם ללא סימן של 32 סיביות או 64 סיביות ללא סימן

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של מספר שלם ללא סימן 32 סיביות או 1 סיביות ללא סימן או מספר שלם ללא סימן 4 סיביות או מספר שלם ללא סימן 8 סיביות או מספר שלם ללא סימן 16 סיביות או מספר שלם ללא סימן 32 סיביות או מספר שלם ללא סימן 64 סיביות או סוג מחרוזת TFLite או 8 סיביות ערכי מספר שלם או מסוג QI8 או מסוג QUI8 או QI16 ללא סימן

tfl.gather_nd (TFL::GatherNdOp)

_Gather nd מפעיל

אסוף פרוסות params לתוך Tensor עם צורה שצוינה על ידי indices .

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
params טנסור של מספר שלם ללא סימן 32 סיביות או 1 סיביות ללא סימן או מספר שלם ללא סימן 8 סיביות או מספר שלם ללא סימן 16 סיביות או מספר שלם ללא סימן 64 סיביות או מספר שלם ללא סימן 32 סיביות או 8 סיביות ללא סימן או ערכי סוג מחרוזת QI8 או TFLite
indices טנסור של מספר שלם ללא סימן של 16 סיביות או ערכי מספר שלם ללא סימן של 32 סיביות או 64 סיביות ללא סימן

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של מספר שלם ללא סימן 32 סיביות או 1 סיביות ללא סימן או מספר שלם ללא סימן 8 סיביות או מספר שלם ללא סימן 16 סיביות או מספר שלם ללא סימן 64 סיביות או מספר שלם ללא סימן 32 סיביות או 8 סיביות ללא סימן או ערכי סוג מחרוזת QI8 או TFLite

tfl.gelu (TFL::GeluOp)

פונקציית הפעלה של GELU.

מחשב את פונקציית ההפעלה של GELU מבחינה אלמנטית.

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
approximate ::mlir::BoolAttr תכונת bool

אופרנדים:

אופרנד תֵאוּר
input טנסור של 32 סיביות מסוג ציפה או ערכים מסוג QI8 או QUI8

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של 32 סיביות מסוג ציפה או ערכים מסוג QI8 או QUI8

tfl.greater (TFL::GreaterOp)

מפעיל גדול יותר

מבחינה אלמנטית פעולה גדולה יותר.

תכונות: ::mlir::OpTrait::TFLRuntimeOpTrait , AlwaysSpeculatableImplTrait , QuantizableResult , ResultsBroadcastableShape

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
lhs טנסור של מספר שלם ללא סימן של 32 סיביות או 32 סיביות ללא סימן או מספר שלם ללא סימן של 64 סיביות או ערכי מסוג QUI8 או מסוג QI8 או מסוג TFLite quint8
rhs טנסור של מספר שלם ללא סימן של 32 סיביות או 32 סיביות ללא סימן או מספר שלם ללא סימן של 64 סיביות או ערכי מסוג QUI8 או מסוג QI8 או מסוג TFLite quint8

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של ערכי מספר שלם ללא סימן של סיביות 1

tfl.greater_equal (TFL::GreaterEqualOp)

_אופרטור שווה גדול יותר

פעולה שווה_גדולה מבחינת אלמנט.

תכונות: ::mlir::OpTrait::TFLRuntimeOpTrait , AlwaysSpeculatableImplTrait , QuantizableResult , ResultsBroadcastableShape

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
lhs טנסור של מספר שלם ללא סימן של 32 סיביות או 16 סיביות ללא סימן או מספר שלם ללא סימן 32 סיביות או ערכי מספר שלם ללא סימן 64 סיביות או מסוג QUI8 או מסוג QI8
rhs טנסור של מספר שלם ללא סימן של 32 סיביות או 16 סיביות ללא סימן או מספר שלם ללא סימן 32 סיביות או ערכי מספר שלם ללא סימן 64 סיביות או מסוג QUI8 או מסוג QI8

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של ערכי מספר שלם ללא סימן של סיביות 1

tfl.hard_swish (TFL::HardSwishOp)

פונקציית הפעלה Hardswish.

מחשב את פונקציית הפעלת hard-swish f(x) -> (x * relu6(x+3))/6 מבחינה אלמנט.

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
input טנסור של 32 סיביות ציפה או ערכי QUI8 או QI8

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של 32 סיביות ציפה או ערכי QUI8 או QI8

tfl.hashtable (TFL::HashtableOp)

יוצר טבלת hash לא מאותחלת.

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

ממשקים: TflRuntimeVerifyOpInterface

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
table_id ::mlir::IntegerAttr תכונת מספר שלם ללא סימנים של 32 סיביות
key_dtype ::mlir::TypeAttr כל תכונת סוג
value_dtype ::mlir::TypeAttr כל תכונת סוג

תוצאות:

תוֹצָאָה תֵאוּר
out טנסור של ערכי משאבים

tfl.hashtable_find (TFL::HashtableFindOp)

מחפש מפתחות בטבלה, מוציא את הערכים המתאימים.

keys הטנסור חייבים מאותו סוג למפתחות הטבלה. values הפלט הם מהסוג של ערכי הטבלה.

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

ממשקים: TflRuntimeVerifyOpInterface

אופרנדים:

אופרנד תֵאוּר
hash_table טנסור של ערכי משאבים
keys טנסור של מספר שלם ללא סימן של 32 סיביות או סוג מחרוזת TFLite או ערכי מספר שלם ללא סימן של 64 סיביות
default_value טנסור של מספר שלם ללא סימן של 32 סיביות או 32 סיביות מסוג מחרוזת TFLite או ערכי מספר שלם ללא סימן של 64 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
out טנסור של מספר שלם ללא סימן של 32 סיביות או 32 סיביות מסוג מחרוזת TFLite או ערכי מספר שלם ללא סימן של 64 סיביות

tfl.hashtable_import (TFL::HashtableImportOp)

מחליף את תוכן הטבלה במפתחות ובערכים שצוינו.

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

ממשקים: TflRuntimeVerifyOpInterface

אופרנדים:

אופרנד תֵאוּר
hash_table טנסור של ערכי משאבים
keys טנסור של מספר שלם ללא סימן של 32 סיביות או סוג מחרוזת TFLite או ערכי מספר שלם ללא סימן של 64 סיביות
values טנסור של מספר שלם ללא סימן של 32 סיביות או 32 סיביות מסוג מחרוזת TFLite או ערכי מספר שלם ללא סימן של 64 סיביות

tfl.hashtable_size (TFL::HashtableSizeOp)

מחשב את מספר האלמנטים בטבלה הנתונה.

ממשקים: TflRuntimeVerifyOpInterface

אופרנדים:

אופרנד תֵאוּר
hash_table טנסור של ערכי משאבים

תוצאות:

תוֹצָאָה תֵאוּר
out טנסור של ערכי מספרים שלמים ללא סימן של 64 סיביות

tfl.if (TFL::IfOp)

אם-אז-אחר מבצע

פעולת tfl.if מייצגת מבנה if-then-else לביצוע מותנה של שני אזורי קוד. האופרנד לפעולת if הוא ערך בוליאני. לְדוּגמָה:

tfl.if %b  {
  ...
} else {
  ...
}

tfl.if עשוי גם להחזיר תוצאות המוגדרות באזורים שלה. הערכים המוגדרים נקבעים לפי נתיב הביצוע שנלקח.

דוּגמָה:

%x, %y = tfl.if %b -> (tensor<f32>, tensor<f32>) {
  %x_true = ...
  %y_true = ...
  tfl.yield %x_true, %y_true : tensor<f32>, tensor<f32>
} else {
  %x_false = ...
  %y_false = ...
  tfl.yield %x_false, %y_false : tensor<f32>, tensor<f32>
}

אזורי tfl.if מסתיימים תמיד עם "tfl.yield". אם "tfl.if" לא מגדיר ערכים, ניתן להשאיר את "tfl.yield" בחוץ, והוא יוכנס באופן מרומז. אחרת, זה חייב להיות מפורש. כמו כן, אם "tfl.if" מגדיר ערך אחד או יותר, לא ניתן להשמיט את הבלוק 'אחר'.

דוּגמָה:

tfl.if %b  {
  ...
}

תכונות: NoRegionArguments , RecursiveMemoryEffects , SingleBlockImplicitTerminator<YieldOp> , SingleBlock

ממשקים: RegionBranchOpInterface , TflRuntimeVerifyOpInterface

אופרנדים:

אופרנד תֵאוּר
cond טנסור של ערכי מספר שלם ללא סימן של סיביות 1

תוצאות:

תוֹצָאָה תֵאוּר
results וריאדית של טנסור מכל סוג שהוא

tfl.imag (TFL::ImagOp)

מחזירה את החלק הדמיוני של מספר מרוכב.

בהינתן input טנזור של מספרים מרוכבים, פעולה זו מחזירה טנזור מסוג float שהוא החלק הדמיוני של כל אלמנט input . כל האלמנטים input חייבים להיות מספרים מרוכבים של הטופס \(a + bj\), כאשר a הוא החלק האמיתי ו- b הוא החלק הדמיוני המוחזר על ידי פעולה זו.

תכונות: AlwaysSpeculatableImplTrait , SameOperandsAndResultShape

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
input טנזור מסוג מורכב עם רכיבי ציפה של 32 סיביות או סוג מורכב עם ערכי רכיבי ציפה של 64 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של ערכי ציפה של 32 סיביות או 64 סיביות

tfl.l2_normalization (TFL::L2NormalizationOp)

L2 מנרמל את המפעיל

L2 נורמליזציה אופ

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , FixedOutputRangeInterface , NoMemoryEffect (MemoryEffectOpInterface) , TflArithmeticCountOpInterface , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
fused_activation_function ::mlir::StringAttr תכונת מחרוזת שהערך שלה הוא NONE, או RELU, או RELU_N1_TO_1, או RELU6, או TANH, או SIGN_BIT

אופרנדים:

אופרנד תֵאוּר
input טנסור מסוג ציפה של 32 סיביות או מסוג QUI8 או מסוג QI8 או מסוג QUI16 או מסוג QI16 או ערכי מספר שלם ללא סימן של 8 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור מסוג ציפה של 32 סיביות או מסוג QUI8 או מסוג QI8 או מסוג QUI16 או מסוג QI16 או ערכי מספר שלם ללא סימן של 8 סיביות

tfl.leaky_relu (TFL::LeakyReluOp)

מפעיל Relu דולף

מבחינת אלמנט אופרטור ReLU דולף x -> x >= 0 ? x : (אלפא * x)

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
alpha ::mlir::FloatAttr תכונת ציפה של 32 סיביות

אופרנדים:

אופרנד תֵאוּר
input טנסור מסוג float 32 סיביות או מסוג QUI8 או מסוג QI8 או מסוג TFLite quint8 או ערכי סוג QI16

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור מסוג float 32 סיביות או מסוג QUI8 או מסוג QI8 או מסוג TFLite quint8 או ערכי סוג QI16

tfl.less (TFL::LessOp)

פחות מפעיל

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

תכונות: ::mlir::OpTrait::TFLRuntimeOpTrait , AlwaysSpeculatableImplTrait , QuantizableResult , ResultsBroadcastableShape

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
lhs טנסור של מספר שלם ללא סימן של 32 סיביות או 16 סיביות ללא סימן או מספר שלם ללא סימן 32 סיביות או מספר שלם ללא סימן של 64 סיביות או ערכי סוג QUI8 או מסוג QI8 או TFLite quint8
rhs טנסור של מספר שלם ללא סימן של 32 סיביות או 16 סיביות ללא סימן או מספר שלם ללא סימן 32 סיביות או מספר שלם ללא סימן של 64 סיביות או ערכי סוג QUI8 או מסוג QI8 או TFLite quint8

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של ערכי מספר שלם ללא סימן של סיביות 1

tfl.less_equal (TFL::LessEqualOp)

_אופרטור פחות שווה

מבחינת אלמנט פעולה פחות_שווה.

תכונות: ::mlir::OpTrait::TFLRuntimeOpTrait , AlwaysSpeculatableImplTrait , QuantizableResult , ResultsBroadcastableShape

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
lhs טנסור של מספר שלם ללא סימן של 32 סיביות או 32 סיביות ללא סימן או ערכי מספר שלם ללא סימן של 64 סיביות או מסוג QI8 או מסוג QUI8
rhs טנסור של מספר שלם ללא סימן של 32 סיביות או 32 סיביות ללא סימן או ערכי מספר שלם ללא סימן של 64 סיביות או מסוג QI8 או מסוג QUI8

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של ערכי מספר שלם ללא סימן של סיביות 1

tfl.local_response_normalization (TFL::LocalResponseNormalizationOp)

נורמליזציה של תגובה מקומית.

טנזור input ה-4-D מטופל כמערך 3-D של וקטורים 1-D (לאורך הממד האחרון), וכל וקטור מנורמל באופן עצמאי. בתוך וקטור נתון, כל רכיב מחולק בסכום המשוקלל והריבוע של התשומות בתוך depth_radius . בפירוט,

sqr_sum[a, b, c, d] =
    sum(input[a, b, c, d - depth_radius : d + depth_radius + 1] ** 2)
output = input / (bias + alpha * sqr_sum) ** beta

לפרטים, ראה Krizhevsky וחב', סיווג ImageNet עם רשתות עצביות קונבולוציוניות עמוקות (NIPS 2012) .

תכונות: AlwaysSpeculatableImplTrait , InferTensorType , TF::SameOperandsAndResultTypeResolveRef

ממשקים: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
radius ::mlir::IntegerAttr תכונת מספר שלם ללא סימנים של 32 סיביות
bias ::mlir::FloatAttr תכונת ציפה של 32 סיביות
alpha ::mlir::FloatAttr תכונת ציפה של 32 סיביות
beta ::mlir::FloatAttr תכונת ציפה של 32 סיביות

אופרנדים:

אופרנד תֵאוּר
input טנסור של ערכי ציפה של 32 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של ערכי ציפה של 32 סיביות

tfl.log (TFL::LogOp)

אופרטור לוגריתם טבעי

מבצע פעולת לוגריתם טבעית מבחינת אלמנט בקלט.

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
x טנסור של 32 סיביות מסוג Float או QI8

תוצאות:

תוֹצָאָה תֵאוּר
y טנסור של 32 סיביות מסוג Float או QI8

tfl.log_softmax (TFL::LogSoftmaxOp)

יומן מפעיל softmax

מחשב הפעלת יומן softmax מבחינת אלמנט עם הנוסחה הבאה

קלט - log(reduce_sum(exp(input), dim))

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

ממשקים: ConditionallySpeculatable , FixedOutputRangeInterface , NoMemoryEffect (MemoryEffectOpInterface) , TflArithmeticCountOpInterface , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
input טנסור של 32-bit float או מסוג QUI8 או מסוג QI8 או ערכים מסוג TFLite quint8

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של 32-bit float או מסוג QUI8 או מסוג QI8 או ערכים מסוג TFLite quint8

tfl.logical_and (TFL::LogicalAndOp)

אופרטור AND לוגי

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

תכונות: AlwaysSpeculatableImplTrait , ResultsBroadcastableShape

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
lhs טנסור של ערכי מספר שלם ללא סימן של סיביות 1
rhs טנסור של ערכי מספר שלם ללא סימן של סיביות 1

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של ערכי מספר שלם ללא סימן של סיביות 1

tfl.logical_not (TFL::LogicalNotOp)

אופרטור NOT לוגי

פעולת NOT לוגית מבחינת אלמנט.

תכונות: AlwaysSpeculatableImplTrait , SameOperandsAndResultShape

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
lhs טנסור של ערכי מספר שלם ללא סימן של סיביות 1

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של ערכי מספר שלם ללא סימן של סיביות 1

tfl.logical_or (TFL::LogicalOrOp)

אופרטור OR לוגי

פעולת OR לוגית מבחינת אלמנט.

תכונות: AlwaysSpeculatableImplTrait , ResultsBroadcastableShape

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
lhs טנסור של ערכי מספר שלם ללא סימן של סיביות 1
rhs טנסור של ערכי מספר שלם ללא סימן של סיביות 1

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של ערכי מספר שלם ללא סימן של סיביות 1

tfl.logistic (TFL::LogisticOp)

מפעיל לוגיסטי

מחשב את ה-Sigmoid של הקלט באופן יסודי

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

ממשקים: ConditionallySpeculatable , FixedOutputRangeInterface , NoMemoryEffect (MemoryEffectOpInterface) , TflArithmeticCountOpInterface , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
x טנסור מסוג float 32 סיביות או מסוג QI8 או מסוג QUI8 או מסוג QI16 או ערכי מסוג TFLite quint8

תוצאות:

תוֹצָאָה תֵאוּר
y טנסור מסוג float 32 סיביות או מסוג QI8 או מסוג QUI8 או מסוג QI16 או ערכי מסוג TFLite quint8

tfl.lstm (TFL::LSTMOp)

מפעיל lstm המלא

שכבת רשת חוזרת של יחידת זיכרון לטווח קצר (LSTM). יישום ברירת המחדל ללא חורי הצצה מבוסס על: http://deeplearning.cs.cmu.edu/pdfs/Hochreiter97_lstm.pdf S. Hochreiter ו-J. Schmidhuber. 'זיכרון לטווח קצר'. Neural Computation, 9(8):1735-1780, 1997. יישום חור הצצה מבוסס על: https://research.google.com/pubs/archive/43905.pdf Hasim Sak, Andrew Senior, ופרנסואה Beaufays. "ארכיטקטורות של רשתות עצביות חוזרות לזיכרון לטווח קצר עבור מודלים אקוסטיים בקנה מידה גדול." INTERSPEECH, 2014. הצימוד של שער כניסה ושכח (CIFG) מבוסס על: http://arxiv.org/pdf/1503.04069.pdf Greff et al. 'LSTM: A Search Space Odyssey' נורמליזציה של השכבות מבוססת על: https://arxiv.org/pdf/1607.06450.pdf Ba et al. 'נורמליזציה של שכבה'

תכונות: QuantizableResult

ממשקים: DynamicRangeQuantizedOpInterface , TFL_StatefulOp , TflRuntimeVerifyOpInterface

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
fused_activation_function ::mlir::StringAttr תכונת מחרוזת שהערך שלה הוא NONE, או RELU, או RELU_N1_TO_1, או RELU6, או TANH, או SIGN_BIT
cell_clip ::mlir::FloatAttr תכונת float של 32 סיביות שהערך שלה אינו שלילי
proj_clip ::mlir::FloatAttr תכונת float של 32 סיביות שהערך שלה אינו שלילי
kernel_type ::mlir::TFL::LSTMKernelTypeAttr lstm_kernel_type שהערך שלו הוא mlir::TFL::LSTMKernelType::FULL
asymmetric_quantize_inputs ::mlir::BoolAttr תכונת bool
input_to_input_intermediate ::mlir::TypeAttr כל תכונת סוג
input_to_forget_intermediate ::mlir::TypeAttr כל תכונת סוג
input_to_cell_intermediate ::mlir::TypeAttr כל תכונת סוג
input_to_output_intermediate ::mlir::TypeAttr כל תכונת סוג
effective_hidden_scale_intermediate ::mlir::TypeAttr כל תכונת סוג

אופרנדים:

אופרנד תֵאוּר
input טנסור של 32 סיביות ציפה או ערכי QI8 או QI16
input_to_input_weights טנסור מכל סוג שהוא ערכי או שום סוג
input_to_forget_weights טנסור של 32 סיביות מסוג Float או QI8
input_to_cell_weights טנסור של 32 סיביות מסוג Float או QI8
input_to_output_weights טנסור של 32 סיביות מסוג Float או QI8
recurrent_to_input_weights טנסור מכל סוג שהוא ערכי או שום סוג
recurrent_to_forget_weights טנסור של 32 סיביות מסוג Float או QI8
recurrent_to_cell_weights טנסור של 32 סיביות מסוג Float או QI8
recurrent_to_output_weights טנסור של 32 סיביות מסוג Float או QI8
cell_to_input_weights טנסור מכל סוג שהוא ערכי או שום סוג
cell_to_forget_weights טנסור מכל סוג שהוא ערכי או שום סוג
cell_to_output_weights טנסור מכל סוג שהוא ערכי או שום סוג
input_gate_bias טנסור מכל סוג שהוא ערכי או שום סוג
forget_gate_bias טנסור של 32 סיביות מסוג Float או QI32
cell_bias טנסור של 32 סיביות מסוג Float או QI32
output_gate_bias טנסור של 32 סיביות מסוג Float או QI32
projection_weights טנסור מכל סוג שהוא ערכי או שום סוג
projection_bias טנסור מכל סוג שהוא ערכי או שום סוג
input_activation_state טנסור ממלכתי
input_cell_state טנסור ממלכתי
input_layer_norm_coefficients טנסור מכל סוג שהוא ערכי או שום סוג
forget_layer_norm_coefficients טנסור מכל סוג שהוא ערכי או שום סוג
cell_layer_norm_coefficients טנסור מכל סוג שהוא ערכי או שום סוג
output_layer_norm_coefficients טנסור מכל סוג שהוא ערכי או שום סוג

תוצאות:

תוֹצָאָה תֵאוּר
output ערכי טנסור מכל סוג שהוא

tfl.matrix_diag (TFL::MatrixDiagOp)

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

בהינתן אלכסון, מחזיר טנזור עם האלכסון וכל השאר מרופד באפסים. נניח שלאלכסון יש מידות k [I, J, K, ..., N] , אז הפלט הוא טנזור בדרגה k+1 עם מידות [I, J, K, ..., N, N] כאשר: output[i, j, k, ..., m, n] = 1{m=n} * diagonal[i, j, k, ..., n].

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
diagonal טנסור של מספר שלם ללא סימן של 32 סיביות או 8 סיביות ללא סימן או מספר שלם ללא סימן 16 סיביות או מספר שלם ללא סימן של 32 סיביות או מספר שלם ללא סימן 64 סיביות או מספר שלם ללא סימן 8 סיביות או ערכי סוג QUI8 או מסוג QI8 או מסוג TFLite quint8

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של מספר שלם ללא סימן של 32 סיביות או 8 סיביות ללא סימן או מספר שלם ללא סימן 16 סיביות או מספר שלם ללא סימן של 32 סיביות או מספר שלם ללא סימן 64 סיביות או מספר שלם ללא סימן 8 סיביות או ערכי סוג QUI8 או מסוג QI8 או מסוג TFLite quint8

tfl.matrix_set_diag (TFL::MatrixSetDiagOp)

מחזירה טנזור מטריצה ​​אצווה עם ערכי אלכסון אצווה חדשים.

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

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
input טנסור של מספר שלם ללא סימן של 32 סיביות או 8 סיביות ללא סימן או מספר שלם ללא סימן 16 סיביות או מספר שלם ללא סימן 32 סיביות או מספר שלם ללא סימן 64 סיביות או מספר שלם ללא סימן 8 סיביות או ערכים מסוג QI8 או מסוג QI16 או מסוג QUI8 או מסוג TFLite quint8
diagonal טנסור של מספר שלם ללא סימן של 32 סיביות או 8 סיביות ללא סימן או מספר שלם ללא סימן 16 סיביות או מספר שלם ללא סימן 32 סיביות או מספר שלם ללא סימן 64 סיביות או מספר שלם ללא סימן 8 סיביות או ערכים מסוג QI8 או מסוג QI16 או מסוג QUI8 או מסוג TFLite quint8

תוצאות:

תוֹצָאָה תֵאוּר
result טנסור של מספר שלם ללא סימן של 32 סיביות או 8 סיביות ללא סימן או מספר שלם ללא סימן 16 סיביות או מספר שלם ללא סימן 32 סיביות או מספר שלם ללא סימן 64 סיביות או מספר שלם ללא סימן 8 סיביות או ערכים מסוג QI8 או מסוג QI16 או מסוג QUI8 או מסוג TFLite quint8

tfl.max_pool_2d (TFL::MaxPool2DOp)

Max Pool 2D אופ

מבצע מקסימום פול דו מימדי בכניסה.

כניסות: inputs[0] : נדרש: טנסור הקלט

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflArithmeticCountOpInterface , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
padding ::mlir::StringAttr תכונת string שהערך שלה הוא SAME, או VALID
stride_w ::mlir::IntegerAttr תכונת מספר שלם ללא סימנים של 32 סיביות
stride_h ::mlir::IntegerAttr תכונת מספר שלם ללא סימנים של 32 סיביות
filter_width ::mlir::IntegerAttr תכונת מספר שלם ללא סימנים של 32 סיביות
filter_height ::mlir::IntegerAttr תכונת מספר שלם ללא סימנים של 32 סיביות
fused_activation_function ::mlir::StringAttr תכונת מחרוזת שהערך שלה הוא NONE, או RELU, או RELU_N1_TO_1, או RELU6, או TANH, או SIGN_BIT

אופרנדים:

אופרנד תֵאוּר
input טנסור מסוג float 32 סיביות או מסוג QUI8 או מסוג QI8 או מסוג QI16 או ערכי מסוג TFLite quint8

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור מסוג float 32 סיביות או מסוג QUI8 או מסוג QI8 או מסוג QI16 או ערכי מסוג TFLite quint8

tfl.maximum (TFL::MaximumOp)

מפעיל מקסימום

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

תכונות: ::mlir::OpTrait::TFLRuntimeOpTrait , AlwaysSpeculatableImplTrait , Commutative , QuantizableResult , ResultsBroadcastableShape

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
lhs טנסור של ציפה של 32 סיביות או ערכי 32/64 סיביות ללא סימן או ערכים מסוג QI8 או מסוג QUI8 או מסוג QI16
rhs טנסור של ציפה של 32 סיביות או ערכי 32/64 סיביות ללא סימן או ערכים מסוג QI8 או מסוג QUI8 או מסוג QI16

תוצאות:

תוֹצָאָה תֵאוּר
max טנסור של ציפה של 32 סיביות או ערכי 32/64 סיביות ללא סימן או ערכים מסוג QI8 או מסוג QUI8 או מסוג QI16

tfl.mean (TFL::MeanOp)

מפעיל ממוצע

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

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
keep_dims ::mlir::BoolAttr תכונת bool

אופרנדים:

אופרנד תֵאוּר
input טנסור של מספר שלם ללא סימן 32 סיביות או 32 סיביות ללא סימן או מספר שלם ללא סימן 64 סיביות או ערכים מסוג QI8 או QUI8 או 8 סיביות ללא סימן או ערכים מסוג QI16
axis טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של מספר שלם ללא סימן 32 סיביות או 32 סיביות ללא סימן או מספר שלם ללא סימן 64 סיביות או ערכים מסוג QI8 או QUI8 או 8 סיביות ללא סימן או ערכים מסוג QI16

tfl.minimum (TFL::MinimumOp)

מפעיל מינימלי

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

תכונות: ::mlir::OpTrait::TFLRuntimeOpTrait , AlwaysSpeculatableImplTrait , Commutative , QuantizableResult , ResultsBroadcastableShape

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
lhs טנסור של ציפה של 32 סיביות או ערכי 32/64 סיביות ללא סימן או ערכים מסוג QI8 או מסוג QUI8 או מסוג QI16
rhs טנסור של ציפה של 32 סיביות או ערכי 32/64 סיביות ללא סימן או ערכים מסוג QI8 או מסוג QUI8 או מסוג QI16

תוצאות:

תוֹצָאָה תֵאוּר
min טנסור של ציפה של 32 סיביות או ערכי 32/64 סיביות ללא סימן או ערכים מסוג QI8 או מסוג QUI8 או מסוג QI16

tfl.mirror_pad (TFL::MirrorPadOp)

מפעיל MirrorPad. מרפד טנזור עם ערכי שיקוף.

פעולה זו מרפדת קלט עם ערכי שיקוף בהתאם לריפודים שאתה מציין. ריפודים הוא טנזור שלם עם צורה [n, 2], כאשר n הוא דרגת הקלט. עבור כל ממד D של קלט, ריפודים[D, 0] מציינים כמה ערכים להוסיף לפני תוכן הקלט בממד זה, וריפודים[D, 1] מציינים כמה ערכים להוסיף אחרי תוכן הקלט באותו ממד.

גם ריפודים[D, 0] וגם ריפודים[D, 1] לא צריכים להיות גדולים מ-input.dim_size(D) (או input.dim_size(D) - 1) אם copy_border הוא אמת (אם שקר, בהתאמה).

הגודל המרופד של כל מימד D של הפלט הוא:

paddings(D, 0) + input.dim_size(D) + paddings(D, 1)

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
mode ::mlir::TFL::MirrorPaddingTypeAttr mirror_pad_enum

אופרנדים:

אופרנד תֵאוּר
input טנסור של מספר שלם ללא סימן של 32 סיביות או 32 סיביות ללא סימן או מספר שלם ללא סימן 64 סיביות או מספר שלם ללא סימן של 8 סיביות או ערכי מספר שלם ללא סימן 8 סיביות או מסוג QI8 או מסוג QUI8 או מסוג QI16
pad טנסור של ערכי מספר שלם ללא סימן של 32 סיביות או 64 סיביות ללא סימן

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של מספר שלם ללא סימן של 32 סיביות או 32 סיביות ללא סימן או מספר שלם ללא סימן 64 סיביות או מספר שלם ללא סימן של 8 סיביות או ערכי מספר שלם ללא סימן 8 סיביות או מסוג QI8 או מסוג QUI8 או מסוג QI16

tfl.mul (TFL::MulOp)

אופרטור כפל

פעולת כפל אלמנט.

תכונות: ::mlir::OpTrait::TFLRuntimeOpTrait , AlwaysSpeculatableImplTrait , Commutative , QuantizableResult , ResultsBroadcastableShape

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflArithmeticCountOpInterface , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
fused_activation_function ::mlir::StringAttr תכונת מחרוזת שהערך שלה הוא NONE, או RELU, או RELU_N1_TO_1, או RELU6, או TANH, או SIGN_BIT

אופרנדים:

אופרנד תֵאוּר
lhs טנסור של מספר שלם ללא סימן 32 סיביות או 32 סיביות ללא סימן או מספר שלם ללא סימן 32 סיביות או מספר שלם ללא סימן 64 סיביות או מסוג QI8 או מסוג QUI8 או מסוג QI16 או מספר שלם ללא סימן 16 סיביות או סוג מורכב עם ערכי רכיבים צפים של 32 סיביות
rhs טנסור של מספר שלם ללא סימן 32 סיביות או 32 סיביות ללא סימן או מספר שלם ללא סימן 32 סיביות או מספר שלם ללא סימן 64 סיביות או מסוג QI8 או מסוג QUI8 או מסוג QI16 או מספר שלם ללא סימן 16 סיביות או סוג מורכב עם ערכי רכיבים צפים של 32 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של מספר שלם ללא סימן 32 סיביות או 32 סיביות ללא סימן או מספר שלם ללא סימן 32 סיביות או מספר שלם ללא סימן 64 סיביות או מסוג QI8 או מסוג QUI8 או מסוג QI16 או מספר שלם ללא סימן 16 סיביות או סוג מורכב עם ערכי רכיבים צפים של 32 סיביות

tfl.multinomial (TFL::MultinomialOp)

שואב דוגמאות מהתפלגות קטגורית.

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

ממשקים: TflRuntimeVerifyOpInterface

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
seed ::mlir::IntegerAttr תכונת מספר שלם ללא סימנים של 64 סיביות
seed2 ::mlir::IntegerAttr תכונת מספר שלם ללא סימנים של 64 סיביות

אופרנדים:

אופרנד תֵאוּר
logits טנסור של ערכי ציפה של 32 סיביות
num_samples טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
out טנסור של ערכי מספר שלם ללא סימן של 32 סיביות או 64 סיביות ללא סימן

tfl.neg (TFL::NegOp)

מפעיל שלילה

מחשב שלילה של קלט מבחינה אלמנטרית

תכונות: AlwaysSpeculatableImplTrait , InferTensorType , TF::SameOperandsAndResultTypeResolveRef

ממשקים: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
x טנסור של ערכי מספר שלם ללא סימן של 32 סיביות או 32 סיביות או 64 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
y טנסור של ערכי מספר שלם ללא סימן של 32 סיביות או 32 סיביות או 64 סיביות

tfl.no_value (TFL::NoValueOp)

קבוע ללא ערך.

אין קבוע ערך אופ.

תכונות: AlwaysSpeculatableImplTrait , ConstantLike

ממשקים: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
value ::mlir::UnitAttr תכונת יחידה

תוצאות:

תוֹצָאָה תֵאוּר
none_val שום סוג

tfl.non_max_suppression_v4 (TFL::NonMaxSuppressionV4Op)

בוחר בתאוותנות קבוצת משנה של תיבות תוחמות בסדר יורד של הניקוד,

גיזום תיבות בעלות חפיפה גבוהה של צומת-על-איחוד (IOU) עם תיבות שנבחרו בעבר. תיבות תוחמות עם ציון נמוך מ- score_threshold מוסרות. תיבות תוחמות מסופקות בתור [y1, x1, y2, x2], כאשר (y1, x1) ו-(y2, x2) הן הקואורדינטות של כל זוג אלכסוני של פינות תיבה וניתן לספק את הקואורדינטות כמנורמלות (כלומר, שוכבות בתוך המרווח [0, 1]) או מוחלט. שימו לב שאלגוריתם זה הוא אגנוסטי למקום שבו המקור נמצא במערכת הקואורדינטות, ובאופן כללי יותר אינו משתנה לתמורות אורתוגונליות ותרגומים של מערכת הקואורדינטות; לפיכך, תרגום או השתקפויות של מערכת הקואורדינטות מביאים לכך שאותן תיבות נבחרות על ידי האלגוריתם. הפלט של פעולה זו הוא קבוצה של מספרים שלמים המופיעים באינדקס לאוסף הקלט של תיבות תוחמות המייצגות את התיבות שנבחרו. לאחר מכן ניתן לקבל את קואורדינטות התיבה התוחמת המתאימות למדדים שנבחרו באמצעות tf.gather operation . לדוגמה: selected_indices = tf.image.non_max_suppression_v2( boxes, scores, max_output_size, iou_threshold, score_threshold) selected_boxes = tf.gather(boxes, selected_indexes)

תכונות: AlwaysSpeculatableImplTrait

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
boxes טנסור של ערכי ציפה של 32 סיביות
scores טנסור של ערכי ציפה של 32 סיביות
max_output_size טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות
iou_threshold טנסור של ערכי ציפה של 32 סיביות
score_threshold טנסור של ערכי ציפה של 32 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
selected_indices טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות
valid_outputs טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות

tfl.non_max_suppression_v5 (TFL::NonMaxSuppressionV5Op)

בוחר בתאוותנות קבוצת משנה של תיבות תוחמות בסדר יורד של הניקוד,

גיזום תיבות בעלות חפיפה גבוהה של צומת-על-איחוד (IOU) עם תיבות שנבחרו בעבר. תיבות תוחמות עם ציון נמוך מ- score_threshold מוסרות. תיבות תוחמות מסופקות בתור [y1, x1, y2, x2], כאשר (y1, x1) ו-(y2, x2) הן הקואורדינטות של כל זוג אלכסוני של פינות תיבה וניתן לספק את הקואורדינטות כמנורמלות (כלומר, שוכבות בתוך המרווח [0, 1]) או מוחלט. שימו לב שאלגוריתם זה הוא אגנוסטי למקום שבו המקור נמצא במערכת הקואורדינטות, ובאופן כללי יותר אינו משתנה לתמורות אורתוגונליות ותרגומים של מערכת הקואורדינטות; לפיכך, תרגום או השתקפויות של מערכת הקואורדינטות מביאים לכך שאותן תיבות נבחרות על ידי האלגוריתם. הפלט של פעולה זו הוא קבוצה של מספרים שלמים המופיעים באינדקס לאוסף הקלט של תיבות תוחמות המייצגות את התיבות שנבחרו. לאחר מכן ניתן לקבל את קואורדינטות התיבה התוחמת המתאימות למדדים שנבחרו באמצעות tf.gather operation . לדוגמה: selected_indices = tf.image.non_max_suppression_v2( boxes, scores, max_output_size, iou_threshold, score_threshold) selected_boxes = tf.gather(boxes, selected_indexes) אופציה זו תומכת גם במצב Soft-NMS (עם שקלול גאוסי וכו') (cf , https://arxiv.org/abs/1704.04503 ) שבהם תיבות מפחיתות את הניקוד של תיבות חופפות אחרות במקום לגרום ישירות לחיתוך שלהן. כדי להפעיל מצב Soft-NMS זה, הגדר את הפרמטר soft_nms_sigma להיות גדול מ-0.

תכונות: AlwaysSpeculatableImplTrait

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
boxes טנסור של ערכי ציפה של 32 סיביות
scores טנסור של ערכי ציפה של 32 סיביות
max_output_size טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות
iou_threshold טנסור של ערכי ציפה של 32 סיביות
score_threshold טנסור של ערכי ציפה של 32 סיביות
soft_nms_sigma טנסור של ערכי ציפה של 32 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
selected_indices טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות
selected_scores טנסור של ערכי ציפה של 32 סיביות
valid_outputs טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות

tfl.not_equal (TFL::NotEqualOp)

_אופרטור לא שווה

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

תכונות: ::mlir::OpTrait::TFLRuntimeOpTrait , AlwaysSpeculatableImplTrait , Commutative , ResultsBroadcastableShape

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
lhs טנסור של מספר שלם ללא סימן 1 סיביות או 32 סיביות צף או מספר שלם ללא סימן 32 סיביות או מספר שלם ללא סימן 64 סיביות או ערכים מסוג QUI8 או מסוג QI8 או מסוג TFLite quint8 או ערכי מחרוזת TFLite
rhs טנסור של מספר שלם ללא סימן 1 סיביות או 32 סיביות צף או מספר שלם ללא סימן 32 סיביות או מספר שלם ללא סימן 64 סיביות או ערכים מסוג QUI8 או מסוג QI8 או מסוג TFLite quint8 או ערכי מחרוזת TFLite

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של ערכי מספר שלם ללא סימן של סיביות 1

tfl.NumericVerify (TFL::NumericVerifyOp)

מאמת את המספרים של שני האופרנדים

ה-NumericVerify אופ הוא מבצע ניפוי באגים לאימות המספריות של שתי ההפעלה. זה אופציה מותאמת אישית ב-TFLite. אם log_if_failed הוא true, ה-NumericVerify op מחשב נתונים סטטיסטיים על הבדלים בין הפעלות צפות וקובנטיות, יומני פלט, מגדיר הבדלים לטנסור הפלט וזורק שגיאה אם ​​קיימות שגיאות מעל לסובלנות. אם log_if_failed = false, אז לא אכפת לו משגיאות.

תכונות: QuantizableResult , SameOperandsShape

ממשקים: TflRuntimeVerifyOpInterface

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
tolerance ::mlir::FloatAttr תכונת ציפה של 32 סיביות
log_if_failed ::mlir::BoolAttr תכונת bool

אופרנדים:

אופרנד תֵאוּר
input טנסור מסוג QI8 או מסוג QUI8 או מסוג QI16 או ערכי ציפה של 16 סיביות או TFLite quint8
ref טנסור של ערכי ציפה של 32 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של ערכי ציפה של 32 סיביות

tfl.one_hot (TFL::OneHotOp)

מפעיל OneHot

מחזירה טנסור חד-חם. המיקומים המיוצגים על ידי מדדים indices מקבלים ערך on_value , בעוד שכל המיקומים האחרים מקבלים ערך off_value .

אם indices הקלט הם דרגה N , לפלט יהיה דירוג N+1 , הציר החדש נוצר axis הממד (ברירת מחדל: הציר החדש מצורף בסוף).

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
axis ::mlir::IntegerAttr תכונת מספר שלם ללא סימנים של 32 סיביות

אופרנדים:

אופרנד תֵאוּר
indices טנסור של ערכי מספר שלם ללא סימן של 32 סיביות או 64 סיביות ללא סימן
depth טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות
on_value טנסור של מספר שלם ללא סימן של 32 סיביות או 32 סיביות ללא סימן או מספר שלם ללא סימן של 64 סיביות או מספר שלם ללא סימן של 1 סיביות או ערכי מספר שלם ללא סימן 8 סיביות או 8 סיביות ללא סימן
off_value טנסור של מספר שלם ללא סימן של 32 סיביות או 32 סיביות ללא סימן או מספר שלם ללא סימן של 64 סיביות או מספר שלם ללא סימן של 1 סיביות או ערכי מספר שלם ללא סימן 8 סיביות או 8 סיביות ללא סימן

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של מספר שלם ללא סימן של 32 סיביות או 32 סיביות ללא סימן או מספר שלם ללא סימן של 64 סיביות או מספר שלם ללא סימן של 1 סיביות או ערכי מספר שלם ללא סימן 8 סיביות או 8 סיביות ללא סימן

tfl.pack (TFL::PackOp)

אורזת רשימה של טנסורים לאורך מימד לטנזור אחד

אורזת רשימה של values_count rank- R טנסורים לטנסור rank- (R+1) אחד.

אורז את הטנזורים values_count values לתוך טנזור עם דירוג אחד גבוה יותר מכל טנסור values , על ידי אריזה לאורך ממד axis .

נתונה רשימה של טנסורים של צורה (A, B, C) ;

אם axis == 0 אז לטנזור output תהיה הצורה (N, A, B, C) . אם axis == 1 אז לטנזור output תהיה הצורה (A, N, B, C) . וכו.

לְדוּגמָה:

# 'x' is [1, 4]
# 'y' is [2, 5]
# 'z' is [3, 6]
pack([x, y, z]) => [[1, 4], [2, 5], [3, 6]]  # Pack along first dim.
pack([x, y, z], axis=1) => [[1, 2, 3], [4, 5, 6]]

זה ההפך unpack .

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
values_count ::mlir::IntegerAttr תכונת מספר שלם ללא סימן של 32 סיביות שערכה חיובי
axis ::mlir::IntegerAttr תכונת מספר שלם ללא סימנים של 32 סיביות

אופרנדים:

אופרנד תֵאוּר
values וריאדית של טנסור מכל סוג שהוא

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של מספר שלם ללא סימן של 32 סיביות או 8 סיביות ללא סימן או מספר שלם ללא סימן 16 סיביות או מספר שלם ללא סימן 32 סיביות או מספר שלם ללא סימן 64 סיביות או מספר שלם ללא סימן 8 סיביות או מספר שלם ללא סימן 32 סיביות או מסוג QI8 או מסוג QUI8 או QI16 ערכי סוג סוג או TFLite quint8

tfl.pad (TFL::PadOp)

מפעיל ריפוד

פעולה זו מרפדת input באפסים בהתאם paddings שאתה מציין. paddings הוא טנזור שלם עם צורה [Dn, 2] , כאשר n הוא דרגת input . עבור כל ממד D של input , paddings[D, 0] מציינים כמה אפסים להוסיף לפני תוכן input באותו מימד, paddings[D, 1] מציינים כמה אפסים להוסיף אחרי תוכן input באותו מימד.

הגודל המרופד של כל מימד D של הפלט הוא:

paddings(D, 0) + input.dim_size(D) + paddings(D, 1)

לְדוּגמָה:

# 't' is [[1, 1], [2, 2]]
# 'paddings' is [[1, 1], [2, 2]]
# rank of 't' is 2
pad(t, paddings) ==> [[0, 0, 0, 0, 0, 0]
                      [0, 0, 1, 1, 0, 0]
                      [0, 0, 2, 2, 0, 0]
                      [0, 0, 0, 0, 0, 0]]

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
input טנסור של מספר שלם ללא סימן של 32 סיביות או 32 סיביות ללא סימן או מספר שלם ללא סימן 64 סיביות או ערכים מסוג QI8 או מסוג QUI8 או מסוג TFLite quint8 או מסוג QI16
padding טנסור של ערכי מספרים שלמים ללא סימן של 32/64 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של מספר שלם ללא סימן של 32 סיביות או 32 סיביות ללא סימן או מספר שלם ללא סימן 64 סיביות או ערכים מסוג QI8 או מסוג QUI8 או מסוג TFLite quint8 או מסוג QI16

tfl.padv2 (TFL::PadV2Op)

מפעיל ריפוד v2

פעולה זו מרפדת input בהתאם paddings ול- constant_values ​​שאתה מציין. paddings הוא טנזור שלם עם צורה [Dn, 2] , כאשר n הוא דרגת input . עבור כל ממד D של input , paddings[D, 0] מציינים כמה אפסים להוסיף לפני תוכן input באותו מימד, paddings[D, 1] מציינים כמה אפסים להוסיף אחרי תוכן input באותו מימד. constant_values ​​הוא טנסור סקלרי מאותו סוג של input המציין את הערך לשימוש עבור input ריפוד.

הגודל המרופד של כל מימד D של הפלט הוא:

paddings(D, 0) + input.dim_size(D) + paddings(D, 1)

לְדוּגמָה:

# 't' is [[1, 1], [2, 2]]
# 'paddings' is [[1, 1], [2, 2]]
# rank of 't' is 2
pad(t, paddings) ==> [[0, 0, 0, 0, 0, 0]
                      [0, 0, 1, 1, 0, 0]
                      [0, 0, 2, 2, 0, 0]
                      [0, 0, 0, 0, 0, 0]]

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
input טנסור של מספר שלם ללא סימן של 32 סיביות או 32 סיביות ללא סימן או מספר שלם ללא סימן של 64 סיביות או ערכי מספר שלם ללא סימן 8 סיביות או מסוג QI8 או מסוג QUI8 או TFLite quint8
padding טנסור של ערכי מספרים שלמים ללא סימן של 32/64 סיביות
constant_values טנסור של מספר שלם ללא סימן של 32 סיביות או 32 סיביות ללא סימן או מספר שלם ללא סימן של 64 סיביות או ערכי מספר שלם ללא סימן 8 סיביות או מסוג QI8 או מסוג QUI8 או TFLite quint8

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של מספר שלם ללא סימן של 32 סיביות או 32 סיביות ללא סימן או מספר שלם ללא סימן של 64 סיביות או ערכי מספר שלם ללא סימן 8 סיביות או מסוג QI8 או מסוג QUI8 או TFLite quint8

tfl.poly_call (TFL::PolyCallOp)

שיחת פולי

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

input: רשימה של טנסור קלט שהסוגים שלהם הם T. פלט: רשימה של טנסור פלט שהסוגים שלהם הם T.

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

תכונות: SingleBlockImplicitTerminator<YieldOp> , SingleBlock

ממשקים: RegionBranchOpInterface

אופרנדים:

אופרנד תֵאוּר
input וריאדית של טנסור מכל סוג שהוא

תוצאות:

תוֹצָאָה תֵאוּר
output וריאדית של טנסור מכל סוג שהוא

tfl.pow (TFL::PowOp)

מפעיל כוח

פעולת כוח מבחינה יסודית.

תכונות: ::mlir::OpTrait::TFLRuntimeOpTrait , AlwaysSpeculatableImplTrait , ResultsBroadcastableShape

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
lhs טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות או 32 סיביות
rhs טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות או 32 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות או 32 סיביות

tfl.prelu (TFL::PReluOp)

מפעיל Relu בעל פרמטרים

אופרטור Relu עם פרמטרים x -> x >= 0 ? x : (אלפא * x) כאשר אלפא הוא טנזור הניתן לאימון. קלט ואלפא צריכים להיות באותו גודל לקלט או להיות ניתנים לשידור.

תכונות: ::mlir::OpTrait::TFLRuntimeOpTrait , AlwaysSpeculatableImplTrait , QuantizableResult , ResultsBroadcastableShape , quant::AffineOpCoefficient<-1, 1>

ממשקים: AffineQuantizedOpInterface , ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
input טנסור של 32 סיביות ציפה או ערכים מסוג QI8 או מסוג QUI8 או TFLite quint8
alpha טנסור של 32 סיביות ציפה או ערכים מסוג QI8 או מסוג QUI8 או TFLite quint8

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של 32 סיביות ציפה או ערכים מסוג QI8 או מסוג QUI8 או TFLite quint8

tfl.pseudo_const (TFL::ConstOp)

פסאודו אופ מתמיד.

מייצג ערך קבוע בניב TensorFlow Lite. זו אינה פעולה ממשית והיא תוריד למאגר במקום זאת.

ל-op מותר להיות כל אותו סוג של תכונות כמו tf.Const (למשל, תכונות TF אטומות מותרות).

תכונות: AlwaysSpeculatableImplTrait , ConstantLike , FirstAttrDerivedResultType , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
value ::mlir::ElementsAttr תכונת וקטור/טנזור קבוע

תוצאות:

תוֹצָאָה תֵאוּר
output ערכי טנסור מכל סוג שהוא

tfl.pseudo_qconst (TFL::QConstOp)

פסאודו אופ קבוע כמותי

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

תכונות: AlwaysSpeculatableImplTrait , FirstAttrDerivedResultType

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
qtype ::mlir::TypeAttr תכונת סוג טנזור
value ::mlir::ElementsAttr תכונת וקטור/טנזור קבוע

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור מסוג QUI8 או מסוג QI8 או מסוג QI16 או מסוג QUI16 או ערכי מסוג TFLite quint8

tfl.pseudo_sparse_const (TFL::SparseConstOp)

פסאודו אופ קבוע דליל.

מייצג ערך קבוע דליל בניב TensorFlow Lite. זו אינה פעולה ממשית והיא תוריד למאגר במקום זאת.

תכונות: AlwaysSpeculatableImplTrait , FirstAttrDerivedResultType , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
value ::mlir::ElementsAttr תכונת וקטור/טנזור קבוע
s_param ::mlir::TFL::SparsityParameterAttr פרמטר דלילות.
compressed_data ::mlir::ElementsAttr תכונת וקטור/טנזור קבוע

תוצאות:

תוֹצָאָה תֵאוּר
output ערכי טנסור מכל סוג שהוא

tfl.pseudo_sparse_qconst (TFL::SparseQConstOp)

פסאודו אופ קבוע כמותי דליל

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

תכונות: AlwaysSpeculatableImplTrait , FirstAttrDerivedResultType

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
qtype ::mlir::TypeAttr תכונת סוג טנזור
value ::mlir::ElementsAttr תכונת וקטור/טנזור קבוע
s_param ::mlir::TFL::SparsityParameterAttr פרמטר דלילות.
compressed_data ::mlir::ElementsAttr תכונת וקטור/טנזור קבוע

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור מסוג QUI8 או מסוג QI8 או מסוג QI16 או מסוג QUI16 או ערכי מסוג TFLite quint8

tfl.quantize (TFL::QuantizeOp)

אופרטור quantize

ממירה טנסור נקודה צפה לטנסורים שלמים כמותיים לפי פרמטרי הכימות המוגדרים בתכונת type.

תכונות: FirstAttrDerivedResultType , SameOperandsAndResultShape

ממשקים: NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
qtype ::mlir::TypeAttr תכונת סוג טנזור

אופרנדים:

אופרנד תֵאוּר
input טנסור מסוג ציפה של 32 סיביות או מסוג QI4 או מסוג QI8 או מסוג QUI8 או מסוג QI16 או ערכי מסוג TFLite quint8

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור מסוג QI4 או מסוג QI8 או מסוג QUI8 או מסוג QI16 או ערכי מסוג TFLite quint8

tfl.random_standard_normal (TFL::RandomStandardNormalOp)

מוציא ערכים אקראיים מהתפלגות נורמלית.

לערכים שנוצרו יהיו ממוצע 0 וסטיית תקן 1.

ממשקים: TflRuntimeVerifyOpInterface

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
seed ::mlir::IntegerAttr תכונת מספר שלם ללא סימנים של 64 סיביות
seed2 ::mlir::IntegerAttr תכונת מספר שלם ללא סימנים של 64 סיביות

אופרנדים:

אופרנד תֵאוּר
shape טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
out טנסור של ערכי ציפה של 32 סיביות

tfl.random_uniform (TFL::RandomUniformOp)

מוציא ערכים אקראיים מהתפלגות אחידה.

הערכים שנוצרו עוקבים אחר התפלגות אחידה בטווח [0, 1) . הגבול התחתון 0 נכלל בטווח, ואילו הגבול העליון 1 אינו נכלל.

ממשקים: TflRuntimeVerifyOpInterface

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
seed ::mlir::IntegerAttr תכונת מספר שלם ללא סימנים של 64 סיביות
seed2 ::mlir::IntegerAttr תכונת מספר שלם ללא סימנים של 64 סיביות

אופרנדים:

אופרנד תֵאוּר
shape טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
out טנסור של ערכי ציפה של 32 סיביות

tfl.range (TFL::RangeOp)

מפעיל טווח

מחזירה טנזור 1D המוגדר על ידי רצף start ועד limit עם delta נתונה.

תכונות: AlwaysSpeculatableImplTrait

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
start טנסור של מספר שלם ללא סימן של 32 סיביות או ערכי מספר שלם ללא סימן של 32 סיביות או 64 סיביות
limit טנסור של מספר שלם ללא סימן של 32 סיביות או ערכי מספר שלם ללא סימן של 32 סיביות או 64 סיביות
delta טנסור של מספר שלם ללא סימן של 32 סיביות או ערכי מספר שלם ללא סימן של 32 סיביות או 64 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
result טנסור של מספר שלם ללא סימן של 32 סיביות או ערכי מספר שלם ללא סימן של 32 סיביות או 64 סיביות

tfl.rank (TFL::RankOp)

מפעיל דרגה.

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

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
input ערכי טנסור מכל סוג שהוא

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור מכל סוג של מספר שלם

tfl.read_variable (TFL::ReadVariableOp)

קורא ערך משתנה.

קרא נתונים משתנים המזוהים על ידי 'resource_id'.

ממשקים: TflRuntimeVerifyOpInterface

אופרנדים:

אופרנד תֵאוּר
resource_id טנסור של ערכי משאבים

תוצאות:

תוֹצָאָה תֵאוּר
result טנסור של צף 32 סיביות או 64 סיביות צף או מספר שלם ללא סימן 1 סיביות או מספר שלם ללא סימן 8 סיביות או מספר שלם ללא סימן 8 סיביות או מסוג QI8 או מסוג QUI8 או מספר שלם ללא סימן 32 סיביות או מספר שלם ללא סימן 64 סיביות או סוג QI16 או סוג מורכב עם רכיבי ציפה של 32 סיביות או סוג מורכב עם ערכי רכיבי ציפה של 64 סיביות

tfl.real (TFL::RealOp)

מחזירה את החלק האמיתי של מספר מרוכב.

בהינתן input טנזור של מספרים מרוכבים, פעולה זו מחזירה טנזור מסוג float שהוא החלק האמיתי של כל אלמנט input . כל האלמנטים input חייבים להיות מספרים מרוכבים של הטופס \(a + bj\), כאשר a הוא החלק האמיתי המוחזר על ידי פעולה זו ו- b הוא החלק הדמיוני.

תכונות: AlwaysSpeculatableImplTrait , SameOperandsAndResultShape

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
input טנזור מסוג מורכב עם רכיבי ציפה של 32 סיביות או סוג מורכב עם ערכי רכיבי ציפה של 64 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של ערכי ציפה של 32 סיביות או 64 סיביות

tfl.reduce_all (TFL::ReduceAllOp)

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

מפחית input לאורך הממדים הניתנים axis . אלא אם כן keep_dims נכון, דירוג הטנזור מופחת ב-1 עבור כל כניסה axis . אם keep_dims נכון, הממדים המופחתים נשמרים עם אורך 1.

תכונות: AlwaysSpeculatableImplTrait

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
keep_dims ::mlir::BoolAttr תכונת bool

אופרנדים:

אופרנד תֵאוּר
input טנסור של ערכי מספר שלם ללא סימן של סיביות 1
reduction_indices טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של ערכי מספר שלם ללא סימן של סיביות 1

tfl.reduce_any (TFL::ReduceAnyOp)

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

מפחית input לאורך הממדים הניתנים axis . אלא אם כן keep_dims נכון, דירוג הטנזור מופחת ב-1 עבור כל כניסה axis . אם keep_dims נכון, הממדים המופחתים נשמרים עם אורך 1.

תכונות: AlwaysSpeculatableImplTrait

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
keep_dims ::mlir::BoolAttr תכונת bool

אופרנדים:

אופרנד תֵאוּר
input טנסור של ערכי מספר שלם ללא סימן של סיביות 1
reduction_indices טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של ערכי מספר שלם ללא סימן של סיביות 1

tfl.reduce_max (TFL::ReduceMaxOp)

מפעיל הפחתה מקסימלית

מחשב את ההפחתה המקסימלית לאורך הצירים שצוינו

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
keep_dims ::mlir::BoolAttr תכונת bool

אופרנדים:

אופרנד תֵאוּר
input טנסור של מספר שלם ללא סימן של 32 סיביות או 32 סיביות ללא סימן או מספר שלם ללא סימן 64 סיביות או ערכים מסוג QI8 או מסוג QUI8 או מסוג TFLite quint8 או מסוג QI16
axes טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של מספר שלם ללא סימן של 32 סיביות או 32 סיביות ללא סימן או מספר שלם ללא סימן 64 סיביות או ערכים מסוג QI8 או מסוג QUI8 או מסוג TFLite quint8 או מסוג QI16

tfl.reduce_min (TFL::ReduceMinOp)

מפעיל הפחתה מינימלית

מחשב את ההפחתה המינימלית לאורך הצירים שצוינו

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
keep_dims ::mlir::BoolAttr תכונת bool

אופרנדים:

אופרנד תֵאוּר
input טנסור של מספר שלם ללא סימן של 32 סיביות או 32 סיביות ללא סימן או מספר שלם ללא סימן 64 סיביות או ערכים מסוג QI8 או מסוג QUI8 או מסוג TFLite quint8 או מסוג QI16
axes טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של מספר שלם ללא סימן של 32 סיביות או 32 סיביות ללא סימן או מספר שלם ללא סימן 64 סיביות או ערכים מסוג QI8 או מסוג QUI8 או מסוג TFLite quint8 או מסוג QI16

tfl.reduce_prod (TFL::ReduceProdOp)

מפעיל הפחתת מוצרים

מחשב את המוצר לאורך הצירים שצוינו

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
keep_dims ::mlir::BoolAttr תכונת bool

אופרנדים:

אופרנד תֵאוּר
input טנסור של מספר שלם ללא סימן של 32 סיביות או 32 סיביות ללא סימן או מספר שלם ללא סימן 64 סיביות או ערכים מסוג QI8 או מסוג QUI8 או מסוג TFLite quint8 או מסוג QI16
axes טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של מספר שלם ללא סימן של 32 סיביות או 32 סיביות ללא סימן או מספר שלם ללא סימן 64 סיביות או ערכים מסוג QI8 או מסוג QUI8 או מסוג TFLite quint8 או מסוג QI16

tfl.relu (TFL::ReluOp)

מפעיל Relu

אופרטור Relu מבחינת אלמנט x -> max(0, x)

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
x טנסור של 32 סיביות ציפה או ערכים מסוג QUI8 או מסוג QI8 או QI16

תוצאות:

תוֹצָאָה תֵאוּר
y טנסור של 32 סיביות ציפה או ערכים מסוג QUI8 או מסוג QI8 או QI16

tfl.relu6 (TFL::Relu6Op)

מפעיל Relu6

אופרטור Relu6 x -> max(0, min(6, x)) מבחינת אלמנט

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
x טנסור של 32 סיביות ציפה או ערכי QUI8 או QI8

תוצאות:

תוֹצָאָה תֵאוּר
y טנסור של 32 סיביות ציפה או ערכי QUI8 או QI8

tfl.relu_0_to_1 (TFL::Relu0To1Op)

מפעיל Relu0To1

אופרטור Relu0To1 מבחינת אלמנט x -> max(0, min(1, x))

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
x טנסור של 32 סיביות ציפה או ערכי QUI8 או QI8

תוצאות:

תוֹצָאָה תֵאוּר
y טנסור של 32 סיביות ציפה או ערכי QUI8 או QI8

tfl.relu_n1_to_1 (TFL::Relu1Op)

מפעיל Relu1

אופרטור Relu1 x -> max(-1, min(1, x)) מבחינת אלמנט

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
x טנסור של 32 סיביות ציפה או ערכי QUI8 או QI8

תוצאות:

תוֹצָאָה תֵאוּר
y טנסור של 32 סיביות ציפה או ערכי QUI8 או QI8

tfl.reshape (TFL::ReshapeOp)

מפעיל צורה מחדש

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

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
input ערכי טנסור מכל סוג שהוא
shape טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output ערכי טנסור מכל סוג שהוא

tfl.resize_bilinear (TFL::ResizeBilinearOp)

שינוי גודלBilinear Op

שנה את גודל images size באמצעות אינטרפולציה בילינארית.

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
align_corners ::mlir::BoolAttr תכונת bool
half_pixel_centers ::mlir::BoolAttr תכונת bool

אופרנדים:

אופרנד תֵאוּר
input טנסור של 32-bit float או מסוג TFLite quint8 או מסוג QUI8 או מסוג QI8 או מסוג QI16
size טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של 32-bit float או מסוג TFLite quint8 או מסוג QUI8 או מסוג QI8 או מסוג QI16

tfl.resize_nearest_neighbor (TFL::ResizeNearestNeighborOp)

שנה גודל קרוב לשכן אופ

שנה את גודל images size באמצעות אינטרפולציה של השכן הקרוב ביותר.

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
align_corners ::mlir::BoolAttr תכונת bool
half_pixel_centers ::mlir::BoolAttr תכונת bool

אופרנדים:

אופרנד תֵאוּר
input טנסור של 32-bit float או מסוג TFLite quint8 או מסוג QUI8 או מסוג QI8 או מסוג QI16
size טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של 32-bit float או מסוג TFLite quint8 או מסוג QUI8 או מסוג QI8 או מסוג QI16

tfl.reverse_sequence (TFL::ReverseSequenceOp)

הופך פרוסות באורך משתנה.

אופציה זו input קלט ראשון לאורך הממד batch_dim , ולכל פרוסה i , הופכת את האלמנטים seq_lengths[i] הראשונים לאורך הממד seq_dim .

האלמנטים של seq_lengths חייבים לציית ל- seq_lengths[i] <= input.dims[seq_dim] , ו- seq_lengths חייב להיות וקטור באורך input.dims[batch_dim] .

פרוסת הפלט i לאורך הממד batch_dim ניתנת לאחר מכן על ידי פרוסת הקלט i , כאשר הפרוסות הראשונות seq_lengths[i] לאורך הממד seq_dim הפוכות.

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
seq_dim ::mlir::IntegerAttr תכונת מספר שלם ללא סימן של 32 סיביות שהערך שלה אינו שלילי
batch_dim ::mlir::IntegerAttr תכונת מספר שלם ללא סימן של 32 סיביות שהערך שלה אינו שלילי

אופרנדים:

אופרנד תֵאוּר
input טנסור של מספר שלם ללא סימן של 32 סיביות או 32 סיביות ללא סימן או מספר שלם ללא סימן של 64 סיביות או ערכי סוג QI16 או מסוג QUI8 או מסוג TFLite quint8
seq_lengths טנסור של ערכי מספרים שלמים ללא סימן של 32/64 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של מספר שלם ללא סימן של 32 סיביות או 32 סיביות ללא סימן או מספר שלם ללא סימן של 64 סיביות או ערכי סוג QI16 או מסוג QUI8 או מסוג TFLite quint8

tfl.reverse_v2 (TFL::ReverseV2Op)

מפעיל ReverseV2

הופך ממדים ספציפיים של טנזור.

נתון טנזור, וציר טנזור int32/int64 המייצג את קבוצת הממדים של טנזור להיפוך. פעולה זו הופכת כל מימד i שעבורו קיים ציר j st[j] == i.

ארגוס: טנסור: טנסור. חייב להיות אחד מהסוגים הבאים: uint8, int8, int16, int32, int64, float32, bool עד 8-D.

ציר: טנסור. חייב להיות אחד מהסוגים הבאים: int32, int64. עם אלמנט אחד בלבד שהוא אינדקס הציר. TODO: הוסף תמיכה עבור מספר אלמנטים.

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
input טנסור של מספר שלם ללא סימן 32 סיביות או 8 סיביות ללא סימן או מספר שלם ללא סימן 16 סיביות או מספר שלם ללא סימן 32 סיביות או 64 סיביות ללא סימן או מספר שלם ללא סימן מסוג QI16 או מסוג QUI8 או מסוג QI8 או TFLite quint8 מסוג או ערכי מספר שלם ללא סימן 1-bit
axis טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של מספר שלם ללא סימן 32 סיביות או 8 סיביות ללא סימן או מספר שלם ללא סימן 16 סיביות או מספר שלם ללא סימן 32 סיביות או 64 סיביות ללא סימן או מספר שלם ללא סימן מסוג QI16 או מסוג QUI8 או מסוג QI8 או TFLite quint8 מסוג או ערכי מספר שלם ללא סימן 1-bit

tfl.rfft2d (TFL::RFFT2dOp)

טרנספורמציה מהירה של פורייה בעלת ערך אמיתי דו-ממדי.

מחשב את התמרת פורייה הבדידה הדו-ממדית של אות בעל ערך אמיתי על פני שני ממדי input הפנימיים ביותר.

מכיוון שה-DFT של אות אמיתי הוא סימטרי הרמיטי, RFFT2D מחזיר רק את הרכיבים הייחודיים fft_length / 2 + 1 של ה-FFT עבור המימד הפנימי ביותר של output : מונח התדר האפס, ואחריו ה- fft_length / 2 התדר החיובי תנאים.

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

תכונות: AlwaysSpeculatableImplTrait

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
input טנסור של ערכי ציפה של 32 סיביות
fft_length טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור מסוג מורכב עם ערכי רכיבי ציפה של 32 סיביות

tfl.right_shift (TFL::RightShiftOp)

מפעיל Shift ימני

Elementwise מחשב את ההזזה ימינה בסיביות של lhs על ידי rhs .

תכונות: AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
lhs טנסור של מספר שלם ללא סימן 8 סיביות או 8 סיביות ללא סימן או מספר שלם ללא סימן 16 סיביות או מספר שלם ללא סימן 16 סיביות או ערכי מספר שלם ללא סימן 32 סיביות או 32 סיביות ללא סימן
rhs טנסור של מספר שלם ללא סימן 8 סיביות או 8 סיביות ללא סימן או מספר שלם ללא סימן 16 סיביות או מספר שלם ללא סימן 16 סיביות או ערכי מספר שלם ללא סימן 32 סיביות או 32 סיביות ללא סימן

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של מספר שלם ללא סימן 8 סיביות או 8 סיביות ללא סימן או מספר שלם ללא סימן 16 סיביות או מספר שלם ללא סימן 16 סיביות או ערכי מספר שלם ללא סימן 32 סיביות או 32 סיביות ללא סימן

tfl.round (TFL::RoundOp)

מפעיל סיבוב

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

תכונות: AlwaysSpeculatableImplTrait , InferTensorType , TF::SameOperandsAndResultTypeResolveRef

ממשקים: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
x טנסור של ערכי ציפה של 32 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
y טנסור של ערכי ציפה של 32 סיביות

tfl.rsqrt (TFL::RsqrtOp)

הדדי של אופרטור שורש ריבועי

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

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
x טנסור של 32 סיביות ציפה או ערכי QI8 או QI16

תוצאות:

תוֹצָאָה תֵאוּר
y טנסור של 32 סיביות ציפה או ערכי QI8 או QI16

tfl.scatter_nd (TFL::ScatterNdOp)

_מפזר nd אופרטור

פיזור updates לטנזור חדש לפי indices

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
indices טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות
updates טנסור של מספר שלם ללא סימן של 32 סיביות או 8 סיביות ללא סימן או מספר שלם ללא סימן של 64 סיביות או ערכים שלם ללא סימן של 32 סיביות או מספר שלם ללא סימן 8 סיביות או 1 סיביות ללא סימן
shape טנסור 1D מכל סוג שהוא

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של מספר שלם ללא סימן של 32 סיביות או 8 סיביות ללא סימן או מספר שלם ללא סימן של 64 סיביות או ערכים שלם ללא סימן של 32 סיביות או מספר שלם ללא סימן 8 סיביות או 1 סיביות ללא סימן

tfl.segment_sum (TFL::SegmentSumOp)

אופרטור SegmentSum

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

תכונות: AlwaysSpeculatableImplTrait

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
input טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות או 32 סיביות
segment_ids טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות או 32 סיביות

tfl.select (TFL::SelectOp)

בחר מפעיל

בחר ערכים של 'x' אם הערך המתאים של 'תנאי' נכון או הערך של 'y' אם הוא שקר. ישנם גדלי קלט חוקיים של מצב:

  1. או באותה צורה (במקרה זה הבחירה היא אלמנטית), או
  2. התנאי חייב להיות דירוג 1 ולהתאים מעל הממד הראשון.

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
condition טנסור של ערכי מספר שלם ללא סימן של סיביות 1
x טנסור של מספר שלם ללא סימן 32 סיביות או 1 סיביות ללא סימן או מספר שלם ללא סימן 8 סיביות או מספר שלם ללא סימן 16 סיביות או מספר שלם ללא סימן 32 סיביות או מספר שלם ללא סימן 64 סיביות או מספר שלם ללא סימן 32 סיביות או מסוג QI8 או מסוג QUI8 או QI16 ערכי סוג סוג או TFLite quint8
y טנסור של מספר שלם ללא סימן 32 סיביות או 1 סיביות ללא סימן או מספר שלם ללא סימן 8 סיביות או מספר שלם ללא סימן 16 סיביות או מספר שלם ללא סימן 32 סיביות או מספר שלם ללא סימן 64 סיביות או מספר שלם ללא סימן 32 סיביות או מסוג QI8 או מסוג QUI8 או QI16 ערכי סוג סוג או TFLite quint8

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של מספר שלם ללא סימן 32 סיביות או 1 סיביות ללא סימן או מספר שלם ללא סימן 8 סיביות או מספר שלם ללא סימן 16 סיביות או מספר שלם ללא סימן 32 סיביות או מספר שלם ללא סימן 64 סיביות או מספר שלם ללא סימן 32 סיביות או מסוג QI8 או מסוג QUI8 או QI16 ערכי סוג סוג או TFLite quint8

tfl.select_v2 (TFL::SelectV2Op)

אופרטור SelectV2

בחר ערכים של 'x' אם הערך המתאים של 'תנאי' נכון או הערך של 'y' אם הוא שקר. ישנם גדלי קלט חוקיים של מצב:

  1. או באותה צורה (במקרה זה הבחירה היא אלמנטית), או
  2. צורות הניתנות לשידור בין 'תנאי', 'x' ו-'y'.

תכונות: ::mlir::OpTrait::TFLRuntimeOpTrait , AlwaysSpeculatableImplTrait , QuantizableResult , ResultsBroadcastableShape

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
condition טנסור של ערכי מספר שלם ללא סימן של סיביות 1
x טנסור של מספר שלם ללא סימן 32 סיביות או 1 סיביות ללא סימן או מספר שלם ללא סימן 8 סיביות או מספר שלם ללא סימן 16 סיביות או מספר שלם ללא סימן 32 סיביות או מספר שלם ללא סימן 64 סיביות או מספר שלם ללא סימן 32 סיביות או מסוג QI8 או מסוג QUI8 או QI16 ערכי סוג סוג או TFLite quint8
y טנסור של מספר שלם ללא סימן 32 סיביות או 1 סיביות ללא סימן או מספר שלם ללא סימן 8 סיביות או מספר שלם ללא סימן 16 סיביות או מספר שלם ללא סימן 32 סיביות או מספר שלם ללא סימן 64 סיביות או מספר שלם ללא סימן 32 סיביות או מסוג QI8 או מסוג QUI8 או QI16 ערכי סוג סוג או TFLite quint8

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של מספר שלם ללא סימן 32 סיביות או 1 סיביות ללא סימן או מספר שלם ללא סימן 8 סיביות או מספר שלם ללא סימן 16 סיביות או מספר שלם ללא סימן 32 סיביות או מספר שלם ללא סימן 64 סיביות או מספר שלם ללא סימן 32 סיביות או מסוג QI8 או מסוג QUI8 או QI16 ערכי סוג סוג או TFLite quint8

tfl.shape (TFL::ShapeOp)

מפעיל צורה

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

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
out_type ::mlir::תכונה תכונה נגזרת

אופרנדים:

אופרנד תֵאוּר
input ערכי טנסור מכל סוג שהוא

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של ערכי מספר שלם ללא סימן של 32 סיביות או 64 סיביות ללא סימן

tfl.sign (TFL::SignOp)

פעולת שלט

מחזירה NaN אם x הוא NaN, 0 אם x הוא 0, -1 אם x < 0 ו-1 אם x > 0.

תכונות: AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType , SameOperandsAndResultShape

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
x טנסור של ערכי מספר שלם של 32 סיביות או 64 סיביות או 32 סיביות ללא סימן

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של ערכי מספר שלם של 32 סיביות או 64 סיביות או 32 סיביות ללא סימן

tfl.sin (TFL::SinOp)

מפעיל סינוס

מחשב את סינוס הקלט מבחינה אלמנטרית

תכונות: AlwaysSpeculatableImplTrait , InferTensorType , TF::SameOperandsAndResultTypeResolveRef

ממשקים: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
x טנסור של ערכי ציפה של 32 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
y טנסור של ערכי ציפה של 32 סיביות

tfl.slice (TFL::SliceOp)

החזר פרוסה מ'קלט'.

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

begin מבוסס על אפס; size מבוסס על אחד. אם גודל [i] הוא -1, כל הרכיבים הנותרים בממד i נכללים בפרוסה. במילים אחרות, זה שווה ערך להגדרה: size[i] = input.dim_size(i) - begin[i]

דרישות : 0 <= התחלה[i] <= התחלה[i] + מידה[i] <= Di for i ב-[0, n)

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
input טנסור של מספר שלם ללא סימן 32 סיביות או 32 סיביות ללא סימן או מספר שלם ללא סימן 64 סיביות או מספר שלם ללא סימן 8 סיביות או מספר שלם ללא סימן 8 סיביות או מספר שלם ללא סימן 32 סיביות או מספר שלם ללא סימן 1 סיביות או סוג מחרוזת TFLite או מסוג QI8 או ערכי סוג QUI8 או TFLite quint8 או QI16
begin טנסור של ערכי מספרים שלמים ללא סימן של 32/64 סיביות
size טנסור של ערכי מספרים שלמים ללא סימן של 32/64 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של מספר שלם ללא סימן 32 סיביות או 32 סיביות ללא סימן או מספר שלם ללא סימן 64 סיביות או מספר שלם ללא סימן 8 סיביות או מספר שלם ללא סימן 8 סיביות או מספר שלם ללא סימן 32 סיביות או מספר שלם ללא סימן 1 סיביות או סוג מחרוזת TFLite או מסוג QI8 או ערכי סוג QUI8 או TFLite quint8 או QI16

tfl.softmax (TFL::SoftmaxOp)

מפעיל Softmax

מחשב הפעלת softmax מבחינת אלמנטים עם הנוסחה הבאה

exp(input) / tf.reduce_sum(exp(input * beta), dim)

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

ממשקים: ConditionallySpeculatable , FixedOutputRangeInterface , NoMemoryEffect (MemoryEffectOpInterface) , TflArithmeticCountOpInterface , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
beta ::mlir::FloatAttr תכונת ציפה של 32 סיביות

אופרנדים:

אופרנד תֵאוּר
input טנסור מסוג ציפה של 32 סיביות או מסוג QI8 או מסוג QUI8 או ערכי מסוג TFLite quint8 או מסוג QI16

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור מסוג ציפה של 32 סיביות או מסוג QI8 או מסוג QUI8 או ערכי מסוג TFLite quint8 או מסוג QI16

tfl.space_to_batch_nd (TFL::SpaceToBatchNdOp)

מפעיל SpaceToBatchNd

פעולה זו מעצבת מחדש את ממדי החלל למימד "אצווה" 0

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
input טנסור של מספר שלם ללא סימן של 32 סיביות או 32 סיביות ללא סימן או מספר שלם ללא סימן 64 סיביות או ערכים מסוג QI8 או מסוג QUI8 או מסוג TFLite quint8 או מסוג QI16
block_shape טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות
paddings טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של מספר שלם ללא סימן של 32 סיביות או 32 סיביות ללא סימן או מספר שלם ללא סימן 64 סיביות או ערכים מסוג QI8 או מסוג QUI8 או מסוג TFLite quint8 או מסוג QI16

tfl.space_to_depth (TFL::SpaceToDepthOp)

מפעיל SpaceToDepth

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

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
block_size ::mlir::IntegerAttr תכונת מספר שלם ללא סימן של 32 סיביות שערכה חיובי

אופרנדים:

אופרנד תֵאוּר
input טנסור של מספר שלם ללא סימן של 32 סיביות או 32 סיביות ללא סימן או מספר שלם ללא סימן של 64 סיביות או ערכי סוג QI8 או מסוג QUI8 או מסוג TFLite quint8

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של מספר שלם ללא סימן של 32 סיביות או 32 סיביות ללא סימן או מספר שלם ללא סימן של 64 סיביות או ערכי סוג QI8 או מסוג QUI8 או מסוג TFLite quint8

tfl.sparse_to_dense (TFL::SparseToDenseOp)

ממיר ייצוג דליל לטנזור צפוף.

בונה מערך dense עם shape output_shape כך

# If sparse_indices is scalar
dense[i] = (i == sparse_indices ? sparse_values : default_value)

# If sparse_indices is a vector, then for each i
dense[sparse_indices[i]] = sparse_values[i]

# If sparse_indices is an n by d matrix, then for each i in [0, n)
dense[sparse_indices[i][0], ..., sparse_indices[i][d-1]] = sparse_values[i]

כל שאר הערכים ב- dense מוגדרים ל- default_value . אם sparse_values ​​הוא סקלרי, כל המדדים הדלילים מוגדרים לערך יחיד זה.

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

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
sparse_indices טנסור של ערכי מספרים שלמים ללא סימן של 32/64 סיביות
output_shape טנסור של ערכי מספרים שלמים ללא סימן של 32/64 סיביות
sparse_values טנסור של מספר שלם ללא סימן של 32 סיביות או מספר שלם ללא סימן 64 סיביות או מספר שלם ללא סימן של 8 סיביות או מסוג QI8 או 8 סיביות ללא סימן או מספר שלם ללא סימן או מסוג QUI8 או ערכי TFLite quint8 או 32 סיביות
default_value טנסור של מספר שלם ללא סימן של 32 סיביות או מספר שלם ללא סימן 64 סיביות או מספר שלם ללא סימן של 8 סיביות או מסוג QI8 או 8 סיביות ללא סימן או מספר שלם ללא סימן או מסוג QUI8 או ערכי TFLite quint8 או 32 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
dense טנסור של מספר שלם ללא סימן של 32 סיביות או מספר שלם ללא סימן 64 סיביות או מספר שלם ללא סימן של 8 סיביות או מסוג QI8 או 8 סיביות ללא סימן או מספר שלם ללא סימן או מסוג QUI8 או ערכי TFLite quint8 או 32 סיביות

tfl.split (TFL::SplitOp)

מפצל טנסור לטנזורים num_split לאורך ממד אחד.

מפצל את טנסור value לאורך split_dim למספר תת-טנסורים בעלי צורה זהה לזה המקורי, למעט split_dim . זהה ל-tf.Split.

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
num_splits ::mlir::IntegerAttr תכונת מספר שלם ללא סימן של 32 סיביות שערכה חיובי

אופרנדים:

אופרנד תֵאוּר
split_dim טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות
value טנסור של מספר שלם ללא סימן של 32 סיביות או 16 סיביות ללא סימן או מספר שלם ללא סימן 32 סיביות או מספר שלם ללא סימן של 8 סיביות או ערכי מספר שלם ללא סימן 8 סיביות או מסוג QI8 או מסוג QUI8 או QI16

תוצאות:

תוֹצָאָה תֵאוּר
outputs וריאדית של טנסור מכל סוג שהוא

tfl.split_v (TFL::SplitVOp)

מפצל טנסור לטנזורים num_split לאורך ממד אחד.

מפצל את טנסור value לאורך split_dim למספר תת-טנסורים בעלי צורה זהה לזה המקורי, למעט split_dim . הקיבוץ של תת-הטנסורים שנוצרו נקבע על ידי size-splits . זהה ל-tf.SplitV.

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
num_splits ::mlir::IntegerAttr תכונת מספר שלם ללא סימן של 32 סיביות שערכה חיובי

אופרנדים:

אופרנד תֵאוּר
value טנסור של מספר שלם ללא סימן 32 סיביות או 16 סיביות ללא סימן או מספר שלם ללא סימן 32 סיביות או מספר שלם ללא סימן 64 סיביות או מספר שלם ללא סימן 8 סיביות או 8 סיביות ללא סימן או ערכים מסוג QI8 או מסוג QUI8 או QI16
size_splits טנזור 1D של ערכי מספרים שלמים ללא סימן של 32 סיביות
split_dim טנסור 0D של ערכי מספרים שלמים ללא סימן של 32 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
outputs וריאדית של טנסור מכל סוג שהוא

tfl.sqrt (TFL::SqrtOp)

מפעיל שורש ריבועי

מחשב שורש ריבועי של קלט מבחינה אלמנט

תכונות: AlwaysSpeculatableImplTrait , InferTensorType , TF::SameOperandsAndResultTypeResolveRef

ממשקים: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
x טנסור של ערכי ציפה של 32 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
y טנסור של ערכי ציפה של 32 סיביות

tfl.square (TFL::SquareOp)

מפעיל מרובע

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

תכונות: AlwaysSpeculatableImplTrait , InferTensorType , TF::SameOperandsAndResultTypeResolveRef

ממשקים: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
x טנסור של ערכי ציפה של 32 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
y טנסור של ערכי ציפה של 32 סיביות

tfl.squared_difference (TFL::SquaredDifferenceOp)

מפעיל הפרש בריבוע

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

תכונות: ::mlir::OpTrait::TFLRuntimeOpTrait , AlwaysSpeculatableImplTrait , QuantizableResult , ResultsBroadcastableShape

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
lhs טנסור של 32 סיביות ציפה או 32 סיביות חסרות סימנים או ערכי סוג QI8
rhs טנסור של 32 סיביות ציפה או 32 סיביות חסרות סימנים או ערכי סוג QI8

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של 32 סיביות ציפה או 32 סיביות חסרות סימנים או ערכי סוג QI8

tfl.squeeze (TFL::SqueezeOp)

מסיר ממדים בגודל 1 מצורת טנזור.

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

לְדוּגמָה:

# 't' is a tensor of shape [1, 2, 1, 3, 1, 1]
shape(squeeze(t)) ==> [2, 3]

לחלופין, כדי להסיר ממדים ספציפיים בגודל 1:

# 't' is a tensor of shape [1, 2, 1, 3, 1, 1]
shape(squeeze(t, [2, 4])) ==> [1, 2, 3, 1]

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
squeeze_dims ::mlir::ArrayAttr תכונת מערך מספר שלם של 64 סיביות שגודלה הוא לכל היותר 8

אופרנדים:

אופרנד תֵאוּר
input ערכי טנסור מכל סוג שהוא

תוצאות:

תוֹצָאָה תֵאוּר
output ערכי טנסור מכל סוג שהוא

tfl.strided_slice (TFL::StridedSliceOp)

StridedSlice Op

החזר פרוסה צעד input .

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
begin_mask ::mlir::IntegerAttr תכונת מספר שלם ללא סימנים של 32 סיביות
end_mask ::mlir::IntegerAttr תכונת מספר שלם ללא סימנים של 32 סיביות
ellipsis_mask ::mlir::IntegerAttr תכונת מספר שלם ללא סימנים של 32 סיביות
new_axis_mask ::mlir::IntegerAttr תכונת מספר שלם ללא סימנים של 32 סיביות
shrink_axis_mask ::mlir::IntegerAttr תכונת מספר שלם ללא סימנים של 32 סיביות
offset ::mlir::BoolAttr תכונת bool

אופרנדים:

אופרנד תֵאוּר
input טנסור של מספר שלם ללא סימן של 32 סיביות או 32 סיביות ללא סימן או מספר שלם ללא סימן 64 סיביות או מספר שלם ללא סימן 8 סיביות או מספר שלם ללא סימן 8 סיביות או מספר שלם ללא סימן 32 סיביות או מסוג QI8 או מסוג QUI8 או מספר שלם ללא סימן של 1 סיביות או 16 מספר שלם ללא סימן סיביות או סוג QI16 או ערכי סוג מחרוזת TFLite quint8 או TFLite
begin טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות
end טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות
strides טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של מספר שלם ללא סימן של 32 סיביות או 32 סיביות ללא סימן או מספר שלם ללא סימן 64 סיביות או מספר שלם ללא סימן 8 סיביות או מספר שלם ללא סימן 8 סיביות או מספר שלם ללא סימן 32 סיביות או מסוג QI8 או מסוג QUI8 או מספר שלם ללא סימן של 1 סיביות או 16 מספר שלם ללא סימן סיביות או סוג QI16 או ערכי סוג מחרוזת TFLite quint8 או TFLite

tfl.sub (TFL::SubOp)

אופרטור חיסור

פעולת חיסור אלמנט.

תכונות: ::mlir::OpTrait::TFLRuntimeOpTrait , AlwaysSpeculatableImplTrait , QuantizableResult , ResultsBroadcastableShape

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflArithmeticCountOpInterface , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
fused_activation_function ::mlir::StringAttr תכונת מחרוזת שהערך שלה הוא NONE, או RELU, או RELU_N1_TO_1, או RELU6, או TANH, או SIGN_BIT

אופרנדים:

אופרנד תֵאוּר
lhs טנסור של מספר שלם ללא סימן של 32 סיביות או 32 סיביות ללא סימן או מספר שלם ללא סימן 64 סיביות או ערכי סוג QI8 או מסוג QUI8 או QI16
rhs טנסור של מספר שלם ללא סימן של 32 סיביות או 32 סיביות ללא סימן או מספר שלם ללא סימן 64 סיביות או ערכי סוג QI8 או מסוג QUI8 או QI16

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של מספר שלם ללא סימן של 32 סיביות או 32 סיביות ללא סימן או מספר שלם ללא סימן 64 סיביות או ערכי סוג QI8 או מסוג QUI8 או QI16

tfl.sum (TFL::SumOp)

אופרטור סכום

מחשב את הפחתת הסכום לאורך הצירים שצוינו

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
keep_dims ::mlir::BoolAttr תכונת bool

אופרנדים:

אופרנד תֵאוּר
input טנסור של מספר שלם ללא סימן של 32 סיביות או 32 סיביות ללא סימן או מספר שלם ללא סימן 64 סיביות או ערכים מסוג QI8 או מסוג QUI8 או מסוג TFLite quint8 או מסוג QI16
axes טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של מספר שלם ללא סימן של 32 סיביות או 32 סיביות ללא סימן או מספר שלם ללא סימן 64 סיביות או ערכים מסוג QI8 או מסוג QUI8 או מסוג TFLite quint8 או מסוג QI16

tfl.svdf (TFL::SVDFOp)

מפעיל מסנן פירוק ערך יחיד

ה-SVDF op הוא פירוק של אופ המחובר בצפיפות למסננים בדרגה נמוכה. לפרטים: https://research.google.com/pubs/pub43813.html https://arxiv.org/abs/1812.02802

תכונות: QuantizableResult , quant::AccumulatorUniformScale<3, 2, 4>

ממשקים: DynamicRangeQuantizedOpInterface , TFL_StatefulOp , TflRuntimeVerifyOpInterface

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
rank ::mlir::IntegerAttr תכונת מספר שלם ללא סימן של 32 סיביות שערכה חיובי
fused_activation_function ::mlir::StringAttr תכונת מחרוזת שהערך שלה הוא NONE, או RELU, או RELU_N1_TO_1, או RELU6, או TANH, או SIGN_BIT
asymmetric_quantize_inputs ::mlir::BoolAttr תכונת bool

אופרנדים:

אופרנד תֵאוּר
input טנסור של 32 סיביות מסוג Float או QI8
feature_weights טנסור של 32 סיביות מסוג ציפה או ערכים מסוג QI8 או QUI8
time_weights טנסור של 32 סיביות מסוג ציפה או ערכי QI16
input_gate_bias טנסור מכל סוג שהוא ערכי או שום סוג
activation_state טנסור ממלכתי

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של 32 סיביות מסוג Float או QI8

tfl.tanh (TFL::TanhOp)

אופרטור משיק היפרבולי

מחשב טנגנס היפרבולי של קלט מבחינת אלמנט

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

ממשקים: ConditionallySpeculatable , FixedOutputRangeInterface , NoMemoryEffect (MemoryEffectOpInterface) , TflArithmeticCountOpInterface , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
input טנסור מסוג float 32 סיביות או מסוג QI8 או מסוג QUI8 או מסוג QI16 או ערכי מסוג TFLite quint8

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור מסוג float 32 סיביות או מסוג QI8 או מסוג QUI8 או מסוג QI16 או ערכי מסוג TFLite quint8

tfl.tile (TFL::TileOp)

מפעיל אריחים.

בונה טנזור על ידי ריצוף טנזור נתון.

פעולה זו יוצרת טנזור חדש על ידי שכפול קלט מספר פעמים. לממד ה-i' של טנסור הפלט יש רכיבי input.dims(i) * multiples[i], וערכי הקלט משוכפלים כפולות[i] פעמים לאורך הממד 'i'. לדוגמה, ריצוף [abcd] על ידי [2] מייצר [abcdabcd].

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
input טנסור של מספר שלם ללא סימן 32 סיביות או 1 סיביות ללא סימן או מספר שלם ללא סימן 32 סיביות או מספר שלם ללא סימן 64 סיביות או 8 סיביות ללא סימן או ערכי סוג מחרוזת QI8 או מסוג QUI8 או TFLite
multiples טנסור של ערכי מספרים שלמים ללא סימן של 32/64 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של מספר שלם ללא סימן 32 סיביות או 1 סיביות ללא סימן או מספר שלם ללא סימן 32 סיביות או מספר שלם ללא סימן 64 סיביות או 8 סיביות ללא סימן או ערכי סוג מחרוזת QI8 או מסוג QUI8 או TFLite

tfl.topk_v2 (TFL::TopKV2Op)

מפעיל TopK

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

התוצאות ממוינות תמיד בסדר יורד.

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
input טנסור של מספר שלם ללא סימן 32 סיביות או 8 סיביות ללא סימן או מספר שלם ללא סימן 16 סיביות או מספר שלם ללא סימן 32 סיביות או מספר שלם ללא סימן 64 סיביות או ערכי מספר שלם ללא סימן 8 סיביות או ערכים מסוג QI8 או QUI8
k טנסור של ערכי מספר שלם ללא סימן של 16 סיביות או 32 סיביות ללא סימן

תוצאות:

תוֹצָאָה תֵאוּר
values טנסור של מספר שלם ללא סימן 32 סיביות או 8 סיביות ללא סימן או מספר שלם ללא סימן 16 סיביות או מספר שלם ללא סימן 32 סיביות או מספר שלם ללא סימן 64 סיביות או ערכי מספר שלם ללא סימן 8 סיביות או ערכים מסוג QI8 או QUI8
indices טנסור של ערכי מספר שלם ללא סימן של 16 סיביות או 32 סיביות ללא סימן

tfl.transpose (TFL::TransposeOp)

מפעיל Transpose

מחזירה את ההעברה של x

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
input טנסור של מספר שלם ללא סימן 32 סיביות או מספר שלם ללא סימן 32 סיביות או מספר שלם ללא סימן 8 סיביות או מספר שלם ללא סימן 8 סיביות או סוג QI8 או מסוג QUI8 או מסוג TFLite quint8 או מספר שלם ללא סימן 1 סיביות או ערכי מספר שלם ללא סימן 64 סיביות או QI16
perm טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של מספר שלם ללא סימן 32 סיביות או מספר שלם ללא סימן 32 סיביות או מספר שלם ללא סימן 8 סיביות או מספר שלם ללא סימן 8 סיביות או סוג QI8 או מסוג QUI8 או מסוג TFLite quint8 או מספר שלם ללא סימן 1 סיביות או ערכי מספר שלם ללא סימן 64 סיביות או QI16

tfl.transpose_conv (TFL::TransposeConvOp)

אופרטור המרת קונבולציה

מבצע פעולת טרנספוזי קונבולציה בקלט.

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult , quant::AccumulatorUniformScale<3, 1, 2> , quant::AffineOpCoefficient<0, 1>

ממשקים: AffineQuantizedOpInterface , ConditionallySpeculatable , DynamicRangeQuantizedOpInterface , NoMemoryEffect (MemoryEffectOpInterface) , TFL_SparseOp , TflArithmeticCountOpInterface , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
padding ::mlir::StringAttr תכונת string שהערך שלה הוא SAME, או VALID
stride_h ::mlir::IntegerAttr תכונת מספר שלם ללא סימן של 32 סיביות שערכה חיובי
stride_w ::mlir::IntegerAttr תכונת מספר שלם ללא סימן של 32 סיביות שערכה חיובי
fused_activation_function ::mlir::StringAttr תכונת מחרוזת שהערך שלה הוא NONE, או RELU, או RELU_N1_TO_1, או RELU6, או TANH, או SIGN_BIT

אופרנדים:

אופרנד תֵאוּר
output_shape טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות
weights טנסור של 32 סיביות ציפה או ערכים מסוג QI8 או מסוג QUI8 או QI16
input טנסור של 32 סיביות ציפה או ערכים מסוג QI8 או מסוג QUI8 או QI16
bias טנסור מכל סוג שהוא ערכי או שום סוג

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של 32 סיביות ציפה או ערכים מסוג QI8 או מסוג QUI8 או QI16

tfl.unidirectional_sequence_lstm (TFL::UnidirectionalSequenceLSTMOp)

אופרטור lstm ברצף חד-כיווני

רשת עצבית חוזרת שצוינה על ידי תא LSTM. אופ זה תומך בגלגול הקלט לאורך מידות הזמן או אצווה, ומיישם את הפעולה הבאה עבור כל אלמנט ברצף s = 1...sequence_length: פלטים[s] = מצב = הפעלה(LSTMOp(inputs[s]))

כאשר LSTMOp הוא LSTM TF Lite Op וה-"activation" היא הפונקציה המועברת כארגומנט "fused_activation_function" (אם לא "NONE").

תכונות: QuantizableResult

ממשקים: DynamicRangeQuantizedOpInterface , InferTypeOpInterface , TFL_StatefulOp , TflRuntimeVerifyOpInterface

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
fused_activation_function ::mlir::StringAttr תכונת מחרוזת שהערך שלה הוא NONE, או RELU, או RELU_N1_TO_1, או RELU6, או TANH, או SIGN_BIT
cell_clip ::mlir::FloatAttr תכונת float של 32 סיביות שהערך שלה אינו שלילי
proj_clip ::mlir::FloatAttr תכונת float של 32 סיביות שהערך שלה אינו שלילי
time_major ::mlir::BoolAttr תכונת bool
asymmetric_quantize_inputs ::mlir::BoolAttr תכונת bool
diagonal_recurrent_tensors ::mlir::BoolAttr תכונת bool
input_to_input_intermediate ::mlir::TypeAttr כל תכונת סוג
input_to_forget_intermediate ::mlir::TypeAttr כל תכונת סוג
input_to_cell_intermediate ::mlir::TypeAttr כל תכונת סוג
input_to_output_intermediate ::mlir::TypeAttr כל תכונת סוג
effective_hidden_scale_intermediate ::mlir::TypeAttr כל תכונת סוג

אופרנדים:

אופרנד תֵאוּר
input טנסור של ערכי ציפה של 32 סיביות
input_to_input_weights טנסור מכל סוג שהוא ערכי או שום סוג
input_to_forget_weights טנסור של 32 סיביות מסוג Float או QI8
input_to_cell_weights טנסור של 32 סיביות מסוג Float או QI8
input_to_output_weights טנסור של 32 סיביות מסוג Float או QI8
recurrent_to_input_weights טנסור מכל סוג שהוא ערכי או שום סוג
recurrent_to_forget_weights טנסור של 32 סיביות מסוג Float או QI8
recurrent_to_cell_weights טנסור של 32 סיביות מסוג Float או QI8
recurrent_to_output_weights טנסור של 32 סיביות מסוג Float או QI8
cell_to_input_weights טנסור מכל סוג שהוא ערכי או שום סוג
cell_to_forget_weights טנסור מכל סוג שהוא ערכי או שום סוג
cell_to_output_weights טנסור מכל סוג שהוא ערכי או שום סוג
input_gate_bias טנסור מכל סוג שהוא ערכי או שום סוג
forget_gate_bias טנסור של ערכי ציפה של 32 סיביות
cell_bias טנסור של ערכי ציפה של 32 סיביות
output_gate_bias טנסור של ערכי ציפה של 32 סיביות
projection_weights טנסור מכל סוג שהוא ערכי או שום סוג
projection_bias טנסור מכל סוג שהוא ערכי או שום סוג
input_activation_state טנסור ממלכתי
input_cell_state טנסור ממלכתי
input_layer_norm_coefficients טנסור מכל סוג שהוא ערכי או שום סוג
forget_layer_norm_coefficients טנסור מכל סוג שהוא ערכי או שום סוג
cell_layer_norm_coefficients טנסור מכל סוג שהוא ערכי או שום סוג
output_layer_norm_coefficients טנסור מכל סוג שהוא ערכי או שום סוג

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של 32 סיביות מסוג Float או QI8

tfl.unidirectional_sequence_rnn (TFL::UnidirectionalSequenceRNNOp)

אופרטור rnn רצף חד כיווני

רשת עצבית חוזרת שצוינה על ידי תא RNN. האופציה הזו קולטת קלט בפורמט {batch_size, seq_len, input_size} או {seq_len, batch_size, input_size} אם הוא מתקדם בזמן.

הוא מיישם את הפעולה הבאה עבור כל רכיב ברצף s = 1...sequence_length: יציאות[s] = מצב = הפעלה(RNNOp(כניסות[s]))

כאשר RNNOp הוא RNNOp TF Lite Op וה-"activation" היא הפונקציה המועברת כארגומנט "fused_activation_function" (אם לא "NONE").

תכונות: QuantizableResult

ממשקים: DynamicRangeQuantizedOpInterface , TFL_StatefulOp , TflRuntimeVerifyOpInterface

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
time_major ::mlir::BoolAttr תכונת bool
fused_activation_function ::mlir::StringAttr תכונת מחרוזת שהערך שלה הוא NONE, או RELU, או RELU_N1_TO_1, או RELU6, או TANH, או SIGN_BIT
asymmetric_quantize_inputs ::mlir::BoolAttr תכונת bool

אופרנדים:

אופרנד תֵאוּר
input טנסור של ערכי ציפה של 32 סיביות
input_to_input_weights טנסור של 32 סיביות מסוג Float או QI8
recurrent_to_input_weights טנסור של 32 סיביות מסוג Float או QI8
input_gate_bias טנסור של ערכי ציפה של 32 סיביות
hidden_state טנסור ממלכתי

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של ערכי ציפה של 32 סיביות

tfl.unique (TFL::UniqueOp)

אופ.

פעולה זו מחזירה output טנסור המכיל את כל האלמנטים הייחודיים של input ממוינים באותו סדר שבו הם מתרחשים input . פעולה זו גם מחזירה טנסור idx בגודל זהה ל- x המכיל את האינדקס של כל ערך input output הפלט הייחודי. במילים אחרות:

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
idx_out_type ::mlir::תכונה תכונה נגזרת

אופרנדים:

אופרנד תֵאוּר
input טנסור של מספר שלם ללא סימן של 8 סיביות או מסוג QI8 או מספר שלם ללא סימן של 8 סיביות או מסוג QUI8 או מספר שלם ללא סימן של 16 סיביות או מסוג QI16 או ערכי מספר שלם ללא סימן 32 סיביות או 64 סיביות ללא סימן או ערכי ציפה של 32 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של מספר שלם ללא סימן של 8 סיביות או מסוג QI8 או מספר שלם ללא סימן של 8 סיביות או מסוג QUI8 או מספר שלם ללא סימן של 16 סיביות או מסוג QI16 או ערכי מספר שלם ללא סימן 32 סיביות או 64 סיביות ללא סימן או ערכי ציפה של 32 סיביות
idx טנסור של ערכי מספרים שלמים ללא סימן של 32/64 סיביות

tfl.unpack (TFL::UnpackOp)

פורק טנזור לאורך מימד למספר טנסורים

מפרק מימד נתון של טנסור rank- R לטנזורים num rank- (R-1) .

מפרק num טנסורים value על ידי שיבוץ אותו לאורך ממד axis . לדוגמה, בהינתן טנזור של צורה (A, B, C, D) ;

אם axis == 0 אז הטנזור ה-i' output הוא value[i, :, :, :] ולכל טנסור output תהיה צורה (B, C, D) . (שימו לב שהמימד שנפרק לאורך נעלם, בניגוד split ).

אם axis == 1 אז הטנזור ה-i' output הוא value[:, i, :, :] ולכל טנזור output תהיה צורה (A, C, D) . וכו.

זה ההיפך pack .

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultElementType

ממשקים: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
num ::mlir::IntegerAttr תכונת מספר שלם ללא סימן של 32 סיביות שהערך שלה אינו שלילי
axis ::mlir::IntegerAttr תכונת מספר שלם ללא סימנים של 32 סיביות

אופרנדים:

אופרנד תֵאוּר
input טנסור של מספר שלם ללא סימן 32 סיביות או 1 סיביות ללא סימן או מספר שלם ללא סימן 8 סיביות או מספר שלם ללא סימן 8 סיביות או מספר שלם ללא סימן 32 סיביות או ערכים מסוג QI8 או מסוג QUI8 או 16 סיביות ללא סימן או ערכים מסוג QI16

תוצאות:

תוֹצָאָה תֵאוּר
outputs וריאדית של טנסור מכל סוג שהוא

tfl.unsorted_segment_max (TFL::UnsortedSegmentMaxOp)

אופרטור UnsortedSegmentMax

מחשב את הערך המקסימלי לאורך מקטעים של טנזור כך שפלט[i] = max(data[j...]) כאשר segment_ids[j...] = i אם המקסימום ריק עבור מזהה פלח נתון i, זה מפלט את הערך הקטן ביותר האפשרי עבור הסוג המספרי הספציפי, פלט[i] = numeric_limits::lowest(). שים לב שהערכים של segment_ID מאומתים תמיד כדי להיות פחות מ-num_segments ונרשמת שגיאה עבור מדדים מחוץ לתחום.

תכונות: AlwaysSpeculatableImplTrait

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
input טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות או 32 סיביות
segment_ids טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות
num_segments טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות או 32 סיביות

tfl.unsorted_segment_min (TFL::UnsortedSegmentMinOp)

אופרטור UnsortedSegmentMin

מחשב את הערך המינימלי לאורך מקטעים של טנזור כך שפלט[i] = min(data[j...]) כאשר segment_ids[j...] = i אם המינימום ריק עבור מזהה פלח נתון i, זה מפלט את הערך הגדול ביותר האפשרי עבור הסוג המספרי הספציפי, פלט[i] = numeric_limits::max(). שים לב שהערכים של segment_ID מאומתים תמיד כדי להיות פחות מ-num_segments ונרשמת שגיאה עבור מדדים מחוץ לתחום.

תכונות: AlwaysSpeculatableImplTrait

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
input טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות או 32 סיביות
segment_ids טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות
num_segments טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות או 32 סיביות

tfl.unsorted_segment_prod (TFL::UnsortedSegmentProdOp)

אופרטור UnsortedSegmentProd

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

תכונות: AlwaysSpeculatableImplTrait

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
input טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות או 32 סיביות
segment_ids טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות
num_segments טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות או 32 סיביות

tfl.unsorted_segment_sum (TFL::UnsortedSegmentSumOp)

אופרטור UnsortedSegmentSum

מפילוח טנזור, מחשב את output הנובע מסיכום אלמנטים הממופים לאותו segment_id. כלומר output[i] שווה לסכום הטנזור של כל האלמנטים מטנסור הקלט שמופה ל-segment_id i . אם לא ממופים טנסורים ל-segment_id מסויים, הפלט במדד זה יהיה טנסור אפס עם הצורה המתאימה. שים לב שהערכים של segment_ID מאומתים תמיד כקטנים מ- num_segments ונרשמת שגיאה עבור מדדים מחוץ לתחום

תכונות: AlwaysSpeculatableImplTrait

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
input טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות או 32 סיביות
segment_ids טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות
num_segments טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output טנסור של ערכי מספרים שלמים ללא סימן של 32 סיביות או 32 סיביות

tfl.var_handle (TFL::VarHandleOp)

מחזירה נקודת אחיזה למשאב משתנה מהשם שלו.

מחזירה נקודת אחיזה עבור משאב משתנה משמו. container: הקונטיינר שהמשתנה הזה ממוקם בו. shared_name: השם שלפיו מתייחסים למשתנה זה.

ממשקים: TflRuntimeVerifyOpInterface

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
container ::mlir::StringAttr תכונת מחרוזת
shared_name ::mlir::StringAttr תכונת מחרוזת

תוצאות:

תוֹצָאָה תֵאוּר
resource_handle טנסור של ערכי משאבים

tfl.where (TFL::WhereOp)

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

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

תכונות: AlwaysSpeculatableImplTrait

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
condition טנסור של מספר שלם ללא סימן 1 סיביות או 32 סיביות צף או מספר שלם ללא סימן 32/64 סיביות או ערכי מספר שלם ללא סימן 8 סיביות או 8 סיביות ללא סימן או 32 סיביות ללא סימן

תוצאות:

תוֹצָאָה תֵאוּר
index טנסור של ערכי מספרים שלמים ללא סימן של 64 סיביות

tfl.while (TFL::WhileOp)

בעוד לולאה

פלט = קלט; while (cond(output)) { output = body(output) }

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

input: רשימה של טנסור קלט שהסוגים שלהם הם T. פלט: רשימה של טנסור פלט שהסוגים שלהם הם T. cond: אזור שלוקח 'קלט' ומחזיר טנסור סקלרי בוליאני. גוף: אזור שלוקח רשימה של טנסורים ומחזיר רשימה נוספת של טנסורים. לשתי הרשימות יש את אותם סוגים.

תכונות: SingleBlockImplicitTerminator<YieldOp> , SingleBlock

ממשקים: LoopLikeOpInterface , TflRuntimeVerifyOpInterface

תכונות:

תְכוּנָה סוג MLIR תֵאוּר
is_stateless ::mlir::BoolAttr תכונת bool

אופרנדים:

אופרנד תֵאוּר
input וריאדית של טנסור מכל סוג שהוא

תוצאות:

תוֹצָאָה תֵאוּר
output וריאדית של טנסור מכל סוג שהוא

tfl.yield (tfl :: תשואה)

תפעול תפוקה

פעולת "התשואה" מייצגת פעולת החזרה בתוך התנאי וגוף זרימת הבקרה המובנית (למשל, בזמן), וסגולה של ControlNodeOp. הפעולה לוקחת מספר משתנה של אופרנדים ואינה מניבה תוצאות. על מספר האופרנד והסוגים להתאים לחתימת האזור המכילה את הפעולה.

תכונות: AlwaysSpeculatableImplTrait , QuantizableResult Terminator

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
«ללא שם» variadic מכל סוג

tfl.zeros_like (tfl :: zeroslimeop)

מפעיל אפס דמוי

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

תכונות: AlwaysSpeculatableImplTrait , SameOperandsAndResultShape

ממשקים: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

אפקטים: MemoryEffects::Effect{}

אופרנדים:

אופרנד תֵאוּר
input טנזור של מספר שלם שלם שלם שלם או 32 סיביות או 32 סיביות שלם שלם או 32 סיביות או 32 סיביות

תוצאות:

תוֹצָאָה תֵאוּר
output טנזור של מספר שלם שלם שלם שלם או 32 סיביות או 32 סיביות שלם שלם או 32 סיביות או 32 סיביות

תכונות

Dimensionmetadataattr

מטא נתונים של מימד.

תַחבִּיר: 

#tfl.dimension_metadata<
  ::mlir::TFL::DimensionTypeAttr,   # format
  int32_t,   # dense_size
  ::llvm::ArrayRef<int32_t>,   # segments
  ::llvm::ArrayRef<int32_t>   # indices
>

פרמטרים:

פָּרָמֶטֶר סוג C ++ תֵאוּר
פוּרמָט ::mlir::TFL::DimensionTypeAttr dimension_type
dens_size int32_t
קטעים ::llvm::ArrayRef<int32_t>
מדדים ::llvm::ArrayRef<int32_t>

SparsityParameterattr

פרמטר דלילות.

תַחבִּיר: 

#tfl.sparsity_parameter<
  ::llvm::ArrayRef<int32_t>,   # traversal_order
  ::llvm::ArrayRef<int32_t>,   # block_map
  ::llvm::ArrayRef<DimensionMetadataAttr>   # dim_metadata
>

פרמטרים:

פָּרָמֶטֶר סוג C ++ תֵאוּר
Traversal_Order ::llvm::ArrayRef<int32_t>
block_map ::llvm::ArrayRef<int32_t>
dim_metadata ::llvm::ArrayRef<DimensionMetadataAttr>

Constbytesattr

ייצוג תכונת מחרוזת של בתים מלוכדים

דוגמאות לתחביר: 

#tfl<const_bytes : "0xDEADBEEF">

פרמטרים:

פָּרָמֶטֶר סוג C ++ תֵאוּר
עֵרֶך ::llvm::StringRef

DimensionTypeattr

dimension_type

תַחבִּיר:

#tfl.dimension_type_attr<
  ::mlir::TFL::DimensionType   # value
>

מקרי enum:

  • צפוף ( DENSE )
  • Sparse_csr ( SPARSE_CSR ) #### פרמטרים:
פָּרָמֶטֶר סוג C ++ תֵאוּר
עֵרֶך ::mlir::TFL::DimensionType enum of סוג Dimensentype

Lstmkerneltypeattr

lstm_kernel_type

תַחבִּיר:

#tfl.lstm_kernel_type_attr<
  ::mlir::TFL::LSTMKernelType   # value
>

מקרי enum:

  • מלא ( FULL )
  • פרמטרים בסיסיים ( BASIC ) ####:
פָּרָמֶטֶר סוג C ++ תֵאוּר
עֵרֶך ::mlir::TFL::LSTMKernelType enum מהסוג lstmkerneltype

MirrorPaddingTypeattr

mirror_pad_enum

תַחבִּיר:

#tfl.mirror_pad_attr<
  ::mlir::TFL::MirrorPaddingType   # value
>

מקרי enum:

  • לשקף ( REFLECT )
  • פרמטרים סימטריים ( SYMMETRIC ) ####:
פָּרָמֶטֶר סוג C ++ תֵאוּר
עֵרֶך ::mlir::TFL::MirrorPaddingType enum מהסוג MirrorPaddingType

Enums

DimensionType

dimension_type

מקרים:

סֵמֶל עֵרֶך חוּט
צָפוּף 0 צָפוּף
Sparse_csr 1 Sparse_csr

Lstmkerneltype

lstm_kernel_type

מקרים:

סֵמֶל עֵרֶך חוּט
מָלֵא 0 מָלֵא
בְּסִיסִי 1 בְּסִיסִי

MirrorPaddingType

mirror_pad_enum

מקרים:

סֵמֶל עֵרֶך חוּט
לְשַׁקֵף 0 לְשַׁקֵף
סימטרי 1 סימטרי