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