Dialekt TensorFlow Lite.
Ten dialekt jest mapowany na operacje TensorFlow Lite.
Niezmienniki:
- Wszystkie wartości są typu Tensor (w szczególności skalary są reprezentowane za pomocą tensorów zerowymiarowych);
Operacje
tfl.abs
(TFL::AbsOp)
Operator wartości bezwzględnej
Biorąc pod uwagę tensor x
, operacja ta zwraca tensor zawierający wartość bezwzględną każdego elementu w x
. Na przykład, jeśli x jest elementem wejściowym, a y jest elementem wyjściowym, ta operacja oblicza \(y = |x|\).
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
, SameOperandsAndResultShape
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
x | tensor 16-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby zmiennoprzecinkowej lub wartości typu QI8 lub QI16 |
Wyniki:
Wynik | Opis |
---|---|
y | tensor 16-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby zmiennoprzecinkowej lub wartości typu QI8 lub QI16 |
tfl.add
(TFL::AddOp)
Operator dodawania
Operacja dodawania elementowego.
Cechy: ::mlir::OpTrait::TFLRuntimeOpTrait
, AlwaysSpeculatableImplTrait
, Commutative
, QuantizableResult
, ResultsBroadcastableShape
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflArithmeticCountOpInterface
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
fused_activation_function | ::mlir::StringAttr | atrybut łańcuchowy, którego wartość to NONE, RELU, RELU_N1_TO_1, RELU6, TANH lub SIGN_BIT |
Operandy:
Operand | Opis |
---|---|
lhs | tensor 32-bitowej liczby zmiennoprzecinkowej lub 16-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub wartości typu QI8, typu QUI8 lub typu QI16 |
rhs | tensor 32-bitowej liczby zmiennoprzecinkowej lub 16-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub wartości typu QI8, typu QUI8 lub typu QI16 |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowej liczby zmiennoprzecinkowej lub 16-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub wartości typu QI8, typu QUI8 lub typu QI16 |
tfl.add_n
(TFL::AddNOp)
_Dodaj operator n
Dodaje wszystkie tensory wejściowe elementarnie.
Cechy: AlwaysSpeculatableImplTrait
, Commutative
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflArithmeticCountOpInterface
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
inputs | variadic tensora wartości dowolnego typu |
Wyniki:
Wynik | Opis |
---|---|
sum | tensor 32-bitowych wartości zmiennoprzecinkowych lub 32-bitowych wartości całkowitych bez znaku |
tfl.arg_max
(TFL::ArgMaxOp)
Operator ArgMax
Zwraca indeks o największej wartości spośród wszystkich wymiarów tensora.
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
output_type | ::mlir::Atrybut | atrybut pochodny |
Operandy:
Operand | Opis |
---|---|
input | tensor 1-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby zmiennoprzecinkowej lub 32-bitowej liczby całkowitej bez znaku lub 8-bitowej liczby całkowitej bez znaku lub 8-bitowej liczby całkowitej bez znaku lub wartości typu QI8 lub QUI8 |
dim | tensor 32/64-bitowych wartości całkowitych bez znaku |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32/64-bitowych wartości całkowitych bez znaku |
tfl.arg_min
(TFL::ArgMinOp)
Operator ArgMin
Zwraca indeks o najmniejszej wartości spośród wymiarów tensora. a = [1, 10, 26,9, 2,8, 166,32, 62,3] b = tf.math.argmin(input = a) c = tf.keras.backend.eval(b)
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
output_type | ::mlir::Atrybut | atrybut pochodny |
Operandy:
Operand | Opis |
---|---|
input | tensor 1-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby zmiennoprzecinkowej lub 32-bitowej liczby całkowitej bez znaku lub 8-bitowej liczby całkowitej bez znaku lub 8-bitowej liczby całkowitej bez znaku lub wartości typu QI8 lub QUI8 |
dim | tensor 32/64-bitowych wartości całkowitych bez znaku |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32/64-bitowych wartości całkowitych bez znaku |
tfl.assign_variable
(TFL::AssignVariableOp)
Przypisuje nową wartość do zmiennej.
Każda operacja ReadVariableOp z zależnością kontrolną od tej operacji gwarantuje zwrócenie tej wartości lub kolejnej, nowszej wartości zmiennej.
Interfejsy: TflRuntimeVerifyOpInterface
Operandy:
Operand | Opis |
---|---|
resource_id | tensor wartości zasobów |
value | tensor 32-bitowej liczby zmiennoprzecinkowej lub 64-bitowej liczby zmiennoprzecinkowej lub 1-bitowej liczby całkowitej bez znaku lub 8-bitowej liczby całkowitej bez znaku lub 8-bitowej liczby całkowitej bez znaku lub typu QI8 lub typu QUI8 lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub typu QI16 lub typ złożony z 32-bitowymi elementami zmiennoprzecinkowymi lub typ złożony z 64-bitowymi wartościami elementów zmiennoprzecinkowych |
tfl.atan2
(TFL::Atan2Op)
Operacja Atan2
Operacja „atan2” oblicza arcus tangens y/x elementowo, uwzględniając znaki argumentów.
Cechy: AlwaysSpeculatableImplTrait
, SameOperandsAndResultElementType
, SameOperandsAndResultShape
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
y | tensor 32-bitowych lub 64-bitowych wartości zmiennoprzecinkowych |
x | tensor 32-bitowych lub 64-bitowych wartości zmiennoprzecinkowych |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowych lub 64-bitowych wartości zmiennoprzecinkowych |
tfl.average_pool_2d
(TFL::AveragePool2DOp)
_Średni_pula Operator 2d
Wykonuje operację uśredniania puli na wejściu.
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflArithmeticCountOpInterface
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
filter_height | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku |
filter_width | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku |
padding | ::mlir::StringAttr | atrybut string, którego wartość to SAME lub VALID |
stride_h | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku |
stride_w | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku |
fused_activation_function | ::mlir::StringAttr | atrybut łańcuchowy, którego wartość to NONE, RELU, RELU_N1_TO_1, RELU6, TANH lub SIGN_BIT |
Operandy:
Operand | Opis |
---|---|
input | tensor 32-bitowego typu float lub wartości typu QI8, typu QUI8 lub typu QI16 |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowego typu float lub wartości typu QI8, typu QUI8 lub typu QI16 |
tfl.basic_lstm
(TFL::BasicLSTMop)
Podstawowy operator lstm
podstawowy operator komórkowy LSTM.
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
fused_activation_function | ::mlir::StringAttr | atrybut łańcuchowy, którego wartość to NONE, RELU, RELU_N1_TO_1, RELU6, TANH lub SIGN_BIT |
cell_clip | ::mlir::FloatAttr | 32-bitowy atrybut zmiennoprzecinkowy, którego wartość jest nieujemna |
proj_clip | ::mlir::FloatAttr | 32-bitowy atrybut zmiennoprzecinkowy, którego wartość jest nieujemna |
kernel_type | ::mlir::TFL::LSTMKernelTypeAttr | lstm_kernel_type, którego wartość to mlir::TFL::LSTMKernelType::BASIC |
Operandy:
Operand | Opis |
---|---|
data_input | tensor 32-bitowych wartości typu float lub QUI8 |
prev_activ_input | tensor 32-bitowych wartości typu float lub QUI8 |
weights_input | tensor 32-bitowych wartości typu float lub QUI8 |
biases_input | tensor 32-bitowych wartości typu float lub QI32 |
prev_state_input | tensor 32-bitowych wartości typu float lub QI16 |
Wyniki:
Wynik | Opis |
---|---|
activ_output | Tensor 2D dowolnego typu wartości |
state_output | Tensor 2D dowolnego typu wartości |
concat_temp | Tensor 2D dowolnego typu wartości |
activ_temp | Tensor 2D dowolnego typu wartości |
tfl.batch_matmul
(TFL::BatchMatMulOp)
Operator mnożenia macierzy wsadowej
Wykonuje wsadowe mnożenie macierzy na wejściach. Jest zgodny z konwencjami TensorFlow BatchMatMulV2, z obsługą nieznanych wymiarów w wymiarach wsadowych i transmisji.
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)
Cechy: ::mlir::OpTrait::TFLRuntimeOpTrait
, AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, DynamicRangeQuantizedOpInterface
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
adj_x | ::mlir::BoolAttr | atrybut boolowy |
adj_y | ::mlir::BoolAttr | atrybut boolowy |
asymmetric_quantize_inputs | ::mlir::BoolAttr | atrybut boolowy |
Operandy:
Operand | Opis |
---|---|
x | tensor 32-bitowego typu float lub typu QI8 lub typu QI16 lub 8-bitowych wartości całkowitych bez znaku |
y | tensor 32-bitowego typu float lub typu QI8 lub typu QI16 lub 8-bitowych wartości całkowitych bez znaku |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowego typu float lub typu QI8 lub QI16 lub 32-bitowych wartości całkowitych bez znaku |
tfl.batch_to_space_nd
(TFL::BatchToSpaceNdOp)
Operator BatchToSpaceNd
Ta operacja przekształca wymiar „wsadowy” 0 w wymiary przestrzenne.
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
input | tensor 32-bitowej liczby zmiennoprzecinkowej lub 8-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub 8-bitowej liczby całkowitej bez znaku lub wartości typu QI8, typu QUI8 lub typu QI16 |
block_shape | tensor 32-bitowych wartości całkowitych bez znaku |
indices | tensor 32-bitowych wartości całkowitych bez znaku |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowej liczby zmiennoprzecinkowej lub 16-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub 8-bitowej liczby całkowitej bez znaku lub wartości typu QI8, typu QUI8 lub typu QI16 |
tfl.bidirectional_sequence_lstm
(TFL::BidirectionSequenceLSTMop)
Dwukierunkowy operator lstm sekwencji
Dwukierunkowy lstm to zasadniczo dwa lstm, jeden biegnący do przodu, a drugi biegnący do tyłu. Wynikiem jest połączenie dwóch lstm.
Cechy: QuantizableResult
Interfejsy: DynamicRangeQuantizedOpInterface
, TFL_StatefulOp
, TflRuntimeVerifyOpInterface
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
fused_activation_function | ::mlir::StringAttr | atrybut łańcuchowy, którego wartość to NONE, RELU, RELU_N1_TO_1, RELU6, TANH lub SIGN_BIT |
cell_clip | ::mlir::FloatAttr | 32-bitowy atrybut zmiennoprzecinkowy, którego wartość jest nieujemna |
proj_clip | ::mlir::FloatAttr | 32-bitowy atrybut zmiennoprzecinkowy, którego wartość jest nieujemna |
merge_outputs | ::mlir::BoolAttr | atrybut boolowy |
time_major | ::mlir::BoolAttr | atrybut boolowy |
asymmetric_quantize_inputs | ::mlir::BoolAttr | atrybut boolowy |
Operandy:
Operand | Opis |
---|---|
input | tensor 32-bitowych wartości zmiennoprzecinkowych lub 8-bitowych wartości całkowitych bez znaku |
fw_input_to_input_weights | tensor dowolnego typu wartości lub żadnego typu |
fw_input_to_forget_weights | tensor 32-bitowych wartości zmiennoprzecinkowych lub 8-bitowych wartości całkowitych bez znaku |
fw_input_to_cell_weights | tensor 32-bitowych wartości zmiennoprzecinkowych lub 8-bitowych wartości całkowitych bez znaku |
fw_input_to_output_weights | tensor 32-bitowych wartości zmiennoprzecinkowych lub 8-bitowych wartości całkowitych bez znaku |
fw_recurrent_to_input_weights | tensor dowolnego typu wartości lub żadnego typu |
fw_recurrent_to_forget_weights | tensor 32-bitowych wartości zmiennoprzecinkowych lub 8-bitowych wartości całkowitych bez znaku |
fw_recurrent_to_cell_weights | tensor 32-bitowych wartości zmiennoprzecinkowych lub 8-bitowych wartości całkowitych bez znaku |
fw_recurrent_to_output_weights | tensor 32-bitowych wartości zmiennoprzecinkowych lub 8-bitowych wartości całkowitych bez znaku |
fw_cell_to_input_weights | tensor dowolnego typu wartości lub żadnego typu |
fw_cell_to_forget_weights | tensor dowolnego typu wartości lub żadnego typu |
fw_cell_to_output_weights | tensor dowolnego typu wartości lub żadnego typu |
fw_input_gate_bias | tensor dowolnego typu wartości lub żadnego typu |
fw_forget_gate_bias | tensor 32-bitowych wartości zmiennoprzecinkowych |
fw_cell_bias | tensor 32-bitowych wartości zmiennoprzecinkowych |
fw_output_gate_bias | tensor 32-bitowych wartości zmiennoprzecinkowych |
fw_projection_weights | tensor dowolnego typu wartości lub żadnego typu |
fw_projection_bias | tensor dowolnego typu wartości lub żadnego typu |
bw_input_to_input_weights | tensor dowolnego typu wartości lub żadnego typu |
bw_input_to_forget_weights | tensor 32-bitowych wartości zmiennoprzecinkowych lub 8-bitowych wartości całkowitych bez znaku |
bw_input_to_cell_weights | tensor 32-bitowych wartości zmiennoprzecinkowych lub 8-bitowych wartości całkowitych bez znaku |
bw_input_to_output_weights | tensor 32-bitowych wartości zmiennoprzecinkowych lub 8-bitowych wartości całkowitych bez znaku |
bw_recurrent_to_input_weights | tensor dowolnego typu wartości lub żadnego typu |
bw_recurrent_to_forget_weights | tensor 32-bitowych wartości zmiennoprzecinkowych lub 8-bitowych wartości całkowitych bez znaku |
bw_recurrent_to_cell_weights | tensor 32-bitowych wartości zmiennoprzecinkowych lub 8-bitowych wartości całkowitych bez znaku |
bw_recurrent_to_output_weights | tensor 32-bitowych wartości zmiennoprzecinkowych lub 8-bitowych wartości całkowitych bez znaku |
bw_cell_to_input_weights | tensor dowolnego typu wartości lub żadnego typu |
bw_cell_to_forget_weights | tensor dowolnego typu wartości lub żadnego typu |
bw_cell_to_output_weights | tensor dowolnego typu wartości lub żadnego typu |
bw_input_gate_bias | tensor dowolnego typu wartości lub żadnego typu |
bw_forget_gate_bias | tensor 32-bitowych wartości zmiennoprzecinkowych |
bw_cell_bias | tensor 32-bitowych wartości zmiennoprzecinkowych |
bw_output_gate_bias | tensor 32-bitowych wartości zmiennoprzecinkowych |
bw_projection_weights | tensor dowolnego typu wartości lub żadnego typu |
bw_projection_bias | tensor dowolnego typu wartości lub żadnego typu |
fw_input_activation_state | tensor stanowy |
fw_input_cell_state | tensor stanowy |
bw_input_activation_state | tensor stanowy |
bw_input_cell_state | tensor stanowy |
aux_input | tensor dowolnego typu wartości lub żadnego typu |
fw_aux_input_to_input_weights | tensor dowolnego typu wartości lub żadnego typu |
fw_aux_input_to_forget_weights | tensor dowolnego typu wartości lub żadnego typu |
fw_aux_input_to_cell_weights | tensor dowolnego typu wartości lub żadnego typu |
fw_aux_input_to_output_weights | tensor dowolnego typu wartości lub żadnego typu |
bw_aux_input_to_input_weights | tensor dowolnego typu wartości lub żadnego typu |
bw_aux_input_to_forget_weights | tensor dowolnego typu wartości lub żadnego typu |
bw_aux_input_to_cell_weights | tensor dowolnego typu wartości lub żadnego typu |
bw_aux_input_to_output_weights | tensor dowolnego typu wartości lub żadnego typu |
Wyniki:
Wynik | Opis |
---|---|
fw_output | tensor dowolnego typu wartości |
bw_output | tensor dowolnego typu wartości |
tfl.bitcast
(TFL::BitcastOp)
Operator transmisji bitowej
Przesyła bitcast tensora z jednego typu na inny.
Cechy: AlwaysSpeculatableImplTrait
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
input | tensor dowolnego typu wartości |
Wyniki:
Wynik | Opis |
---|---|
output | tensor dowolnego typu wartości |
tfl.bitwise_xor
(TFL::BitwiseXorOp)
Bitowy operator Xor
Elementwise oblicza bitowy XOR lhs
i rhs
.
Cechy: AlwaysSpeculatableImplTrait
, Commutative
, SameOperandsAndResultElementType
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
lhs | tensor 8-bitowej liczby całkowitej bez znaku lub 8-bitowej liczby całkowitej bez znaku lub 16-bitowej liczby całkowitej bez znaku lub 16-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 32-bitowej wartości całkowitej bez znaku |
rhs | tensor 8-bitowej liczby całkowitej bez znaku lub 8-bitowej liczby całkowitej bez znaku lub 16-bitowej liczby całkowitej bez znaku lub 16-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 32-bitowej wartości całkowitej bez znaku |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 8-bitowej liczby całkowitej bez znaku lub 8-bitowej liczby całkowitej bez znaku lub 16-bitowej liczby całkowitej bez znaku lub 16-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 32-bitowej wartości całkowitej bez znaku |
tfl.broadcast_args
(TFL::BroadcastArgsOp)
Zwróć kształt s0 op s1 za pomocą transmisji.
Mając s0
i s1
, tensory reprezentujące kształty, obliczamy r0
, emitowany kształt. Wszystkie s0
, s1
i r0
są wektorami całkowitymi.
Cechy: AlwaysSpeculatableImplTrait
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
s0 | tensor 32/64-bitowych wartości całkowitych bez znaku |
s1 | tensor 32/64-bitowych wartości całkowitych bez znaku |
Wyniki:
Wynik | Opis |
---|---|
r0 | tensor 32/64-bitowych wartości całkowitych bez znaku |
tfl.broadcast_to
(TFL::BroadcastToOp)
Rozgłaszaj tablicę dla zgodnego kształtu.
Rozgłaszanie to proces tworzenia tablic, które mają kształty zgodne z operacjami arytmetycznymi. Dwa kształty są zgodne, jeśli dla każdej pary wymiarów są one równe lub jeden z nich jest jeden. Próba rozgłaszania Tensora do kształtu rozpoczyna się od wymiarów końcowych i przesuwa się dalej.
Na przykład,
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]], kształt=(3, 3), dtyp=int32)
W powyższym przykładzie wejściowy Tensor o kształcie [1, 3]
jest rozgłaszany do Tensora wyjściowego o kształcie [3, 3]
.
Podczas wykonywania operacji rozgłaszania, takich jak mnożenie tensora przez skalar, rozgłaszanie (zwykle) zapewnia pewną korzyść czasową lub przestrzenną, ponieważ nadawany tensor nigdy się nie materializuje.
Jednak broadcast_to
nie niesie ze sobą żadnych takich korzyści. Nowo utworzony tensor przejmuje pełną pamięć nadawanego kształtu. (Jednak w kontekście wykresu broadcast_to
może zostać połączone z kolejnymi operacjami, a następnie zoptymalizowane.)
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
input | tensor 32-bitowej liczby zmiennoprzecinkowej lub 32-bitowej liczby całkowitej bez znaku lub 1-bitowej liczby całkowitej bez znaku lub 4-bitowej liczby całkowitej bez znaku lub 8-bitowej liczby całkowitej bez znaku lub typu QI8 lub 8-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub typu QUI8 lub 16 -bitowa liczba całkowita bez znaku lub typ QI16 lub 64-bitowa liczba całkowita bez znaku lub typ złożony z 32-bitowymi wartościami elementów zmiennoprzecinkowych |
shape | tensor 32/64-bitowych wartości całkowitych bez znaku |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowej liczby zmiennoprzecinkowej lub 32-bitowej liczby całkowitej bez znaku lub 1-bitowej liczby całkowitej bez znaku lub 4-bitowej liczby całkowitej bez znaku lub 8-bitowej liczby całkowitej bez znaku lub typu QI8 lub 8-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub typu QUI8 lub 16 -bitowa liczba całkowita bez znaku lub typ QI16 lub 64-bitowa liczba całkowita bez znaku lub typ złożony z 32-bitowymi wartościami elementów zmiennoprzecinkowych |
tfl.bucketize
(TFL::BucketizeOp)
Podział danych wejściowych na podstawie „granic”.
Przykład:
Jeśli wejściami są boundaries = [0, 10, 100]
i input = [[-5, 10000][150, 10][5, 100]]
, wówczas na wyjściu zostanie output = [[0, 3][3, 2][1, 3]]
.
Cechy: AlwaysSpeculatableImplTrait
, SameOperandsAndResultShape
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
boundaries | ::mlir::ArrayAttr | 32-bitowy atrybut tablicy zmiennoprzecinkowej |
Operandy:
Operand | Opis |
---|---|
input | tensor 32-bitowej liczby zmiennoprzecinkowej lub 64-bitowej liczby zmiennoprzecinkowej lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej wartości całkowitej bez znaku |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowych wartości całkowitych bez znaku |
tfl.call_once
(TFL::CallOnceOp)
Wywołuje funkcję inicjującą
Ta operacja wywołuje daną funkcję inicjującą dla inicjatora sesji w dialekcie zapisanego modelu tf.
Interfejsy: TflRuntimeVerifyOpInterface
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
session_init_function | ::mlir::StringAttr | atrybut ciągu |
tfl.cast
(TFL::CastOp)
Operator obsady
Rzutuje dane wejściowe z typu wejściowego na typ wyjściowy.
Cechy: AlwaysSpeculatableImplTrait
, SameOperandsAndResultShape
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
input | tensor 16-bitowego typu float lub bfloat16 lub 32-bitowego typu float lub 64-bitowego float lub 1-bitowej liczby całkowitej bez znaku lub 4-bitowej liczby całkowitej bez znaku lub 16-bitowej liczby całkowitej bez znaku lub 16-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 32-bitowa liczba całkowita bez znaku lub 64-bitowa liczba całkowita bez znaku lub typ TFLite quint8 lub 8-bitowa liczba całkowita bez znaku lub 8-bitowa liczba całkowita bez znaku lub typ złożony z 32-bitowymi wartościami elementów zmiennoprzecinkowych |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 16-bitowego typu float lub bfloat16 lub 32-bitowego typu float lub 64-bitowego float lub 1-bitowej liczby całkowitej bez znaku lub 16-bitowej liczby całkowitej bez znaku lub 16-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowa liczba całkowita bez znaku lub typ TFLite quint8 lub 8-bitowa liczba całkowita bez znaku lub 8-bitowa liczba całkowita bez znaku lub typ złożony z 32-bitowymi wartościami elementów zmiennoprzecinkowych |
tfl.ceil
(TFL::CeilOp)
Operator sufitu
Zwraca elementową wartość ceil wejścia.
Cechy: AlwaysSpeculatableImplTrait
, InferTensorType
, TF::SameOperandsAndResultTypeResolveRef
Interfejsy: ConditionallySpeculatable
, InferShapedTypeOpInterface
, InferTypeOpInterface
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
x | tensor 32-bitowych wartości zmiennoprzecinkowych |
Wyniki:
Wynik | Opis |
---|---|
y | tensor 32-bitowych wartości zmiennoprzecinkowych |
tfl.complex_abs
(TFL::ComplexAbsOp)
Oblicza zespoloną wartość bezwzględną tensora.
Biorąc pod uwagę tensor x
liczb zespolonych, ta operacja zwraca tensor typu float
lub double
, który jest wartością bezwzględną każdego elementu w x
. Wszystkie elementy w x
muszą być liczbami zespolonymi w postaci \(a + bj\). Wartość bezwzględna jest obliczana jako \( \sqrt{a^2 + b^2}\).
Cechy: AlwaysSpeculatableImplTrait
, SameOperandsAndResultShape
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
input | tensor typu złożonego z 32-bitowymi elementami zmiennoprzecinkowymi lub typu złożonego z 64-bitowymi wartościami elementów zmiennoprzecinkowych |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowych lub 64-bitowych wartości zmiennoprzecinkowych |
tfl.concatenation
(TFL::ConcatenationOp)
Operator łączenia
Łączy tensory wzdłuż jednego wymiaru
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
axis | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku |
fused_activation_function | ::mlir::StringAttr | atrybut łańcuchowy, którego wartość to NONE, RELU, RELU_N1_TO_1, RELU6, TANH lub SIGN_BIT |
Operandy:
Operand | Opis |
---|---|
values | variadic tensora wartości dowolnego typu |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowej liczby zmiennoprzecinkowej lub 64-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 16-bitowej liczby całkowitej bez znaku lub 8-bitowej liczby całkowitej bez znaku lub typu QI8 lub typu QUI8 lub 8-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 1 -bitowe wartości całkowite bez znaku |
tfl.control_node
(TFL::ControlNodeOp)
Operacja TFL.control_node
zawija operacje na pojedynczym bloku w celu dołączenia krawędzi sterujących.
Służy do zawijania regionów i dołączania do nich zależności sterujących. Zwykle dzieje się to w jednym z ostatnich kroków przed emisją modelu z płaskim buforem, aby umożliwić optymalizacje oparte na ustalonej kolejności operacji (takich jak rematerializacja). Eksporter z płaskim buforem rozpakuje zawinięty region i opatrzy wygenerowany model metadanymi tak, że wszelkie zmiany kolejności w czasie wykonywania będą zgodne z kolejnością podaną przez zależności sterujące.
Cechy: HasParent<mlir::func::FuncOp>
, RecursiveMemoryEffects
, SingleBlockImplicitTerminator<YieldOp>
, SingleBlock
Operandy:
Operand | Opis |
---|---|
controlInputs | wariancja kontroli |
Wyniki:
Wynik | Opis |
---|---|
outputs | variadic tensora wartości dowolnego typu |
control | kontrola |
tfl.conv_2d
(TFL::Conv2DOp)
Operator splotu
Wykonuje operację splotu na wejściach.
Wejścia: inputs[0]
: wymagane: tensor aktywacji wejścia inputs[1]
: wymagane: tensor wagi filtra inputs[2]
: opcjonalnie: tensor polaryzacji
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
, quant::AccumulatorUniformScale<2, 0, 1>
, quant::AffineOpCoefficient<0, 1>
Interfejsy: AffineQuantizedOpInterface
, ConditionallySpeculatable
, DynamicRangeQuantizedOpInterface
, InferTypeOpInterface
, NoMemoryEffect (MemoryEffectOpInterface)
, TFL_SparseOp
, TflArithmeticCountOpInterface
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
dilation_h_factor | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku |
dilation_w_factor | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku |
fused_activation_function | ::mlir::StringAttr | atrybut łańcuchowy, którego wartość to NONE, RELU, RELU_N1_TO_1, RELU6, TANH lub SIGN_BIT |
padding | ::mlir::StringAttr | atrybut string, którego wartość to SAME lub VALID |
stride_h | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku |
stride_w | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku |
Operandy:
Operand | Opis |
---|---|
input | tensor 32-bitowego typu float lub wartości typu QI8, typu QUI8 lub typu QI16 |
filter | tensor 32-bitowego typu float lub wartości typu QI4, typu QI8 lub typu QUI8 |
bias | tensor dowolnego typu wartości lub żadnego typu |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowego typu float lub wartości typu QI8, typu QUI8 lub typu QI16 |
tfl.conv_3d
(TFL::Conv3Dop)
Operator splotu 3D
Wykonuje operację splotu na wejściach 3D. Wejścia: inputs[0]
: wymagane: tensor aktywacji wejścia inputs[1]
: wymagane: tensor wagi filtra inputs[2]
: opcjonalnie: tensor polaryzacji
Cechy: AlwaysSpeculatableImplTrait
, quant::AccumulatorUniformScale<2, 0, 1>
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
dilation_d_factor | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku |
dilation_h_factor | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku |
dilation_w_factor | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku |
fused_activation_function | ::mlir::StringAttr | atrybut łańcuchowy, którego wartość to NONE, RELU, RELU_N1_TO_1, RELU6, TANH lub SIGN_BIT |
padding | ::mlir::StringAttr | atrybut string, którego wartość to SAME lub VALID |
stride_d | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku |
stride_h | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku |
stride_w | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku |
Operandy:
Operand | Opis |
---|---|
input | tensor 32-bitowych wartości zmiennoprzecinkowych |
filter | tensor 32-bitowych wartości zmiennoprzecinkowych |
bias | tensor dowolnego typu wartości lub żadnego typu |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowych wartości zmiennoprzecinkowych |
tfl.conv_3d_transpose
(TFL::Conv3DTransposeOp)
Transponowany operator Convolution 3D
Wykonuje transponowaną operację splotu na wejściach 3D. Wejścia: inputs[0]
: wymagane: kształt tensora wyjściowego inputs[1]
: wymagane: tensor wagi filtra inputs[2]
: wymagane: tensor aktywacji inputs[3]
: opcjonalnie: tensor polaryzacji
Cechy: AlwaysSpeculatableImplTrait
, quant::AccumulatorUniformScale<2, 0, 1>
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
dilation_d_factor | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku |
dilation_h_factor | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku |
dilation_w_factor | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku |
fused_activation_function | ::mlir::StringAttr | atrybut łańcuchowy, którego wartość to NONE, RELU, RELU_N1_TO_1, RELU6, TANH lub SIGN_BIT |
padding | ::mlir::StringAttr | atrybut string, którego wartość to SAME lub VALID |
stride_d | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku |
stride_h | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku |
stride_w | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku |
Operandy:
Operand | Opis |
---|---|
output_shape | tensor 32-bitowych wartości całkowitych bez znaku |
filter | tensor 32-bitowych wartości zmiennoprzecinkowych |
input | tensor 32-bitowych wartości zmiennoprzecinkowych |
bias | tensor dowolnego typu wartości lub żadnego typu |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowych wartości zmiennoprzecinkowych |
tfl.cos
(TFL::CosOp)
Operator cosinus
Oblicza elementarny cosinus danych wejściowych
Cechy: AlwaysSpeculatableImplTrait
, InferTensorType
, TF::SameOperandsAndResultTypeResolveRef
Interfejsy: ConditionallySpeculatable
, InferShapedTypeOpInterface
, InferTypeOpInterface
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
x | tensor 32-bitowych wartości zmiennoprzecinkowych |
Wyniki:
Wynik | Opis |
---|---|
y | tensor 32-bitowych wartości zmiennoprzecinkowych |
tfl.cumsum
(TFL::CumsumOp)
Operator Cumsum
Oblicz skumulowaną sumę tensora x wzdłuż osi.
Cechy: AlwaysSpeculatableImplTrait
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
exclusive | ::mlir::BoolAttr | atrybut boolowy |
reverse | ::mlir::BoolAttr | atrybut boolowy |
Operandy:
Operand | Opis |
---|---|
input | tensor 32-bitowej liczby zmiennoprzecinkowej lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej wartości całkowitej bez znaku |
axis | tensor 32-bitowych wartości całkowitych bez znaku |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowej liczby zmiennoprzecinkowej lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej wartości całkowitej bez znaku |
tfl.custom
(TFL::CustomOp)
Opcja niestandardowa
Ogólna opcja dla dowolnej niestandardowej operacji TFLite.
wejście: lista wejść w oryginalnym op. kod_niestandardowy: Ciąg używany do określenia, która dokładnie jest ta operacja, co odpowiada kodom_operatora.kodowi_niestandardowemu w buforze płaskim. opcja_niestandardowa: uchwyt do zapisywania atrybutów op w formie bajtów. wyjście: Lista wyników w oryginalnym op.
Interfejsy: TflRuntimeVerifyOpInterface
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
custom_code | ::mlir::StringAttr | atrybut ciągu |
custom_option | ::mlir::TFL::ConstBytesAttr | Reprezentacja atrybutu ciągu skompilowanych bajtów |
Operandy:
Operand | Opis |
---|---|
input | variadic tensora dowolnego typu wartości lub żadnego typu |
Wyniki:
Wynik | Opis |
---|---|
output | variadic tensora wartości dowolnego typu |
tfl.custom_tf
(TFL::CustomTfOp)
Opakowania dla niestandardowych operacji TF.
Operacja otaczająca dowolną niestandardową operację TF. Należą do nich operacje zdefiniowane przy użyciu custom_opdefs lub połączone, które nie są zdefiniowane w dialekcie TF. Ta operacja po prostu otacza niestandardową operację wewnątrz regionu. Uwaga nr 1, ta operacja nie będzie obejmować niestandardowych operacji TF Lite zdefiniowanych za pomocą CustomOp. Uwaga nr 2, ta operacja jest po prostu wewnętrzną reprezentacją wewnątrz konwertera i nie jest eksponowana/eksportowana, gdy model jest eksportowany do Flatbuffer.
Cechy: IsolatedFromAbove
, RecursiveMemoryEffects
, SingleBlockImplicitTerminator<YieldOp>
, SingleBlock
Interfejsy: InferTypeOpInterface
, TflRuntimeVerifyOpInterface
Operandy:
Operand | Opis |
---|---|
input | variadic tensora dowolnego typu wartości lub żadnego typu |
Wyniki:
Wynik | Opis |
---|---|
output | variadic tensora wartości dowolnego typu |
tfl.densify
(TFL::DensifyOp)
Operator zagęszczania
Konwertuje tensor rzadki na format gęsty.
Cechy: AlwaysSpeculatableImplTrait
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
input | tensor 32-bitowych wartości zmiennoprzecinkowych lub 8-bitowych wartości całkowitych bez znaku |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowych wartości zmiennoprzecinkowych lub 8-bitowych wartości całkowitych bez znaku |
tfl.depth_to_space
(TFL::DepthToSpaceOp)
Operator DepthToSpace
Przestawia dane z głębi na bloki danych przestrzennych. Jest to odwrotna transformacja SpaceToDepth. Mówiąc dokładniej, ta operacja generuje kopię tensora wejściowego, w którym wartości z wymiaru depth
są przenoszone w blokach przestrzennych do wymiarów height
i width
. Atrybut block_size
wskazuje rozmiar bloku wejściowego i sposób przenoszenia danych.
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
block_size | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku, którego wartość jest dodatnia |
Operandy:
Operand | Opis |
---|---|
input | tensor 32-bitowej liczby zmiennoprzecinkowej lub 8-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub wartości TFLite quint8 lub 8-bitowej liczby całkowitej bez znaku lub typu QI8 lub QUI8 |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowej liczby zmiennoprzecinkowej lub 8-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub wartości TFLite quint8 lub 8-bitowej liczby całkowitej bez znaku lub typu QI8 lub QUI8 |
tfl.depthwise_conv_2d
(TFL::DepthwiseConv2DOp)
Operator splotu rozdzielany wgłębnie
Wykonuje operację splotu na wejściach.
Wejścia: inputs[0]
: wymagane: tensor aktywacji wejścia inputs[1]
: wymagane: tensor wagi filtra inputs[2]
: opcjonalnie: tensor polaryzacji
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
, quant::AccumulatorUniformScale<2, 0, 1>
, quant::AffineOpCoefficient<3, 1>
Interfejsy: AffineQuantizedOpInterface
, ConditionallySpeculatable
, DynamicRangeQuantizedOpInterface
, NoMemoryEffect (MemoryEffectOpInterface)
, TFL_SparseOp
, TflArithmeticCountOpInterface
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
dilation_h_factor | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku |
dilation_w_factor | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku |
fused_activation_function | ::mlir::StringAttr | atrybut łańcuchowy, którego wartość to NONE, RELU, RELU_N1_TO_1, RELU6, TANH lub SIGN_BIT |
padding | ::mlir::StringAttr | atrybut string, którego wartość to SAME lub VALID |
stride_h | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku |
stride_w | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku |
depth_multiplier | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku |
Operandy:
Operand | Opis |
---|---|
input | tensor 32-bitowego typu float lub wartości typu QI8, typu QUI8 lub typu QI16 |
filter | tensor 32-bitowego typu float lub wartości typu QI4, typu QI8 lub typu QUI8 |
bias | tensor dowolnego typu wartości lub żadnego typu |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowego typu float lub wartości typu QI8, typu QUI8 lub typu QI16 |
tfl.dequantize
(TFL::DekwantyzacjaOp)
Operator dekwantyzacji
Konwertuje skwantowaną tablicę liczb całkowitych na liczby zmiennoprzecinkowe zgodnie z parametrami kwantyzacji.
Interfejsy: NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
input | tensor typu QI4 lub QI8 lub typu QUI8 lub typu QI16 lub 16-bitowe wartości zmiennoprzecinkowe |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowych wartości zmiennoprzecinkowych |
tfl.dilate
(TFL::DilateOp)
Operator dylatacji
Rozszerza tensor, dodając nowe elementy pomiędzy istniejącymi. Cechy: AlwaysSpeculatableImplTrait
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
input | tensor 8-bitowej liczby całkowitej bez znaku lub 16-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub 8-bitowej liczby całkowitej bez znaku lub 16-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub 32-bitowe wartości zmiennoprzecinkowe lub 64-bitowe wartości zmiennoprzecinkowe |
dilations | tensor 32-bitowych wartości całkowitych bez znaku |
padding_value | Tensor 0D dowolnego typu |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 8-bitowej liczby całkowitej bez znaku lub 16-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub 8-bitowej liczby całkowitej bez znaku lub 16-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub 32-bitowe wartości zmiennoprzecinkowe lub 64-bitowe wartości zmiennoprzecinkowe |
tfl.div
(TFL::DivOp)
Operator podziału
Operacja dzielenia elementarnego.
Cechy: ::mlir::OpTrait::TFLRuntimeOpTrait
, AlwaysSpeculatableImplTrait
, ResultsBroadcastableShape
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflArithmeticCountOpInterface
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
fused_activation_function | ::mlir::StringAttr | atrybut łańcuchowy, którego wartość to NONE, RELU, RELU_N1_TO_1, RELU6, TANH lub SIGN_BIT |
Operandy:
Operand | Opis |
---|---|
lhs | tensor 32-bitowej liczby zmiennoprzecinkowej lub 32-bitowej liczby całkowitej bez znaku lub wartości typu QUI8 |
rhs | tensor 32-bitowej liczby zmiennoprzecinkowej lub 32-bitowej liczby całkowitej bez znaku lub wartości typu QUI8 |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowej liczby zmiennoprzecinkowej lub 32-bitowej liczby całkowitej bez znaku lub wartości typu QUI8 |
tfl.dynamic_update_slice
(TFL::DynamicUpdateSliceOp)
DynamicUpdateSlice.
Opcja DynamicUpdateSlice, która ma tę samą semantykę co XLA DynamicUpdateSlice. Generuje wynik będący wartością operandu tablicy wejściowej, z nadpisaniem aktualizacji wycinka w start_indices.
Zobacz https://www.tensorflow.org/xla/operative_semantics#dynamicupdateslice
Cechy: AlwaysSpeculatableImplTrait
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
operand | tensor 1-bitowej liczby całkowitej bez znaku lub 8-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub 32-bitowej wartości zmiennoprzecinkowej |
update | tensor 1-bitowej liczby całkowitej bez znaku lub 8-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub 32-bitowej wartości zmiennoprzecinkowej |
start_indices | tensor 32/64-bitowych wartości całkowitych bez znaku |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 1-bitowej liczby całkowitej bez znaku lub 8-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub 32-bitowej wartości zmiennoprzecinkowej |
tfl.elu
(TFL::EluOp)
Operator wykładniczej jednostki liniowej
Oblicza wykładniczą liniową f(x) -> exp(x) - 1 dla x < 0, x dla x >= 0. elementarnie.
Cechy: AlwaysSpeculatableImplTrait
, SameOperandsAndResultShape
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
x | tensor 32-bitowych wartości zmiennoprzecinkowych lub 8-bitowych wartości całkowitych bez znaku |
Wyniki:
Wynik | Opis |
---|---|
y | tensor 32-bitowych wartości zmiennoprzecinkowych lub 8-bitowych wartości całkowitych bez znaku |
tfl.embedding_lookup
(TFL::EmbeddingLookupOp)
Osadzanie operatora wyszukiwania
Wyszukuje identyfikatory na liście tensorów osadzania.
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, DynamicRangeQuantizedOpInterface
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
lookup | tensor 32-bitowych wartości całkowitych bez znaku |
value | tensor 32-bitowej liczby zmiennoprzecinkowej lub 8-bitowej liczby całkowitej bez znaku lub 8-bitowej liczby całkowitej bez znaku lub wartości typu QI4 |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowej liczby zmiennoprzecinkowej lub 8-bitowej liczby całkowitej bez znaku lub 8-bitowej wartości całkowitej bez znaku |
tfl.equal
(TFL::EqualOp)
Operator równości
Zwraca element prawdy x == y elementowo
Cechy: ::mlir::OpTrait::TFLRuntimeOpTrait
, AlwaysSpeculatableImplTrait
, Commutative
, QuantizableResult
, ResultsBroadcastableShape
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
x | tensor 1-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby zmiennoprzecinkowej lub 16-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub typu QI8 lub typu QUI8 lub 8-bitowej liczby całkowitej bez znaku lub wartości typu łańcuchowego TFLite |
y | tensor 1-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby zmiennoprzecinkowej lub 16-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub typu QI8 lub typu QUI8 lub 8-bitowej liczby całkowitej bez znaku lub wartości typu łańcuchowego TFLite |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 1-bitowych wartości całkowitych bez znaku |
tfl.exp
(TFL::ExpOp)
Naturalny operator potęgowania
Wykonuje na wejściu elementarną operację naturalnego potęgowania.
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
x | tensor 32-bitowych wartości zmiennoprzecinkowych lub typu QI8 lub QI16 |
Wyniki:
Wynik | Opis |
---|---|
y | tensor 32-bitowych wartości zmiennoprzecinkowych lub typu QI8 lub QI16 |
tfl.expand_dims
(TFL::ExpandDimsOp)
Wstawia wymiar 1 do kształtu tensora.
Mając input
tensora, operacja ta wstawia wymiar 1 na axis
indeksu wymiaru kształtu danych input
. axis
indeksu wymiaru zaczyna się od zera; jeśli określisz liczbę ujemną dla axis
będzie ona liczona wstecz od końca.
Ta operacja jest przydatna, jeśli chcesz dodać wymiar wsadowy do pojedynczego elementu. Na przykład, jeśli masz pojedynczy obraz kształtu [height, width, channels]
, możesz utworzyć z niego partię 1 obrazu za pomocą expand_dims(image, 0)
, która utworzy kształt [1, height, width, channels]
.
Inne przykłady:
# '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]
Ta operacja wymaga, aby:
-1-input.dims() <= dim <= input.dims()
Ta operacja jest powiązana z squeeze()
, która usuwa wymiary o rozmiarze 1.
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
input | tensor dowolnego typu wartości |
dim | tensor 32/64-bitowych wartości całkowitych bez znaku |
Wyniki:
Wynik | Opis |
---|---|
output | tensor dowolnego typu wartości |
tfl.external_const
(TFL::ExternalConstOp)
Zewnętrzna stała op.
Zewnętrzna operacja const przechowuje buffer_index
, który wskazuje stałą w buforze płaskim.
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
buffer_index | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku |
Wyniki:
Wynik | Opis |
---|---|
output | tensor dowolnego typu wartości |
tfl.fake_quant
(TFL::FakeQuantOp)
Operator FakeQuant
Fałszywie kwantyzuj tensor „wejściowy” typu float za pomocą skalarów zmiennoprzecinkowych min i max do tensora „wyjściowego” o tym samym kształcie co dane wejściowe.
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
min | ::mlir::FloatAttr | 32-bitowy atrybut zmiennoprzecinkowy |
max | ::mlir::FloatAttr | 32-bitowy atrybut zmiennoprzecinkowy |
num_bits | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku, którego minimalna wartość to 2, a maksymalna wartość to 16 |
narrow_range | ::mlir::BoolAttr | atrybut bool, którego wartość jest fałszywa |
Operandy:
Operand | Opis |
---|---|
input | tensor 32-bitowych wartości zmiennoprzecinkowych |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowych wartości zmiennoprzecinkowych |
tfl.fill
(TFL::FillOp)
Wypełnij tensor podaną wartością.
Wypełnij tensor podaną wartością.
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
dims | tensor 32/64-bitowych wartości całkowitych bez znaku |
input | tensor 32-bitowej liczby zmiennoprzecinkowej lub 16-bitowej liczby zmiennoprzecinkowej lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub 1-bitowej liczby całkowitej bez znaku lub wartości typu QI8 lub QI16 lub typu łańcuchowego TFLite |
Wyniki:
Wynik | Opis |
---|---|
result | tensor 32-bitowej liczby zmiennoprzecinkowej lub 16-bitowej liczby zmiennoprzecinkowej lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub 1-bitowej liczby całkowitej bez znaku lub typu QI8 lub QI16 lub wartości typu TFLite |
tfl.floor
(TFL::FloorOp)
Operator piętra
Zwraca elementową wartość minimalną danych wejściowych.
Cechy: AlwaysSpeculatableImplTrait
, InferTensorType
, TF::SameOperandsAndResultTypeResolveRef
Interfejsy: ConditionallySpeculatable
, InferShapedTypeOpInterface
, InferTypeOpInterface
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
x | tensor 32-bitowych wartości zmiennoprzecinkowych |
Wyniki:
Wynik | Opis |
---|---|
y | tensor 32-bitowych wartości zmiennoprzecinkowych |
tfl.floor_div
(TFL::FloorDivOp)
Operator div piętra
Operacja div podłogowa oparta na elementach.
Cechy: ::mlir::OpTrait::TFLRuntimeOpTrait
, AlwaysSpeculatableImplTrait
, ResultsBroadcastableShape
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
lhs | tensor 32-bitowej liczby zmiennoprzecinkowej lub 8-bitowej liczby całkowitej bez znaku lub 16-bitowej liczby całkowitej bez znaku lub 32-bitowej wartości całkowitej bez znaku |
rhs | tensor 32-bitowej liczby zmiennoprzecinkowej lub 8-bitowej liczby całkowitej bez znaku lub 16-bitowej liczby całkowitej bez znaku lub 32-bitowej wartości całkowitej bez znaku |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowej liczby zmiennoprzecinkowej lub 8-bitowej liczby całkowitej bez znaku lub 16-bitowej liczby całkowitej bez znaku lub 32-bitowej wartości całkowitej bez znaku |
tfl.floor_mod
(TFL::FloorModOp)
Przypomnienie o podziale
Operacja przypomnienia o dzieleniu elementowym.
Cechy: ::mlir::OpTrait::TFLRuntimeOpTrait
, AlwaysSpeculatableImplTrait
, ResultsBroadcastableShape
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
lhs | tensor 8-bitowej liczby całkowitej bez znaku lub 16-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub 32-bitowej wartości zmiennoprzecinkowej |
rhs | tensor 8-bitowej liczby całkowitej bez znaku lub 16-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub 32-bitowej wartości zmiennoprzecinkowej |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 8-bitowej liczby całkowitej bez znaku lub 16-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub 32-bitowej wartości zmiennoprzecinkowej |
tfl.fully_connected
(TFL::FullyConnectedOp)
W pełni podłączony op
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
, quant::AccumulatorUniformScale<2, 0, 1>
, quant::AffineOpCoefficient<0, 1>
Interfejsy: AffineQuantizedOpInterface
, ConditionallySpeculatable
, DynamicRangeQuantizedOpInterface
, NoMemoryEffect (MemoryEffectOpInterface)
, TFL_SparseOp
, TflArithmeticCountOpInterface
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
fused_activation_function | ::mlir::StringAttr | atrybut łańcuchowy, którego wartość to NONE, RELU, RELU_N1_TO_1, RELU6, TANH lub SIGN_BIT |
weights_format | ::mlir::StringAttr | atrybut string, którego wartość to DEFAULT lub SHUFFLED4x16INT8 |
keep_num_dims | ::mlir::BoolAttr | atrybut boolowy |
asymmetric_quantize_inputs | ::mlir::BoolAttr | atrybut boolowy |
Operandy:
Operand | Opis |
---|---|
input | tensor 32-bitowego typu float lub wartości typu QI8 lub typu QUI8, typu QI16 lub typu QUI16 |
filter | tensor 32-bitowego typu float lub wartości typu QI4 lub typu QI8, typu QUI8 lub typu QI16 |
bias | tensor dowolnego typu wartości lub żadnego typu |
Wyniki:
Wynik | Opis |
---|---|
output | variadic tensora wartości dowolnego typu |
tfl.gather
(TFL::GatherOp)
Zbierz operatora
Zbierz wycinki z axis
osi params
zgodnie z indices
.
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, DynamicRangeQuantizedOpInterface
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
axis | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku |
batch_dims | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku |
Operandy:
Operand | Opis |
---|---|
params | tensor 32-bitowej liczby zmiennoprzecinkowej lub 1-bitowej liczby całkowitej bez znaku lub 4-bitowej liczby całkowitej bez znaku lub 8-bitowej liczby całkowitej bez znaku lub 16-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub typu łańcuchowego TFLite lub 8-bitowej liczba całkowita bez znaku lub wartości typu QI8, typu QUI8 lub typu QI16 |
indices | tensor 16-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej wartości całkowitej bez znaku |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowej liczby zmiennoprzecinkowej lub 1-bitowej liczby całkowitej bez znaku lub 4-bitowej liczby całkowitej bez znaku lub 8-bitowej liczby całkowitej bez znaku lub 16-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub typu łańcuchowego TFLite lub 8-bitowej liczba całkowita bez znaku lub wartości typu QI8, typu QUI8 lub typu QI16 |
tfl.gather_nd
(TFL::GatherNdOp)
_Zbierz operator
Zbierz wycinki z params
do Tensora o kształcie określonym przez indices
.
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
params | tensor 32-bitowej liczby zmiennoprzecinkowej lub 1-bitowej liczby całkowitej bez znaku lub 8-bitowej liczby całkowitej bez znaku lub 16-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 8-bitowej liczby całkowitej bez znaku lub wartości typu QI8 lub TFLite typu string |
indices | tensor 16-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej wartości całkowitej bez znaku |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowej liczby zmiennoprzecinkowej lub 1-bitowej liczby całkowitej bez znaku lub 8-bitowej liczby całkowitej bez znaku lub 16-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 8-bitowej liczby całkowitej bez znaku lub wartości typu QI8 lub TFLite typu string |
tfl.gelu
(TFL::GeluOp)
Funkcja aktywacji GELU.
Oblicza funkcję aktywacji GELU według elementów.
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
, SameOperandsAndResultShape
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
approximate | ::mlir::BoolAttr | atrybut boolowy |
Operandy:
Operand | Opis |
---|---|
input | tensor 32-bitowych wartości zmiennoprzecinkowych lub typu QI8 lub QUI8 |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowych wartości zmiennoprzecinkowych lub typu QI8 lub QUI8 |
tfl.greater
(TFL::WiększyOp)
Większy operator
Lepsze działanie pod względem elementów.
Cechy: ::mlir::OpTrait::TFLRuntimeOpTrait
, AlwaysSpeculatableImplTrait
, QuantizableResult
, ResultsBroadcastableShape
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
lhs | tensor 32-bitowej liczby zmiennoprzecinkowej lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub wartości typu QUI8, typu QI8 lub TFLite typu quint8 |
rhs | tensor 32-bitowej liczby zmiennoprzecinkowej lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub wartości typu QUI8, typu QI8 lub TFLite typu quint8 |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 1-bitowych wartości całkowitych bez znaku |
tfl.greater_equal
(TFL::GreaterEqualOp)
_Większy operator równości
Operacja „większa_równa” na elementach.
Cechy: ::mlir::OpTrait::TFLRuntimeOpTrait
, AlwaysSpeculatableImplTrait
, QuantizableResult
, ResultsBroadcastableShape
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
lhs | tensor 32-bitowej liczby zmiennoprzecinkowej lub 16-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub wartości typu QUI8 lub QI8 |
rhs | tensor 32-bitowej liczby zmiennoprzecinkowej lub 16-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub wartości typu QUI8 lub QI8 |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 1-bitowych wartości całkowitych bez znaku |
tfl.hard_swish
(TFL::HardSwishOp)
Funkcja aktywacji Hardswish.
Oblicza funkcję aktywacji twardego ruchu f(x) -> (x * relu6(x+3))/6 według elementu.
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
, SameOperandsAndResultShape
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
input | tensor 32-bitowych wartości zmiennoprzecinkowych lub typu QUI8 lub QI8 |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowych wartości zmiennoprzecinkowych lub typu QUI8 lub QI8 |
tfl.hashtable
(TFL::HashtableOp)
Tworzy niezainicjowaną tabelę skrótów.
Ta operacja tworzy tabelę mieszającą, określając typ jej kluczy i wartości. Przed użyciem tabeli należy ją zainicjować. Po inicjalizacji tabela będzie niezmienna.
Interfejsy: TflRuntimeVerifyOpInterface
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
table_id | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku |
key_dtype | ::mlir::Attr typu | dowolny atrybut typu |
value_dtype | ::mlir::Attr typu | dowolny atrybut typu |
Wyniki:
Wynik | Opis |
---|---|
out | tensor wartości zasobów |
tfl.hashtable_find
(TFL::HashtableFindOp)
Wyszukuje klucze w tabeli i wyświetla odpowiednie wartości.
keys
tensorowe muszą być tego samego typu co klucze tabeli. values
wyjściowe są typu wartości tabelarycznych.
Skalarna default_value
to wartość wyjściowa dla kluczy, których nie ma w tabeli. Musi być również tego samego typu co wartości w tabeli.
Interfejsy: TflRuntimeVerifyOpInterface
Operandy:
Operand | Opis |
---|---|
hash_table | tensor wartości zasobów |
keys | tensor 32-bitowej liczby całkowitej bez znaku lub typu ciągu TFLite lub 64-bitowej wartości całkowitej bez znaku |
default_value | tensor 32-bitowej liczby zmiennoprzecinkowej lub 32-bitowej liczby całkowitej bez znaku lub typu łańcuchowego TFLite lub 64-bitowej wartości całkowitej bez znaku |
Wyniki:
Wynik | Opis |
---|---|
out | tensor 32-bitowej liczby zmiennoprzecinkowej lub 32-bitowej liczby całkowitej bez znaku lub typu łańcuchowego TFLite lub 64-bitowej wartości całkowitej bez znaku |
tfl.hashtable_import
(TFL::HashtableImportOp)
Zastępuje zawartość tabeli określonymi kluczami i wartościami.
keys
tensorowe muszą być tego samego typu co klucze tabeli. values
tensora muszą być typu wartości tabeli.
Interfejsy: TflRuntimeVerifyOpInterface
Operandy:
Operand | Opis |
---|---|
hash_table | tensor wartości zasobów |
keys | tensor 32-bitowej liczby całkowitej bez znaku lub typu ciągu TFLite lub 64-bitowej wartości całkowitej bez znaku |
values | tensor 32-bitowej liczby zmiennoprzecinkowej lub 32-bitowej liczby całkowitej bez znaku lub typu łańcuchowego TFLite lub 64-bitowej wartości całkowitej bez znaku |
tfl.hashtable_size
(TFL::HashtableSizeOp)
Oblicza liczbę elementów w podanej tabeli.
Interfejsy: TflRuntimeVerifyOpInterface
Operandy:
Operand | Opis |
---|---|
hash_table | tensor wartości zasobów |
Wyniki:
Wynik | Opis |
---|---|
out | tensor 64-bitowych wartości całkowitych bez znaku |
tfl.if
(TFL::IfOp)
Operacja „jeśli-to-inaczej”.
Operacja tfl.if
reprezentuje konstrukcję if-then-else służącą do warunkowego wykonania dwóch regionów kodu. Operand operacji if jest wartością logiczną. Na przykład:
tfl.if %b {
...
} else {
...
}
tfl.if
może również zwracać wyniki zdefiniowane w jego regionach. Zdefiniowane wartości są określane na podstawie ścieżki wykonania.
Przykład:
%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>
}
Regiony tfl.if
są zawsze zakończone ciągiem „tfl.yield”. Jeśli „tfl.if” nie definiuje żadnych wartości, „tfl.yield” można pominąć i zostanie ono wstawione domyślnie. W przeciwnym razie musi to być wyraźne. Ponadto, jeśli „tfl.if” definiuje jedną lub więcej wartości, nie można pominąć bloku „else”.
Przykład:
tfl.if %b {
...
}
Cechy: NoRegionArguments
, RecursiveMemoryEffects
, SingleBlockImplicitTerminator<YieldOp>
, SingleBlock
Interfejsy: RegionBranchOpInterface
, TflRuntimeVerifyOpInterface
Operandy:
Operand | Opis |
---|---|
cond | tensor 1-bitowych wartości całkowitych bez znaku |
Wyniki:
Wynik | Opis |
---|---|
results | variadic tensora wartości dowolnego typu |
tfl.imag
(TFL::ImagOp)
Zwraca część urojoną liczby zespolonej.
Mając input
tensor liczb zespolonych, operacja ta zwraca tensor typu float
, który jest częścią urojoną każdego elementu na input
. Wszystkie elementy input
muszą być liczbami zespolonymi w postaci \(a + bj\), gdzie a to część rzeczywista, a b to część urojona zwrócona przez tę operację.
Cechy: AlwaysSpeculatableImplTrait
, SameOperandsAndResultShape
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
input | tensor typu złożonego z 32-bitowymi elementami zmiennoprzecinkowymi lub typu złożonego z 64-bitowymi wartościami elementów zmiennoprzecinkowych |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowych lub 64-bitowych wartości zmiennoprzecinkowych |
tfl.l2_normalization
(TFL::L2NormalizationOp)
Operator normalizacji L2
L2Normalizacja op
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, FixedOutputRangeInterface
, NoMemoryEffect (MemoryEffectOpInterface)
, TflArithmeticCountOpInterface
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
fused_activation_function | ::mlir::StringAttr | atrybut łańcuchowy, którego wartość to NONE, RELU, RELU_N1_TO_1, RELU6, TANH lub SIGN_BIT |
Operandy:
Operand | Opis |
---|---|
input | tensor 32-bitowego typu zmiennoprzecinkowego lub typu QUI8 lub typu QI8 lub typu QUI16 lub typu QI16 lub 8-bitowych wartości całkowitych bez znaku |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowego typu zmiennoprzecinkowego lub typu QUI8 lub typu QI8 lub typu QUI16 lub typu QI16 lub 8-bitowych wartości całkowitych bez znaku |
tfl.leaky_relu
(TFL::LeakyReluOp)
Nieszczelny operator Relu
Elementarny operator Leaky ReLU x -> x >= 0? x : (alfa * x)
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
, SameOperandsAndResultShape
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
alpha | ::mlir::FloatAttr | 32-bitowy atrybut zmiennoprzecinkowy |
Operandy:
Operand | Opis |
---|---|
input | tensor 32-bitowego typu float lub wartości typu QUI8 lub QI8 lub TFLite typu quint8 lub typu QI16 |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowego typu float lub wartości typu QUI8 lub QI8 lub TFLite typu quint8 lub typu QI16 |
tfl.less
(TFL::LessOp)
Mniej operatora
Elementarnie mniej operacji.
Cechy: ::mlir::OpTrait::TFLRuntimeOpTrait
, AlwaysSpeculatableImplTrait
, QuantizableResult
, ResultsBroadcastableShape
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
lhs | tensor 32-bitowej liczby zmiennoprzecinkowej lub 16-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub wartości typu QUI8, typu QI8 lub TFLite typu quint8 |
rhs | tensor 32-bitowej liczby zmiennoprzecinkowej lub 16-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub wartości typu QUI8, typu QI8 lub TFLite typu quint8 |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 1-bitowych wartości całkowitych bez znaku |
tfl.less_equal
(TFL::LessEqualOp)
_Mniejszy operator równości
Elementowa operacja less_equal.
Cechy: ::mlir::OpTrait::TFLRuntimeOpTrait
, AlwaysSpeculatableImplTrait
, QuantizableResult
, ResultsBroadcastableShape
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
lhs | tensor 32-bitowej liczby zmiennoprzecinkowej lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub wartości typu QI8 lub QUI8 |
rhs | tensor 32-bitowej liczby zmiennoprzecinkowej lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub wartości typu QI8 lub QUI8 |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 1-bitowych wartości całkowitych bez znaku |
tfl.local_response_normalization
(TFL::LocalResponseNormalizationOp)
Normalizacja odpowiedzi lokalnej.
Tensor input
4-D jest traktowany jako tablica 3-D wektorów 1-D (wzdłuż ostatniego wymiaru), a każdy wektor jest normalizowany niezależnie. W obrębie danego wektora każdy składnik jest dzielony przez ważoną kwadratową sumę danych wejściowych w depth_radius
. Szczegółowo,
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
Aby uzyskać szczegółowe informacje, zobacz Krizhevsky i in., Klasyfikacja ImageNet z głębokimi splotowymi sieciami neuronowymi (NIPS 2012) .
Cechy: AlwaysSpeculatableImplTrait
, InferTensorType
, TF::SameOperandsAndResultTypeResolveRef
Interfejsy: ConditionallySpeculatable
, InferShapedTypeOpInterface
, InferTypeOpInterface
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
radius | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku |
bias | ::mlir::FloatAttr | 32-bitowy atrybut zmiennoprzecinkowy |
alpha | ::mlir::FloatAttr | 32-bitowy atrybut zmiennoprzecinkowy |
beta | ::mlir::FloatAttr | 32-bitowy atrybut zmiennoprzecinkowy |
Operandy:
Operand | Opis |
---|---|
input | tensor 32-bitowych wartości zmiennoprzecinkowych |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowych wartości zmiennoprzecinkowych |
tfl.log
(TFL::LogOp)
Operator logarytmu naturalnego
Wykonuje na wejściu elementarną operację logarytmu naturalnego.
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
x | tensor 32-bitowych wartości typu float lub QI8 |
Wyniki:
Wynik | Opis |
---|---|
y | tensor 32-bitowych wartości typu float lub QI8 |
tfl.log_softmax
(TFL::LogSoftmaxOp)
Zaloguj operatora softmax
Oblicza elementarne aktywacje softmax za pomocą następującego wzoru
wejście - log(reduce_sum(exp(input), dim))
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
, SameOperandsAndResultShape
Interfejsy: ConditionallySpeculatable
, FixedOutputRangeInterface
, NoMemoryEffect (MemoryEffectOpInterface)
, TflArithmeticCountOpInterface
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
input | tensor 32-bitowego typu float lub wartości typu QUI8, typu QI8 lub typu TFLite quint8 |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowego typu float lub wartości typu QUI8, typu QI8 lub typu TFLite quint8 |
tfl.logical_and
(TFL::LogicalAndOp)
Operator logiczny AND
Elementowa logiczna operacja AND.
Cechy: AlwaysSpeculatableImplTrait
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
lhs | tensor 1-bitowych wartości całkowitych bez znaku |
rhs | tensor 1-bitowych wartości całkowitych bez znaku |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 1-bitowych wartości całkowitych bez znaku |
tfl.logical_not
(TFL::LogicalNotOp)
Operator logiczny NOT
Elementarna logiczna operacja NOT.
Cechy: AlwaysSpeculatableImplTrait
, SameOperandsAndResultShape
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
lhs | tensor 1-bitowych wartości całkowitych bez znaku |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 1-bitowych wartości całkowitych bez znaku |
tfl.logical_or
(TFL::LogicalOrOp)
Operator logiczny OR
Elementowa logiczna operacja OR.
Cechy: AlwaysSpeculatableImplTrait
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
lhs | tensor 1-bitowych wartości całkowitych bez znaku |
rhs | tensor 1-bitowych wartości całkowitych bez znaku |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 1-bitowych wartości całkowitych bez znaku |
tfl.logistic
(TFL::LogisticOp)
Operator logistyczny
Oblicza elementarną sigmoidę danych wejściowych
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
, SameOperandsAndResultShape
Interfejsy: ConditionallySpeculatable
, FixedOutputRangeInterface
, NoMemoryEffect (MemoryEffectOpInterface)
, TflArithmeticCountOpInterface
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
x | tensor 32-bitowego typu float lub typu QI8, typu QUI8, typu QI16 lub wartości typu TFLite quint8 |
Wyniki:
Wynik | Opis |
---|---|
y | tensor 32-bitowego typu float lub typu QI8, typu QUI8, typu QI16 lub wartości typu TFLite quint8 |
tfl.lstm
(TFL::LSTMop)
Pełny operator lstm
Warstwa sieci rekurencyjnej długiej jednostki pamięci krótkotrwałej (LSTM). Domyślna implementacja bez wizjera oparta jest na: http://deeplearning.cs.cmu.edu/pdfs/Hochreiter97_lstm.pdf S. Hochreitera i J. Schmidhubera. „Długa pamięć krótkotrwała”. Neural Computation, 9(8):1735-1780, 1997. Implementacja wizjera opiera się na: https://research.google.com/pubs/archive/43905.pdf Hasim Sak, Andrew Senior i Francoise Beaufays. „Architektury sieci neuronowych rekurencyjnych z pamięcią długoterminową do modelowania akustycznego na dużą skalę”. INTERSPEECH, 2014. Sprzężenie bramki wejściowej i zapominającej (CIFG) opiera się na: http://arxiv.org/pdf/1503.04069.pdf Greff et al. „LSTM: A Search Space Odyssey” Normalizacja warstw opiera się na: https://arxiv.org/pdf/1607.06450.pdf Ba et al. „Normalizacja warstw”
Cechy: QuantizableResult
Interfejsy: DynamicRangeQuantizedOpInterface
, TFL_StatefulOp
, TflRuntimeVerifyOpInterface
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
fused_activation_function | ::mlir::StringAttr | atrybut łańcuchowy, którego wartość to NONE, RELU, RELU_N1_TO_1, RELU6, TANH lub SIGN_BIT |
cell_clip | ::mlir::FloatAttr | 32-bitowy atrybut zmiennoprzecinkowy, którego wartość jest nieujemna |
proj_clip | ::mlir::FloatAttr | 32-bitowy atrybut zmiennoprzecinkowy, którego wartość jest nieujemna |
kernel_type | ::mlir::TFL::LSTMKernelTypeAttr | lstm_kernel_type, którego wartość to mlir::TFL::LSTMKernelType::FULL |
asymmetric_quantize_inputs | ::mlir::BoolAttr | atrybut boolowy |
input_to_input_intermediate | ::mlir::Attr typu | dowolny atrybut typu |
input_to_forget_intermediate | ::mlir::Attr typu | dowolny atrybut typu |
input_to_cell_intermediate | ::mlir::Attr typu | dowolny atrybut typu |
input_to_output_intermediate | ::mlir::Attr typu | dowolny atrybut typu |
effective_hidden_scale_intermediate | ::mlir::Attr typu | dowolny atrybut typu |
Operandy:
Operand | Opis |
---|---|
input | tensor 32-bitowych wartości zmiennoprzecinkowych lub typu QI8 lub QI16 |
input_to_input_weights | tensor dowolnego typu wartości lub żadnego typu |
input_to_forget_weights | tensor 32-bitowych wartości typu float lub QI8 |
input_to_cell_weights | tensor 32-bitowych wartości typu float lub QI8 |
input_to_output_weights | tensor 32-bitowych wartości typu float lub QI8 |
recurrent_to_input_weights | tensor dowolnego typu wartości lub żadnego typu |
recurrent_to_forget_weights | tensor 32-bitowych wartości typu float lub QI8 |
recurrent_to_cell_weights | tensor 32-bitowych wartości typu float lub QI8 |
recurrent_to_output_weights | tensor 32-bitowych wartości typu float lub QI8 |
cell_to_input_weights | tensor dowolnego typu wartości lub żadnego typu |
cell_to_forget_weights | tensor dowolnego typu wartości lub żadnego typu |
cell_to_output_weights | tensor dowolnego typu wartości lub żadnego typu |
input_gate_bias | tensor dowolnego typu wartości lub żadnego typu |
forget_gate_bias | tensor 32-bitowych wartości typu float lub QI32 |
cell_bias | tensor 32-bitowych wartości typu float lub QI32 |
output_gate_bias | tensor 32-bitowych wartości typu float lub QI32 |
projection_weights | tensor dowolnego typu wartości lub żadnego typu |
projection_bias | tensor dowolnego typu wartości lub żadnego typu |
input_activation_state | tensor stanowy |
input_cell_state | tensor stanowy |
input_layer_norm_coefficients | tensor dowolnego typu wartości lub żadnego typu |
forget_layer_norm_coefficients | tensor dowolnego typu wartości lub żadnego typu |
cell_layer_norm_coefficients | tensor dowolnego typu wartości lub żadnego typu |
output_layer_norm_coefficients | tensor dowolnego typu wartości lub żadnego typu |
Wyniki:
Wynik | Opis |
---|---|
output | tensor dowolnego typu wartości |
tfl.matrix_diag
(TFL::MatrixDiagOp)
Zwraca tensor z podaną przekątną i wszystko inne dopełnione zerami.
Biorąc pod uwagę przekątną, zwraca tensor z przekątną i wszystko inne dopełnione zerami. Załóżmy, że przekątna ma k wymiarów [I, J, K, ..., N]
, wówczas wynikiem jest tensor rzędu k+1
o wymiarach [I, J, K, ..., N, N]
gdzie: output[i, j, k, ..., m, n] = 1{m=n} * diagonal[i, j, k, ..., n].
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
diagonal | tensor 32-bitowej liczby zmiennoprzecinkowej lub 8-bitowej liczby całkowitej bez znaku lub 16-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub 8-bitowej liczby całkowitej bez znaku lub typu QUI8, typu QI8 lub wartości typu TFLite quint8 |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowej liczby zmiennoprzecinkowej lub 8-bitowej liczby całkowitej bez znaku lub 16-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub 8-bitowej liczby całkowitej bez znaku lub typu QUI8, typu QI8 lub wartości typu TFLite quint8 |
tfl.matrix_set_diag
(TFL::MatrixSetDiagOp)
Zwraca tensor macierzy wsadowej z nowymi wsadowymi wartościami przekątnej.
Biorąc pod uwagę input
i diagonal
, operacja ta zwraca tensor o tym samym kształcie i wartościach co input
, z wyjątkiem głównej przekątnej najbardziej wewnętrznych macierzy. Zostaną one nadpisane przez wartości w diagonal
.
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
input | tensor 32-bitowej liczby zmiennoprzecinkowej lub 8-bitowej liczby całkowitej bez znaku lub 16-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub 8-bitowej liczby całkowitej bez znaku lub typu QI8 lub typu QI16 lub typu QUI8 lub wartości typu TFLite quint8 |
diagonal | tensor 32-bitowej liczby zmiennoprzecinkowej lub 8-bitowej liczby całkowitej bez znaku lub 16-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub 8-bitowej liczby całkowitej bez znaku lub typu QI8 lub typu QI16 lub typu QUI8 lub wartości typu TFLite quint8 |
Wyniki:
Wynik | Opis |
---|---|
result | tensor 32-bitowej liczby zmiennoprzecinkowej lub 8-bitowej liczby całkowitej bez znaku lub 16-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub 8-bitowej liczby całkowitej bez znaku lub typu QI8 lub typu QI16 lub typu QUI8 lub wartości typu TFLite quint8 |
tfl.max_pool_2d
(TFL::MaxPool2DOp)
Max Pool 2D op
Wykonuje na wejściu maksymalną pulę 2D.
Wejścia: inputs[0]
: wymagane: tensor wejściowy
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflArithmeticCountOpInterface
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
padding | ::mlir::StringAttr | atrybut string, którego wartość to SAME lub VALID |
stride_w | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku |
stride_h | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku |
filter_width | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku |
filter_height | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku |
fused_activation_function | ::mlir::StringAttr | atrybut łańcuchowy, którego wartość to NONE, RELU, RELU_N1_TO_1, RELU6, TANH lub SIGN_BIT |
Operandy:
Operand | Opis |
---|---|
input | tensor 32-bitowego typu float lub typu QUI8, typu QI8, typu QI16 lub wartości typu TFLite quint8 |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowego typu float lub typu QUI8, typu QI8, typu QI16 lub wartości typu TFLite quint8 |
tfl.maximum
(TFL::MaximumOp)
Maksymalny operator
Maksymalne działanie według elementów.
Cechy: ::mlir::OpTrait::TFLRuntimeOpTrait
, AlwaysSpeculatableImplTrait
, Commutative
, QuantizableResult
, ResultsBroadcastableShape
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
lhs | tensor 32-bitowej liczby zmiennoprzecinkowej lub 32/64-bitowej liczby całkowitej bez znaku lub wartości typu QI8, typu QUI8 lub typu QI16 |
rhs | tensor 32-bitowej liczby zmiennoprzecinkowej lub 32/64-bitowej liczby całkowitej bez znaku lub wartości typu QI8, typu QUI8 lub typu QI16 |
Wyniki:
Wynik | Opis |
---|---|
max | tensor 32-bitowej liczby zmiennoprzecinkowej lub 32/64-bitowej liczby całkowitej bez znaku lub wartości typu QI8, typu QUI8 lub typu QI16 |
tfl.mean
(TFL::MeanOp)
Średni operator
Oblicza średnią elementów w wymiarach tensora. Zmniejsza tensor wejściowy wzdłuż wymiarów podanych na osi. O ile keepdims nie ma wartości true, stopień tensora jest zmniejszany o 1 dla każdego wpisu w osi. Jeżeli opcja keepdims ma wartość true, zmniejszone wymiary zostaną zachowane z długością 1.
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
keep_dims | ::mlir::BoolAttr | atrybut boolowy |
Operandy:
Operand | Opis |
---|---|
input | tensor 32-bitowej liczby zmiennoprzecinkowej lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub typu QI8 lub typu QUI8 lub 8-bitowej liczby całkowitej bez znaku lub wartości typu QI16 |
axis | tensor 32-bitowych wartości całkowitych bez znaku |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowej liczby zmiennoprzecinkowej lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub typu QI8 lub typu QUI8 lub 8-bitowej liczby całkowitej bez znaku lub wartości typu QI16 |
tfl.minimum
(TFL::MinimumOp)
Minimalny operator
Minimalna operacja elementarna.
Cechy: ::mlir::OpTrait::TFLRuntimeOpTrait
, AlwaysSpeculatableImplTrait
, Commutative
, QuantizableResult
, ResultsBroadcastableShape
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
lhs | tensor 32-bitowej liczby zmiennoprzecinkowej lub 32/64-bitowej liczby całkowitej bez znaku lub wartości typu QI8, typu QUI8 lub typu QI16 |
rhs | tensor 32-bitowej liczby zmiennoprzecinkowej lub 32/64-bitowej liczby całkowitej bez znaku lub wartości typu QI8, typu QUI8 lub typu QI16 |
Wyniki:
Wynik | Opis |
---|---|
min | tensor 32-bitowej liczby zmiennoprzecinkowej lub 32/64-bitowej liczby całkowitej bez znaku lub wartości typu QI8, typu QUI8 lub typu QI16 |
tfl.mirror_pad
(TFL::MirrorPadOp)
Operator MirrorPada. Wypełnia tensor wartościami lustrzanymi.
Ta operacja wypełnia dane wejściowe wartościami lustrzanymi zgodnie z określonymi dopełnieniami. paddings to tensor liczb całkowitych o kształcie [n, 2], gdzie n jest stopniem wejścia. Dla każdego wymiaru D danych wejściowych dopełnienia[D, 0] wskazują, ile wartości należy dodać przed zawartością danych wejściowych w tym wymiarze, a dopełnienia[D, 1] wskazują, ile wartości należy dodać po zawartości danych wejściowych w tym wymiarze.
Zarówno paddings[D, 0], jak i paddings[D, 1] nie mogą być większe niż input.dim_size(D) (lub input.dim_size(D) - 1), jeśli copy_border ma wartość true (jeśli odpowiednio false).
Wyściełany rozmiar każdego wymiaru D wyniku to:
dopełnienia(D, 0) + input.dim_size(D) + dopełnienia(D, 1)
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
mode | ::mlir::TFL::MirrorPaddingTypeAttr | lustro_pad_enum |
Operandy:
Operand | Opis |
---|---|
input | tensor 32-bitowej liczby zmiennoprzecinkowej lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub 8-bitowej liczby całkowitej bez znaku lub 8-bitowej liczby całkowitej bez znaku lub wartości typu QI8, typu QUI8 lub typu QI16 |
pad | tensor 32-bitowej liczby całkowitej bez znaku lub 64-bitowej wartości całkowitej bez znaku |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowej liczby zmiennoprzecinkowej lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub 8-bitowej liczby całkowitej bez znaku lub 8-bitowej liczby całkowitej bez znaku lub wartości typu QI8, typu QUI8 lub typu QI16 |
tfl.mul
(TFL::MulOp)
Operator mnożenia
Operacja mnożenia elementarnego.
Cechy: ::mlir::OpTrait::TFLRuntimeOpTrait
, AlwaysSpeculatableImplTrait
, Commutative
, QuantizableResult
, ResultsBroadcastableShape
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflArithmeticCountOpInterface
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
fused_activation_function | ::mlir::StringAttr | atrybut łańcuchowy, którego wartość to NONE, RELU, RELU_N1_TO_1, RELU6, TANH lub SIGN_BIT |
Operandy:
Operand | Opis |
---|---|
lhs | tensor 32-bitowej liczby zmiennoprzecinkowej lub 32-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub typu QI8 lub typu QUI8 lub typu QI16 lub 16-bitowej liczby całkowitej bez znaku lub typu zespolonego z 32-bitowymi wartościami elementów zmiennoprzecinkowych |
rhs | tensor 32-bitowej liczby zmiennoprzecinkowej lub 32-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub typu QI8 lub typu QUI8 lub typu QI16 lub 16-bitowej liczby całkowitej bez znaku lub typu zespolonego z 32-bitowymi wartościami elementów zmiennoprzecinkowych |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowej liczby zmiennoprzecinkowej lub 32-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub typu QI8 lub typu QUI8 lub typu QI16 lub 16-bitowej liczby całkowitej bez znaku lub typu zespolonego z 32-bitowymi wartościami elementów zmiennoprzecinkowych |
tfl.multinomial
(TFL::MultinomialOp)
Rysuje próbki z rozkładu kategorycznego.
Wygenerowane wartości będą miały rozkład kategoryczny oparty na logits
lub nieznormalizowanych logarytmicznych prawdopodobieństwach podanych dla wszystkich klas.
Interfejsy: TflRuntimeVerifyOpInterface
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
seed | ::mlir::IntegerAttr | 64-bitowy atrybut liczby całkowitej bez znaku |
seed2 | ::mlir::IntegerAttr | 64-bitowy atrybut liczby całkowitej bez znaku |
Operandy:
Operand | Opis |
---|---|
logits | tensor 32-bitowych wartości zmiennoprzecinkowych |
num_samples | tensor 32-bitowych wartości całkowitych bez znaku |
Wyniki:
Wynik | Opis |
---|---|
out | tensor 32-bitowej liczby całkowitej bez znaku lub 64-bitowej wartości całkowitej bez znaku |
tfl.neg
(TFL::NegOp)
Operator negacji
Oblicza elementarną negację danych wejściowych
Cechy: AlwaysSpeculatableImplTrait
, InferTensorType
, TF::SameOperandsAndResultTypeResolveRef
Interfejsy: ConditionallySpeculatable
, InferShapedTypeOpInterface
, InferTypeOpInterface
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
x | tensor 32-bitowej liczby zmiennoprzecinkowej lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej wartości całkowitej bez znaku |
Wyniki:
Wynik | Opis |
---|---|
y | tensor 32-bitowej liczby zmiennoprzecinkowej lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej wartości całkowitej bez znaku |
tfl.no_value
(TFL::NoValueOp)
Stała reprezentująca brak wartości.
Brak stałej wartości op.
Cechy: AlwaysSpeculatableImplTrait
, ConstantLike
Interfejsy: ConditionallySpeculatable
, InferTypeOpInterface
, NoMemoryEffect (MemoryEffectOpInterface)
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
value | ::mlir::Attrjednostki | atrybut jednostki |
Wyniki:
Wynik | Opis |
---|---|
none_val | żaden typ |
tfl.non_max_suppression_v4
(TFL::NonMaxSuppressionV4Op)
Chciwie wybiera podzbiór obwiedni w malejącej kolejności punktów,
przycinanie skrzynek, które mają wysoki współczynnik przecięcia nad związkiem (IOU), nakładają się na wcześniej wybrane pola. Ramki ograniczające z wynikiem mniejszym niż score_threshold
są usuwane. Ramki ograniczające są dostarczane jako [y1, x1, y2, x2], gdzie (y1, x1) i (y2, x2) są współrzędnymi dowolnej pary przekątnych narożników prostokątów, a współrzędne mogą być podane jako znormalizowane (tzn. leżące w przedział [0, 1]) lub bezwzględny. Należy zauważyć, że ten algorytm jest niezależny od tego, gdzie początek znajduje się w układzie współrzędnych i, bardziej ogólnie, jest niezmienny w stosunku do transformacji ortogonalnych i translacji układu współrzędnych; w ten sposób tłumaczenie lub odbicia układu współrzędnych powodują, że algorytm wybiera te same pola. Wynikiem tej operacji jest zbiór liczb całkowitych indeksowanych w zbiorze wejściowym ramek ograniczających reprezentujących wybrane ramki. Współrzędne ramki ograniczającej odpowiadające wybranym indeksom można następnie uzyskać za pomocą tf.gather operation
. Na przykład: wybrane_indices = tf.image.non_max_suppression_v2(boxy, scores, max_output_size, iou_threshold, score_threshold) wybrane_boxy = tf.gather(boxes, wybrane_indices)
Cechy: AlwaysSpeculatableImplTrait
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
boxes | tensor 32-bitowych wartości zmiennoprzecinkowych |
scores | tensor 32-bitowych wartości zmiennoprzecinkowych |
max_output_size | tensor 32-bitowych wartości całkowitych bez znaku |
iou_threshold | tensor 32-bitowych wartości zmiennoprzecinkowych |
score_threshold | tensor 32-bitowych wartości zmiennoprzecinkowych |
Wyniki:
Wynik | Opis |
---|---|
selected_indices | tensor 32-bitowych wartości całkowitych bez znaku |
valid_outputs | tensor 32-bitowych wartości całkowitych bez znaku |
tfl.non_max_suppression_v5
(TFL::NonMaxSuppressionV5Op)
Chciwie wybiera podzbiór obwiedni w malejącej kolejności punktów,
przycinanie skrzynek, które mają wysoki współczynnik przecięcia nad związkiem (IOU), nakładają się na wcześniej wybrane pola. Ramki ograniczające z wynikiem mniejszym niż score_threshold
są usuwane. Ramki ograniczające są dostarczane jako [y1, x1, y2, x2], gdzie (y1, x1) i (y2, x2) są współrzędnymi dowolnej pary przekątnych narożników prostokątów, a współrzędne mogą być podane jako znormalizowane (tzn. leżące w przedział [0, 1]) lub bezwzględny. Należy zauważyć, że ten algorytm jest niezależny od tego, gdzie początek znajduje się w układzie współrzędnych i, bardziej ogólnie, jest niezmienny w stosunku do transformacji ortogonalnych i translacji układu współrzędnych; w ten sposób tłumaczenie lub odbicia układu współrzędnych powodują, że algorytm wybiera te same pola. Wynikiem tej operacji jest zbiór liczb całkowitych indeksowanych w zbiorze wejściowym ramek ograniczających reprezentujących wybrane ramki. Współrzędne ramki ograniczającej odpowiadające wybranym indeksom można następnie uzyskać za pomocą tf.gather operation
. Na przykład: wybrane_indices = tf.image.non_max_suppression_v2(boxs, scores, max_output_size, iou_threshold, score_threshold) wybrane_boxes = tf.gather(boxes, wybrane_indices) Ta opcja obsługuje również tryb Soft-NMS (z ważeniem Gaussa) (por. Bodla i in. , https://arxiv.org/abs/1704.04503 ), gdzie pola zmniejszają punktację innych nakładających się pól, zamiast bezpośrednio powodować ich przycinanie. Aby włączyć ten tryb Soft-NMS, ustaw parametr soft_nms_sigma
na większy niż 0.
Cechy: AlwaysSpeculatableImplTrait
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
boxes | tensor 32-bitowych wartości zmiennoprzecinkowych |
scores | tensor 32-bitowych wartości zmiennoprzecinkowych |
max_output_size | tensor 32-bitowych wartości całkowitych bez znaku |
iou_threshold | tensor 32-bitowych wartości zmiennoprzecinkowych |
score_threshold | tensor 32-bitowych wartości zmiennoprzecinkowych |
soft_nms_sigma | tensor 32-bitowych wartości zmiennoprzecinkowych |
Wyniki:
Wynik | Opis |
---|---|
selected_indices | tensor 32-bitowych wartości całkowitych bez znaku |
selected_scores | tensor 32-bitowych wartości zmiennoprzecinkowych |
valid_outputs | tensor 32-bitowych wartości całkowitych bez znaku |
tfl.not_equal
(TFL::NotEqualOp)
_Nie równy operator
Elementowa operacja not_equal.
Cechy: ::mlir::OpTrait::TFLRuntimeOpTrait
, AlwaysSpeculatableImplTrait
, Commutative
, ResultsBroadcastableShape
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
lhs | tensor 1-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby zmiennoprzecinkowej lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub wartości typu QUI8 lub QI8 lub TFLite typu quint8 lub TFLite typu string |
rhs | tensor 1-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby zmiennoprzecinkowej lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub wartości typu QUI8 lub QI8 lub TFLite typu quint8 lub TFLite typu string |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 1-bitowych wartości całkowitych bez znaku |
tfl.NumericVerify
(TFL::NumericVerifyOp)
Weryfikuje wartości liczbowe dwóch operandów
Operacja NumericVerify to opcja debugowania służąca do weryfikacji wartości liczbowych dwóch aktywacji. Jest to niestandardowa opcja w TFLite. Jeśli log_if_failed ma wartość true, operacja NumericVerify oblicza statystyki dotyczące różnic między aktywacjami zmiennoprzecinkowymi i skwantowanymi, dzienniki wyjściowe, ustawia różnice w tensorach wyjściowych i zgłasza błąd, jeśli istnieją błędy przekraczające tolerancję. Jeśli log_if_failed = false, to nie przejmuje się błędami.
Cechy: QuantizableResult
, SameOperandsShape
Interfejsy: TflRuntimeVerifyOpInterface
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
tolerance | ::mlir::FloatAttr | 32-bitowy atrybut zmiennoprzecinkowy |
log_if_failed | ::mlir::BoolAttr | atrybut boolowy |
Operandy:
Operand | Opis |
---|---|
input | tensor typu QI8 lub typu QUI8 lub typu QI16 lub 16-bitowy float lub wartości typu TFLite quint8 |
ref | tensor 32-bitowych wartości zmiennoprzecinkowych |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowych wartości zmiennoprzecinkowych |
tfl.one_hot
(TFL::OneHotOp)
Operator OneHot
Zwraca tensor jednego gorącego. Lokalizacje reprezentowane przez indeksy w indices
przyjmują wartość on_value
, podczas gdy wszystkie inne lokalizacje przyjmują wartość off_value
.
Jeśli indices
wejściowe mają rangę N
, wyjście będzie miało rangę N+1
. Nowa oś tworzona jest na axis
wymiaru (domyślnie: nowa oś jest dodawana na końcu).
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
axis | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku |
Operandy:
Operand | Opis |
---|---|
indices | tensor 32-bitowej liczby całkowitej bez znaku lub 64-bitowej wartości całkowitej bez znaku |
depth | tensor 32-bitowych wartości całkowitych bez znaku |
on_value | tensor 32-bitowej liczby zmiennoprzecinkowej lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub 1-bitowej liczby całkowitej bez znaku lub 8-bitowej liczby całkowitej bez znaku lub 8-bitowej wartości całkowitej bez znaku |
off_value | tensor 32-bitowej liczby zmiennoprzecinkowej lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub 1-bitowej liczby całkowitej bez znaku lub 8-bitowej liczby całkowitej bez znaku lub 8-bitowej wartości całkowitej bez znaku |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowej liczby zmiennoprzecinkowej lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub 1-bitowej liczby całkowitej bez znaku lub 8-bitowej liczby całkowitej bez znaku lub 8-bitowej wartości całkowitej bez znaku |
tfl.pack
(TFL::PackOp)
Pakuje listę tensorów wzdłuż wymiaru do jednego tensora
Pakuje listę values_count
tensorów rangi R
do jednego tensora rangi (R+1)
.
Pakuje tensory values_count
w values
do tensora o randze o jeden wyższej niż każdy tensor w values
, pakując je wzdłuż wymiaru axis
.
Biorąc pod uwagę listę tensorów kształtu (A, B, C)
;
jeśli axis == 0
to tensor output
będzie miał postać (N, A, B, C)
. jeśli axis == 1
to tensor output
będzie miał postać (A, N, B, C)
. Itp.
Na przykład:
# '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]]
Jest to przeciwieństwo unpack
.
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
values_count | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku, którego wartość jest dodatnia |
axis | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku |
Operandy:
Operand | Opis |
---|---|
values | variadic tensora wartości dowolnego typu |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowej liczby zmiennoprzecinkowej lub 8-bitowej liczby całkowitej bez znaku lub 16-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub 8-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub typu QI8 lub typu QUI8 lub QI16 typu lub wartości typu TFLite quint8 |
tfl.pad
(TFL::PadOp)
Operator dopełniający
Ta operacja uzupełnia input
zerami zgodnie z określonymi paddings
. paddings
to tensor liczb całkowitych o kształcie [Dn, 2]
, gdzie n jest stopniem input
. Dla każdego wymiaru D input
paddings[D, 0]
wskazuje, ile zer należy dodać przed zawartością danych input
w tym wymiarze, a paddings[D, 1]
wskazuje, ile zer należy dodać po zawartości input
w tym wymiarze.
Wyściełany rozmiar każdego wymiaru D wyniku to:
paddings(D, 0) + input.dim_size(D) + paddings(D, 1)
Na przykład:
# '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]]
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
input | tensor 32-bitowej liczby zmiennoprzecinkowej lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub wartości typu QI8 lub typu QUI8 lub TFLite typu quint8 lub typu QI16 |
padding | tensor 32/64-bitowych wartości całkowitych bez znaku |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowej liczby zmiennoprzecinkowej lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub wartości typu QI8 lub typu QUI8 lub TFLite typu quint8 lub typu QI16 |
tfl.padv2
(TFL::PadV2Op)
Operator dopełniania v2
Ta operacja uzupełnia input
zgodnie z określonymi paddings
i constant_values
. paddings
to tensor liczb całkowitych o kształcie [Dn, 2]
, gdzie n jest stopniem input
. Dla każdego wymiaru D input
paddings[D, 0]
wskazuje, ile zer należy dodać przed zawartością danych input
w tym wymiarze, a paddings[D, 1]
wskazuje, ile zer należy dodać po zawartości input
w tym wymiarze. constant_values
to tensor skalarny tego samego typu co input
, który wskazuje wartość, która ma zostać użyta do wypełnienia danych input
.
Wyściełany rozmiar każdego wymiaru D wyniku to:
paddings(D, 0) + input.dim_size(D) + paddings(D, 1)
Na przykład:
# '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]]
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
input | tensor 32-bitowej liczby zmiennoprzecinkowej lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub 8-bitowej liczby całkowitej bez znaku lub wartości typu QI8, typu QUI8 lub TFLite typu quint8 |
padding | tensor 32/64-bitowych wartości całkowitych bez znaku |
constant_values | tensor 32-bitowej liczby zmiennoprzecinkowej lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub 8-bitowej liczby całkowitej bez znaku lub wartości typu QI8, typu QUI8 lub TFLite typu quint8 |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowej liczby zmiennoprzecinkowej lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub 8-bitowej liczby całkowitej bez znaku lub wartości typu QI8, typu QUI8 lub TFLite typu quint8 |
tfl.poly_call
(TFL::PolyCallOp)
Połączenie poli
Mieć wiele ciał funkcji dla tego samego obliczenia. Pozwala to kompilatorowi/interpreterowi programu wybrać jedną z dostępnych opcji wykonania programu, w oparciu o tę, która jest najbardziej odpowiednia dla docelowego backendu.
wejście: lista tensorów wejściowych, których typy to T. wyjście: lista tensorów wyjściowych, których typy to T.
wywołanie: wiele regionów, z których każdy zawiera te same obliczenia semantyczne, ale w różnych formach.
Cechy: SingleBlockImplicitTerminator<YieldOp>
, SingleBlock
Interfejsy: RegionBranchOpInterface
Operandy:
Operand | Opis |
---|---|
input | variadic tensora wartości dowolnego typu |
Wyniki:
Wynik | Opis |
---|---|
output | variadic tensora wartości dowolnego typu |
tfl.pow
(TFL::PowOp)
Operator mocy
Elementarne działanie mocy.
Cechy: ::mlir::OpTrait::TFLRuntimeOpTrait
, AlwaysSpeculatableImplTrait
, ResultsBroadcastableShape
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
lhs | tensor 32-bitowych wartości zmiennoprzecinkowych lub 32-bitowych wartości całkowitych bez znaku |
rhs | tensor 32-bitowych wartości zmiennoprzecinkowych lub 32-bitowych wartości całkowitych bez znaku |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowych wartości zmiennoprzecinkowych lub 32-bitowych wartości całkowitych bez znaku |
tfl.prelu
(TFL::PReluOp)
Sparametryzowany operator Relu
Sparametryzowany operator Relu x -> x >= 0 ? x : (alfa * x) gdzie alfa jest tensorem, który można trenować. input i alfa powinny mieć ten sam rozmiar co input lub nadawać się do transmisji.
Cechy: ::mlir::OpTrait::TFLRuntimeOpTrait
, AlwaysSpeculatableImplTrait
, QuantizableResult
, ResultsBroadcastableShape
, quant::AffineOpCoefficient<-1, 1>
Interfejsy: AffineQuantizedOpInterface
, ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
input | tensor 32-bitowego typu Float lub Qi8 lub wartości typu Qui8 lub Tflite Quint8 |
alpha | tensor 32-bitowego typu Float lub Qi8 lub wartości typu Qui8 lub Tflite Quint8 |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowego typu Float lub Qi8 lub wartości typu Qui8 lub Tflite Quint8 |
tfl.pseudo_const
(tfl :: constop)
Stały pseudo op.
Reprezentuje stałą wartość w dialekcie Tensorflow Lite. To nie jest faktyczna operacja i zamiast tego zostanie obniżona do buforowania.
OP może mieć ten sam typ atrybutów, co TF.CONST (np. Nieprawte atrybuty TF są dozwolone).
Cechy: AlwaysSpeculatableImplTrait
, ConstantLike
, FirstAttrDerivedResultType
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
value | :: mlir :: elementsAttr | Stały atrybut wektor/tensor |
Wyniki:
Wynik | Opis |
---|---|
output | tensor dowolnego typu wartości |
tfl.pseudo_qconst
(tfl :: qConstop)
Kwantyzowane stałe pseudo op
Reprezentuje kwantyczną stałą wartość w dialekcie Tensorflow Lite. To nie jest faktyczna operacja i zamiast tego zostanie obniżona do buforowania. Parametry kwantyzacji są przechowywane jako atrybut typu w tej stałej.
Cechy: AlwaysSpeculatableImplTrait
, FirstAttrDerivedResultType
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
qtype | :: mlir :: typeattr | Atrybut typu tensor |
value | :: mlir :: elementsAttr | Stały atrybut wektor/tensor |
Wyniki:
Wynik | Opis |
---|---|
output | Tensor typu Qui8 lub typu Qi8 lub typu Qi16 lub wartości typu Qui16 lub wartości typu quint8 Tflite |
tfl.pseudo_sparse_const
(tfl :: Sparseconstop)
Rzadkie stałe pseudo op.
Reprezentuje rzadką stałą wartość w dialekcie Tensorflow Lite. To nie jest faktyczna operacja i zamiast tego zostanie obniżona do buforowania.
Cechy: AlwaysSpeculatableImplTrait
, FirstAttrDerivedResultType
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
value | :: mlir :: elementsAttr | Stały atrybut wektor/tensor |
s_param | :: mlir :: tfl :: RiROTityParameterAttr | Parametr rzadkości. |
compressed_data | :: mlir :: elementsAttr | Stały atrybut wektor/tensor |
Wyniki:
Wynik | Opis |
---|---|
output | tensor dowolnego typu wartości |
tfl.pseudo_sparse_qconst
(tfl :: steargeqConstop)
Rzadkie kwantyzowane stałe pseudo op
Reprezentuje rzadką kwantyczną wartość stałą w dialekcie Tensorflow Lite. To nie jest faktyczna operacja i zamiast tego zostanie obniżona do buforowania. Parametry kwantyzacji są przechowywane jako atrybut typu w tej stałej.
Cechy: AlwaysSpeculatableImplTrait
, FirstAttrDerivedResultType
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
qtype | :: mlir :: typeattr | Atrybut typu tensor |
value | :: mlir :: elementsAttr | Stały atrybut wektor/tensor |
s_param | :: mlir :: tfl :: RiROTityParameterAttr | Parametr rzadkości. |
compressed_data | :: mlir :: elementsAttr | Stały atrybut wektor/tensor |
Wyniki:
Wynik | Opis |
---|---|
output | Tensor typu Qui8 lub typu Qi8 lub typu Qi16 lub wartości typu Qui16 lub wartości typu quint8 Tflite |
tfl.quantize
(tfl :: kwantizeop)
Kwantyza operatora
Przekształca tensory zmiennoprzecinkowe na kwantyzowane tensory całkowite zgodnie z parametrami kwantyzacji zdefiniowanymi w atrybucie typu.
Cechy: FirstAttrDerivedResultType
, SameOperandsAndResultShape
Interfejsy: NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
qtype | :: mlir :: typeattr | Atrybut typu tensor |
Operandy:
Operand | Opis |
---|---|
input | tensor 32-bitowego typu Float lub Qi4 lub typu Qi8 lub typu Qui8 lub typu Qi16 lub wartości typu Quint8 Tflite |
Wyniki:
Wynik | Opis |
---|---|
output | Tensor typu Qi4 lub typu Qi8 lub typu Qui8 lub typu Qi16 lub wartości typu Quint8 Tflite |
tfl.random_standard_normal
(tfl :: Randomstandnormalop)
Wyświetla losowe wartości z rozkładu normalnego.
Wygenerowane wartości będą miały średnią 0 i odchylenie standardowe 1.
Interfejsy: TflRuntimeVerifyOpInterface
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
seed | ::mlir::IntegerAttr | 64-bitowy atrybut liczb całkowitych |
seed2 | ::mlir::IntegerAttr | 64-bitowy atrybut liczb całkowitych |
Operandy:
Operand | Opis |
---|---|
shape | tensor 32-bitowych wartości całkowitych bez znaku |
Wyniki:
Wynik | Opis |
---|---|
out | tensor 32-bitowych wartości zmiennoprzecinkowych |
tfl.random_uniform
(tfl :: land ImpandUmiform)
Wyświetla losowe wartości z jednolitego rozkładu.
Wygenerowane wartości są zgodne z jednolitym rozkładem w zakresie [0, 1)
. Dolna granica 0 jest zawarta w zakresie, podczas gdy górna granica 1 jest wykluczona.
Interfejsy: TflRuntimeVerifyOpInterface
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
seed | ::mlir::IntegerAttr | 64-bitowy atrybut liczb całkowitych |
seed2 | ::mlir::IntegerAttr | 64-bitowy atrybut liczb całkowitych |
Operandy:
Operand | Opis |
---|---|
shape | tensor 32-bitowych wartości całkowitych bez znaku |
Wyniki:
Wynik | Opis |
---|---|
out | tensor 32-bitowych wartości zmiennoprzecinkowych |
tfl.range
(TFL :: RangeP)
Operator zasięgu
Zwraca tensor 1D zdefiniowany przez sekwencję od start
do limit
za pomocą danej delta
.
Cechy: AlwaysSpeculatableImplTrait
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
start | tensor 32-bitowej liczby całkowitej lub 32-bitowej pływaku lub 64-bitowych wartości liczb całkowitych |
limit | tensor 32-bitowej liczby całkowitej lub 32-bitowej pływaku lub 64-bitowych wartości liczb całkowitych |
delta | tensor 32-bitowej liczby całkowitej lub 32-bitowej pływaku lub 64-bitowych wartości liczb całkowitych |
Wyniki:
Wynik | Opis |
---|---|
result | tensor 32-bitowej liczby całkowitej lub 32-bitowej pływaku lub 64-bitowych wartości liczb całkowitych |
tfl.rank
(tfl :: rankop)
Operator rangi.
Zwraca stopień tensora.
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
input | tensor dowolnego typu wartości |
Wyniki:
Wynik | Opis |
---|---|
output | tensor dowolnego typu liczb całkowitych |
tfl.read_variable
(tfl :: readvarableop)
Odczytuje wartość zmienną.
Odczyt dane zmiennych zidentyfikowane przez „Resource_id”.
Interfejsy: TflRuntimeVerifyOpInterface
Operandy:
Operand | Opis |
---|---|
resource_id | tensor wartości zasobów |
Wyniki:
Wynik | Opis |
---|---|
result | tensor 32-bitowej liczby zmiennoprzecinkowej lub 64-bitowej liczby zmiennoprzecinkowej lub 1-bitowej liczby całkowitej bez znaku lub 8-bitowej liczby całkowitej bez znaku lub 8-bitowej liczby całkowitej bez znaku lub typu QI8 lub typu QUI8 lub 32-bitowej liczby całkowitej bez znaku lub 64-bitowej liczby całkowitej bez znaku lub typu QI16 lub typ złożony z 32-bitowymi elementami zmiennoprzecinkowymi lub typ złożony z 64-bitowymi wartościami elementów zmiennoprzecinkowych |
tfl.real
(tfl :: realop)
Zwraca prawdziwą część złożonej liczby.
Biorąc pod uwagę input
tensora liczb złożonych, operacja ta zwraca tensor typu float
, który jest prawdziwą częścią każdego elementu na input
. Wszystkie elementy w input
muszą być złożonymi liczbami formularza \(a + bj\), gdzie A jest prawdziwą częścią zwróconą przez tę operację, a B jest częścią wyobrażoną.
Cechy: AlwaysSpeculatableImplTrait
, SameOperandsAndResultShape
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
input | tensor typu złożonego z 32-bitowymi elementami zmiennoprzecinkowymi lub typu złożonego z 64-bitowymi wartościami elementów zmiennoprzecinkowych |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowych lub 64-bitowych wartości zmiennoprzecinkowych |
tfl.reduce_all
(tfl :: reduceallop)
Oblicza „logiczne i” elementów w różnych wymiarach tensora.
Zmniejsza input
wzdłuż wymiarów podanych w axis
. Chyba że keep_dims
nie jest prawdziwy, ranga tensor jest zmniejszona o 1 dla każdego wpisu w axis
. Jeśli keep_dims
jest prawdziwy, zmniejszone wymiary są zachowywane z długością 1.
Cechy: AlwaysSpeculatableImplTrait
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
keep_dims | ::mlir::BoolAttr | atrybut boolowy |
Operandy:
Operand | Opis |
---|---|
input | tensor 1-bitowych wartości liczb całkowitych |
reduction_indices | tensor 32-bitowych wartości całkowitych bez znaku |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 1-bitowych wartości liczb całkowitych |
tfl.reduce_any
(tfl :: reduceaneop)
Oblicza „logiczne lub” elementów w różnych wymiarach tensora.
Zmniejsza input
wzdłuż wymiarów podanych w axis
. Chyba że keep_dims
nie jest prawdziwy, ranga tensor jest zmniejszona o 1 dla każdego wpisu w axis
. Jeśli keep_dims
jest prawdziwy, zmniejszone wymiary są zachowywane z długością 1.
Cechy: AlwaysSpeculatableImplTrait
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
keep_dims | ::mlir::BoolAttr | atrybut boolowy |
Operandy:
Operand | Opis |
---|---|
input | tensor 1-bitowych wartości liczb całkowitych |
reduction_indices | tensor 32-bitowych wartości całkowitych bez znaku |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 1-bitowych wartości liczb całkowitych |
tfl.reduce_max
(tfl :: reduceMaxop)
Operator maksymalnego redukcji
Oblicza maksymalną redukcję wzdłuż określonych osi
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
keep_dims | ::mlir::BoolAttr | atrybut boolowy |
Operandy:
Operand | Opis |
---|---|
input | tensor 32-bitowego pływaka lub 32-bitowej liczby całkowitej lub 64-bitowej liczby całkowitej lub typu Qi8 lub typu Qui8 lub Tflite Quint8 lub wartości typu Qi16 |
axes | tensor 32-bitowych wartości całkowitych bez znaku |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowego pływaka lub 32-bitowej liczby całkowitej lub 64-bitowej liczby całkowitej lub typu Qi8 lub typu Qui8 lub Tflite Quint8 lub wartości typu Qi16 |
tfl.reduce_min
(tfl :: reduceminop)
Operator redukcji min
Oblicza redukcję minuty wzdłuż określonych osi
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
keep_dims | ::mlir::BoolAttr | atrybut boolowy |
Operandy:
Operand | Opis |
---|---|
input | tensor 32-bitowego pływaka lub 32-bitowej liczby całkowitej lub 64-bitowej liczby całkowitej lub typu Qi8 lub typu Qui8 lub Tflite Quint8 lub wartości typu Qi16 |
axes | tensor 32-bitowych wartości całkowitych bez znaku |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowego pływaka lub 32-bitowej liczby całkowitej lub 64-bitowej liczby całkowitej lub typu Qi8 lub typu Qui8 lub Tflite Quint8 lub wartości typu Qi16 |
tfl.reduce_prod
(tfl :: redukujprodop)
Operator redukcji produkcji
Oblicza produkt wzdłuż określonych osi
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
keep_dims | ::mlir::BoolAttr | atrybut boolowy |
Operands:
Operand | Opis |
---|---|
input | tensor 32-bitowego pływaka lub 32-bitowej liczby całkowitej lub 64-bitowej liczby całkowitej lub typu Qi8 lub typu Qui8 lub Tflite Quint8 lub wartości typu Qi16 |
axes | tensor 32-bitowych wartości całkowitych bez znaku |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowego pływaka lub 32-bitowej liczby całkowitej lub 64-bitowej liczby całkowitej lub typu Qi8 lub typu Qui8 lub Tflite Quint8 lub wartości typu Qi16 |
tfl.relu
(tfl :: reluop)
Operator relU
Element -Wise operator X -> Max (0, x)
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
, SameOperandsAndResultShape
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operands:
Operand | Opis |
---|---|
x | tensor 32-bitowego typu Float lub Qui8 lub wartości typu Qi8 lub typu Qi16 |
Wyniki:
Wynik | Opis |
---|---|
y | tensor 32-bitowego typu Float lub Qui8 lub wartości typu Qi8 lub typu Qi16 |
tfl.relu6
(tfl :: relu6op)
Operator RELU6
Element -Wise Operator X -> Max (0, min (6, x))
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
, SameOperandsAndResultShape
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operands:
Operand | Opis |
---|---|
x | tensor wartości 32-bitowych typu Float lub Qui8 lub typu Qi8 |
Wyniki:
Wynik | Opis |
---|---|
y | tensor wartości 32-bitowych typu Float lub Qui8 lub typu Qi8 |
tfl.relu_0_to_1
(tfl :: relu0to1op)
Operator RELU0TO1
Element -Wise operator relU0to1 x -> max (0, min (1, x))
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
, SameOperandsAndResultShape
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operands:
Operand | Opis |
---|---|
x | tensor wartości 32-bitowych typu Float lub Qui8 lub typu Qi8 |
Wyniki:
Wynik | Opis |
---|---|
y | tensor wartości 32-bitowych typu Float lub Qui8 lub typu Qi8 |
tfl.relu_n1_to_1
(tfl :: relu1op)
Operator RELU1
Element-Wise Operator X-> Max (-1, min (1, x))
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
, SameOperandsAndResultShape
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operands:
Operand | Opis |
---|---|
x | tensor wartości 32-bitowych typu Float lub Qui8 lub typu Qi8 |
Wyniki:
Wynik | Opis |
---|---|
y | tensor wartości 32-bitowych typu Float lub Qui8 lub typu Qi8 |
tfl.reshape
(tfl :: reshapeop)
Operator przekształcenia
Wytwarza tensor o tych samych wartościach, ale inny kształt statyczny zdefiniowany przez typ wyjściowy.
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, InferTypeOpInterface
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operands:
Operand | Opis |
---|---|
input | tensor dowolnego typu wartości |
shape | tensor 32-bitowych wartości całkowitych bez znaku |
Wyniki:
Wynik | Opis |
---|---|
output | tensor dowolnego typu wartości |
tfl.resize_bilinear
(tfl :: reseBilinearop)
Zmiana resizebilinear op
Zmień rozmiar images
na size
za pomocą interpolacji dwustronnej.
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
align_corners | ::mlir::BoolAttr | atrybut boolowy |
half_pixel_centers | ::mlir::BoolAttr | atrybut boolowy |
Operands:
Operand | Opis |
---|---|
input | tensor 32-bitowego typu Float lub Tflite Quint8 lub typu Qui8 lub typu Qi8 lub wartości typu Qi16 |
size | tensor 32-bitowych wartości całkowitych bez znaku |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowego typu Float lub Tflite Quint8 lub typu Qui8 lub typu Qi8 lub wartości typu Qi16 |
tfl.resize_nearest_neighbor
(tfl :: resizenearestneighborop)
Resizeenearestneighbor op
Zmień rozmiar images
na size
za pomocą interpolacji najbliższych sąsiadów.
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
align_corners | ::mlir::BoolAttr | atrybut boolowy |
half_pixel_centers | ::mlir::BoolAttr | atrybut boolowy |
Operands:
Operand | Opis |
---|---|
input | tensor 32-bitowego typu Float lub Tflite Quint8 lub typu Qui8 lub typu Qi8 lub wartości typu Qi16 |
size | tensor 32-bitowych wartości całkowitych bez znaku |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowego typu Float lub Tflite Quint8 lub typu Qui8 lub typu Qi8 lub wartości typu Qi16 |
tfl.reverse_sequence
(tfl :: reversesequenceop)
Odwraca plastry o zmiennej długości.
Ten OP najpierw przecina input
wzdłuż wymiaru batch_dim
i dla każdego plastra i
odwraca pierwsze elementy seq_lengths[i]
wzdłuż wymiaru seq_dim
.
Elementy seq_lengths
muszą być przestrzegane seq_lengths[i] <= input.dims[seq_dim]
, a seq_lengths
muszą być wektorem długości input.dims[batch_dim]
.
Wyjście wyjściowe i
wzdłuż wymiaru batch_dim
jest następnie podawane przez pokrój wejściowy i
, z pierwszymi seq_lengths[i]
wzdłuż wymiaru seq_dim
.
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
seq_dim | ::mlir::IntegerAttr | 32-bitowy atrybut liczb całkowitych, którego wartość jest nie caska |
batch_dim | ::mlir::IntegerAttr | 32-bitowy atrybut liczb całkowitych, którego wartość jest nie caska |
Operands:
Operand | Opis |
---|---|
input | tensor 32-bitowego pływaka lub 32-bitowej liczby całkowitej lub 64-bitowej liczby całkowitej lub typu Qi16 lub typu Qui8 lub wartości typu Quint8 Tflite Quint8 |
seq_lengths | tensor 32/64-bitowych wartości całkowitych bez znaku |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowego pływaka lub 32-bitowej liczby całkowitej lub 64-bitowej liczby całkowitej lub typu Qi16 lub typu Qui8 lub wartości typu Quint8 Tflite Quint8 |
tfl.reverse_v2
(tfl :: reversev2op)
Operator reversev2
Odwraca określone wymiary tensora.
Biorąc pod uwagę tensor i oś tensor INT32/INT64 reprezentująca zestaw wymiarów tensor do odwrócenia. Ta operacja odwraca każdy wymiar i, dla którego istnieje oś st [j] == i.
Args: Tensor: Tensor. Musi być jednym z następujących typów: uint8, int8, int16, int32, int64, float32, bool do 8-d.
Oś: tensor. Musi być jednym z następujących typów: INT32, INT64. z tylko 1 elementem, który jest wskaźnikiem osi. TODO: Dodaj obsługę wielu elementów.
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operands:
Operand | Opis |
---|---|
input | tensor 32-bitowego pływaka lub 8-bitowy niepodpisany liczba całkowita lub 16-bitowa liczba całkowita lub 32-bitowa liczba całkowita lub 64-bitowa liczba całkowita lub typ Qi16 lub typ Qui8 lub typ Qi8 lub Tflite Quint8 lub 1-bitowe wartości liczby całkowitej |
axis | tensor 32-bitowych wartości całkowitych bez znaku |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowego pływaka lub 8-bitowy niepodpisany liczba całkowita lub 16-bitowa liczba całkowita lub 32-bitowa liczba całkowita lub 64-bitowa liczba całkowita lub typ Qi16 lub typ Qui8 lub typ Qi8 lub Tflite Quint8 lub 1-bitowe wartości liczby całkowitej |
tfl.rfft2d
(tfl :: rfft2dop)
2D rzeczywistą szybką transformację Fouriera.
Oblicza 2-wymiarową dyskretną transformację Fouriera sygnału według wartości rzeczywistej w wysokości 2 wymiarów input
.
Ponieważ DFT rzeczywistego output
jest hermitańsko-symetryczna, RFFT2D
zwraca jedynie unikalne elementy FFT_LOGNE fft_length / 2
fft_length / 2 + 1
warunki.
Wzdłuż każdej osi RFFT2D
jest obliczany na, jeśli fft_length
jest mniejszy niż odpowiedni wymiar input
, wymiar jest przycięty. Jeśli jest większy, wymiar jest wyściełany zerami.
Cechy: AlwaysSpeculatableImplTrait
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
input | tensor 32-bitowych wartości zmiennoprzecinkowych |
fft_length | tensor 32-bitowych wartości całkowitych bez znaku |
Wyniki:
Wynik | Opis |
---|---|
output | tensor typu złożonego z 32-bitowymi wartościami elementów zmiennoprzecinkowych |
tfl.right_shift
(tfl :: rightshiftop)
PRAWY Operator zmiany
ElementWise oblicza przesunięcie Bitwise lhs
przez rhs
.
Cechy: AlwaysSpeculatableImplTrait
, SameOperandsAndResultElementType
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operands:
Operand | Opis |
---|---|
lhs | tensor 8-bitowej liczby całkowitej bez znaku lub 8-bitowej liczby całkowitej bez znaku lub 16-bitowej liczby całkowitej bez znaku lub 16-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 32-bitowej wartości całkowitej bez znaku |
rhs | tensor 8-bitowej liczby całkowitej bez znaku lub 8-bitowej liczby całkowitej bez znaku lub 16-bitowej liczby całkowitej bez znaku lub 16-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 32-bitowej wartości całkowitej bez znaku |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 8-bitowej liczby całkowitej bez znaku lub 8-bitowej liczby całkowitej bez znaku lub 16-bitowej liczby całkowitej bez znaku lub 16-bitowej liczby całkowitej bez znaku lub 32-bitowej liczby całkowitej bez znaku lub 32-bitowej wartości całkowitej bez znaku |
tfl.round
(tfl :: Roundop)
Okrągły operator
Okrąża wartości tensora do najbliższej liczby całkowitej, pod względem elementu.
Cechy: AlwaysSpeculatableImplTrait
, InferTensorType
, TF::SameOperandsAndResultTypeResolveRef
Interfejsy: ConditionallySpeculatable
, InferShapedTypeOpInterface
, InferTypeOpInterface
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operands:
Operand | Opis |
---|---|
x | tensor 32-bitowych wartości zmiennoprzecinkowych |
Wyniki:
Wynik | Opis |
---|---|
y | tensor 32-bitowych wartości zmiennoprzecinkowych |
tfl.rsqrt
(tfl :: rsqrtop)
Wzajemne operatora pierwiastków kwadratowych
Oblicza elementowy odwrotny pierwiastek kwadratowy wejścia
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
, SameOperandsAndResultShape
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operands:
Operand | Opis |
---|---|
x | tensor wartości 32-bitowej lub wartości typu qi8 lub typu qi16 |
Wyniki:
Wynik | Opis |
---|---|
y | tensor wartości 32-bitowej lub wartości typu qi8 lub typu qi16 |
tfl.scatter_nd
(tfl :: scatterndop)
_ Operator ND
updates
rozproszenia w nowym tensor zgodnie z indices
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operands:
Operand | Opis |
---|---|
indices | tensor 32-bitowych wartości całkowitych bez znaku |
updates | tensor 32-bitowego pływaka lub 8-bitowej liczby całkowitej lub 64-bitowej liczby całkowitej lub 32-bitowej liczby całkowitej lub 8-bitowej niepodpisanej liczb całkowity |
shape | 1d tensor dowolnego typu wartości |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowego pływaka lub 8-bitowej liczby całkowitej lub 64-bitowej liczby całkowitej lub 32-bitowej liczby całkowitej lub 8-bitowej niepodpisanej liczb całkowity |
tfl.segment_sum
(tfl :: segmentsumop)
Operator segmentów
Oblicza sumę wzdłuż segmentów tensora.
Cechy: AlwaysSpeculatableImplTrait
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operands:
Operand | Opis |
---|---|
input | tensor 32-bitowych wartości zmiennoprzecinkowych lub 32-bitowych wartości całkowitych bez znaku |
segment_ids | tensor 32-bitowych wartości całkowitych bez znaku |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowych wartości zmiennoprzecinkowych lub 32-bitowych wartości całkowitych bez znaku |
tfl.select
(tfl :: selectop)
Wybierz operatora
Wybierz wartości „x”, jeśli odpowiednia wartość „warunku” jest prawdziwa lub wartość „y”, jeśli fałsz. Istnieją prawidłowe rozmiary wprowadzania stanu:
- Albo ten sam kształt (w którym to przypadku wybrane jest elementWise), lub
- Warunek musi być ranking 1 i pasował do pierwszego wymiaru.
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operands:
Operand | Opis |
---|---|
condition | tensor 1-bitowych wartości liczb całkowitych |
x | tensor 32-bitowej liczby liczbowej liczby całkowitej lub 1-bitowej lub 8-bitowej liczby całkowitej lub 16-bitowej liczby całkowitej lub 32-bitowej liczby całkowitej lub 64-bitowej liczby całkowitej lub 32-bitowej niepodpisanej liczbie całkowitej lub typu Qi8 lub QII8 lub QI16 Typ lub wartości typu Quint8 Tflite |
y | tensor 32-bitowej liczby liczbowej liczby całkowitej lub 1-bitowej lub 8-bitowej liczby całkowitej lub 16-bitowej liczby całkowitej lub 32-bitowej liczby całkowitej lub 64-bitowej liczby całkowitej lub 32-bitowej niepodpisanej liczbie całkowitej lub typu Qi8 lub QII8 lub QI16 Typ lub wartości typu Quint8 Tflite |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowej liczby liczbowej liczby całkowitej lub 1-bitowej lub 8-bitowej liczby całkowitej lub 16-bitowej liczby całkowitej lub 32-bitowej liczby całkowitej lub 64-bitowej liczby całkowitej lub 32-bitowej niepodpisanej liczbie całkowitej lub typu Qi8 lub QII8 lub QI16 Typ lub wartości typu Quint8 Tflite |
tfl.select_v2
(tfl :: selectv2op)
Operator SelectV2
Wybierz wartości „x”, jeśli odpowiednia wartość „warunku” jest prawdziwa lub wartość „y”, jeśli fałsz. Istnieją prawidłowe rozmiary wprowadzania stanu:
- Albo ten sam kształt (w którym to przypadku wybrane jest elementWise), lub
- Nadawane kształty między „warunkiem”, „x” i „y”.
Cechy: ::mlir::OpTrait::TFLRuntimeOpTrait
, AlwaysSpeculatableImplTrait
, QuantizableResult
, ResultsBroadcastableShape
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operands:
Operand | Opis |
---|---|
condition | tensor 1-bitowych wartości liczb całkowitych |
x | tensor 32-bitowej liczby liczbowej liczby całkowitej lub 1-bitowej lub 8-bitowej liczby całkowitej lub 16-bitowej liczby całkowitej lub 32-bitowej liczby całkowitej lub 64-bitowej liczby całkowitej lub 32-bitowej niepodpisanej liczbie całkowitej lub typu Qi8 lub QII8 lub QI16 Typ lub wartości typu Quint8 Tflite |
y | tensor 32-bitowej liczby liczbowej liczby całkowitej lub 1-bitowej lub 8-bitowej liczby całkowitej lub 16-bitowej liczby całkowitej lub 32-bitowej liczby całkowitej lub 64-bitowej liczby całkowitej lub 32-bitowej niepodpisanej liczbie całkowitej lub typu Qi8 lub QII8 lub QI16 Typ lub wartości typu Quint8 Tflite |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowej liczby liczbowej liczby całkowitej lub 1-bitowej lub 8-bitowej liczby całkowitej lub 16-bitowej liczby całkowitej lub 32-bitowej liczby całkowitej lub 64-bitowej liczby całkowitej lub 32-bitowej niepodpisanej liczbie całkowitej lub typu Qi8 lub QII8 lub QI16 Typ lub wartości typu Quint8 Tflite |
tfl.shape
(tfl :: Shapeop)
Operator kształtu
Zwraca kształt tensora.
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
out_type | ::mlir::Atrybut | atrybut pochodny |
Operandy:
Operand | Opis |
---|---|
input | tensor dowolnego typu wartości |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowej liczby całkowitej lub 64-bitowej wartości liczb całkowitych |
tfl.sign
(tfl :: signop)
Operacja podpisu
Zwraca nan, jeśli x to nan, 0, jeśli x to 0, -1 Jeśli x <0 i 1, jeśli x> 0.
Cechy: AlwaysSpeculatableImplTrait
, SameOperandsAndResultElementType
, SameOperandsAndResultShape
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operands:
Operand | Opis |
---|---|
x | tensor 32-bitowych pływaków lub 64-bitowych lub 32-bitowych wartości liczb całkowitych |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowych pływaków lub 64-bitowych lub 32-bitowych wartości liczb całkowitych |
tfl.sin
(tfl :: sinop)
Operator sinusoidalny
Oblicza sinus pod względem elementów wejściowych
Cechy: AlwaysSpeculatableImplTrait
, InferTensorType
, TF::SameOperandsAndResultTypeResolveRef
Interfejsy: ConditionallySpeculatable
, InferShapedTypeOpInterface
, InferTypeOpInterface
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operands:
Operand | Opis |
---|---|
x | tensor 32-bitowych wartości zmiennoprzecinkowych |
Wyniki:
Wynik | Opis |
---|---|
y | tensor 32-bitowych wartości zmiennoprzecinkowych |
tfl.slice
(tfl :: sliceop)
Zwróć plasterek z „wejścia”.
Tensor wyjściowy jest tensor o wymiarach opisanych przez „rozmiar”, którego wartości są wyodrębnione z „wejścia”, zaczynając od przesunięć w „początek”.
begin
jest oparty na zero; size
jest jeden. Jeśli rozmiar [i] wynosi -1, wszystkie pozostałe elementy wymiaru I są zawarte w plasterze. Innymi słowy, jest to równoważne ustawienie: rozmiar [i] = input.dim_size (i) - początek [i]
Wymagania : 0 <= początek [i] <= początek [i] + rozmiar [i] <= di dla i w [0, n)
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operands:
Operand | Opis |
---|---|
input | tensor 32-bitowej pływakowej lub 32-bitowej liczby całkowitej lub 64-bitowej liczby całkowitej lub 8-bitowej liczby całkowitej lub 8-bitowej niezgonowanej liczby całkowitej lub 32-bitowej niezgonowanej liczby całkowity Typ Qui8 lub wartości typu Quint8 lub wartości Qi16 |
begin | tensor 32/64-bitowych wartości całkowitych bez znaku |
size | tensor 32/64-bitowych wartości całkowitych bez znaku |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowej pływakowej lub 32-bitowej liczby całkowitej lub 64-bitowej liczby całkowitej lub 8-bitowej liczby całkowitej lub 8-bitowej niezgonowanej liczby całkowitej lub 32-bitowej niezgonowanej liczby całkowity Typ Qui8 lub wartości typu Quint8 lub wartości Qi16 |
tfl.softmax
(tfl :: softmaxop)
Operator Softmax
Oblicza aktywacje miękka z elementami z następującym wzorem
exp (wejście) / tf.rereduce_sum (exp (input * beta), DIM)
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
, SameOperandsAndResultShape
Interfejsy: ConditionallySpeculatable
, FixedOutputRangeInterface
, NoMemoryEffect (MemoryEffectOpInterface)
, TflArithmeticCountOpInterface
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
beta | ::mlir::FloatAttr | 32-bitowy atrybut float |
Operands:
Operand | Opis |
---|---|
input | tensor 32-bitowego typu Float lub Qi8 lub typu Qui8 lub Tflite Quint8 lub wartości typu Qi16 |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowego typu Float lub Qi8 lub typu Qui8 lub Tflite Quint8 lub wartości typu Qi16 |
tfl.space_to_batch_nd
(tfl :: spacetobatchndop)
Operator SpacetObatchnd
Ta operacja przekształca wymiary przestrzeni w wymiar „partii” 0
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operands:
Operand | Opis |
---|---|
input | tensor 32-bitowego pływaka lub 32-bitowej liczby całkowitej lub 64-bitowej liczby całkowitej lub typu Qi8 lub typu Qui8 lub Tflite Quint8 lub wartości typu Qi16 |
block_shape | tensor 32-bitowych wartości całkowitych bez znaku |
paddings | tensor 32-bitowych wartości całkowitych bez znaku |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowego pływaka lub 32-bitowej liczby całkowitej lub 64-bitowej liczby całkowitej lub typu Qi8 lub typu Qui8 lub Tflite Quint8 lub wartości typu Qi16 |
tfl.space_to_depth
(tfl :: spacetodepthop)
Operator spacetodepth
Zatrudnia bloki danych przestrzennych na głębokość. Mówiąc dokładniej, ten OP przedstawia kopię tensora wejściowego, w którym wartości z wymiarów height
i width
są przenoszone do wymiaru depth
. block_size
wskazuje rozmiar bloku wejściowego.
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
block_size | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku, którego wartość jest dodatnia |
Operands:
Operand | Opis |
---|---|
input | tensor 32-bitowego pływaka lub 32-bitowej liczby całkowitej lub 64-bitowej liczb całkowitych lub typu Qi8 lub typu Qui8 lub wartości typu Quint8 Tflite Quint8 |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowego pływaka lub 32-bitowej liczby całkowitej lub 64-bitowej liczb całkowitych lub typu Qi8 lub typu Qui8 lub wartości typu Quint8 Tflite Quint8 |
tfl.sparse_to_dense
(tfl :: sparsetodenseop)
Przekształca rzadką reprezentację w gęsty tensor.
Buduje tablicę dense
z kształtem 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]
Wszystkie pozostałe wartości w dense
są ustawione na default_value
. Jeśli sparse_values
są skalarne, wszystkie rzadkie wskaźniki są ustawione na tę pojedynczą wartość.
Wskaźniki powinny być sortowane w kolejności leksykograficznej, a wskaźniki nie mogą zawierać żadnych powtórzeń. Jeśli validate_indices
jest prawdą, właściwości te są sprawdzane podczas wykonywania.
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operands:
Operand | Opis |
---|---|
sparse_indices | tensor 32/64-bitowych wartości całkowitych bez znaku |
output_shape | tensor 32/64-bitowych wartości całkowitych bez znaku |
sparse_values | tensor 32-bitowej liczby całkowitej lub 64-bitowej liczby całkowitej lub 8-bitowej liczby całkowitej lub typu Qi8 lub 8-bit niepodpisanej lub typu qui8 lub typu Tflite Quint8 lub 32-bitowe wartości pływakowe |
default_value | tensor 32-bitowej liczby całkowitej lub 64-bitowej liczby całkowitej lub 8-bitowej liczby całkowitej lub typu Qi8 lub 8-bit niepodpisanej lub typu qui8 lub typu Tflite Quint8 lub 32-bitowe wartości pływakowe |
Wyniki:
Wynik | Opis |
---|---|
dense | tensor 32-bitowej liczby całkowitej lub 64-bitowej liczby całkowitej lub 8-bitowej liczby całkowitej lub typu Qi8 lub 8-bit niepodpisanej lub typu qui8 lub typu Tflite Quint8 lub 32-bitowe wartości pływakowe |
tfl.split
(tfl :: splitop)
Dzieli tensor na tensory num_split
wzdłuż jednego wymiaru.
Dzieli tensor value
wzdłuż split_dim
na liczbę podrzędnych o tym samym kształcie co oryginalny, z wyjątkiem split_dim
. Tak samo jak tf.split.
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
num_splits | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku, którego wartość jest dodatnia |
Operands:
Operand | Opis |
---|---|
split_dim | tensor 32-bitowych wartości całkowitych bez znaku |
value | tensor 32-bitowej pływakowej lub 16-bitowej liczby całkowitej lub 32-bitowej liczby całkowitej lub 8-bitowej liczby całkowitej lub 8-bitowej niezgonowanej liczby całkowitej lub typu QI8 lub typu QI16 |
Wyniki:
Wynik | Opis |
---|---|
outputs | variadic tensora wartości dowolnego typu |
tfl.split_v
(tfl :: splitvop)
Dzieli tensor na tensory num_split
wzdłuż jednego wymiaru.
Dzieli tensor value
wzdłuż split_dim
na liczbę podrzędnych o tym samym kształcie co oryginalny, z wyjątkiem split_dim
. Grupowanie powstałych podrzędnych jest decydowane według size-splits
. Tak samo jak TF.splitv.
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
num_splits | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku, którego wartość jest dodatnia |
Operands:
Operand | Opis |
---|---|
value | tensor 32-bitowej liczby liczbowej liczby liczbowej lub 16-bitowej lub 32-bitowej liczby całkowitej lub 64-bitowej liczby całkowitej lub 8-bitowej liczby całkowitej lub 8-bitowej niepodpisanej liczbie całkowitych lub typu Qi8 lub typu Qui8 lub typu QI16 |
size_splits | 1d tensor 32-bitowych wartości liczb całkowitych |
split_dim | 0d tensor 32-bitowych wartości liczb całkowitych |
Wyniki:
Wynik | Opis |
---|---|
outputs | variadic tensora wartości dowolnego typu |
tfl.sqrt
(tfl :: sqrtop)
Operator root kwadratowych
Oblicza pierwiastek kwadratowy wejścia
Cechy: AlwaysSpeculatableImplTrait
, InferTensorType
, TF::SameOperandsAndResultTypeResolveRef
Interfejsy: ConditionallySpeculatable
, InferShapedTypeOpInterface
, InferTypeOpInterface
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operands:
Operand | Opis |
---|---|
x | tensor 32-bitowych wartości zmiennoprzecinkowych |
Wyniki:
Wynik | Opis |
---|---|
y | tensor 32-bitowych wartości zmiennoprzecinkowych |
tfl.square
(tfl :: SquareP)
Operator kwadratowy
Oblicza kwadrat elementarnego wejścia
Cechy: AlwaysSpeculatableImplTrait
, InferTensorType
, TF::SameOperandsAndResultTypeResolveRef
Interfejsy: ConditionallySpeculatable
, InferShapedTypeOpInterface
, InferTypeOpInterface
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
x | tensor 32-bitowych wartości zmiennoprzecinkowych |
Wyniki:
Wynik | Opis |
---|---|
y | tensor 32-bitowych wartości zmiennoprzecinkowych |
tfl.squared_difference
(tfl :: squredDifferenceP)
Operator różnic kwadratowych
Pod względem elementowym operacja różnicy kwadratowej.
Cechy: ::mlir::OpTrait::TFLRuntimeOpTrait
, AlwaysSpeculatableImplTrait
, QuantizableResult
, ResultsBroadcastableShape
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operands:
Operand | Opis |
---|---|
lhs | tensor 32-bitowego pływaka lub 32-bitowe wartości liczb całkowitych lub wartości typu Qi8 |
rhs | tensor 32-bitowego pływaka lub 32-bitowe wartości liczb całkowitych lub wartości typu Qi8 |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowego pływaka lub 32-bitowe wartości liczb całkowitych lub wartości typu Qi8 |
tfl.squeeze
(tfl :: squezeop)
Usuwa wymiary rozmiaru 1 z kształtu tensora.
Biorąc pod uwagę input
tensora, operacja ta zwraca tensor tego samego typu z usuniętymi wymiarami rozmiaru 1. Jeśli nie chcesz usunąć wszystkich wymiarów rozmiaru 1, możesz usunąć określony rozmiar 1, określając squeeze_dims
.
Na przykład:
# 't' is a tensor of shape [1, 2, 1, 3, 1, 1]
shape(squeeze(t)) ==> [2, 3]
Lub, aby usunąć określony rozmiar 1 Wymiary:
# 't' is a tensor of shape [1, 2, 1, 3, 1, 1]
shape(squeeze(t, [2, 4])) ==> [1, 2, 3, 1]
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
squeeze_dims | ::mlir::ArrayAttr | 64-bitowy atrybut macierzy całkowitej, którego rozmiar wynosi najwyżej 8 |
Operands:
Operand | Opis |
---|---|
input | tensor dowolnego typu wartości |
Wyniki:
Wynik | Opis |
---|---|
output | tensor dowolnego typu wartości |
tfl.strided_slice
(tfl :: stridedSliceop)
StridedSlice op
Zwróć kropkę z input
.
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
begin_mask | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku |
end_mask | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku |
ellipsis_mask | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku |
new_axis_mask | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku |
shrink_axis_mask | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku |
offset | ::mlir::BoolAttr | atrybut boolowy |
Operands:
Operand | Opis |
---|---|
input | tensor 32-bitowej pływakowej lub 32-bitowej liczby całkowitej lub 64-bitowej liczby całkowitej lub 8-bitowej liczby całkowitej lub 8-bitowej niezgonowanej liczby całkowitej lub 32-bitowej niezgonowanej liczby całkowity -Bit Liczba całkowita lub QI16 Typ lub Tflite Quint8 Typ lub Tflite String Wartości typu |
begin | tensor 32-bitowych wartości całkowitych bez znaku |
end | tensor 32-bitowych wartości całkowitych bez znaku |
strides | tensor 32-bitowych wartości całkowitych bez znaku |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowej pływakowej lub 32-bitowej liczby całkowitej lub 64-bitowej liczby całkowitej lub 8-bitowej liczby całkowitej lub 8-bitowej niezgonowanej liczby całkowitej lub 32-bitowej niezgonowanej liczby całkowity -Bit Liczba całkowita lub QI16 Typ lub Tflite Quint8 Typ lub Tflite String Wartości typu |
tfl.sub
(tfl :: subop)
Operator odejmowania
Operacja odejmowania elementu.
Cechy: ::mlir::OpTrait::TFLRuntimeOpTrait
, AlwaysSpeculatableImplTrait
, QuantizableResult
, ResultsBroadcastableShape
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflArithmeticCountOpInterface
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
fused_activation_function | ::mlir::StringAttr | atrybut łańcuchowy, którego wartość to NONE, RELU, RELU_N1_TO_1, RELU6, TANH lub SIGN_BIT |
Operands:
Operand | Opis |
---|---|
lhs | tensor 32-bitowego pływaka lub 32-bitowej liczby całkowitej lub 64-bitowej liczby całkowitej lub wartości QI8 lub wartości typu Qui8 lub typu Qi16 |
rhs | tensor 32-bitowego pływaka lub 32-bitowej liczby całkowitej lub 64-bitowej liczby całkowitej lub wartości QI8 lub wartości typu Qui8 lub typu Qi16 |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowego pływaka lub 32-bitowej liczby całkowitej lub 64-bitowej liczby całkowitej lub wartości QI8 lub wartości typu Qui8 lub typu Qi16 |
tfl.sum
(tfl :: sumop)
Operator suma
Oblicza redukcję sum wzdłuż określonych osi
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
keep_dims | ::mlir::BoolAttr | atrybut boolowy |
Operands:
Operand | Opis |
---|---|
input | tensor 32-bitowego pływaka lub 32-bitowej liczby całkowitej lub 64-bitowej liczby całkowitej lub typu Qi8 lub typu Qui8 lub Tflite Quint8 lub wartości typu Qi16 |
axes | tensor 32-bitowych wartości całkowitych bez znaku |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowego pływaka lub 32-bitowej liczby całkowitej lub 64-bitowej liczby całkowitej lub typu Qi8 lub typu Qui8 lub Tflite Quint8 lub wartości typu Qi16 |
tfl.svdf
(tfl :: svdfop)
Operator filtru rozkładu pojedynczej wartości
SVDF OP jest rozkładem gęsto połączonego OP w filtry o niskiej randze. Szczegółowe informacje: https://research.google.com/pubs/pub43813.html https://arxiv.org/abs/1812.02802
Cechy: QuantizableResult
, quant::AccumulatorUniformScale<3, 2, 4>
Interfejsy: DynamicRangeQuantizedOpInterface
, TFL_StatefulOp
, TflRuntimeVerifyOpInterface
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
rank | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku, którego wartość jest dodatnia |
fused_activation_function | ::mlir::StringAttr | atrybut łańcuchowy, którego wartość to NONE, RELU, RELU_N1_TO_1, RELU6, TANH lub SIGN_BIT |
asymmetric_quantize_inputs | ::mlir::BoolAttr | atrybut boolowy |
Operands:
Operand | Opis |
---|---|
input | tensor o wartości 32-bitowej lub wartości typu qi8 |
feature_weights | tensor wartości 32-bitowych typu Float lub Qi8 lub typu Qui8 |
time_weights | tensor 32-bitowych wartości typu float lub QI16 |
input_gate_bias | tensor dowolnego typu wartości lub żadnego typu |
activation_state | tensor stanowy |
Wyniki:
Wynik | Opis |
---|---|
output | tensor o wartości 32-bitowej lub wartości typu qi8 |
tfl.tanh
(tfl :: tanhop)
Hiperboliczny operator stycznej
Oblicza elementarne hiperboliczne styczne wejściowe
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
, SameOperandsAndResultShape
Interfejsy: ConditionallySpeculatable
, FixedOutputRangeInterface
, NoMemoryEffect (MemoryEffectOpInterface)
, TflArithmeticCountOpInterface
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operands:
Operand | Opis |
---|---|
input | tensor 32-bitowego typu Float lub Qi8 lub typu Qui8 lub typu Qi16 lub wartości typu Quint8 Tflite |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowego typu Float lub Qi8 lub typu Qui8 lub typu Qi16 lub wartości typu Quint8 Tflite |
tfl.tile
(tfl :: tileop)
Operator płytek.
Konstruuje tensor poprzez kafelowanie danego tensora.
Ta operacja tworzy nowy tensor poprzez powtórzenie czasów mnożników wejściowych. Wymiar mocy tensor ma wejście.dims (i) * mnożnie elementy [i], a wartości wejściowe są replikowanymi wielokrotnościami [i] razy wzdłuż wymiaru „I'th”. Na przykład kafelki [ABCD] przez [2] produkuje [ABCDABCD].
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operands:
Operand | Opis |
---|---|
input | Tensor 32-bitowej liczby liczbowej liczby liczbowej lub 1-bitowej lub 32-bitowej liczby całkowitej lub 64-bitowej liczby całkowitej lub 8-bitowej niezagrożonej liczby całkowity |
multiples | tensor 32/64-bitowych wartości całkowitych bez znaku |
Wyniki:
Wynik | Opis |
---|---|
output | Tensor 32-bitowej liczby liczbowej liczby liczbowej lub 1-bitowej lub 32-bitowej liczby całkowitej lub 64-bitowej liczby całkowitej lub 8-bitowej niezagrożonej liczby całkowity |
tfl.topk_v2
(tfl :: topkv2op)
Operator TOPK
Zwraca górny k
element wzdłuż każdego ostatniego wymiarowego wycinka input
i wskaźniki wartości w ostatnim wymiarze tensora wejściowego.
Wyniki są zawsze sortowane w kolejności malejącej.
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operands:
Operand | Opis |
---|---|
input | tensor 32-bitowej liczby liczbowej liczby liczbowej lub 8-bitowej lub 16-bitowej liczby całkowitej lub 32-bitowej liczby całkowitej lub 64-bitowej liczby całkowitej lub 8-bitowej niepodpisanej liczbie całkowitych lub typu Qi8 lub typu Qui8 typu |
k | tensor 16-bitowej liczby całkowitej lub 32-bitowe wartości liczb całkowitych |
Wyniki:
Wynik | Opis |
---|---|
values | tensor 32-bitowej liczby liczbowej liczby liczbowej lub 8-bitowej lub 16-bitowej liczby całkowitej lub 32-bitowej liczby całkowitej lub 64-bitowej liczby całkowitej lub 8-bitowej niepodpisanej liczbie całkowitych lub typu Qi8 lub typu Qui8 typu |
indices | tensor 16-bitowej liczby całkowitej lub 32-bitowe wartości liczb całkowitych |
tfl.transpose
(tfl :: transposeop)
Operator transponowania
Zwraca transpozycję x
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
input | tensor 32-bitowej liczby całkowitej lub 32-bitowej pływakowej lub 8-bitowej liczby całkowitej lub 8-bitowej niepodpisanej liczb całkowitych lub typu QI8 lub typu Qui8 lub Tflite Quint8 lub 1-bitowa liczba całkowita lub 64-bitowa liczba liczb całkowitych lub wartości typu QI16 |
perm | tensor 32-bitowych wartości całkowitych bez znaku |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowej liczby całkowitej lub 32-bitowej pływakowej lub 8-bitowej liczby całkowitej lub 8-bitowej niepodpisanej liczb całkowitych lub typu QI8 lub typu Qui8 lub Tflite Quint8 lub 1-bitowa liczba całkowita lub 64-bitowa liczba liczb całkowitych lub wartości typu QI16 |
tfl.transpose_conv
(tfl :: TransposeConvop)
Transpose operator splotu
Wykonuje operację splotu Transpose przy wejściu.
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
, quant::AccumulatorUniformScale<3, 1, 2>
, quant::AffineOpCoefficient<0, 1>
Interfejsy: AffineQuantizedOpInterface
, ConditionallySpeculatable
, DynamicRangeQuantizedOpInterface
, NoMemoryEffect (MemoryEffectOpInterface)
, TFL_SparseOp
, TflArithmeticCountOpInterface
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
padding | ::mlir::StringAttr | atrybut string, którego wartość to SAME lub VALID |
stride_h | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku, którego wartość jest dodatnia |
stride_w | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku, którego wartość jest dodatnia |
fused_activation_function | ::mlir::StringAttr | atrybut łańcuchowy, którego wartość to NONE, RELU, RELU_N1_TO_1, RELU6, TANH lub SIGN_BIT |
Operands:
Operand | Opis |
---|---|
output_shape | tensor 32-bitowych wartości całkowitych bez znaku |
weights | tensor 32-bitowego typu float lub wartości typu QI8, typu QUI8 lub typu QI16 |
input | tensor 32-bitowego typu float lub wartości typu QI8, typu QUI8 lub typu QI16 |
bias | tensor dowolnego typu wartości lub żadnego typu |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowego typu float lub wartości typu QI8, typu QUI8 lub typu QI16 |
tfl.unidirectional_sequence_lstm
(tfl :: UnitirectionalSeCenceLstmop)
Operator LSTM sekwencji jednokierunkowej
Powtarzająca się sieć neuronowa określona przez komórkę LSTM. Ten OP obsługuje rozwinięcie danych wejściowych wzdłuż wymiarów czasu lub okresu i implementuje następującą operację dla każdego elementu w sekwencji s = 1 ... sekwencyjna długość: wyjścia [s] = stan = aktywacja (LSTMOP (wejścia [s]))
gdzie LSTMOP jest LSTM TF Lite OP, a „aktywacja” jest funkcją przekazaną jako argument „fed_activation_function” (jeśli nie „brak”).
Cechy: QuantizableResult
Interfejsy: DynamicRangeQuantizedOpInterface
, InferTypeOpInterface
, TFL_StatefulOp
, TflRuntimeVerifyOpInterface
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
fused_activation_function | ::mlir::StringAttr | atrybut łańcuchowy, którego wartość to NONE, RELU, RELU_N1_TO_1, RELU6, TANH lub SIGN_BIT |
cell_clip | ::mlir::FloatAttr | 32-bitowy atrybut zmiennoprzecinkowy, którego wartość jest nieujemna |
proj_clip | ::mlir::FloatAttr | 32-bitowy atrybut zmiennoprzecinkowy, którego wartość jest nieujemna |
time_major | ::mlir::BoolAttr | atrybut boolowy |
asymmetric_quantize_inputs | ::mlir::BoolAttr | atrybut boolowy |
diagonal_recurrent_tensors | ::mlir::BoolAttr | atrybut boolowy |
input_to_input_intermediate | :: mlir :: typeattr | dowolny atrybut typu |
input_to_forget_intermediate | :: mlir :: typeattr | dowolny atrybut typu |
input_to_cell_intermediate | :: mlir :: typeattr | dowolny atrybut typu |
input_to_output_intermediate | :: mlir :: typeattr | dowolny atrybut typu |
effective_hidden_scale_intermediate | :: mlir :: typeattr | dowolny atrybut typu |
Operands:
Operand | Opis |
---|---|
input | tensor 32-bitowych wartości zmiennoprzecinkowych |
input_to_input_weights | tensor dowolnego typu wartości lub żadnego typu |
input_to_forget_weights | tensor o wartości 32-bitowej lub wartości typu qi8 |
input_to_cell_weights | tensor o wartości 32-bitowej lub wartości typu qi8 |
input_to_output_weights | tensor o wartości 32-bitowej lub wartości typu qi8 |
recurrent_to_input_weights | tensor dowolnego typu wartości lub żadnego typu |
recurrent_to_forget_weights | tensor o wartości 32-bitowej lub wartości typu qi8 |
recurrent_to_cell_weights | tensor o wartości 32-bitowej lub wartości typu qi8 |
recurrent_to_output_weights | tensor o wartości 32-bitowej lub wartości typu qi8 |
cell_to_input_weights | tensor dowolnego typu wartości lub żadnego typu |
cell_to_forget_weights | tensor dowolnego typu wartości lub żadnego typu |
cell_to_output_weights | tensor dowolnego typu wartości lub żadnego typu |
input_gate_bias | tensor dowolnego typu wartości lub żadnego typu |
forget_gate_bias | tensor 32-bitowych wartości zmiennoprzecinkowych |
cell_bias | tensor 32-bitowych wartości zmiennoprzecinkowych |
output_gate_bias | tensor 32-bitowych wartości zmiennoprzecinkowych |
projection_weights | tensor dowolnego typu wartości lub żadnego typu |
projection_bias | tensor dowolnego typu wartości lub żadnego typu |
input_activation_state | tensor stanowy |
input_cell_state | tensor stanowy |
input_layer_norm_coefficients | tensor dowolnego typu wartości lub żadnego typu |
forget_layer_norm_coefficients | tensor dowolnego typu wartości lub żadnego typu |
cell_layer_norm_coefficients | tensor dowolnego typu wartości lub żadnego typu |
output_layer_norm_coefficients | tensor dowolnego typu wartości lub żadnego typu |
Wyniki:
Wynik | Opis |
---|---|
output | tensor o wartości 32-bitowej lub wartości typu qi8 |
tfl.unidirectional_sequence_rnn
(tfl :: UnitirectionalSeCernnop)
Operator sekwencji jednokierunkowej RNN
Powtarzająca się sieć neuronowa określona przez komórkę RNN. Ten OP przyjmuje dane wejściowe w formacie {Batch_Size, SEQ_LEN, INPUT_SIZE} lub {seq_len, batch_size, input_size}, jeśli jest to zamieszane w czasie.
Wdraża następującą operację dla każdego elementu w sekwencji s = 1 ... sekwencyjna długość: wyjścia [s] = stan = aktywacja (rnnop (wejścia [s]))))
gdzie RNNOP jest RNNOP TF Lite OP, a „aktywacja” jest funkcją przekazywaną jako argument „fed_activation_function” (jeśli nie „brak”).
Cechy: QuantizableResult
Interfejsy: DynamicRangeQuantizedOpInterface
, TFL_StatefulOp
, TflRuntimeVerifyOpInterface
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
time_major | ::mlir::BoolAttr | atrybut boolowy |
fused_activation_function | ::mlir::StringAttr | atrybut łańcuchowy, którego wartość to NONE, RELU, RELU_N1_TO_1, RELU6, TANH lub SIGN_BIT |
asymmetric_quantize_inputs | ::mlir::BoolAttr | atrybut boolowy |
Operands:
Operand | Opis |
---|---|
input | tensor 32-bitowych wartości zmiennoprzecinkowych |
input_to_input_weights | tensor o wartości 32-bitowej lub wartości typu qi8 |
recurrent_to_input_weights | tensor o wartości 32-bitowej lub wartości typu qi8 |
input_gate_bias | tensor 32-bitowych wartości zmiennoprzecinkowych |
hidden_state | tensor stanowy |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowych wartości zmiennoprzecinkowych |
tfl.unique
(tfl :: unikalny)
Unikalny op.
Ta operacja zwraca output
tensora zawierające wszystkie unikalne elementy input
posortowane w tej samej kolejności, w której występują na input
. Ta operacja zwraca również idx
tensor tego samego rozmiaru co x
, który zawiera indeks każdej wartości input
w unikalnym output
wyjściowym. Innymi słowy:
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
idx_out_type | ::mlir::Atrybut | atrybut pochodny |
Operands:
Operand | Opis |
---|---|
input | tensor 8-bitowej liczby całkowitej lub typu Qi8 lub 8-bit niepodpisany typu liczb całkowitych lub Qui8 lub 16-bitowa liczba całkowita lub typ qi16 lub 32-bitowa liczba całkowita lub 64-bitowa liczba całkowita lub 32-bitowa liczba pływakowa lub 32-bitowe wartości pływające |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 8-bitowej liczby całkowitej lub typu Qi8 lub 8-bit niepodpisany typu liczb całkowitych lub Qui8 lub 16-bitowa liczba całkowita lub typ qi16 lub 32-bitowa liczba całkowita lub 64-bitowa liczba całkowita lub 32-bitowa liczba pływakowa lub 32-bitowe wartości pływające |
idx | tensor 32/64-bitowych wartości całkowitych bez znaku |
tfl.unpack
(tfl :: unpackop)
Rozpakowuje tensor wzdłuż wymiaru na wiele tensorów
Rozpakowuje dany wymiar tensor R
na num
Rank- (R-1)
.
Rozpakowuje TENSORY num
z value
, przesuwając je wzdłuż wymiaru axis
. Na przykład, biorąc pod uwagę tensor kształtu (A, B, C, D)
;
Jeśli axis == 0
, wówczas tensor w output
jest value[i, :, :, :]
i każdy tensor na output
będzie miał kształt (B, C, D)
. (Należy pamiętać, że wymiar rozpakowany zniknął, w przeciwieństwie do split
).
Jeśli axis == 1
, to ten tensor w output
jest value[:, i, :, :]
, a każdy tensor na output
będzie miał kształt (A, C, D)
. Itp.
To jest przeciwieństwo pack
.
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
, SameOperandsAndResultElementType
Interfejsy: ConditionallySpeculatable
, InferTypeOpInterface
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
num | ::mlir::IntegerAttr | 32-bitowy atrybut liczb całkowitych, którego wartość jest nie caska |
axis | ::mlir::IntegerAttr | 32-bitowy atrybut liczby całkowitej bez znaku |
Operands:
Operand | Opis |
---|---|
input | Tensor 32-bitowej liczby liczbowej liczby liczbowej lub 1-bitowej lub 8-bitowej liczby całkowitej lub 8-bitowej bez znaku całkowity |
Wyniki:
Wynik | Opis |
---|---|
outputs | variadic tensora wartości dowolnego typu |
tfl.unsorted_segment_max
(tfl :: unSortedSegmentMaxop)
Operator UnsortedSegmentMax
Oblicza maksymalną wartość wzdłuż segmentów tensora, tak że wyjście [i] = max (dane [j ....]) gdzie segment_ids [j ...] = i jeśli maksimum jest puste dla danego identyfikatora segmentu i it, to Wyświetla najmniejszą możliwą wartość dla określonego typu liczbowego, wyjściowe [i] = numeric_limits :: najniższe (). Uwaga Wartości segmentu_dysp są zawsze zatwierdzone jako mniej niż NUM_SEGMENTY, a błąd jest wyświetlany dla wskaźników poza nieokreślonymi.
Cechy: AlwaysSpeculatableImplTrait
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operands:
Operand | Opis |
---|---|
input | tensor 32-bitowych wartości zmiennoprzecinkowych lub 32-bitowych wartości całkowitych bez znaku |
segment_ids | tensor 32-bitowych wartości całkowitych bez znaku |
num_segments | tensor 32-bitowych wartości całkowitych bez znaku |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowych wartości zmiennoprzecinkowych lub 32-bitowych wartości całkowitych bez znaku |
tfl.unsorted_segment_min
(tfl :: unSortedSegmentMinop)
Operator UnsortedSegmentMin
Oblicza minimalną wartość wzdłuż segmentów tensora, tak że wyjście [i] = min (dane [j ....]) gdzie segment_ids [j ...] = i jeśli minimum jest puste dla danego identyfikatora segmentu i it, to Wydaja największą możliwą wartość dla określonego typu liczbowego, wyjściowe [i] = numeric_Limits :: max (). Uwaga Wartości segmentu_dysp są zawsze zatwierdzone jako mniej niż NUM_SEGMENTY, a błąd jest wyświetlany dla wskaźników poza nieokreślonymi.
Cechy: AlwaysSpeculatableImplTrait
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operands:
Operand | Opis |
---|---|
input | tensor 32-bitowych wartości zmiennoprzecinkowych lub 32-bitowych wartości całkowitych bez znaku |
segment_ids | tensor 32-bitowych wartości całkowitych bez znaku |
num_segments | tensor 32-bitowych wartości całkowitych bez znaku |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowych wartości zmiennoprzecinkowych lub 32-bitowych wartości całkowitych bez znaku |
tfl.unsorted_segment_prod
(tfl :: unSortedSegmentProdop)
Operator UnsortedSegmentProd
Oblicza produkt wzdłuż segmentów tensora.
Cechy: AlwaysSpeculatableImplTrait
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operands:
Operand | Opis |
---|---|
input | tensor 32-bitowych wartości zmiennoprzecinkowych lub 32-bitowych wartości całkowitych bez znaku |
segment_ids | tensor 32-bitowych wartości całkowitych bez znaku |
num_segments | tensor 32-bitowych wartości całkowitych bez znaku |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowych wartości zmiennoprzecinkowych lub 32-bitowych wartości całkowitych bez znaku |
tfl.unsorted_segment_sum
(tfl :: unSortedSegmentsumop)
UnsortedSegmentsum Operator
Z segmentacji tensora oblicza output
wynikające z sumowania elementów zmapowanych na ten sam segment_d. IE output[i]
jest równe sumie tensora wszystkich elementów z wejściowego tensora odwzorowanego na segment_id i
. Jeśli żadne tensory nie są odwzorowane na określony uwzględniony segment_id, wyjście na ten indice będzie to tensor zerowy o odpowiednim kształcie. Zwróć uwagę, że wartości segmentu_
Cechy: AlwaysSpeculatableImplTrait
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operands:
Operand | Opis |
---|---|
input | tensor 32-bitowych wartości zmiennoprzecinkowych lub 32-bitowych wartości całkowitych bez znaku |
segment_ids | tensor 32-bitowych wartości całkowitych bez znaku |
num_segments | tensor 32-bitowych wartości całkowitych bez znaku |
Wyniki:
Wynik | Opis |
---|---|
output | tensor 32-bitowych wartości zmiennoprzecinkowych lub 32-bitowych wartości całkowitych bez znaku |
tfl.var_handle
(tfl :: varhandleop)
Zwraca uchwyt do zmiennego zasobu z jego nazwy.
Zwraca uchwyt dla zmiennego zasobu z jego nazwy. Kontener: Włączono pojemnik na tę zmienną. Shared_name: Nazwa, o którą ta zmienna jest określona.
Interfejsy: TflRuntimeVerifyOpInterface
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
container | ::mlir::StringAttr | atrybut ciągu |
shared_name | ::mlir::StringAttr | atrybut ciągu |
Wyniki:
Wynik | Opis |
---|---|
resource_handle | tensor wartości zasobów |
tfl.where
(tfl :: homop)
Zwraca lokalizacje wartości niezerowych / prawdziwych w tensorze.
Ta operacja zwraca współrzędne prawdziwych elementów w condition
. Współrzędne są zwracane w tensorze 2D, w którym pierwszy wymiar (wiersze) reprezentuje liczbę prawdziwych elementów, a drugi wymiar (kolumny) reprezentuje współrzędne elementów prawdziwych. Pamiętaj, że kształt tensora wyjściowego może się różnić w zależności od tego, ile prawdziwych wartości jest w condition
. Wskaźniki są wysyłane w kolejności szeregu wiersza.
Cechy: AlwaysSpeculatableImplTrait
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Efekty: MemoryEffects::Effect{}
Operands:
Operand | Opis |
---|---|
condition | tensor 1-bitowej liczby całkowitej lub 32-bitowej pływaku lub 32/64-bitowej liczby całkowitej lub 8-bitowej liczby całkowitej lub 8-bitowej niepodpisanej liczbie całkowity |
Wyniki:
Wynik | Opis |
---|---|
index | tensor 64-bitowych wartości liczb całkowitych |
tfl.while
.
Podczas pętli
wyjście = wejście; while (cond (wyjściowe)) {wyjście = body (wyjściowe)}
Podczas gdy pętla, w której przechodzą wszystkie wartości przez argumenty z domyślnym przechwytywaniem.
Wejście: Lista tensorów wejściowych, których typy to T. Wyjście: lista tensorów wyjściowych, których typy to T. Cond: Region, który przyjmuje „wejście” i zwraca boolean skalarny tensor. Ciało: region, który zajmuje listę tensorów i zwraca kolejną listę tensorów. Obie listy mają te same typy.
Cechy: SingleBlockImplicitTerminator<YieldOp>
, SingleBlock
Interfejsy: LoopLikeOpInterface
, TflRuntimeVerifyOpInterface
Atrybuty:
Atrybut | Typ MLIR | Opis |
---|---|---|
is_stateless | ::mlir::BoolAttr | atrybut boolowy |
Operands:
Operand | Opis |
---|---|
input | variadic tensora wartości dowolnego typu |
Wyniki:
Wynik | Opis |
---|---|
output | variadic tensora wartości dowolnego typu |
tfl.yield
(tfl :: pertop)
Wydajność
Operacja „wydajności” reprezentuje operację powrotu w obrębie warunkowego i ciała strukturalnego przepływu sterowania (np. While) oraz terminatora dla ControlNodeop. Operacja przyjmuje zmienną liczbę operandów i nie daje żadnych wyników. Numer i typy operand muszą pasować do podpisu regionu zawierającego operację.
Cechy: AlwaysSpeculatableImplTrait
, QuantizableResult
, Terminator
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Operandy:
Operand | Opis |
---|---|
"anonimowy" | zmienne dowolnego typu |
tfl.zeros_like
(tfl :: zeros podobny)
Operator podobny do zera
Zwraca tensor zerów o tym samym kształcie i typu co tensor wejściowy.
Cechy: AlwaysSpeculatableImplTrait
, SameOperandsAndResultShape
Interfejsy: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Operands:
Operand | Opis |
---|---|
input | Tensor 64-bitowej liczby całkowitej lub 32-bitowej liczby całkowitej lub 32-bitowej wartości pływakowej |
Wyniki:
Wynik | Opis |
---|---|
output | Tensor 64-bitowej liczby całkowitej lub 32-bitowej liczby całkowitej lub 32-bitowej wartości pływakowej |
Atrybuty
Dimensionmetadataattr
Metadane wymiarowe.
Składnia:
#tfl.dimension_metadata<
::mlir::TFL::DimensionTypeAttr, # format
int32_t, # dense_size
::llvm::ArrayRef<int32_t>, # segments
::llvm::ArrayRef<int32_t> # indices
>
Parametry:
Parametr | Typ C ++ | Opis |
---|---|---|
format | ::mlir::TFL::DimensionTypeAttr | Dimension_Type |
gense_Size | int32_t | |
segmenty | ::llvm::ArrayRef<int32_t> | |
wskaźniki | ::llvm::ArrayRef<int32_t> |
RAMTITYPARAMETERTTR
Parametr rzadkości.
Składnia:
#tfl.sparsity_parameter<
::llvm::ArrayRef<int32_t>, # traversal_order
::llvm::ArrayRef<int32_t>, # block_map
::llvm::ArrayRef<DimensionMetadataAttr> # dim_metadata
>
Parametry:
Parametr | Typ C ++ | Opis |
---|---|---|
traversal_order | ::llvm::ArrayRef<int32_t> | |
block_map | ::llvm::ArrayRef<int32_t> | |
dim_metadata | ::llvm::ArrayRef<DimensionMetadataAttr> |
ConstBytesAttr
Reprezentacja atrybutu ciągu skompilowanych bajtów
Syntax Examples:
#tfl<const_bytes : "0xDEADBEEF">
Parametry:
Parametr | C++ type | Opis |
---|---|---|
wartość | ::llvm::StringRef |
DimensionTypeAttr
dimension_type
Składnia:
#tfl.dimension_type_attr<
::mlir::TFL::DimensionType # value
>
Enum cases:
- DENSE (
DENSE
) - SPARSE_CSR (
SPARSE_CSR
) #### Parameters:
Parametr | C++ type | Opis |
---|---|---|
wartość | ::mlir::TFL::DimensionType | an enum of type DimensionType |
LSTMKernelTypeAttr
lstm_kernel_type
Składnia:
#tfl.lstm_kernel_type_attr<
::mlir::TFL::LSTMKernelType # value
>
Enum cases:
- FULL (
FULL
) - BASIC (
BASIC
) #### Parameters:
Parametr | C++ type | Opis |
---|---|---|
wartość | ::mlir::TFL::LSTMKernelType | an enum of type LSTMKernelType |
MirrorPaddingTypeAttr
mirror_pad_enum
Składnia:
#tfl.mirror_pad_attr<
::mlir::TFL::MirrorPaddingType # value
>
Enum cases:
- REFLECT (
REFLECT
) - SYMMETRIC (
SYMMETRIC
) #### Parameters:
Parametr | C++ type | Opis |
---|---|---|
wartość | ::mlir::TFL::MirrorPaddingType | an enum of type MirrorPaddingType |
Enums
DimensionType
dimension_type
Sprawy:
Symbol | Wartość | Strunowy |
---|---|---|
GĘSTY | 0 | GĘSTY |
SPARSE_CSR | 1 | SPARSE_CSR |
LSTMKernelType
lstm_kernel_type
Sprawy:
Symbol | Wartość | Strunowy |
---|---|---|
PEŁNY | 0 | PEŁNY |
PODSTAWOWY | 1 | PODSTAWOWY |
MirrorPaddingType
mirror_pad_enum
Sprawy:
Symbol | Wartość | Strunowy |
---|---|---|
ODBIJAĆ | 0 | ODBIJAĆ |
SYMETRYCZNY | 1 | SYMETRYCZNY |