Le dialecte TensorFlow Lite.
Ce dialecte correspond aux opérations TensorFlow Lite.
Invariants :
- Toutes les valeurs sont de type Tensor (en particulier, les scalaires sont représentés à l'aide de tenseurs de dimension zéro) ;
Opérations
tfl.abs
(TFL::AbsOp)
Opérateur de valeur absolue
Étant donné un tenseur x
, cette opération renvoie un tenseur contenant la valeur absolue de chaque élément de x
. Par exemple, si x est un élément d'entrée et y est un élément de sortie, cette opération calcule \(y = |x|\).
Traits : AlwaysSpeculatableImplTrait
, QuantizableResult
, SameOperandsAndResultShape
Interfaces : ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effets : MemoryEffects::Effect{}
Opérandes :
Opérande | Description |
---|---|
x | tenseur d'entier sans signe de 16 bits ou d'entier sans signe de 32 bits ou de valeurs flottantes de 32 bits ou de type QI8 ou de type QI16 |
Résultats:
Résultat | Description |
---|---|
y | tenseur d'entier sans signe de 16 bits ou d'entier sans signe de 32 bits ou de valeurs flottantes de 32 bits ou de type QI8 ou de type QI16 |
tfl.add
(TFL::AddOp)
Opérateur d'addition
Opération d’addition par élément.
Traits : ::mlir::OpTrait::TFLRuntimeOpTrait
, AlwaysSpeculatableImplTrait
, Commutative
, QuantizableResult
, ResultsBroadcastableShape
Interfaces : ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflArithmeticCountOpInterface
, TflRuntimeVerifyOpInterface
Effets : MemoryEffects::Effect{}
Attributs :
Attribut | Type MLIR | Description |
---|---|---|
fused_activation_function | ::mlir::StringAttr | attribut de chaîne dont la valeur est NONE, ou RELU, ou RELU_N1_TO_1, ou RELU6, ou TANH, ou SIGN_BIT |
Opérandes :
Opérande | Description |
---|---|
lhs | tenseur de valeurs flottantes de 32 bits ou d'entier sans signe de 16 bits ou d'entier sans signe de 32 bits ou d'entier sans signe de 64 bits ou de valeurs de type QI8 ou de type QUI8 ou de type QI16 |
rhs | tenseur de valeurs flottantes de 32 bits ou d'entier sans signe de 16 bits ou d'entier sans signe de 32 bits ou d'entier sans signe de 64 bits ou de valeurs de type QI8 ou de type QUI8 ou de type QI16 |
Résultats:
Résultat | Description |
---|---|
output | tenseur de valeurs flottantes de 32 bits ou d'entier sans signe de 16 bits ou d'entier sans signe de 32 bits ou d'entier sans signe de 64 bits ou de valeurs de type QI8 ou de type QUI8 ou de type QI16 |
tfl.add_n
(TFL::AddNOp)
_Ajouter n opérateur
Ajoute tous les tenseurs d'entrée par élément.
Traits : AlwaysSpeculatableImplTrait
, Commutative
Interfaces : ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflArithmeticCountOpInterface
, TflRuntimeVerifyOpInterface
Effets : MemoryEffects::Effect{}
Opérandes :
Opérande | Description |
---|---|
inputs | variadique de valeurs de tenseur de tout type |
Résultats:
Résultat | Description |
---|---|
sum | tenseur de valeurs flottantes de 32 bits ou d'entiers sans signe de 32 bits |
tfl.arg_max
(TFL::ArgMaxOp)
Opérateur ArgMax
Renvoie l'index avec la plus grande valeur sur toutes les dimensions d'un tenseur.
Traits : AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces : ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effets : MemoryEffects::Effect{}
Attributs :
Attribut | Type MLIR | Description |
---|---|---|
output_type | ::mlir::Attribut | attribut dérivé |
Opérandes :
Opérande | Description |
---|---|
input | tenseur d'un entier sans signe de 1 bit ou d'un flottant de 32 bits ou d'un entier sans signe de 32 bits ou d'un entier sans signe de 8 bits ou d'un entier non signé de 8 bits ou de valeurs de type QI8 ou de type QUI8 |
dim | tenseur de valeurs entières sans signe 32/64 bits |
Résultats:
Résultat | Description |
---|---|
output | tenseur de valeurs entières sans signe 32/64 bits |
tfl.arg_min
(TFL::ArgMinOp)
Opérateur ArgMin
Renvoie l'index avec la plus petite valeur sur les dimensions d'un tenseur. a = [1, 10, 26,9, 2,8, 166,32, 62,3] b = tf.math.argmin(input = a) c = tf.keras.backend.eval(b)
Traits : AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces : ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effets : MemoryEffects::Effect{}
Attributs :
Attribut | Type MLIR | Description |
---|---|---|
output_type | ::mlir::Attribut | attribut dérivé |
Opérandes :
Opérande | Description |
---|---|
input | tenseur d'un entier sans signe de 1 bit ou d'un flottant de 32 bits ou d'un entier sans signe de 32 bits ou d'un entier sans signe de 8 bits ou d'un entier non signé de 8 bits ou de valeurs de type QI8 ou de type QUI8 |
dim | tenseur de valeurs entières sans signe 32/64 bits |
Résultats:
Résultat | Description |
---|---|
output | tenseur de valeurs entières sans signe 32/64 bits |
tfl.assign_variable
(TFL::AssignVariableOp)
Attribue une nouvelle valeur à une variable.
Tout ReadVariableOp avec une dépendance de contrôle sur cette opération est assuré de renvoyer cette valeur ou une valeur ultérieure plus récente de la variable.
Interfaces : TflRuntimeVerifyOpInterface
Opérandes :
Opérande | Description |
---|---|
resource_id | tenseur des valeurs des ressources |
value | tenseur de 32 bits flottants ou 64 bits flottants ou entier sans signe 1 bit ou entier non signé 8 bits ou entier sans signe 8 bits ou type QI8 ou type QUI8 ou entier sans signe 32 bits ou entier sans signe 64 bits ou type QI16 ou type complexe avec des éléments flottants de 32 bits ou type complexe avec des valeurs d'éléments flottants de 64 bits |
tfl.atan2
(TFL::Atan2Op)
Opération Atan2
L'opération "atan2" calcule l'arctangente de y/x élément par élément, en respectant les signes des arguments.
Traits : AlwaysSpeculatableImplTrait
, SameOperandsAndResultElementType
, SameOperandsAndResultShape
Interfaces : ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effets : MemoryEffects::Effect{}
Opérandes :
Opérande | Description |
---|---|
y | tenseur de valeurs flottantes 32 bits ou 64 bits |
x | tenseur de valeurs flottantes 32 bits ou 64 bits |
Résultats:
Résultat | Description |
---|---|
output | tenseur de valeurs flottantes 32 bits ou 64 bits |
tfl.average_pool_2d
(TFL::AveragePool2DOp)
Opérateur _Average_pool 2D
Effectue une opération de pooling moyen en entrée.
Traits : AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces : ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflArithmeticCountOpInterface
, TflRuntimeVerifyOpInterface
Effets : MemoryEffects::Effect{}
Attributs :
Attribut | Type MLIR | Description |
---|---|---|
filter_height | ::mlir::IntegerAttr | Attribut entier sans signe de 32 bits |
filter_width | ::mlir::IntegerAttr | Attribut entier sans signe de 32 bits |
padding | ::mlir::StringAttr | attribut de chaîne dont la valeur est SAME ou VALID |
stride_h | ::mlir::IntegerAttr | Attribut entier sans signe de 32 bits |
stride_w | ::mlir::IntegerAttr | Attribut entier sans signe de 32 bits |
fused_activation_function | ::mlir::StringAttr | attribut de chaîne dont la valeur est NONE, ou RELU, ou RELU_N1_TO_1, ou RELU6, ou TANH, ou SIGN_BIT |
Opérandes :
Opérande | Description |
---|---|
input | tenseur de valeurs flottantes 32 bits ou de type QI8 ou de type QUI8 ou de type QI16 |
Résultats:
Résultat | Description |
---|---|
output | tenseur de valeurs flottantes 32 bits ou de type QI8 ou de type QUI8 ou de type QI16 |
tfl.basic_lstm
(TFL::BasicLSTMOp)
L'opérateur lstm de base
Opérateur de cellule LSTM de base.
Traits : AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces : ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effets : MemoryEffects::Effect{}
Attributs :
Attribut | Type MLIR | Description |
---|---|---|
fused_activation_function | ::mlir::StringAttr | attribut de chaîne dont la valeur est NONE, ou RELU, ou RELU_N1_TO_1, ou RELU6, ou TANH, ou SIGN_BIT |
cell_clip | ::mlir::FloatAttr | Attribut float 32 bits dont la valeur est non négative |
proj_clip | ::mlir::FloatAttr | Attribut float 32 bits dont la valeur est non négative |
kernel_type | ::mlir::TFL::LSTMKernelTypeAttr | lstm_kernel_type dont la valeur est mlir::TFL::LSTMKernelType::BASIC |
Opérandes :
Opérande | Description |
---|---|
data_input | tenseur de valeurs de type float ou QUI8 32 bits |
prev_activ_input | tenseur de valeurs de type float ou QUI8 32 bits |
weights_input | tenseur de valeurs de type float ou QUI8 32 bits |
biases_input | tenseur de valeurs de type float ou QI32 32 bits |
prev_state_input | tenseur de valeurs de type float ou QI16 32 bits |
Résultats:
Résultat | Description |
---|---|
activ_output | Tenseur 2D de tout type de valeurs |
state_output | Tenseur 2D de tout type de valeurs |
concat_temp | Tenseur 2D de tout type de valeurs |
activ_temp | Tenseur 2D de tout type de valeurs |
tfl.batch_matmul
(TFL::BatchMatMulOp)
Opérateur de multiplication matricielle par lots
Effectue une multiplication matricielle par lots sur les entrées. Suit les conventions de TensorFlow BatchMatMulV2, avec prise en charge des dimensions inconnues dans les dimensions du lot et la diffusion.
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)
Traits : ::mlir::OpTrait::TFLRuntimeOpTrait
, AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces : ConditionallySpeculatable
, DynamicRangeQuantizedOpInterface
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effets : MemoryEffects::Effect{}
Attributs :
Attribut | Type MLIR | Description |
---|---|---|
adj_x | ::mlir::BoolAttr | attribut booléen |
adj_y | ::mlir::BoolAttr | attribut booléen |
asymmetric_quantize_inputs | ::mlir::BoolAttr | attribut booléen |
Opérandes :
Opérande | Description |
---|---|
x | tenseur de type float 32 bits ou QI8 ou type QI16 ou valeurs entières sans signe 8 bits |
y | tenseur de type float 32 bits ou QI8 ou type QI16 ou valeurs entières sans signe 8 bits |
Résultats:
Résultat | Description |
---|---|
output | tenseur de type flottant 32 bits ou de type QI8 ou de type QI16 ou de valeurs entières sans signe de 32 bits |
tfl.batch_to_space_nd
(TFL :: BatchToSpaceNdOp)
Opérateur BatchToSpaceNd
Cette opération remodèle la dimension "batch" 0 en dimensions spatiales.
Traits : AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces : ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Effets : MemoryEffects::Effect{}
Opérandes :
Opérande | Description |
---|---|
input | tenseur de valeurs flottantes de 32 bits ou d'entier sans signe de 8 bits ou d'entier sans signe de 32 bits ou d'entier sans signe de 64 bits ou d'entier non signé de 8 bits ou de valeurs de type QI8 ou de type QUI8 ou de type QI16 |
block_shape | tenseur de valeurs entières sans signe de 32 bits |
indices | tenseur de valeurs entières sans signe de 32 bits |
Résultats:
Résultat | Description |
---|---|
output | tenseur de valeurs flottantes de 32 bits ou d'entier sans signe de 16 bits ou d'entier sans signe de 32 bits ou d'entier sans signe de 64 bits ou d'entier non signé de 8 bits ou de valeurs de type QI8 ou de type QUI8 ou de type QI16 |
tfl.bidirectional_sequence_lstm
(TFL :: BidirectionnelSequenceLSTMOp)
Opérateur lstm de séquence bidirectionnelle
Le LSTM bidirectionnel est essentiellement composé de deux LSTM, l'un allant vers l'avant et l'autre vers l'arrière. Et le résultat est la concaténation des deux lstms.
Traits : QuantizableResult
Interfaces : DynamicRangeQuantizedOpInterface
, TFL_StatefulOp
, TflRuntimeVerifyOpInterface
Attributs :
Attribut | Type MLIR | Description |
---|---|---|
fused_activation_function | ::mlir::StringAttr | attribut de chaîne dont la valeur est NONE, ou RELU, ou RELU_N1_TO_1, ou RELU6, ou TANH, ou SIGN_BIT |
cell_clip | ::mlir::FloatAttr | Attribut float 32 bits dont la valeur est non négative |
proj_clip | ::mlir::FloatAttr | Attribut float 32 bits dont la valeur est non négative |
merge_outputs | ::mlir::BoolAttr | attribut booléen |
time_major | ::mlir::BoolAttr | attribut booléen |
asymmetric_quantize_inputs | ::mlir::BoolAttr | attribut booléen |
Opérandes :
Opérande | Description |
---|---|
input | tenseur de valeurs flottantes de 32 bits ou d'entiers sans signe de 8 bits |
fw_input_to_input_weights | tenseur de n'importe quel type de valeurs ou aucun type |
fw_input_to_forget_weights | tenseur de valeurs flottantes de 32 bits ou d'entiers sans signe de 8 bits |
fw_input_to_cell_weights | tenseur de valeurs flottantes de 32 bits ou d'entiers sans signe de 8 bits |
fw_input_to_output_weights | tenseur de valeurs flottantes de 32 bits ou d'entiers sans signe de 8 bits |
fw_recurrent_to_input_weights | tenseur de n'importe quel type de valeurs ou aucun type |
fw_recurrent_to_forget_weights | tenseur de valeurs flottantes de 32 bits ou d'entiers sans signe de 8 bits |
fw_recurrent_to_cell_weights | tenseur de valeurs flottantes de 32 bits ou d'entiers sans signe de 8 bits |
fw_recurrent_to_output_weights | tenseur de valeurs flottantes de 32 bits ou d'entiers sans signe de 8 bits |
fw_cell_to_input_weights | tenseur de n'importe quel type de valeurs ou aucun type |
fw_cell_to_forget_weights | tenseur de n'importe quel type de valeurs ou aucun type |
fw_cell_to_output_weights | tenseur de n'importe quel type de valeurs ou aucun type |
fw_input_gate_bias | tenseur de n'importe quel type de valeurs ou aucun type |
fw_forget_gate_bias | tenseur de valeurs flottantes 32 bits |
fw_cell_bias | tenseur de valeurs flottantes 32 bits |
fw_output_gate_bias | tenseur de valeurs flottantes 32 bits |
fw_projection_weights | tenseur de n'importe quel type de valeurs ou aucun type |
fw_projection_bias | tenseur de n'importe quel type de valeurs ou aucun type |
bw_input_to_input_weights | tenseur de n'importe quel type de valeurs ou aucun type |
bw_input_to_forget_weights | tenseur de valeurs flottantes de 32 bits ou d'entiers sans signe de 8 bits |
bw_input_to_cell_weights | tenseur de valeurs flottantes de 32 bits ou d'entiers sans signe de 8 bits |
bw_input_to_output_weights | tenseur de valeurs flottantes de 32 bits ou d'entiers sans signe de 8 bits |
bw_recurrent_to_input_weights | tenseur de n'importe quel type de valeurs ou aucun type |
bw_recurrent_to_forget_weights | tenseur de valeurs flottantes de 32 bits ou d'entiers sans signe de 8 bits |
bw_recurrent_to_cell_weights | tenseur de valeurs flottantes de 32 bits ou d'entiers sans signe de 8 bits |
bw_recurrent_to_output_weights | tenseur de valeurs flottantes de 32 bits ou d'entiers sans signe de 8 bits |
bw_cell_to_input_weights | tenseur de n'importe quel type de valeurs ou aucun type |
bw_cell_to_forget_weights | tenseur de n'importe quel type de valeurs ou aucun type |
bw_cell_to_output_weights | tenseur de n'importe quel type de valeurs ou aucun type |
bw_input_gate_bias | tenseur de n'importe quel type de valeurs ou aucun type |
bw_forget_gate_bias | tenseur de valeurs flottantes 32 bits |
bw_cell_bias | tenseur de valeurs flottantes 32 bits |
bw_output_gate_bias | tenseur de valeurs flottantes 32 bits |
bw_projection_weights | tenseur de n'importe quel type de valeurs ou aucun type |
bw_projection_bias | tenseur de n'importe quel type de valeurs ou aucun type |
fw_input_activation_state | tenseur avec état |
fw_input_cell_state | tenseur avec état |
bw_input_activation_state | tenseur avec état |
bw_input_cell_state | tenseur avec état |
aux_input | tenseur de n'importe quel type de valeurs ou aucun type |
fw_aux_input_to_input_weights | tenseur de n'importe quel type de valeurs ou aucun type |
fw_aux_input_to_forget_weights | tenseur de n'importe quel type de valeurs ou aucun type |
fw_aux_input_to_cell_weights | tenseur de n'importe quel type de valeurs ou aucun type |
fw_aux_input_to_output_weights | tenseur de n'importe quel type de valeurs ou aucun type |
bw_aux_input_to_input_weights | tenseur de n'importe quel type de valeurs ou aucun type |
bw_aux_input_to_forget_weights | tenseur de n'importe quel type de valeurs ou aucun type |
bw_aux_input_to_cell_weights | tenseur de n'importe quel type de valeurs ou aucun type |
bw_aux_input_to_output_weights | tenseur de n'importe quel type de valeurs ou aucun type |
Résultats:
Résultat | Description |
---|---|
fw_output | tenseur de tout type de valeurs |
bw_output | tenseur de tout type de valeurs |
tfl.bitcast
(TFL :: BitcastOp)
Opérateur de diffusion de bits
Bitcaste un tenseur d'un type à un autre.
Traits : AlwaysSpeculatableImplTrait
Interfaces : ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effets : MemoryEffects::Effect{}
Opérandes :
Opérande | Description |
---|---|
input | tenseur de tout type de valeurs |
Résultats:
Résultat | Description |
---|---|
output | tenseur de tout type de valeurs |
tfl.bitwise_xor
(TFL :: BitwiseXorOp)
Opérateur Xor au niveau du bit
Elementwise calcule le XOR au niveau du bit de lhs
et rhs
.
Traits : AlwaysSpeculatableImplTrait
, Commutative
, ResultsBroadcastableShape
, SameOperandsAndResultElementType
Interfaces : ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effets : MemoryEffects::Effect{}
Opérandes :
Opérande | Description |
---|---|
lhs | tenseur d'entier sans signe de 8 bits ou d'entier non signé de 8 bits ou d'entier sans signe de 16 bits ou d'entier sans signe de 16 bits ou d'entier sans signe de 32 bits ou de valeurs entières non signées de 32 bits |
rhs | tenseur d'entier sans signe de 8 bits ou d'entier non signé de 8 bits ou d'entier sans signe de 16 bits ou d'entier sans signe de 16 bits ou d'entier sans signe de 32 bits ou de valeurs entières non signées de 32 bits |
Résultats:
Résultat | Description |
---|---|
output | tenseur d'entier sans signe de 8 bits ou d'entier non signé de 8 bits ou d'entier sans signe de 16 bits ou d'entier sans signe de 16 bits ou d'entier sans signe de 32 bits ou de valeurs entières non signées de 32 bits |
tfl.broadcast_args
(TFL::BroadcastArgsOp)
Renvoie la forme de s0 op s1 avec diffusion.
Étant donnés s0
et s1
, tenseurs qui représentent des formes, calculez r0
, la forme diffusée. s0
, s1
et r0
sont tous des vecteurs entiers.
Traits : AlwaysSpeculatableImplTrait
Interfaces : ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effets : MemoryEffects::Effect{}
Opérandes :
Opérande | Description |
---|---|
s0 | tenseur de valeurs entières sans signe 32/64 bits |
s1 | tenseur de valeurs entières sans signe 32/64 bits |
Résultats:
Résultat | Description |
---|---|
r0 | tenseur de valeurs entières sans signe 32/64 bits |
tfl.broadcast_to
(TFL::BroadcastToOp)
Diffusez un tableau pour une forme compatible.
La diffusion est le processus de création de tableaux ayant des formes compatibles pour les opérations arithmétiques. Deux formes sont compatibles si pour chaque paire de dimensions elles sont égales ou si l'une d'elles en est une. Lorsque vous essayez de diffuser un Tensor sur une forme, il commence par les dimensions de fin et progresse.
Par exemple,
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]], forme=(3, 3), dtype=int32)
Dans l'exemple ci-dessus, le Tensor d'entrée avec la forme de [1, 3]
est diffusé vers le Tensor de sortie avec la forme de [3, 3]
.
Lors d'opérations de diffusion telles que la multiplication d'un tenseur par un scalaire, la diffusion confère (généralement) un certain avantage temporel ou spatial, car le tenseur diffusé n'est jamais matérialisé.
Cependant, broadcast_to
n’apporte pas de tels avantages. Le tenseur nouvellement créé prend toute la mémoire de la forme diffusée. (Dans un contexte graphique, broadcast_to
peut cependant être fusionné avec une opération ultérieure, puis optimisé.)
Traits : AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces : ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effets : MemoryEffects::Effect{}
Opérandes :
Opérande | Description |
---|---|
input | tenseur de 32 bits flottants ou entiers sans signe de 32 bits ou entiers sans signe de 1 bits ou entiers sans signe de 4 bits ou entiers sans signe de 8 bits ou de type QI8 ou entiers non signés de 8 bits ou entiers non signés de 32 bits ou de type QUI8 ou 16 entier sans signe de 32 bits ou type QI16 ou entier sans signe de 64 bits ou type complexe avec des valeurs d'éléments flottants de 32 bits |
shape | tenseur de valeurs entières sans signe 32/64 bits |
Résultats:
Résultat | Description |
---|---|
output | tenseur de 32 bits flottants ou entiers sans signe de 32 bits ou entiers sans signe de 1 bits ou entiers sans signe de 4 bits ou entiers sans signe de 8 bits ou de type QI8 ou entiers non signés de 8 bits ou entiers non signés de 32 bits ou de type QUI8 ou 16 entier sans signe de 32 bits ou type QI16 ou entier sans signe de 64 bits ou type complexe avec des valeurs d'éléments flottants de 32 bits |
tfl.bucketize
(TFL::BucketizeOp)
Bucketise les « entrées » en fonction des « limites ».
Exemple:
Si les entrées sont boundaries = [0, 10, 100]
et input = [[-5, 10000][150, 10][5, 100]]
, alors la sortie sera output = [[0, 3][3, 2][1, 3]]
.
Traits : AlwaysSpeculatableImplTrait
, SameOperandsAndResultShape
Interfaces : ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effets : MemoryEffects::Effect{}
Attributs :
Attribut | Type MLIR | Description |
---|---|---|
boundaries | ::mlir::ArrayAttr | Attribut de tableau flottant 32 bits |
Opérandes :
Opérande | Description |
---|---|
input | tenseur de valeurs flottantes 32 bits ou flottantes 64 bits ou d'entiers sans signe 32 bits ou de valeurs entières sans signe 64 bits |
Résultats:
Résultat | Description |
---|---|
output | tenseur de valeurs entières sans signe de 32 bits |
tfl.call_once
(TFL::CallOnceOp)
Appelle une fonction d'initialisation
Cette opération invoque la fonction d'initialisation donnée pour l'initialiseur de session dans le dialecte du modèle enregistré tf.
Interfaces : TflRuntimeVerifyOpInterface
Attributs :
Attribut | Type MLIR | Description |
---|---|---|
session_init_function | ::mlir::StringAttr | attribut de chaîne |
tfl.cast
(TFL::CastOp)
Opérateur de casting
Convertit l’entrée du type d’entrée en type de sortie.
Traits : AlwaysSpeculatableImplTrait
, SameOperandsAndResultShape
Interfaces : ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effets : MemoryEffects::Effect{}
Opérandes :
Opérande | Description |
---|---|
input | tenseur de type float 16 bits ou bfloat16 ou float 32 bits ou float 64 bits ou entier sans signe 1 bit ou entier sans signe 4 bits ou entier sans signe 16 bits ou entier non signé 16 bits ou entier sans signe 32 bits ou Entier non signé de 32 bits ou entier sans signe de 64 bits ou type TFLite quint8 ou entier non signé de 8 bits ou entier sans signe de 8 bits ou type complexe avec des valeurs d'éléments flottants de 32 bits |
Résultats:
Résultat | Description |
---|---|
output | tenseur de type float 16 bits ou bfloat16 ou float 32 bits ou float 64 bits ou entier sans signe 1 bit ou entier sans signe 16 bits ou entier non signé 16 bits ou entier sans signe 32 bits ou entier sans signe 32 bits ou Entier sans signe 64 bits ou type TFLite quint8 ou entier non signé 8 bits ou entier sans signe 8 bits ou type complexe avec valeurs d'éléments flottants 32 bits |
tfl.ceil
(TFL::CeilOp)
Opérateur de plafond
Renvoie la valeur plafond par élément de l’entrée.
Traits : AlwaysSpeculatableImplTrait
, InferTensorType
, TF::SameOperandsAndResultTypeResolveRef
Interfaces : ConditionallySpeculatable
, InferShapedTypeOpInterface
, InferTypeOpInterface
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effets : MemoryEffects::Effect{}
Opérandes :
Opérande | Description |
---|---|
x | tenseur de valeurs flottantes 32 bits |
Résultats:
Résultat | Description |
---|---|
y | tenseur de valeurs flottantes 32 bits |
tfl.complex_abs
(TFL :: ComplexAbsOp)
Calcule la valeur absolue complexe d'un tenseur.
Étant donné un tenseur x
de nombres complexes, cette opération renvoie un tenseur de type float
ou double
qui est la valeur absolue de chaque élément de x
. Tous les éléments de x
doivent être des nombres complexes de la forme \(a + bj\). La valeur absolue est calculée comme \( \sqrt{a^2 + b^2}\).
Traits : AlwaysSpeculatableImplTrait
, SameOperandsAndResultShape
Interfaces : ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effets : MemoryEffects::Effect{}
Opérandes :
Opérande | Description |
---|---|
input | tenseur de type complexe avec des éléments flottants de 32 bits ou de type complexe avec des valeurs d'éléments flottants de 64 bits |
Résultats:
Résultat | Description |
---|---|
output | tenseur de valeurs flottantes 32 bits ou 64 bits |
tfl.concatenation
(TFL::ConcaténationOp)
Opérateur de concaténation
Concatène les tenseurs le long d'une dimension
Traits : AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces : ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Effets : MemoryEffects::Effect{}
Attributs :
Attribut | Type MLIR | Description |
---|---|---|
axis | ::mlir::IntegerAttr | Attribut entier sans signe de 32 bits |
fused_activation_function | ::mlir::StringAttr | attribut de chaîne dont la valeur est NONE, ou RELU, ou RELU_N1_TO_1, ou RELU6, ou TANH, ou SIGN_BIT |
Opérandes :
Opérande | Description |
---|---|
values | variadique de valeurs de tenseur de tout type |
Résultats:
Résultat | Description |
---|---|
output | tenseur de flottant 32 bits ou entier sans signe 64 bits ou entier sans signe 32 bits ou entier sans signe 16 bits ou entier sans signe 8 bits ou type QI8 ou type QUI8 ou entier non signé 8 bits ou entier non signé 32 bits ou 1 -valeurs entières sans signe de bits |
tfl.control_node
(TFL::ControlNodeOp)
L'opération TFL.control_node
encapsule les opérations sur un seul bloc afin d'attacher des bords de contrôle.
Ceci est utilisé pour envelopper des régions et leur attacher des dépendances de contrôle. Généralement, cela se produit dans l'une des dernières étapes avant l'émission du modèle flatbuffer afin de permettre des optimisations qui reposent sur un ordre fixe d'opérations (telles que la rematérialisation.) L'exportateur flatbuffer déballera la région encapsulée et annotera le modèle généré avec des métadonnées. de telle sorte que toute réorganisation d'exécution respectera l'ordre donné par les dépendances de contrôle.
Traits : HasParent<mlir::func::FuncOp>
, RecursiveMemoryEffects
, SingleBlockImplicitTerminator<YieldOp>
, SingleBlock
Opérandes :
Opérande | Description |
---|---|
controlInputs | variadique de contrôle |
Résultats:
Résultat | Description |
---|---|
outputs | variadique de valeurs de tenseur de tout type |
control | contrôle |
tfl.conv_2d
(TFL :: Conv2DOp)
Opérateur de convolution
Effectue une opération de convolution sur les entrées.
Entrées : inputs[0]
: obligatoire : le tenseur d'activation des entrées inputs[1]
: obligatoire : le tenseur de poids du filtre inputs[2]
: facultatif : le tenseur de biais
Traits : AlwaysSpeculatableImplTrait
, QuantizableResult
, quant::AccumulatorUniformScale<2, 0, 1>
, quant::AffineOpCoefficient<0, 1>
Interfaces : AffineQuantizedOpInterface
, ConditionallySpeculatable
, DynamicRangeQuantizedOpInterface
, InferTypeOpInterface
, NoMemoryEffect (MemoryEffectOpInterface)
, TFL_SparseOp
, TflArithmeticCountOpInterface
, TflRuntimeVerifyOpInterface
Effets : MemoryEffects::Effect{}
Attributs :
Attribut | Type MLIR | Description |
---|---|---|
dilation_h_factor | ::mlir::IntegerAttr | Attribut entier sans signe de 32 bits |
dilation_w_factor | ::mlir::IntegerAttr | Attribut entier sans signe de 32 bits |
fused_activation_function | ::mlir::StringAttr | attribut de chaîne dont la valeur est NONE, ou RELU, ou RELU_N1_TO_1, ou RELU6, ou TANH, ou SIGN_BIT |
padding | ::mlir::StringAttr | attribut de chaîne dont la valeur est SAME ou VALID |
stride_h | ::mlir::IntegerAttr | Attribut entier sans signe de 32 bits |
stride_w | ::mlir::IntegerAttr | Attribut entier sans signe de 32 bits |
Opérandes :
Opérande | Description |
---|---|
input | tenseur de valeurs flottantes 32 bits ou de type QI8 ou de type QUI8 ou de type QI16 |
filter | tenseur de valeurs flottantes 32 bits ou de type QI4 ou de type QI8 ou de type QUI8 |
bias | tenseur de n'importe quel type de valeurs ou aucun type |
Résultats:
Résultat | Description |
---|---|
output | tenseur de valeurs flottantes 32 bits ou de type QI8 ou de type QUI8 ou de type QI16 |
tfl.conv_3d
(TFL :: Conv3DOp)
Opérateur 3D de convolution
Effectue une opération de convolution sur les entrées 3D. Entrées : inputs[0]
: obligatoire : le tenseur d'activation des entrées inputs[1]
: obligatoire : le tenseur de poids du filtre inputs[2]
: facultatif : le tenseur de biais
Traits : AlwaysSpeculatableImplTrait
, quant::AccumulatorUniformScale<2, 0, 1>
Interfaces : ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effets : MemoryEffects::Effect{}
Attributs :
Attribut | Type MLIR | Description |
---|---|---|
dilation_d_factor | ::mlir::IntegerAttr | Attribut entier sans signe de 32 bits |
dilation_h_factor | ::mlir::IntegerAttr | Attribut entier sans signe de 32 bits |
dilation_w_factor | ::mlir::IntegerAttr | Attribut entier sans signe de 32 bits |
fused_activation_function | ::mlir::StringAttr | attribut de chaîne dont la valeur est NONE, ou RELU, ou RELU_N1_TO_1, ou RELU6, ou TANH, ou SIGN_BIT |
padding | ::mlir::StringAttr | attribut de chaîne dont la valeur est SAME ou VALID |
stride_d | ::mlir::IntegerAttr | Attribut entier sans signe de 32 bits |
stride_h | ::mlir::IntegerAttr | Attribut entier sans signe de 32 bits |
stride_w | ::mlir::IntegerAttr | Attribut entier sans signe de 32 bits |
Opérandes :
Opérande | Description |
---|---|
input | tenseur de valeurs flottantes 32 bits |
filter | tenseur de valeurs flottantes 32 bits |
bias | tenseur de n'importe quel type de valeurs ou aucun type |
Résultats:
Résultat | Description |
---|---|
output | tenseur de valeurs flottantes 32 bits |
tfl.conv_3d_transpose
(TFL :: Conv3DTransposeOp)
Opérateur 3D de convolution transposée
Effectue une opération de convolution transposée sur les entrées 3D. Entrées : inputs[0]
: obligatoire : la forme du tenseur de sortie inputs[1]
: obligatoire : le tenseur de poids du filtre inputs[2]
: obligatoire : le tenseur d'activation d'entrée inputs[3]
: facultatif : le tenseur de biais
Traits : AlwaysSpeculatableImplTrait
, quant::AccumulatorUniformScale<2, 0, 1>
Interfaces : ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effets : MemoryEffects::Effect{}
Attributs :
Attribut | Type MLIR | Description |
---|---|---|
dilation_d_factor | ::mlir::IntegerAttr | Attribut entier sans signe de 32 bits |
dilation_h_factor | ::mlir::IntegerAttr | Attribut entier sans signe de 32 bits |
dilation_w_factor | ::mlir::IntegerAttr | Attribut entier sans signe de 32 bits |
fused_activation_function | ::mlir::StringAttr | attribut de chaîne dont la valeur est NONE, ou RELU, ou RELU_N1_TO_1, ou RELU6, ou TANH, ou SIGN_BIT |
padding | ::mlir::StringAttr | attribut de chaîne dont la valeur est SAME ou VALID |
stride_d | ::mlir::IntegerAttr | Attribut entier sans signe de 32 bits |
stride_h | ::mlir::IntegerAttr | Attribut entier sans signe de 32 bits |
stride_w | ::mlir::IntegerAttr | Attribut entier sans signe de 32 bits |
Opérandes :
Opérande | Description |
---|---|
output_shape | tenseur de valeurs entières sans signe de 32 bits |
filter | tenseur de valeurs flottantes 32 bits |
input | tenseur de valeurs flottantes 32 bits |
bias | tenseur de n'importe quel type de valeurs ou aucun type |
Résultats:
Résultat | Description |
---|---|
output | tenseur de valeurs flottantes 32 bits |
tfl.cos
(TFL::CosOp)
Opérateur cosinus
Calcule le cosinus de l'entrée par élément
Traits : AlwaysSpeculatableImplTrait
, InferTensorType
, TF::SameOperandsAndResultTypeResolveRef
Interfaces : ConditionallySpeculatable
, InferShapedTypeOpInterface
, InferTypeOpInterface
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effets : MemoryEffects::Effect{}
Opérandes :
Opérande | Description |
---|---|
x | tenseur de valeurs flottantes 32 bits |
Résultats:
Résultat | Description |
---|---|
y | tenseur de valeurs flottantes 32 bits |
tfl.cumsum
(TFL::CumsumOp)
Opérateur cumulatif
Calculez la somme cumulée du tenseur x le long de l'axe.
Traits : AlwaysSpeculatableImplTrait
Interfaces : ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effets : MemoryEffects::Effect{}
Attributs :
Attribut | Type MLIR | Description |
---|---|---|
exclusive | ::mlir::BoolAttr | attribut booléen |
reverse | ::mlir::BoolAttr | attribut booléen |
Opérandes :
Opérande | Description |
---|---|
input | tenseur de valeurs flottantes de 32 bits ou d'entiers sans signe de 32 bits ou de valeurs entières sans signe de 64 bits |
axis | tenseur de valeurs entières sans signe de 32 bits |
Résultats:
Résultat | Description |
---|---|
output | tenseur de valeurs flottantes de 32 bits ou d'entiers sans signe de 32 bits ou de valeurs entières sans signe de 64 bits |
tfl.custom
(TFL::CustomOp)
Opération personnalisée
Une opération générique pour toute opération personnalisée TFLite.
input : Une liste d’entrées dans l’opération originale. custom_code : une chaîne utilisée pour identifier exactement cette opération, qui correspond à Operator_codes.custom_code dans le flatbuffer. custom_option : un support pour enregistrer les attributs op en mode octets. sortie : une liste de sorties dans l'opération d'origine.
Interfaces : TflRuntimeVerifyOpInterface
Attributs :
Attribut | Type MLIR | Description |
---|---|---|
custom_code | ::mlir::StringAttr | attribut de chaîne |
custom_option | ::mlir::TFL::ConstBytesAttr | Une représentation d'attribut de chaîne des octets compilés |
Opérandes :
Opérande | Description |
---|---|
input | variadique de tenseur de tout type de valeurs ou aucun type |
Résultats:
Résultat | Description |
---|---|
output | variadique de valeurs de tenseur de tout type |
tfl.custom_tf
(TFL::CustomTfOp)
Wrapper Op pour les opérations personnalisées TF.
Une opération wrapper autour de n’importe quelle opération Custom TF. Celles-ci incluent les opérations définies à l'aide de custom_opdefs ou liées qui ne sont pas définies dans le dialecte TF. Cette opération enveloppe simplement l'opération personnalisée dans une région. Remarque n°1, cette opération n'inclura pas les opérations personnalisées TF Lite définies à l'aide de CustomOp. Remarque n°2, cette opération n'est qu'une représentation interne à l'intérieur du convertisseur et n'est pas exposée/exportée lorsque le modèle est exporté vers Flatbuffer.
Traits : IsolatedFromAbove
, RecursiveMemoryEffects
, SingleBlockImplicitTerminator<YieldOp>
, SingleBlock
Interfaces : InferTypeOpInterface
, TflRuntimeVerifyOpInterface
Opérandes :
Opérande | Description |
---|---|
input | variadique de tenseur de tout type de valeurs ou aucun type |
Résultats:
Résultat | Description |
---|---|
output | variadique de valeurs de tenseur de tout type |
tfl.densify
(TFL::DensifyOp)
Opérateur densification
Convertit le tenseur clairsemé en format dense.
Traits : AlwaysSpeculatableImplTrait
Interfaces : ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effets : MemoryEffects::Effect{}
Opérandes :
Opérande | Description |
---|---|
input | tenseur de valeurs flottantes de 32 bits ou d'entiers sans signe de 8 bits |
Résultats:
Résultat | Description |
---|---|
output | tenseur de valeurs flottantes de 32 bits ou d'entiers sans signe de 8 bits |
tfl.depth_to_space
(TFL :: ProfondeurToSpaceOp)
Opérateur ProfondeurVers Espace
Réorganise les données de la profondeur en blocs de données spatiales. Il s'agit de la transformation inverse de SpaceToDepth. Plus précisément, cette opération génère une copie du tenseur d'entrée où les valeurs de la dimension depth
sont déplacées dans des blocs spatiaux vers les dimensions height
et width
. L'attr block_size
indique la taille du bloc d'entrée et la manière dont les données sont déplacées.
Traits : AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces : ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Effets : MemoryEffects::Effect{}
Attributs :
Attribut | Type MLIR | Description |
---|---|---|
block_size | ::mlir::IntegerAttr | Attribut entier sans signe de 32 bits dont la valeur est positive |
Opérandes :
Opérande | Description |
---|---|
input | tenseur de valeurs flottantes de 32 bits ou d'entier sans signe de 8 bits ou d'entier sans signe de 32 bits ou d'entier sans signe de 64 bits ou de type TFLite quint8 ou d'entier non signé de 8 bits ou de valeurs de type QI8 ou de type QUI8 |
Résultats:
Résultat | Description |
---|---|
output | tenseur de valeurs flottantes de 32 bits ou d'entier sans signe de 8 bits ou d'entier sans signe de 32 bits ou d'entier sans signe de 64 bits ou de type TFLite quint8 ou d'entier non signé de 8 bits ou de valeurs de type QI8 ou de type QUI8 |
tfl.depthwise_conv_2d
(TFL :: DepthwiseConv2DOp)
Opérateur de convolution séparable en profondeur
Effectue une opération de convolution sur les entrées.
Entrées : inputs[0]
: obligatoire : le tenseur d'activation des entrées inputs[1]
: obligatoire : le tenseur de poids du filtre inputs[2]
: facultatif : le tenseur de biais
Traits : AlwaysSpeculatableImplTrait
, QuantizableResult
, quant::AccumulatorUniformScale<2, 0, 1>
, quant::AffineOpCoefficient<3, 1>
Interfaces : AffineQuantizedOpInterface
, ConditionallySpeculatable
, DynamicRangeQuantizedOpInterface
, NoMemoryEffect (MemoryEffectOpInterface)
, TFL_SparseOp
, TflArithmeticCountOpInterface
, TflRuntimeVerifyOpInterface
Effets : MemoryEffects::Effect{}
Attributs :
Attribut | Type MLIR | Description |
---|---|---|
dilation_h_factor | ::mlir::IntegerAttr | Attribut entier sans signe de 32 bits |
dilation_w_factor | ::mlir::IntegerAttr | Attribut entier sans signe de 32 bits |
fused_activation_function | ::mlir::StringAttr | attribut de chaîne dont la valeur est NONE, ou RELU, ou RELU_N1_TO_1, ou RELU6, ou TANH, ou SIGN_BIT |
padding | ::mlir::StringAttr | attribut de chaîne dont la valeur est SAME ou VALID |
stride_h | ::mlir::IntegerAttr | Attribut entier sans signe de 32 bits |
stride_w | ::mlir::IntegerAttr | Attribut entier sans signe de 32 bits |
depth_multiplier | ::mlir::IntegerAttr | Attribut entier sans signe de 32 bits |
Opérandes :
Opérande | Description |
---|---|
input | tenseur de valeurs flottantes 32 bits ou de type QI8 ou de type QUI8 ou de type QI16 |
filter | tenseur de valeurs flottantes 32 bits ou de type QI4 ou de type QI8 ou de type QUI8 |
bias | tenseur de n'importe quel type de valeurs ou aucun type |
Résultats:
Résultat | Description |
---|---|
output | tenseur de valeurs flottantes 32 bits ou de type QI8 ou de type QUI8 ou de type QI16 |
tfl.dequantize
(TFL::DequantizeOp)
Opérateur de déquantification
Convertit un tableau quantifié d'entiers en virgules flottantes en fonction des paramètres de quantification.
Interfaces : NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effets : MemoryEffects::Effect{}
Opérandes :
Opérande | Description |
---|---|
input | tenseur de type QI4 ou type QI8 ou type QUI8 ou type QI16 ou valeurs flottantes 16 bits |
Résultats:
Résultat | Description |
---|---|
output | tenseur de valeurs flottantes 32 bits |
tfl.dilate
(TFL::DilateOp)
Opérateur de dilatation
Étend un tenseur en ajoutant de nouveaux éléments entre ceux existants. Traits : AlwaysSpeculatableImplTrait
Interfaces : ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effets : MemoryEffects::Effect{}
Opérandes :
Opérande | Description |
---|---|
input | tenseur d'un entier sans signe de 8 bits ou d'un entier sans signe de 16 bits ou d'un entier sans signe de 32 bits ou d'un entier sans signe de 64 bits ou d'un entier non signé de 8 bits ou d'un entier non signé de 16 bits ou d'un entier non signé de 32 bits ou d'un entier non signé de 64 bits ou Valeurs flottantes 32 bits ou 64 bits |
dilations | tenseur de valeurs entières sans signe de 32 bits |
padding_value | Tenseur 0D de tout type de valeurs |
Résultats:
Résultat | Description |
---|---|
output | tenseur d'un entier sans signe de 8 bits ou d'un entier sans signe de 16 bits ou d'un entier sans signe de 32 bits ou d'un entier sans signe de 64 bits ou d'un entier non signé de 8 bits ou d'un entier non signé de 16 bits ou d'un entier non signé de 32 bits ou d'un entier non signé de 64 bits ou Valeurs flottantes 32 bits ou 64 bits |
tfl.div
(TFL::DivOp)
Opérateur de division
Opération de division par éléments.
Traits : ::mlir::OpTrait::TFLRuntimeOpTrait
, AlwaysSpeculatableImplTrait
, ResultsBroadcastableShape
Interfaces : ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflArithmeticCountOpInterface
, TflRuntimeVerifyOpInterface
Effets : MemoryEffects::Effect{}
Attributs :
Attribut | Type MLIR | Description |
---|---|---|
fused_activation_function | ::mlir::StringAttr | attribut de chaîne dont la valeur est NONE, ou RELU, ou RELU_N1_TO_1, ou RELU6, ou TANH, ou SIGN_BIT |
Opérandes :
Opérande | Description |
---|---|
lhs | tenseur de valeurs flottantes 32 bits ou entières sans signe 32 bits ou de type QUI8 |
rhs | tenseur de valeurs flottantes 32 bits ou entières sans signe 32 bits ou de type QUI8 |
Résultats:
Résultat | Description |
---|---|
output | tenseur de valeurs flottantes 32 bits ou entières sans signe 32 bits ou de type QUI8 |
tfl.dynamic_update_slice
(TFL :: DynamicUpdateSliceOp)
DynamicUpdateSlice.
Opération DynamicUpdateSlice qui a la même sémantique avec XLA DynamicUpdateSlice. Génère un résultat qui est la valeur de l'opérande du tableau d'entrée, avec une mise à jour de tranche écrasée à start_indices.
Voir https://www.tensorflow.org/xla/operation_semantics#dynamicupdateslice
Traits : AlwaysSpeculatableImplTrait
Interfaces : ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effets : MemoryEffects::Effect{}
Opérandes :
Opérande | Description |
---|---|
operand | tenseur d'un entier sans signe de 1 bit ou d'un entier sans signe de 8 bits ou d'un entier sans signe de 32 bits ou d'un entier sans signe de 64 bits ou de valeurs flottantes de 32 bits |
update | Tensor d'un entier sans signe 1 bits ou entier sans signe 8 bits ou en entier sans signe 32 bits ou en entier sans signe 64 bits ou à 32 bits |
start_indices | tenseur de valeurs entières sans signe 32/64 bits |
Résultats:
Résultat | Description |
---|---|
output | Tensor d'un entier sans signe 1 bits ou entier sans signe 8 bits ou en entier sans signe 32 bits ou en entier sans signe 64 bits ou à 32 bits |
tfl.elu
(tfl :: eluop)
Opérateur d'unité linéaire exponentielle
Calcule le fonentiel linéaire f (x) -> exp (x) - 1 pour x <0, x pour x> = 0. en termes d'élément.
TRAITS: AlwaysSpeculatableImplTrait
, SameOperandsAndResultShape
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effets: MemoryEffects::Effect{}
Opérandes:
Opérande | Description |
---|---|
x | Tensor de Float 32 bits ou de valeurs entières sans signe 8 bits |
Résultats:
Résultat | Description |
---|---|
y | Tensor de Float 32 bits ou de valeurs entières sans signe 8 bits |
tfl.embedding_lookup
(tfl :: Embeddinglookupop)
Opérateur de recherche d'intégration
Fonds les ID dans une liste de tenseurs d'intégration.
TRAITS: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces: AffineQuantizedOpInterface
, ConditionallySpeculatable
, DynamicRangeQuantizedOpInterface
, NoMemoryEffect (MemoryEffectOpInterface)
TflRuntimeVerifyOpInterface
Effets: MemoryEffects::Effect{}
Opérandes:
Opérande | Description |
---|---|
lookup | tenseur de valeurs entières sans signe 32 bits |
value | Tensor d'un flotteur 32 bits ou d'un entier sans signe 8 bits ou de valeurs de type ou de type Qi8 ou de type Qi8 de type ou de type QI8 ou de type QI4 ou QI4 |
Résultats:
Résultat | Description |
---|---|
output | tenseur de flotteur 32 bits ou entier sans signe 8 bits ou valeurs entières non signées 8 bits |
tfl.equal
(tfl :: equalop)
Opérateur égal
Renvoie l'élément de vérité de x == y élément par élément
TRAITS: ::mlir::OpTrait::TFLRuntimeOpTrait
, Commutative
AlwaysSpeculatableImplTrait
, QuantizableResult
, ResultsBroadcastableShape
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effets: MemoryEffects::Effect{}
Opérandes:
Opérande | Description |
---|---|
x | Tensor d'un entier sans signe 1 bits ou d'un flotteur 32 bits ou d'un entier sans signe 16 bits ou d'un entier non signé 32 bits ou d'un entier de type Qi8 ou de type QI8 de type ou de type QI8 ou de type qui8 ou 8 bits non signé ou tflite |
y | Tensor d'un entier sans signe 1 bits ou d'un flotteur 32 bits ou d'un entier sans signe 16 bits ou d'un entier non signé 32 bits ou d'un entier de type Qi8 ou de type QI8 de type ou de type QI8 ou de type qui8 ou 8 bits non signé ou tflite |
Résultats:
Résultat | Description |
---|---|
output | tenseur de valeurs entières sans signe 1 bits |
tfl.exp
(tfl :: expop)
Opérateur d'exponenation naturelle
Effectue un fonctionnement d'exponentiation naturelle sur l'élément sur l'entrée.
TRAITS: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effets: MemoryEffects::Effect{}
Opérandes:
Opérande | Description |
---|---|
x | Tensor de valeurs de type flotteur 32 bits ou de type qi8 ou qi16 |
Résultats:
Résultat | Description |
---|---|
y | Tensor de valeurs de type flotteur 32 bits ou de type qi8 ou qi16 |
tfl.expand_dims
(Tfl :: ExpandDimSop)
Insère une dimension de 1 dans la forme d'un tenseur.
Étant donné une input
du tenseur, cette opération insère une dimension de 1 à l' axis
de l'indice de dimension de la forme de input
. L' axis
de l'indice de dimension commence à zéro; Si vous spécifiez un nombre négatif pour axis
il est compté vers l'arrière de la fin.
Cette opération est utile si vous souhaitez ajouter une dimension de lot à un seul élément. Par exemple, si vous avez une seule image de forme [height, width, channels]
, vous pouvez en faire un lot de 1 image avec expand_dims(image, 0)
, qui fera la forme [1, height, width, channels]
.
Autres exemples:
# '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]
Cette opération nécessite que:
-1-input.dims() <= dim <= input.dims()
Cette opération est liée à squeeze()
, qui supprime les dimensions de la taille 1.
TRAITS: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Effets: MemoryEffects::Effect{}
Opérandes:
Opérande | Description |
---|---|
input | tenseur de tout type de valeurs |
dim | tenseur de valeurs entières sans signe 32/64 bits |
Résultats:
Résultat | Description |
---|---|
output | tenseur de tout type de valeurs |
tfl.external_const
(tfl :: externalconstop)
Const OP externe.
Le const op externe contient un buffer_index
qui pointe vers une constante dans le flatbuffer.
TRAITS: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effets: MemoryEffects::Effect{}
Attributs :
Attribut | Type mlir | Description |
---|---|---|
buffer_index | :: Mlir :: Integerattr | Attribut entier sans signe 32 bits |
Résultats:
Résultat | Description |
---|---|
output | tenseur de tout type de valeurs |
tfl.fake_quant
(tfl :: FakeQuantop)
Faux opérateur
Fake-Quantifie le tenseur «Entrées» de type flottant via des scalaires de flottants min et max sur le tenseur «sort» de la même forme que les entrées.
TRAITS: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effets: MemoryEffects::Effect{}
Attributs :
Attribut | Type mlir | Description |
---|---|---|
min | :: mlir :: floatattr | Attribut de flotteur 32 bits |
max | :: mlir :: floatattr | Attribut de flotteur 32 bits |
num_bits | :: Mlir :: Integerattr | Attribut entier sans signe 32 bits dont la valeur minimale est 2 dont la valeur maximale est de 16 |
narrow_range | :: mlir :: boolattr | Attribut bool dont la valeur est fausse |
Opérandes:
Opérande | Description |
---|---|
input | tenseur de valeurs flottantes 32 bits |
Résultats:
Résultat | Description |
---|---|
output | tenseur de valeurs flottantes 32 bits |
tfl.fill
(tfl :: fillop)
Remplissez le tenseur de valeur donnée.
Remplissez le tenseur de valeur donnée.
TRAITS: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Effets: MemoryEffects::Effect{}
Opérandes:
Opérande | Description |
---|---|
dims | tenseur de valeurs entières sans signe 32/64 bits |
input | tenseur de flotteur 32 bits ou de flotteur 16 bits ou entier sans signe 32 bits ou entier sans signe 64 bits ou entier sans signe 1 bits de type ou de type Qi8 ou Qi16 ou Tflite de type de chaîne |
Résultats:
Résultat | Description |
---|---|
result | tenseur de flotteur 32 bits ou de flotteur 16 bits ou entier sans signe 32 bits ou entier sans signe 64 bits ou entier sans signe 1 bits de type ou de type Qi8 ou Qi16 ou Tflite de type de chaîne |
tfl.floor
(Tfl :: Floorop)
Plancher
Renvoie la valeur du plancher des éléments de l'entrée.
TRAITS: AlwaysSpeculatableImplTrait
, InferTensorType
, TF::SameOperandsAndResultTypeResolveRef
Interfaces: ConditionallySpeculatable
, InferShapedTypeOpInterface
, InferTypeOpInterface
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effets: MemoryEffects::Effect{}
Opérandes:
Opérande | Description |
---|---|
x | tenseur de valeurs flottantes 32 bits |
Résultats:
Résultat | Description |
---|---|
y | tenseur de valeurs flottantes 32 bits |
tfl.floor_div
(tfl :: floordivop)
Opérateur de plancher
Fonctionnement des div au sol des éléments.
TRAITS: ::mlir::OpTrait::TFLRuntimeOpTrait
, AlwaysSpeculatableImplTrait
, ResultsBroadcastableShape
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effets: MemoryEffects::Effect{}
Opérandes:
Opérande | Description |
---|---|
lhs | Tensor de flotteur 32 bits ou entier sans signe 8 bits ou entier sans signe 16 bits ou valeurs entières sans signe 32 bits |
rhs | Tensor de flotteur 32 bits ou entier sans signe 8 bits ou entier sans signe 16 bits ou valeurs entières sans signe 32 bits |
Résultats:
Résultat | Description |
---|---|
output | Tensor de flotteur 32 bits ou entier sans signe 8 bits ou entier sans signe 16 bits ou valeurs entières sans signe 32 bits |
tfl.floor_mod
(tfl :: floormodop)
Rappel de division
Fonctionnement du rappel de division par élément.
TRAITS: ::mlir::OpTrait::TFLRuntimeOpTrait
, AlwaysSpeculatableImplTrait
, ResultsBroadcastableShape
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effets: MemoryEffects::Effect{}
Opérandes:
Opérande | Description |
---|---|
lhs | Tensor d'un entier sans signe 8 bits ou entier sans signe 16 bits ou en entier sans signe 32 bits ou en entier sans signe 64 bits ou à 32 bits |
rhs | Tensor d'un entier sans signe 8 bits ou entier sans signe 16 bits ou en entier sans signe 32 bits ou en entier sans signe 64 bits ou à 32 bits |
Résultats:
Résultat | Description |
---|---|
output | Tensor d'un entier sans signe 8 bits ou entier sans signe 16 bits ou en entier sans signe 32 bits ou en entier sans signe 64 bits ou à 32 bits |
tfl.fully_connected
(tfl :: FullConnectedOp)
OP entièrement connecté
TRAITS: AlwaysSpeculatableImplTrait
, QuantizableResult
, quant::AccumulatorUniformScale<2, 0, 1>
, quant::AffineOpCoefficient<0, 1>
Interfaces: AffineQuantizedOpInterface
, ConditionallySpeculatable
, DynamicRangeQuantizedOpInterface
, NoMemoryEffect (MemoryEffectOpInterface)
, TFL_SparseOp
, TflArithmeticCountOpInterface
, TflRuntimeVerifyOpInterface
Effets: MemoryEffects::Effect{}
Attributs :
Attribut | Type mlir | Description |
---|---|---|
fused_activation_function | :: mlir :: stringattr | attribut de chaîne dont la valeur n'est pas, ou relu, ou relu_n1_to_1, ou relu6, ou tanh, ou signe_bit |
weights_format | :: mlir :: stringattr | attribut de chaîne dont la valeur est par défaut, ou shuffled4x16int8 |
keep_num_dims | :: mlir :: boolattr | attribut bool |
asymmetric_quantize_inputs | :: mlir :: boolattr | attribut bool |
Opérandes:
Opérande | Description |
---|---|
input | Tensor de type flotteur 32 bits ou de type Qi8 ou de type Qui8 ou de type Type Qi16 ou Qui16 |
filter | Tensor de type flotteur 32 bits ou de type Qi4 ou de type Qi8 ou de type QI8 ou de type Qi16 |
bias | tenseur de tout type de valeurs ou aucun type |
Résultats:
Résultat | Description |
---|---|
output | variadique du tenseur de tout type de valeurs |
tfl.gather
(tfl :: rassemblement)
Rasseoir opérateur
Rassemblez les tranches de l' axis
params
de l'axe en fonction des indices
.
TRAITS: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces: ConditionallySpeculatable
, DynamicRangeQuantizedOpInterface
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Effets: MemoryEffects::Effect{}
Attributs :
Attribut | Type mlir | Description |
---|---|---|
axis | :: Mlir :: Integerattr | Attribut entier sans signe 32 bits |
batch_dims | :: Mlir :: Integerattr | Attribut entier sans signe 32 bits |
Opérandes:
Opérande | Description |
---|---|
params | Tensor d'un flotteur 32 bits ou d'un entier sans signe 1 bits ou d'un entier sans signe sans sign Valeurs de type de type ou de type Qi8 ou Qi8 de type ou de type QI8 |
indices | Tensor d'un entier sans signe 16 bits ou en entier sans signe 32 bits ou des valeurs entières sans signe 64 bits |
Résultats:
Résultat | Description |
---|---|
output | Tensor d'un flotteur 32 bits ou d'un entier sans signe 1 bits ou d'un entier sans signe sans sign Valeurs de type de type ou de type Qi8 ou Qi8 de type ou de type QI8 |
tfl.gather_nd
(tfl :: Gatherndop)
_Gather et opérateur
Rassemblez des tranches des params
dans un tenseur avec une forme spécifiée par indices
.
TRAITS: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Effets: MemoryEffects::Effect{}
Opérandes:
Opérande | Description |
---|---|
params | Tensor d'un flotteur 32 bits ou d'un entier non signé 1 bits ou d'un entier non signé à 8 bits ou en entier sim sans signe 16 bits ou en entier non signé 64 bits ou 32 bits entier de type entier non signé ou à 8 bits |
indices | Tensor d'un entier sans signe 16 bits ou en entier sans signe 32 bits ou des valeurs entières sans signe 64 bits |
Résultats:
Résultat | Description |
---|---|
output | Tensor d'un flotteur 32 bits ou d'un entier non signé 1 bits ou d'un entier non signé à 8 bits ou en entier sim sans signe 16 bits ou en entier non signé 64 bits ou 32 bits entier de type entier non signé ou à 8 bits |
tfl.gelu
(tfl :: geluop)
Fonction d'activation de Gelu.
Calcule la fonction d'activation de Gelu en termes d'élément.
TRAITS: AlwaysSpeculatableImplTrait
, QuantizableResult
, SameOperandsAndResultShape
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effets: MemoryEffects::Effect{}
Attributs :
Attribut | Type mlir | Description |
---|---|---|
approximate | :: mlir :: boolattr | attribut bool |
Opérandes:
Opérande | Description |
---|---|
input | tenseur de valeurs de type flotteur ou de type Qi8 de type ou de type Qi8 |
Résultats:
Résultat | Description |
---|---|
output | tenseur de valeurs de type flotteur ou de type Qi8 de type ou de type Qi8 |
tfl.greater
(Tfl :: Greaterop)
Plus grand opérateur
Opération plus grande en termes d'éléments.
TRAITS: ::mlir::OpTrait::TFLRuntimeOpTrait
, AlwaysSpeculatableImplTrait
, QuantizableResult
, ResultsBroadcastableShape
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effets: MemoryEffects::Effect{}
Opérandes:
Opérande | Description |
---|---|
lhs | Tensor de flotteur 32 bits ou entier sans signe 32 bits ou entier sans signe 64 bits de type ou de type QI8 ou de type QI8 ou Tflite Quint8 |
rhs | Tensor de flotteur 32 bits ou entier sans signe 32 bits ou entier sans signe 64 bits de type ou de type QI8 ou de type QI8 ou Tflite Quint8 |
Résultats:
Résultat | Description |
---|---|
output | tenseur de valeurs entières sans signe 1 bits |
tfl.greater_equal
(Tfl :: GreaterEqualop)
_Greater Opérateur égal
Fonctionnement du grand_équal sur le plan des éléments.
TRAITS: ::mlir::OpTrait::TFLRuntimeOpTrait
, AlwaysSpeculatableImplTrait
, QuantizableResult
, ResultsBroadcastableShape
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effets: MemoryEffects::Effect{}
Opérandes:
Opérande | Description |
---|---|
lhs | Tensor de flotteur 32 bits ou entier sans signe 16 bits ou entier sans signe 32 bits ou valeurs de type de type QI8 ou de type QI8 |
rhs | Tensor de flotteur 32 bits ou entier sans signe 16 bits ou entier sans signe 32 bits ou valeurs de type de type QI8 ou de type QI8 |
Résultats:
Résultat | Description |
---|---|
output | tenseur de valeurs entières sans signe 1 bits |
tfl.hard_swish
(tfl :: Hardswishop)
Fonction d'activation durswish.
Calcule la fonction d'activation dure-swish f (x) -> (x * relu6 (x + 3)) / 6 élément.
TRAITS: AlwaysSpeculatableImplTrait
, QuantizableResult
, SameOperandsAndResultShape
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effets: MemoryEffects::Effect{}
Opérandes:
Opérande | Description |
---|---|
input | tenseur de valeurs de type flotteur ou qui8 de type ou Qi8 32 bits |
Résultats:
Résultat | Description |
---|---|
output | tenseur de valeurs de type flotteur ou qui8 de type ou Qi8 32 bits |
tfl.hashtable
(tfl :: hashtableop)
Crée une table de hachage non initialisée.
Cet OP crée une table de hachage, spécifiant le type de ses clés et valeurs. Avant d'utiliser le tableau, vous devrez l'initialiser. Après initialisation, le tableau sera immuable.
Interfaces: TflRuntimeVerifyOpInterface
Attributs :
Attribut | Type mlir | Description |
---|---|---|
table_id | :: Mlir :: Integerattr | Attribut entier sans signe 32 bits |
key_dtype | :: mlir :: typattr | Tout type d'attribut |
value_dtype | :: mlir :: typattr | Tout type d'attribut |
Résultats:
Résultat | Description |
---|---|
out | tenseur des valeurs des ressources |
tfl.hashtable_find
(tfl :: hashTableFindop)
Fonds les touches dans un tableau, publie les valeurs correspondantes.
Les keys
du tenseur doivent du même type que les clés de la table. Les values
de sortie sont du type des valeurs du tableau.
Le scalar default_value
est la sortie de valeur pour les touches non présentes dans le tableau. Il doit également être du même type que les valeurs du tableau.
Interfaces: TflRuntimeVerifyOpInterface
Opérandes:
Opérande | Description |
---|---|
hash_table | tenseur des valeurs des ressources |
keys | Tensor de type entier ou de chaîne Tflite 32 bits ou de valeurs entières sans signe 64 bits |
default_value | Tensor de flotteur 32 bits ou de type de chaîne Tflite 32 bits ou de valeurs en entier sans signe 64 bits |
Résultats:
Résultat | Description |
---|---|
out | Tensor de flotteur 32 bits ou de type de chaîne Tflite 32 bits ou de valeurs en entier sans signe 64 bits |
tfl.hashtable_import
(tfl :: hashTableImportop)
Remplace le contenu du tableau par les clés et valeurs spécifiées.
Les keys
du tenseur doivent être du même type que les clés de la table. Les values
du tenseur doivent être du type des valeurs du tableau.
Interfaces: TflRuntimeVerifyOpInterface
Opérandes:
Opérande | Description |
---|---|
hash_table | tenseur des valeurs des ressources |
keys | Tensor de type entier ou de chaîne Tflite 32 bits ou de valeurs entières sans signe 64 bits |
values | Tensor de flotteur 32 bits ou de type de chaîne Tflite 32 bits ou de valeurs en entier sans signe 64 bits |
tfl.hashtable_size
(tfl :: hashtableSizeop)
Calcule le nombre d'éléments dans le tableau donné.
Interfaces: TflRuntimeVerifyOpInterface
Opérandes:
Opérande | Description |
---|---|
hash_table | tenseur des valeurs des ressources |
Résultats:
Résultat | Description |
---|---|
out | tenseur de valeurs entières sans signe 64 bits |
tfl.if
(tfl :: ifop)
Opération if-thel-else
L'opération tfl.if
représente une construction if-then-else pour exécuter conditionnellement deux régions de code. L'opérande vers une opération IF est une valeur booléenne. Par exemple:
tfl.if %b {
...
} else {
...
}
tfl.if
peut également renvoyer des résultats définis dans ses régions. Les valeurs définies sont déterminées par lesquelles le chemin d'exécution est suivi.
Exemple:
%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>
}
Les régions tfl.if
sont toujours terminées avec "tfl.yield". Si "tfl.if" ne définit aucune valeur, le "tfl.yield" peut être laissé de côté et sera inséré implicitement. Sinon, il doit être explicite. De plus, si "tfl.if" définit une ou plusieurs valeurs, le bloc «else» ne peut pas être omis.
Exemple:
tfl.if %b {
...
}
Traits: NoRegionArguments
, RecursiveMemoryEffects
, SingleBlockImplicitTerminator<YieldOp>
, SingleBlock
Interfaces: RegionBranchOpInterface
, TflRuntimeVerifyOpInterface
Opérandes:
Opérande | Description |
---|---|
cond | tenseur de valeurs entières sans signe 1 bits |
Résultats:
Résultat | Description |
---|---|
results | variadique du tenseur de tout type de valeurs |
tfl.imag
(tfl :: imagop)
Renvoie la partie imaginaire d'un nombre complexe.
Compte tenu d'une input
tenseur de nombres complexes, cette opération renvoie un tenseur de float
de type qui est la partie imaginaire de chaque élément de input
. Tous les éléments en input
doivent être des nombres complexes de la forme \(a + bj\), où A est la partie réelle et B est la partie imaginaire renvoyée par cette opération.
TRAITS: AlwaysSpeculatableImplTrait
, SameOperandsAndResultShape
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effets: MemoryEffects::Effect{}
Opérandes:
Opérande | Description |
---|---|
input | tenseur de type complexe avec des éléments flottants 32 bits ou un type complexe avec des valeurs d'éléments flottants 64 bits |
Résultats:
Résultat | Description |
---|---|
output | Tensor de Float 32 bits ou de valeurs de flotteur 64 bits |
tfl.l2_normalization
(Tfl :: l2NormalizationOP)
L2 Normaliser l'opérateur
L2Normalisation op
TRAITS: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces: ConditionallySpeculatable
, FixedOutputRangeInterface
, NoMemoryEffect (MemoryEffectOpInterface)
, TflArithmeticCountOpInterface
, TflRuntimeVerifyOpInterface
Effets: MemoryEffects::Effect{}
Attributs :
Attribut | Type mlir | Description |
---|---|---|
fused_activation_function | :: mlir :: stringattr | attribut de chaîne dont la valeur n'est pas, ou relu, ou relu_n1_to_1, ou relu6, ou tanh, ou signe_bit |
Opérandes:
Opérande | Description |
---|---|
input | Tensor de type flotteur 32 bits ou de type QI8 ou de type QI8 ou de type QI16 ou de type entier sans signe 8 bits |
Résultats:
Résultat | Description |
---|---|
output | Tensor de type flotteur 32 bits ou de type QI8 ou de type QI8 ou de type QI16 ou de type entier sans signe 8 bits |
tfl.leaky_relu
(tfl :: Leakyreluop)
Opérateur de relue
Opérateur de relu d'élève qui fuit x -> x> = 0? x: (alpha * x)
TRAITS: AlwaysSpeculatableImplTrait
, QuantizableResult
, SameOperandsAndResultShape
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effets: MemoryEffects::Effect{}
Attributs :
Attribut | Type mlir | Description |
---|---|---|
alpha | :: mlir :: floatattr | Attribut de flotteur 32 bits |
Opérandes:
Opérande | Description |
---|---|
input | Tensor de type flotteur 32 bits ou de type QI8 ou de type TFLITE QUINT8 TYPE ou TYPE QI16 |
Résultats:
Résultat | Description |
---|---|
output | Tensor de type flotteur 32 bits ou de type QI8 ou de type TFLITE QUINT8 TYPE ou TYPE QI16 |
tfl.less
(tfl :: moins)
Moins opérateur
Élément en moins de fonctionnement.
TRAITS: ::mlir::OpTrait::TFLRuntimeOpTrait
, AlwaysSpeculatableImplTrait
, QuantizableResult
, ResultsBroadcastableShape
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effets: MemoryEffects::Effect{}
Opérandes:
Opérande | Description |
---|---|
lhs | Tensor de flotteur 32 bits ou entier sans signe 16 bits ou entier sans signe 32 bits ou entier sans signe 64 bits |
rhs | Tensor de flotteur 32 bits ou entier sans signe 16 bits ou entier sans signe 32 bits ou entier sans signe 64 bits |
Résultats:
Résultat | Description |
---|---|
output | tenseur de valeurs entières sans signe 1 bits |
tfl.less_equal
(tfl :: LessEqualop)
_ Opérateur égal
Fonctionnement moins élevé en termes d'élément.
TRAITS: ::mlir::OpTrait::TFLRuntimeOpTrait
, AlwaysSpeculatableImplTrait
, QuantizableResult
, ResultsBroadcastableShape
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effets: MemoryEffects::Effect{}
Opérandes:
Opérande | Description |
---|---|
lhs | tenseur de flotteur 32 bits ou entier sans signe 32 bits ou valeurs de type ou de type Qi8 de type ou de type QI8 ou de type Qui8 |
rhs | tenseur de flotteur 32 bits ou entier sans signe 32 bits ou valeurs de type ou de type Qi8 de type ou de type QI8 ou de type Qui8 |
Résultats:
Résultat | Description |
---|---|
output | tenseur de valeurs entières sans signe 1 bits |
tfl.local_response_normalization
(tfl :: localResponSeormalizationOP)
Normalisation de la réponse locale.
Le tenseur input
4-D est traité comme un tableau 3D de vecteurs 1-D (le long de la dernière dimension), et chaque vecteur est normalisé indépendamment. Dans un vecteur donné, chaque composant est divisé par la somme pondérée et carrée des entrées dans depth_radius
. En détails,
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
Pour plus de détails, voir Krizhevsky et al., Imagenet Classification with Deep Convolutionnel Neural Networks (NIPS 2012) .
TRAITS: AlwaysSpeculatableImplTrait
, InferTensorType
, TF::SameOperandsAndResultTypeResolveRef
Interfaces: ConditionallySpeculatable
, InferShapedTypeOpInterface
, InferTypeOpInterface
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effets: MemoryEffects::Effect{}
Attributs :
Attribut | Type mlir | Description |
---|---|---|
radius | :: Mlir :: Integerattr | Attribut entier sans signe 32 bits |
bias | :: mlir :: floatattr | Attribut de flotteur 32 bits |
alpha | :: mlir :: floatattr | Attribut de flotteur 32 bits |
beta | :: mlir :: floatattr | Attribut de flotteur 32 bits |
Opérandes:
Opérande | Description |
---|---|
input | tenseur de valeurs flottantes 32 bits |
Résultats:
Résultat | Description |
---|---|
output | tenseur de valeurs flottantes 32 bits |
tfl.log
(tfl :: logop)
Opérateur de logarithme naturel
Effectue le fonctionnement du logarithme naturel en termes d'élément sur l'entrée.
TRAITS: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effets: MemoryEffects::Effect{}
Opérandes:
Opérande | Description |
---|---|
x | Tensor de valeurs de type flotteur 32 bits ou de type qi8 |
Résultats:
Résultat | Description |
---|---|
y | Tensor de valeurs de type flotteur 32 bits ou de type qi8 |
tfl.log_softmax
(tfl :: LogsoftMaxop)
Opérateur Log Softmax
Calcule les activations logarithologiques logicielles avec la formule suivante
Entrée - log (Redule_sum (exp (entrée), dim))
TRAITS: AlwaysSpeculatableImplTrait
, QuantizableResult
, SameOperandsAndResultShape
Interfaces: ConditionallySpeculatable
, FixedOutputRangeInterface
, NoMemoryEffect (MemoryEffectOpInterface)
, TflArithmeticCountOpInterface
, TflRuntimeVerifyOpInterface
Effets: MemoryEffects::Effect{}
Opérandes:
Opérande | Description |
---|---|
input | Tensor de type flotteur 32 bits ou de type QI8 ou de type Tflite Quint8 Type |
Résultats:
Résultat | Description |
---|---|
output | Tensor de type flotteur 32 bits ou de type QI8 ou de type Tflite Quint8 Type |
tfl.logical_and
(tfl :: logicalandop)
Logique et opérateur
Logique et fonctionnement des éléments.
TRAITS: AlwaysSpeculatableImplTrait
, ResultsBroadcastableShape
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effets: MemoryEffects::Effect{}
Opérandes:
Opérande | Description |
---|---|
lhs | tenseur de valeurs entières sans signe 1 bits |
rhs | tenseur de valeurs entières sans signe 1 bits |
Résultats:
Résultat | Description |
---|---|
output | tenseur de valeurs entières sans signe 1 bits |
tfl.logical_not
(tfl :: logicalNotop)
Logique non opérateur
Élément logique et non opération.
TRAITS: AlwaysSpeculatableImplTrait
, SameOperandsAndResultShape
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effets: MemoryEffects::Effect{}
Opérandes:
Opérande | Description |
---|---|
lhs | tenseur de valeurs entières sans signe 1 bits |
Résultats:
Résultat | Description |
---|---|
output | tenseur de valeurs entières sans signe 1 bits |
tfl.logical_or
(tfl :: logicorop)
Logique ou opérateur
Logique ou fonctionnement en termes d'élément.
TRAITS: AlwaysSpeculatableImplTrait
, ResultsBroadcastableShape
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effets: MemoryEffects::Effect{}
Opérandes:
Opérande | Description |
---|---|
lhs | tenseur de valeurs entières sans signe 1 bits |
rhs | tenseur de valeurs entières sans signe 1 bits |
Résultats:
Résultat | Description |
---|---|
output | tenseur de valeurs entières sans signe 1 bits |
tfl.logistic
(Tfl :: LogisticOp)
Opérateur logistique
Calcule sigmoïde d'élément de saisie
TRAITS: AlwaysSpeculatableImplTrait
, QuantizableResult
, SameOperandsAndResultShape
Interfaces: ConditionallySpeculatable
, FixedOutputRangeInterface
, NoMemoryEffect (MemoryEffectOpInterface)
, TflArithmeticCountOpInterface
, TflRuntimeVerifyOpInterface
Effets: MemoryEffects::Effect{}
Opérandes:
Opérande | Description |
---|---|
x | Tensor de type flotteur 32 bits ou de type Qi8 ou de type Qui8 ou de type Qi16 ou Tflite Quint8 Type |
Résultats:
Résultat | Description |
---|---|
y | Tensor de type flotteur 32 bits ou de type Qi8 ou de type Qui8 ou de type Qi16 ou Tflite Quint8 Type |
tfl.lstm
(tfl :: lstmop)
L'opérateur LSTM complet
Couche de réseau récurrente à long terme de l'unité de mémoire à court terme (LSTM). L'implémentation par défaut non-PEEPHOLE est basée sur: http://deeplearning.cs.cmu.edu/pdfs/hochreiter97_lstm.pdf S. Hochreiter et J. Schmidhuber. «Mémoire à court terme». Neural Computation, 9 (8): 1735-1780, 1997. La mise en œuvre des judiciaires est basée sur: https://research.google.com/pubs/archive/43905.pdf Hasim Sak, Andrew Senior, et Françoise Beaufays. «Architectures de réseau neuronal à long terme à court terme pour la modélisation acoustique à grande échelle.» IntereSpeech, 2014. Le couplage de la porte d'entrée et d'oubli (CIFG) est basé sur: http://arxiv.org/pdf/1503.04069.pdf Greff et al. «LSTM: un espace de recherche Odyssey» La normalisation de la couche est basée sur: https://arxiv.org/pdf/1607.06450.pdf Ba et al. «Normalisation de la couche»
Traits: QuantizableResult
Interfaces: DynamicRangeQuantizedOpInterface
, TFL_StatefulOp
, TflRuntimeVerifyOpInterface
Attributs :
Attribut | Type mlir | Description |
---|---|---|
fused_activation_function | :: mlir :: stringattr | attribut de chaîne dont la valeur n'est pas, ou relu, ou relu_n1_to_1, ou relu6, ou tanh, ou signe_bit |
cell_clip | :: mlir :: floatattr | Attribut flottant 32 bits dont la valeur n'est pas négative |
proj_clip | :: mlir :: floatattr | Attribut flottant 32 bits dont la valeur n'est pas négative |
kernel_type | :: mlir :: tfl :: lstmkerneltypeattr | lstm_kernel_type dont la valeur est Mlir :: tfl :: lstmkernelType :: Full |
asymmetric_quantize_inputs | :: mlir :: boolattr | attribut bool |
input_to_input_intermediate | :: mlir :: typattr | Tout type d'attribut |
input_to_forget_intermediate | :: mlir :: typattr | Tout type d'attribut |
input_to_cell_intermediate | :: mlir :: typattr | Tout type d'attribut |
input_to_output_intermediate | :: mlir :: typattr | Tout type d'attribut |
effective_hidden_scale_intermediate | :: mlir :: typattr | Tout type d'attribut |
Opérandes:
Opérande | Description |
---|---|
input | Tensor de valeurs de type flotteur 32 bits ou de type qi8 ou qi16 |
input_to_input_weights | tenseur de tout type de valeurs ou aucun type |
input_to_forget_weights | Tensor de valeurs de type flotteur 32 bits ou de type qi8 |
input_to_cell_weights | Tensor de valeurs de type flotteur 32 bits ou de type qi8 |
input_to_output_weights | Tensor de valeurs de type flotteur 32 bits ou de type qi8 |
recurrent_to_input_weights | tenseur de tout type de valeurs ou aucun type |
recurrent_to_forget_weights | Tensor de valeurs de type flotteur 32 bits ou de type qi8 |
recurrent_to_cell_weights | Tensor de valeurs de type flotteur 32 bits ou de type qi8 |
recurrent_to_output_weights | Tensor de valeurs de type flotteur 32 bits ou de type qi8 |
cell_to_input_weights | tenseur de tout type de valeurs ou aucun type |
cell_to_forget_weights | tenseur de tout type de valeurs ou aucun type |
cell_to_output_weights | tenseur de tout type de valeurs ou aucun type |
input_gate_bias | tenseur de tout type de valeurs ou aucun type |
forget_gate_bias | Tensor de valeurs de type float 32 bits ou Qi32 |
cell_bias | Tensor de valeurs de type float 32 bits ou Qi32 |
output_gate_bias | Tensor de valeurs de type float 32 bits ou Qi32 |
projection_weights | tenseur de tout type de valeurs ou aucun type |
projection_bias | tenseur de tout type de valeurs ou aucun type |
input_activation_state | tenseur avec état |
input_cell_state | tenseur avec état |
input_layer_norm_coefficients | tenseur de tout type de valeurs ou aucun type |
forget_layer_norm_coefficients | tenseur de tout type de valeurs ou aucun type |
cell_layer_norm_coefficients | tenseur de tout type de valeurs ou aucun type |
output_layer_norm_coefficients | tenseur de tout type de valeurs ou aucun type |
Résultats:
Résultat | Description |
---|---|
output | tenseur de tout type de valeurs |
tfl.matrix_diag
(Tfl :: MatrixDiagop)
Renvoie un tenseur avec la diagonale fournie et tout le reste rembourré de zéros.
Étant donné une diagonale, renvoie un tenseur avec la diagonale et tout le reste rembourré de zéros. Supposons que la diagonale a k dimensions [I, J, K, ..., N]
, alors la sortie est un tenseur de rang k+1
avec des dimensions [I, J, K, ..., N, N]
où: output[i, j, k, ..., m, n] = 1{m=n} * diagonal[i, j, k, ..., n].
TRAITS: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effets: MemoryEffects::Effect{}
Opérandes:
Opérande | Description |
---|---|
diagonal | Tensor de flotteur 32 bits ou entier sans signe 8 bits ou entier sans signe sans signe 16 bits ou entier non signé 32 bits ou entier non signé 64 bits ou valeurs de type NInt8 8 bits |
Résultats:
Résultat | Description |
---|---|
output | Tensor de flotteur 32 bits ou entier sans signe 8 bits ou entier sans signe sans signe 16 bits ou entier non signé 32 bits ou entier non signé 64 bits ou valeurs de type NInt8 8 bits |
tfl.matrix_set_diag
(Tfl :: MatrixSetDiagop)
Renvoie un tenseur matriciel lots avec de nouvelles valeurs diagonales lots.
Étant donné input
et diagonal
, cette opération renvoie un tenseur avec la même forme et les mêmes valeurs comme input
, à l'exception de la diagonale principale des matrices les plus internes. Ceux-ci seront écrasés par les valeurs en diagonal
.
TRAITS: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effets: MemoryEffects::Effect{}
Opérandes:
Opérande | Description |
---|---|
input | Tensor d'un flotteur 32 bits ou d'un entier non signé à 8 bits ou entier sans signe sans signe 16 bits ou 32 bits entier sans signe ou 64 bits ou en entier non signé 8 bits |
diagonal | Tensor d'un flotteur 32 bits ou d'un entier non signé à 8 bits ou entier sans signe sans signe 16 bits ou 32 bits entier sans signe ou 64 bits ou en entier non signé 8 bits |
Résultats:
Résultat | Description |
---|---|
result | Tensor d'un flotteur 32 bits ou d'un entier non signé à 8 bits ou entier sans signe sans signe 16 bits ou 32 bits entier sans signe ou 64 bits ou en entier non signé 8 bits |
tfl.max_pool_2d
(tfl :: maxpool2dop)
Max piscine 2d op
Effectue Max Pool 2D sur l'entrée.
Entrées: inputs[0]
: Obligatoire: le tenseur d'entrée
TRAITS: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflArithmeticCountOpInterface
, TflRuntimeVerifyOpInterface
Effets: MemoryEffects::Effect{}
Attributs :
Attribut | Type mlir | Description |
---|---|---|
padding | :: mlir :: stringattr | attribut de chaîne dont la valeur est la même, ou valide |
stride_w | :: Mlir :: Integerattr | Attribut entier sans signe 32 bits |
stride_h | :: Mlir :: Integerattr | Attribut entier sans signe 32 bits |
filter_width | :: Mlir :: Integerattr | Attribut entier sans signe 32 bits |
filter_height | :: Mlir :: Integerattr | Attribut entier sans signe 32 bits |
fused_activation_function | :: mlir :: stringattr | attribut de chaîne dont la valeur n'est pas, ou relu, ou relu_n1_to_1, ou relu6, ou tanh, ou signe_bit |
Opérandes:
Opérande | Description |
---|---|
input | Tensor de type flotteur 32 bits ou de type QI8 ou de type Qi16 ou de type Tflite Quint8 Type |
Résultats:
Résultat | Description |
---|---|
output | Tensor de type flotteur 32 bits ou de type QI8 ou de type Qi16 ou de type Tflite Quint8 Type |
tfl.maximum
(tfl :: maximumop)
Opérateur maximal
Fonctionnement maximal par élément.
TRAITS: ::mlir::OpTrait::TFLRuntimeOpTrait
, Commutative
AlwaysSpeculatableImplTrait
, QuantizableResult
, ResultsBroadcastableShape
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Effets: MemoryEffects::Effect{}
Opérandes:
Opérande | Description |
---|---|
lhs | Tensor de flotteur 32 bits ou entiers sans signe 32/64 bits ou Type QI8 ou type de type QI16 |
rhs | Tensor de flotteur 32 bits ou entiers sans signe 32/64 bits ou Type QI8 ou type de type QI16 |
Résultats:
Résultat | Description |
---|---|
max | Tensor de flotteur 32 bits ou entiers sans signe 32/64 bits ou Type QI8 ou type de type QI16 |
tfl.mean
(tfl :: Meanop)
Opérateur moyen
Calcule la moyenne des éléments à travers les dimensions d'un tenseur. Réduit Input_tensor le long des dimensions données dans l'axe. À moins que KeepDIMS ne soit vrai, le rang du tenseur est réduit de 1 pour chaque entrée dans l'axe. Si KeepDIMS est vrai, les dimensions réduites sont conservées avec la longueur 1.
TRAITS: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effets: MemoryEffects::Effect{}
Attributs :
Attribut | Type mlir | Description |
---|---|---|
keep_dims | :: mlir :: boolattr | attribut bool |
Opérandes:
Opérande | Description |
---|---|
input | Tensor de flotteur 32 bits ou entier sans signe 32 bits ou entier signé 64 bits ou type Qi8 ou type qui8 ou valeurs de type non signé 8 bits ou Qi16 |
axis | tenseur de valeurs entières sans signe 32 bits |
Résultats:
Résultat | Description |
---|---|
output | Tensor de flotteur 32 bits ou entier sans signe 32 bits ou entier signé 64 bits ou type Qi8 ou type qui8 ou valeurs de type non signé 8 bits ou Qi16 |
tfl.minimum
(tfl :: minimum)
Opérateur min
Fonctionnement min-sage des éléments.
TRAITS: ::mlir::OpTrait::TFLRuntimeOpTrait
, AlwaysSpeculatableImplTrait
Commutative
QuantizableResult
, ResultsBroadcastableShape
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Effets: MemoryEffects::Effect{}
Opérandes:
Opérande | Description |
---|---|
lhs | Tensor de flotteur 32 bits ou entiers sans signe 32/64 bits ou Type QI8 ou type de type QI16 |
rhs | Tensor de flotteur 32 bits ou entiers sans signe 32/64 bits ou Type QI8 ou type de type QI16 |
Résultats:
Résultat | Description |
---|---|
min | Tensor de flotteur 32 bits ou entiers sans signe 32/64 bits ou Type QI8 ou type de type QI16 |
tfl.mirror_pad
(tfl :: mirrorpadop)
Opérateur MirrorPad. Tanne un tenseur avec des valeurs en miroir.
Cet fonctionnement rembourse une entrée avec des valeurs en miroir en fonction des padds que vous spécifiez. paddings is an integer tensor with shape [n, 2], where n is the rank of input. For each dimension D of input, paddings[D, 0] indicates how many values to add before the contents of input in that dimension, and paddings[D, 1] indicates how many values to add after the contents of input in that dimension.
Both paddings[D, 0] and paddings[D, 1] must be no greater than input.dim_size(D) (or input.dim_size(D) - 1) if copy_border is true (if false, respectively).
The padded size of each dimension D of the output is:
paddings(D, 0) + input.dim_size(D) + paddings(D, 1)
Traits: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Attributs :
Attribut | MLIR Type | Description |
---|---|---|
mode | ::mlir::TFL::MirrorPaddingTypeAttr | mirror_pad_enum |
Operands:
Operand | Description |
---|---|
input | tensor of 32-bit float or 32-bit signless integer or 64-bit signless integer or 8-bit signless integer or 8-bit unsigned integer or QI8 type or QUI8 type or QI16 type values |
pad | tensor of 32-bit signless integer or 64-bit signless integer values |
Résultats:
Résultat | Description |
---|---|
output | tensor of 32-bit float or 32-bit signless integer or 64-bit signless integer or 8-bit signless integer or 8-bit unsigned integer or QI8 type or QUI8 type or QI16 type values |
tfl.mul
(TFL::MulOp)
Multiplication operator
Element-wise multiplication operation.
Traits: ::mlir::OpTrait::TFLRuntimeOpTrait
, AlwaysSpeculatableImplTrait
, Commutative
, QuantizableResult
, ResultsBroadcastableShape
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflArithmeticCountOpInterface
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Attributs :
Attribut | MLIR Type | Description |
---|---|---|
fused_activation_function | ::mlir::StringAttr | string attribute whose value is NONE, or RELU, or RELU_N1_TO_1, or RELU6, or TANH, or SIGN_BIT |
Operands:
Operand | Description |
---|---|
lhs | tensor of 32-bit float or 32-bit signless integer or 32-bit unsigned integer or 64-bit signless integer or QI8 type or QUI8 type or QI16 type or 16-bit signless integer or complex type with 32-bit float elements values |
rhs | tensor of 32-bit float or 32-bit signless integer or 32-bit unsigned integer or 64-bit signless integer or QI8 type or QUI8 type or QI16 type or 16-bit signless integer or complex type with 32-bit float elements values |
Résultats:
Résultat | Description |
---|---|
output | tensor of 32-bit float or 32-bit signless integer or 32-bit unsigned integer or 64-bit signless integer or QI8 type or QUI8 type or QI16 type or 16-bit signless integer or complex type with 32-bit float elements values |
tfl.multinomial
(TFL::MultinomialOp)
Draws samples from a categorical distribution.
The generated values will have a categorical distribution based on the logits
or unnormalized log-probabilities provided for all classes.
Interfaces: TflRuntimeVerifyOpInterface
Attributs :
Attribut | MLIR Type | Description |
---|---|---|
seed | ::mlir::IntegerAttr | 64-bit signless integer attribute |
seed2 | ::mlir::IntegerAttr | 64-bit signless integer attribute |
Operands:
Operand | Description |
---|---|
logits | tensor of 32-bit float values |
num_samples | tensor of 32-bit signless integer values |
Résultats:
Résultat | Description |
---|---|
out | tensor of 32-bit signless integer or 64-bit signless integer values |
tfl.neg
(TFL::NegOp)
Negation operator
Computes element-wise negation of input
Traits: AlwaysSpeculatableImplTrait
, InferTensorType
, TF::SameOperandsAndResultTypeResolveRef
Interfaces: ConditionallySpeculatable
, InferShapedTypeOpInterface
, InferTypeOpInterface
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Operands:
Operand | Description |
---|---|
x | tensor of 32-bit float or 32-bit signless integer or 64-bit signless integer values |
Résultats:
Résultat | Description |
---|---|
y | tensor of 32-bit float or 32-bit signless integer or 64-bit signless integer values |
tfl.no_value
(TFL::NoValueOp)
Constant representing no value.
No value constant op.
Traits: AlwaysSpeculatableImplTrait
, ConstantLike
Interfaces: ConditionallySpeculatable
, InferTypeOpInterface
, NoMemoryEffect (MemoryEffectOpInterface)
Effects: MemoryEffects::Effect{}
Attributs :
Attribut | MLIR Type | Description |
---|---|---|
value | ::mlir::UnitAttr | unit attribute |
Résultats:
Résultat | Description |
---|---|
none_val | none type |
tfl.non_max_suppression_v4
(TFL::NonMaxSuppressionV4Op)
Greedily selects a subset of bounding boxes in descending order of score,
pruning away boxes that have high intersection-over-union (IOU) overlap with previously selected boxes. Bounding boxes with score less than score_threshold
are removed. Bounding boxes are supplied as [y1, x1, y2, x2], where (y1, x1) and (y2, x2) are the coordinates of any diagonal pair of box corners and the coordinates can be provided as normalized (ie, lying in the interval [0, 1]) or absolute. Note that this algorithm is agnostic to where the origin is in the coordinate system and more generally is invariant to orthogonal transformations and translations of the coordinate system; thus translating or reflections of the coordinate system result in the same boxes being selected by the algorithm. The output of this operation is a set of integers indexing into the input collection of bounding boxes representing the selected boxes. The bounding box coordinates corresponding to the selected indices can then be obtained using the tf.gather operation
. For example: selected_indices = tf.image.non_max_suppression_v2( boxes, scores, max_output_size, iou_threshold, score_threshold) selected_boxes = tf.gather(boxes, selected_indices)
Traits: AlwaysSpeculatableImplTrait
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Operands:
Operand | Description |
---|---|
boxes | tensor of 32-bit float values |
scores | tensor of 32-bit float values |
max_output_size | tensor of 32-bit signless integer values |
iou_threshold | tensor of 32-bit float values |
score_threshold | tensor of 32-bit float values |
Résultats:
Résultat | Description |
---|---|
selected_indices | tensor of 32-bit signless integer values |
valid_outputs | tensor of 32-bit signless integer values |
tfl.non_max_suppression_v5
(TFL::NonMaxSuppressionV5Op)
Greedily selects a subset of bounding boxes in descending order of score,
pruning away boxes that have high intersection-over-union (IOU) overlap with previously selected boxes. Bounding boxes with score less than score_threshold
are removed. Bounding boxes are supplied as [y1, x1, y2, x2], where (y1, x1) and (y2, x2) are the coordinates of any diagonal pair of box corners and the coordinates can be provided as normalized (ie, lying in the interval [0, 1]) or absolute. Note that this algorithm is agnostic to where the origin is in the coordinate system and more generally is invariant to orthogonal transformations and translations of the coordinate system; thus translating or reflections of the coordinate system result in the same boxes being selected by the algorithm. The output of this operation is a set of integers indexing into the input collection of bounding boxes representing the selected boxes. The bounding box coordinates corresponding to the selected indices can then be obtained using the tf.gather operation
. For example: selected_indices = tf.image.non_max_suppression_v2( boxes, scores, max_output_size, iou_threshold, score_threshold) selected_boxes = tf.gather(boxes, selected_indices) This op also supports a Soft-NMS (with Gaussian weighting) mode (cf Bodla et al, https://arxiv.org/abs/1704.04503 ) where boxes reduce the score of other overlapping boxes instead of directly causing them to be pruned. To enable this Soft-NMS mode, set the soft_nms_sigma
parameter to be larger than 0.
Traits: AlwaysSpeculatableImplTrait
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Operands:
Operand | Description |
---|---|
boxes | tensor of 32-bit float values |
scores | tensor of 32-bit float values |
max_output_size | tensor of 32-bit signless integer values |
iou_threshold | tensor of 32-bit float values |
score_threshold | tensor of 32-bit float values |
soft_nms_sigma | tensor of 32-bit float values |
Résultats:
Résultat | Description |
---|---|
selected_indices | tensor of 32-bit signless integer values |
selected_scores | tensor of 32-bit float values |
valid_outputs | tensor of 32-bit signless integer values |
tfl.not_equal
(TFL::NotEqualOp)
_Not equal operator
Element-wise not_equal operation.
Traits: ::mlir::OpTrait::TFLRuntimeOpTrait
, AlwaysSpeculatableImplTrait
, Commutative
, ResultsBroadcastableShape
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Operands:
Operand | Description |
---|---|
lhs | tensor of 1-bit signless integer or 32-bit float or 32-bit signless integer or 64-bit signless integer or QUI8 type or QI8 type or TFLite quint8 type or TFLite string type values |
rhs | tensor of 1-bit signless integer or 32-bit float or 32-bit signless integer or 64-bit signless integer or QUI8 type or QI8 type or TFLite quint8 type or TFLite string type values |
Résultats:
Résultat | Description |
---|---|
output | tensor of 1-bit signless integer values |
tfl.NumericVerify
(TFL::NumericVerifyOp)
Verifies the numericals of the two operands
The NumericVerify op is a debugging op to verify the numericals of the two activations. It is a custom op in TFLite. If log_if_failed is true, the NumericVerify op calculates statistics on differences between float and quantized activations, output logs, set differences to the output tensors, and throws an error if errors above tolerance exist. If log_if_failed = false, then it doesn't care about errors.
Traits: QuantizableResult
, SameOperandsShape
Interfaces: TflRuntimeVerifyOpInterface
Attributs :
Attribut | MLIR Type | Description |
---|---|---|
tolerance | ::mlir::FloatAttr | 32-bit float attribute |
log_if_failed | ::mlir::BoolAttr | bool attribute |
Operands:
Operand | Description |
---|---|
input | tensor of QI8 type or QUI8 type or QI16 type or 16-bit float or TFLite quint8 type values |
ref | tensor of 32-bit float values |
Résultats:
Résultat | Description |
---|---|
output | tensor of 32-bit float values |
tfl.one_hot
(TFL::OneHotOp)
OneHot operator
Returns a one-hot tensor.The locations represented by indices in indices
take value on_value
, while all other locations take value off_value
.
If the input indices
is rank N
, the output will have rank N+1
, The new axis is created at dimension axis
(default: the new axis is appended at the end).
Traits: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Attributs :
Attribut | MLIR Type | Description |
---|---|---|
axis | ::mlir::IntegerAttr | 32-bit signless integer attribute |
Operands:
Operand | Description |
---|---|
indices | tensor of 32-bit signless integer or 64-bit signless integer values |
depth | tensor of 32-bit signless integer values |
on_value | tensor of 32-bit float or 32-bit signless integer or 64-bit signless integer or 1-bit signless integer or 8-bit signless integer or 8-bit unsigned integer values |
off_value | tensor of 32-bit float or 32-bit signless integer or 64-bit signless integer or 1-bit signless integer or 8-bit signless integer or 8-bit unsigned integer values |
Résultats:
Résultat | Description |
---|---|
output | tensor of 32-bit float or 32-bit signless integer or 64-bit signless integer or 1-bit signless integer or 8-bit signless integer or 8-bit unsigned integer values |
tfl.pack
(TFL::PackOp)
Packs a list of tensors along a dimension into one tensor
Packs a list of values_count
rank- R
tensors into one rank- (R+1)
tensor.
Packs the values_count
tensors in values
into a tensor with rank one higher than each tensor in values
, by packing them along the axis
dimension.
Given a list of tensors of shape (A, B, C)
;
if axis == 0
then the output
tensor will have the shape (N, A, B, C)
. if axis == 1
then the output
tensor will have the shape (A, N, B, C)
. Etc.
Par exemple:
# '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]]
This is the opposite of unpack
.
Traits: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Attributs :
Attribut | MLIR Type | Description |
---|---|---|
values_count | ::mlir::IntegerAttr | 32-bit signless integer attribute whose value is positive |
axis | ::mlir::IntegerAttr | 32-bit signless integer attribute |
Operands:
Operand | Description |
---|---|
values | variadic of tensor of any type values |
Résultats:
Résultat | Description |
---|---|
output | tensor of 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer or 8-bit unsigned integer or 32-bit unsigned integer or QI8 type or QUI8 type or QI16 type or TFLite quint8 type values |
tfl.pad
(TFL::PadOp)
Padding operator
This operation pads a input
with zeros according to the paddings
you specify. paddings
is an integer tensor with shape [Dn, 2]
, where n is the rank of input
. For each dimension D of input
, paddings[D, 0]
indicates how many zeros to add before the contents of input
in that dimension, and paddings[D, 1]
indicates how many zeros to add after the contents of input
in that dimension.
The padded size of each dimension D of the output is:
paddings(D, 0) + input.dim_size(D) + paddings(D, 1)
Par exemple:
# '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]]
Traits: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Operands:
Operand | Description |
---|---|
input | tensor of 32-bit float or 32-bit signless integer or 64-bit signless integer or QI8 type or QUI8 type or TFLite quint8 type or QI16 type values |
padding | tensor of 32/64-bit signless integer values |
Résultats:
Résultat | Description |
---|---|
output | tensor of 32-bit float or 32-bit signless integer or 64-bit signless integer or QI8 type or QUI8 type or TFLite quint8 type or QI16 type values |
tfl.padv2
(TFL::PadV2Op)
Padding operator v2
This operation pads a input
according to the paddings
and constant_values
you specify. paddings
is an integer tensor with shape [Dn, 2]
, where n is the rank of input
. For each dimension D of input
, paddings[D, 0]
indicates how many zeros to add before the contents of input
in that dimension, and paddings[D, 1]
indicates how many zeros to add after the contents of input
in that dimension. constant_values
is a scalar tensor of the same type as input
that indicates the value to use for padding input
.
The padded size of each dimension D of the output is:
paddings(D, 0) + input.dim_size(D) + paddings(D, 1)
Par exemple:
# '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]]
Traits: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Operands:
Operand | Description |
---|---|
input | tensor of 32-bit float or 32-bit signless integer or 64-bit signless integer or 8-bit unsigned integer or QI8 type or QUI8 type or TFLite quint8 type values |
padding | tensor of 32/64-bit signless integer values |
constant_values | tensor of 32-bit float or 32-bit signless integer or 64-bit signless integer or 8-bit unsigned integer or QI8 type or QUI8 type or TFLite quint8 type values |
Résultats:
Résultat | Description |
---|---|
output | tensor of 32-bit float or 32-bit signless integer or 64-bit signless integer or 8-bit unsigned integer or QI8 type or QUI8 type or TFLite quint8 type values |
tfl.poly_call
(TFL::PolyCallOp)
Poly call
Have multiple function bodies for the same computation. This allows a program compiler/interpreter to choose one of the available options to execute the program based on which one is most suitable for the target backend.
input: A list of input tensors whose types are T. output: A list of output tensors whose types are T.
call: Multiple regions, each of which encapsulates the same semantic computation but in different forms.
Traits: SingleBlockImplicitTerminator<YieldOp>
, SingleBlock
Interfaces: RegionBranchOpInterface
Operands:
Operand | Description |
---|---|
input | variadic of tensor of any type values |
Résultats:
Résultat | Description |
---|---|
output | variadic of tensor of any type values |
tfl.pow
(TFL::PowOp)
Power operator
Element-wise power operation.
Traits: ::mlir::OpTrait::TFLRuntimeOpTrait
, AlwaysSpeculatableImplTrait
, ResultsBroadcastableShape
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Operands:
Operand | Description |
---|---|
lhs | tensor of 32-bit float or 32-bit signless integer values |
rhs | tensor of 32-bit float or 32-bit signless integer values |
Résultats:
Résultat | Description |
---|---|
output | tensor of 32-bit float or 32-bit signless integer values |
tfl.prelu
(TFL::PReluOp)
Parameterized Relu operator
Parameterized Relu operator x -> x >= 0 ? x : (alpha * x) where alpha is a trainable tensor. input and alpha should be the same size as input or be broadcastable.
Traits: ::mlir::OpTrait::TFLRuntimeOpTrait
, AlwaysSpeculatableImplTrait
, QuantizableResult
, ResultsBroadcastableShape
, quant::AffineOpCoefficient<-1, 1>
Interfaces: AffineQuantizedOpInterface
, ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Operands:
Operand | Description |
---|---|
input | tensor of 32-bit float or QI8 type or QUI8 type or TFLite quint8 type values |
alpha | tensor of 32-bit float or QI8 type or QUI8 type or TFLite quint8 type values |
Résultats:
Résultat | Description |
---|---|
output | tensor of 32-bit float or QI8 type or QUI8 type or TFLite quint8 type values |
tfl.pseudo_const
(TFL::ConstOp)
Constant pseudo op.
Represents a constant value in TensorFlow Lite dialect. This is not an actual operation and it will be lowered to buffer instead.
The op is allowed to have all the same type of attributes as tf.Const does (eg, opaque TF attributes are allowed).
Traits: AlwaysSpeculatableImplTrait
, ConstantLike
, FirstAttrDerivedResultType
, QuantizableResult
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Attributs :
Attribut | MLIR Type | Description |
---|---|---|
value | ::mlir::ElementsAttr | constant vector/tensor attribute |
Résultats:
Résultat | Description |
---|---|
output | tensor of any type values |
tfl.pseudo_qconst
(TFL::QConstOp)
Quantized constant pseudo op
Represents a quantized constant value in TensorFlow Lite dialect. This is not an actual operation and it will be lowered to buffer instead. The quantization parameters are stored as a type attribute in this constant.
Traits: AlwaysSpeculatableImplTrait
, FirstAttrDerivedResultType
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
Effects: MemoryEffects::Effect{}
Attributs :
Attribut | MLIR Type | Description |
---|---|---|
qtype | ::mlir::TypeAttr | Tensor type attribute |
value | ::mlir::ElementsAttr | constant vector/tensor attribute |
Résultats:
Résultat | Description |
---|---|
output | tensor of QUI8 type or QI8 type or QI16 type or QUI16 type or TFLite quint8 type values |
tfl.pseudo_sparse_const
(TFL::SparseConstOp)
Sparse constant pseudo op.
Represents a sparse constant value in TensorFlow Lite dialect. This is not an actual operation and it will be lowered to buffer instead.
Traits: AlwaysSpeculatableImplTrait
, FirstAttrDerivedResultType
, QuantizableResult
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Attributs :
Attribut | MLIR Type | Description |
---|---|---|
value | ::mlir::ElementsAttr | constant vector/tensor attribute |
s_param | ::mlir::TFL::SparsityParameterAttr | Sparsity parameter. |
compressed_data | ::mlir::ElementsAttr | constant vector/tensor attribute |
Résultats:
Résultat | Description |
---|---|
output | tensor of any type values |
tfl.pseudo_sparse_qconst
(TFL::SparseQConstOp)
Sparse quantized constant pseudo op
Represents a sparse quantized constant value in TensorFlow Lite dialect. This is not an actual operation and it will be lowered to buffer instead. The quantization parameters are stored as a type attribute in this constant.
Traits: AlwaysSpeculatableImplTrait
, FirstAttrDerivedResultType
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Attributs :
Attribut | MLIR Type | Description |
---|---|---|
qtype | ::mlir::TypeAttr | Tensor type attribute |
value | ::mlir::ElementsAttr | constant vector/tensor attribute |
s_param | ::mlir::TFL::SparsityParameterAttr | Sparsity parameter. |
compressed_data | ::mlir::ElementsAttr | constant vector/tensor attribute |
Résultats:
Résultat | Description |
---|---|
output | tensor of QUI8 type or QI8 type or QI16 type or QUI16 type or TFLite quint8 type values |
tfl.quantize
(TFL::QuantizeOp)
Quantize operator
Converts floating point tensors to quantized integer tensors according to the quantization parameters defined in the type attribute.
Traits: FirstAttrDerivedResultType
, SameOperandsAndResultShape
Interfaces: NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Attributs :
Attribut | MLIR Type | Description |
---|---|---|
qtype | ::mlir::TypeAttr | Tensor type attribute |
Operands:
Operand | Description |
---|---|
input | tensor of 32-bit float or QI4 type or QI8 type or QUI8 type or QI16 type or TFLite quint8 type values |
Résultats:
Résultat | Description |
---|---|
output | tensor of QI4 type or QI8 type or QUI8 type or QI16 type or TFLite quint8 type values |
tfl.random_standard_normal
(TFL::RandomStandardNormalOp)
Outputs random values from a normal distribution.
The generated values will have mean 0 and standard deviation 1.
Interfaces: TflRuntimeVerifyOpInterface
Attributs :
Attribut | MLIR Type | Description |
---|---|---|
seed | ::mlir::IntegerAttr | 64-bit signless integer attribute |
seed2 | ::mlir::IntegerAttr | 64-bit signless integer attribute |
Operands:
Operand | Description |
---|---|
shape | tensor of 32-bit signless integer values |
Résultats:
Résultat | Description |
---|---|
out | tensor of 32-bit float values |
tfl.random_uniform
(TFL::RandomUniformOp)
Outputs random values from a uniform distribution.
The generated values follow a uniform distribution in the range [0, 1)
. The lower bound 0 is included in the range, while the upper bound 1 is excluded.
Interfaces: TflRuntimeVerifyOpInterface
Attributs :
Attribut | MLIR Type | Description |
---|---|---|
seed | ::mlir::IntegerAttr | 64-bit signless integer attribute |
seed2 | ::mlir::IntegerAttr | 64-bit signless integer attribute |
Operands:
Operand | Description |
---|---|
shape | tensor of 32-bit signless integer values |
Résultats:
Résultat | Description |
---|---|
out | tensor of 32-bit float values |
tfl.range
(TFL::RangeOp)
Range operator
Returns a 1D tensor defined by a sequence from start
to limit
with a given delta
.
Traits: AlwaysSpeculatableImplTrait
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Operands:
Operand | Description |
---|---|
start | tensor of 32-bit signless integer or 32-bit float or 64-bit signless integer values |
limit | tensor of 32-bit signless integer or 32-bit float or 64-bit signless integer values |
delta | tensor of 32-bit signless integer or 32-bit float or 64-bit signless integer values |
Résultats:
Résultat | Description |
---|---|
result | tensor of 32-bit signless integer or 32-bit float or 64-bit signless integer values |
tfl.rank
(TFL::RankOp)
Rank operator.
Returns the rank of a tensor.
Traits: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Operands:
Operand | Description |
---|---|
input | tensor of any type values |
Résultats:
Résultat | Description |
---|---|
output | tensor of any integer type |
tfl.read_variable
(TFL::ReadVariableOp)
Reads variable value.
Read variable data identified by 'resource_id'.
Interfaces: TflRuntimeVerifyOpInterface
Operands:
Operand | Description |
---|---|
resource_id | tensor of resource values |
Résultats:
Résultat | Description |
---|---|
result | tensor of 32-bit float or 64-bit float or 1-bit signless integer or 8-bit unsigned integer or 8-bit signless integer or QI8 type or QUI8 type or 32-bit signless integer or 64-bit signless integer or QI16 type or complex type with 32-bit float elements or complex type with 64-bit float elements values |
tfl.real
(TFL::RealOp)
Returns the real part of a complex number.
Given a tensor input
of complex numbers, this operation returns a tensor of type float
that is the real part of each element in input
. All elements in input
must be complex numbers of the form \(a + bj\), where a is the real part returned by this operation and b is the imaginary part.
Traits: AlwaysSpeculatableImplTrait
, SameOperandsAndResultShape
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Operands:
Operand | Description |
---|---|
input | tensor of complex type with 32-bit float elements or complex type with 64-bit float elements values |
Résultats:
Résultat | Description |
---|---|
output | tensor of 32-bit float or 64-bit float values |
tfl.reduce_all
(TFL::ReduceAllOp)
Computes the "logical and" of elements across dimensions of a tensor.
Reduces input
along the dimensions given in axis
. Unless keep_dims
is true, the rank of the tensor is reduced by 1 for each entry in axis
. If keep_dims
is true, the reduced dimensions are retained with length 1.
Traits: AlwaysSpeculatableImplTrait
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Attributs :
Attribut | MLIR Type | Description |
---|---|---|
keep_dims | ::mlir::BoolAttr | bool attribute |
Operands:
Operand | Description |
---|---|
input | tensor of 1-bit signless integer values |
reduction_indices | tensor of 32-bit signless integer values |
Résultats:
Résultat | Description |
---|---|
output | tensor of 1-bit signless integer values |
tfl.reduce_any
(TFL::ReduceAnyOp)
Computes the "logical or" of elements across dimensions of a tensor.
Reduces input
along the dimensions given in axis
. Unless keep_dims
is true, the rank of the tensor is reduced by 1 for each entry in axis
. If keep_dims
is true, the reduced dimensions are retained with length 1.
Traits: AlwaysSpeculatableImplTrait
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Attributs :
Attribut | MLIR Type | Description |
---|---|---|
keep_dims | ::mlir::BoolAttr | bool attribute |
Operands:
Operand | Description |
---|---|
input | tensor of 1-bit signless integer values |
reduction_indices | tensor of 32-bit signless integer values |
Résultats:
Résultat | Description |
---|---|
output | tensor of 1-bit signless integer values |
tfl.reduce_max
(TFL::ReduceMaxOp)
Max-reduction operator
Computes the max reduction along the specified axes
Traits: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Attributs :
Attribut | MLIR Type | Description |
---|---|---|
keep_dims | ::mlir::BoolAttr | bool attribute |
Operands:
Operand | Description |
---|---|
input | tensor of 32-bit float or 32-bit signless integer or 64-bit signless integer or QI8 type or QUI8 type or TFLite quint8 type or QI16 type values |
axes | tensor of 32-bit signless integer values |
Résultats:
Résultat | Description |
---|---|
output | tensor of 32-bit float or 32-bit signless integer or 64-bit signless integer or QI8 type or QUI8 type or TFLite quint8 type or QI16 type values |
tfl.reduce_min
(TFL::ReduceMinOp)
Min-reduction operator
Computes the min reduction along the specified axes
Traits: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Attributs :
Attribut | MLIR Type | Description |
---|---|---|
keep_dims | ::mlir::BoolAttr | bool attribute |
Operands:
Operand | Description |
---|---|
input | tensor of 32-bit float or 32-bit signless integer or 64-bit signless integer or QI8 type or QUI8 type or TFLite quint8 type or QI16 type values |
axes | tensor of 32-bit signless integer values |
Résultats:
Résultat | Description |
---|---|
output | tensor of 32-bit float or 32-bit signless integer or 64-bit signless integer or QI8 type or QUI8 type or TFLite quint8 type or QI16 type values |
tfl.reduce_prod
(TFL::ReduceProdOp)
Prod-reduction operator
Computes the product along the specified axes
Traits: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Attributs :
Attribut | MLIR Type | Description |
---|---|---|
keep_dims | ::mlir::BoolAttr | bool attribute |
Operands:
Operand | Description |
---|---|
input | tensor of 32-bit float or 32-bit signless integer or 64-bit signless integer or QI8 type or QUI8 type or TFLite quint8 type or QI16 type values |
axes | tensor of 32-bit signless integer values |
Résultats:
Résultat | Description |
---|---|
output | tensor of 32-bit float or 32-bit signless integer or 64-bit signless integer or QI8 type or QUI8 type or TFLite quint8 type or QI16 type values |
tfl.relu
(TFL::ReluOp)
Relu operator
Element-wise Relu operator x -> max(0, x)
Traits: AlwaysSpeculatableImplTrait
, QuantizableResult
, SameOperandsAndResultShape
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Operands:
Operand | Description |
---|---|
x | tensor of 32-bit float or QUI8 type or QI8 type or QI16 type values |
Résultats:
Résultat | Description |
---|---|
y | tensor of 32-bit float or QUI8 type or QI8 type or QI16 type values |
tfl.relu6
(TFL::Relu6Op)
Relu6 operator
Element-wise Relu6 operator x -> max(0, min(6, x))
Traits: AlwaysSpeculatableImplTrait
, QuantizableResult
, SameOperandsAndResultShape
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Operands:
Operand | Description |
---|---|
x | tensor of 32-bit float or QUI8 type or QI8 type values |
Résultats:
Résultat | Description |
---|---|
y | tensor of 32-bit float or QUI8 type or QI8 type values |
tfl.relu_0_to_1
(TFL::Relu0To1Op)
Relu0To1 operator
Element-wise Relu0To1 operator x -> max(0, min(1, x))
Traits: AlwaysSpeculatableImplTrait
, QuantizableResult
, SameOperandsAndResultShape
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Operands:
Operand | Description |
---|---|
x | tensor of 32-bit float or QUI8 type or QI8 type values |
Résultats:
Résultat | Description |
---|---|
y | tensor of 32-bit float or QUI8 type or QI8 type values |
tfl.relu_n1_to_1
(TFL::Relu1Op)
Relu1 operator
Element-wise Relu1 operator x -> max(-1, min(1, x))
Traits: AlwaysSpeculatableImplTrait
, QuantizableResult
, SameOperandsAndResultShape
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Operands:
Operand | Description |
---|---|
x | tensor of 32-bit float or QUI8 type or QI8 type values |
Résultats:
Résultat | Description |
---|---|
y | tensor of 32-bit float or QUI8 type or QI8 type values |
tfl.reshape
(TFL::ReshapeOp)
Reshape operator
Produces a tensor with the same values but different static shape defined by the output type.
Traits: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces: ConditionallySpeculatable
, InferTypeOpInterface
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Operands:
Operand | Description |
---|---|
input | tensor of any type values |
shape | tensor of 32-bit signless integer values |
Résultats:
Résultat | Description |
---|---|
output | tensor of any type values |
tfl.resize_bilinear
(TFL::ResizeBilinearOp)
ResizeBilinear Op
Resize images
to size
using bilinear interpolation.
Traits: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Attributs :
Attribut | MLIR Type | Description |
---|---|---|
align_corners | ::mlir::BoolAttr | bool attribute |
half_pixel_centers | ::mlir::BoolAttr | bool attribute |
Operands:
Operand | Description |
---|---|
input | tensor of 32-bit float or TFLite quint8 type or QUI8 type or QI8 type or QI16 type values |
size | tensor of 32-bit signless integer values |
Résultats:
Résultat | Description |
---|---|
output | tensor of 32-bit float or TFLite quint8 type or QUI8 type or QI8 type or QI16 type values |
tfl.resize_nearest_neighbor
(TFL::ResizeNearestNeighborOp)
ResizeNearestNeighbor Op
Resize images
to size
using nearest neighbor interpolation.
Traits: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Attributs :
Attribut | MLIR Type | Description |
---|---|---|
align_corners | ::mlir::BoolAttr | bool attribute |
half_pixel_centers | ::mlir::BoolAttr | bool attribute |
Operands:
Operand | Description |
---|---|
input | tensor of 32-bit float or TFLite quint8 type or QUI8 type or QI8 type or QI16 type values |
size | tensor of 32-bit signless integer values |
Résultats:
Résultat | Description |
---|---|
output | tensor of 32-bit float or TFLite quint8 type or QUI8 type or QI8 type or QI16 type values |
tfl.reverse_sequence
(TFL::ReverseSequenceOp)
Reverses variable length slices.
This op first slices input
along the dimension batch_dim
, and for each slice i
, reverses the first seq_lengths[i]
elements along the dimension seq_dim
.
The elements of seq_lengths
must obey seq_lengths[i] <= input.dims[seq_dim]
, and seq_lengths
must be a vector of length input.dims[batch_dim]
.
The output slice i
along dimension batch_dim
is then given by input slice i
, with the first seq_lengths[i]
slices along dimension seq_dim
reversed.
Traits: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Attributs :
Attribut | MLIR Type | Description |
---|---|---|
seq_dim | ::mlir::IntegerAttr | 32-bit signless integer attribute whose value is non-negative |
batch_dim | ::mlir::IntegerAttr | 32-bit signless integer attribute whose value is non-negative |
Operands:
Operand | Description |
---|---|
input | tensor of 32-bit float or 32-bit signless integer or 64-bit signless integer or QI16 type or QUI8 type or TFLite quint8 type values |
seq_lengths | tensor of 32/64-bit signless integer values |
Résultats:
Résultat | Description |
---|---|
output | tensor of 32-bit float or 32-bit signless integer or 64-bit signless integer or QI16 type or QUI8 type or TFLite quint8 type values |
tfl.reverse_v2
(TFL::ReverseV2Op)
ReverseV2 Operator
Reverses specific dimensions of a tensor.
Given a tensor, and a int32/int64 tensor axis representing the set of dimensions of tensor to reverse. This operation reverses each dimension i for which there exists j st axis[j] == i.
Args: tensor: A Tensor. Must be one of the following types: uint8, int8, int16, int32, int64, float32, bool Up to 8-D.
axis: A Tensor. Must be one of the following types: int32, int64. with only 1 element which is the axis index. TODO: Add support for multiple elements.
Traits: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Operands:
Operand | Description |
---|---|
input | tensor of 32-bit float or 8-bit unsigned integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer or QI16 type or QUI8 type or QI8 type or TFLite quint8 type or 1-bit signless integer values |
axis | tensor of 32-bit signless integer values |
Résultats:
Résultat | Description |
---|---|
output | tensor of 32-bit float or 8-bit unsigned integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer or QI16 type or QUI8 type or QI8 type or TFLite quint8 type or 1-bit signless integer values |
tfl.rfft2d
(TFL::RFFT2dOp)
2D real-valued fast Fourier transform.
Computes the 2-dimensional discrete Fourier transform of a real-valued signal over the inner-most 2 dimensions of input
.
Since the DFT of a real signal is Hermitian-symmetric, RFFT2D
only returns the fft_length / 2 + 1
unique components of the FFT for the inner-most dimension of output
: the zero-frequency term, followed by the fft_length / 2
positive-frequency termes.
Along each axis RFFT2D
is computed on, if fft_length
is smaller than the corresponding dimension of input
, the dimension is cropped. If it is larger, the dimension is padded with zeros.
Traits: AlwaysSpeculatableImplTrait
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Operands:
Operand | Description |
---|---|
input | tensor of 32-bit float values |
fft_length | tensor of 32-bit signless integer values |
Résultats:
Résultat | Description |
---|---|
output | tensor of complex type with 32-bit float elements values |
tfl.right_shift
(TFL::RightShiftOp)
Right Shift operator
Elementwise computes the bitwise right-shift of lhs
by rhs
.
Traits: AlwaysSpeculatableImplTrait
, SameOperandsAndResultElementType
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Operands:
Operand | Description |
---|---|
lhs | tensor of 8-bit signless integer or 8-bit unsigned integer or 16-bit signless integer or 16-bit unsigned integer or 32-bit signless integer or 32-bit unsigned integer values |
rhs | tensor of 8-bit signless integer or 8-bit unsigned integer or 16-bit signless integer or 16-bit unsigned integer or 32-bit signless integer or 32-bit unsigned integer values |
Résultats:
Résultat | Description |
---|---|
output | tensor of 8-bit signless integer or 8-bit unsigned integer or 16-bit signless integer or 16-bit unsigned integer or 32-bit signless integer or 32-bit unsigned integer values |
tfl.round
(TFL::RoundOp)
Round operator
Rounds the values of a tensor to the nearest integer, element-wise.
Traits: AlwaysSpeculatableImplTrait
, InferTensorType
, TF::SameOperandsAndResultTypeResolveRef
Interfaces: ConditionallySpeculatable
, InferShapedTypeOpInterface
, InferTypeOpInterface
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Operands:
Operand | Description |
---|---|
x | tensor of 32-bit float values |
Résultats:
Résultat | Description |
---|---|
y | tensor of 32-bit float values |
tfl.rsqrt
(TFL::RsqrtOp)
Reciprocal of square root operator
Computes element-wise reverse square root of input
Traits: AlwaysSpeculatableImplTrait
, QuantizableResult
, SameOperandsAndResultShape
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Operands:
Operand | Description |
---|---|
x | tensor of 32-bit float or QI8 type or QI16 type values |
Résultats:
Résultat | Description |
---|---|
y | tensor of 32-bit float or QI8 type or QI16 type values |
tfl.scatter_nd
(TFL::ScatterNdOp)
_Scatter nd operator
Scatter updates
into a new tensor according to indices
Traits: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Operands:
Operand | Description |
---|---|
indices | tensor of 32-bit signless integer values |
updates | tensor of 32-bit float or 8-bit signless integer or 64-bit signless integer or 32-bit signless integer or 8-bit unsigned integer or 1-bit signless integer values |
shape | 1D tensor of any type values |
Résultats:
Résultat | Description |
---|---|
output | tensor of 32-bit float or 8-bit signless integer or 64-bit signless integer or 32-bit signless integer or 8-bit unsigned integer or 1-bit signless integer values |
tfl.segment_sum
(TFL::SegmentSumOp)
SegmentSum operator
Computes the sum along segments of a tensor.
Traits: AlwaysSpeculatableImplTrait
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Operands:
Operand | Description |
---|---|
input | tensor of 32-bit float or 32-bit signless integer values |
segment_ids | tensor of 32-bit signless integer values |
Résultats:
Résultat | Description |
---|---|
output | tensor of 32-bit float or 32-bit signless integer values |
tfl.select
(TFL::SelectOp)
Sélectionnez l'opérateur
Select values of 'x' if the corresponding value of 'condition' is true or the value of 'y' if false. There are valid condition input sizes:
- Either the same shape (in which case the select is elementwise), or
- condition must be Rank 1 and match over the first dimension.
Traits: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Operands:
Operand | Description |
---|---|
condition | tensor of 1-bit signless integer values |
x | tensor of 32-bit float or 1-bit signless integer or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer or 32-bit unsigned integer or QI8 type or QUI8 type or QI16 type or TFLite quint8 type values |
y | tensor of 32-bit float or 1-bit signless integer or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer or 32-bit unsigned integer or QI8 type or QUI8 type or QI16 type or TFLite quint8 type values |
Résultats:
Résultat | Description |
---|---|
output | tensor of 32-bit float or 1-bit signless integer or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer or 32-bit unsigned integer or QI8 type or QUI8 type or QI16 type or TFLite quint8 type values |
tfl.select_v2
(TFL::SelectV2Op)
SelectV2 operator
Select values of 'x' if the corresponding value of 'condition' is true or the value of 'y' if false. There are valid condition input sizes:
- Either the same shape (in which case the select is elementwise), or
- Broadcastable shapes between 'condition', 'x' and 'y'.
Traits: ::mlir::OpTrait::TFLRuntimeOpTrait
, AlwaysSpeculatableImplTrait
, QuantizableResult
, ResultsBroadcastableShape
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Operands:
Operand | Description |
---|---|
condition | tensor of 1-bit signless integer values |
x | tensor of 32-bit float or 1-bit signless integer or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer or 32-bit unsigned integer or QI8 type or QUI8 type or QI16 type or TFLite quint8 type values |
y | tensor of 32-bit float or 1-bit signless integer or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer or 32-bit unsigned integer or QI8 type or QUI8 type or QI16 type or TFLite quint8 type values |
Résultats:
Résultat | Description |
---|---|
output | tensor of 32-bit float or 1-bit signless integer or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer or 32-bit unsigned integer or QI8 type or QUI8 type or QI16 type or TFLite quint8 type values |
tfl.shape
(TFL::ShapeOp)
Shape operator
Returns the shape of a tensor.
Traits: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Attributs :
Attribut | MLIR Type | Description |
---|---|---|
out_type | ::mlir::Attribute | derived attribute |
Operands:
Operand | Description |
---|---|
input | tensor of any type values |
Résultats:
Résultat | Description |
---|---|
output | tensor of 32-bit signless integer or 64-bit signless integer values |
tfl.sign
(TFL::SignOp)
Sign operation
Returns NaN if x is NaN, 0 if x is 0, -1 if x < 0 and 1 if x > 0.
Traits: AlwaysSpeculatableImplTrait
, SameOperandsAndResultElementType
, SameOperandsAndResultShape
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Operands:
Operand | Description |
---|---|
x | tensor of 32-bit float or 64-bit float or 32-bit signless integer values |
Résultats:
Résultat | Description |
---|---|
output | tensor of 32-bit float or 64-bit float or 32-bit signless integer values |
tfl.sin
(TFL::SinOp)
Sine operator
Computes element-wise Sine of input
Traits: AlwaysSpeculatableImplTrait
, InferTensorType
, TF::SameOperandsAndResultTypeResolveRef
Interfaces: ConditionallySpeculatable
, InferShapedTypeOpInterface
, InferTypeOpInterface
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Operands:
Operand | Description |
---|---|
x | tensor of 32-bit float values |
Résultats:
Résultat | Description |
---|---|
y | tensor of 32-bit float values |
tfl.slice
(TFL::SliceOp)
Return a slice from 'input'.
The output tensor is a tensor with dimensions described by 'size' whose values are extracted from 'input' starting at the offsets in 'begin'.
begin
is zero-based; size
is one-based. If size[i] is -1, all remaining elements in dimension i are included in the slice. In other words, this is equivalent to setting: size[i] = input.dim_size(i) - begin[i]
Requirements : 0 <= begin[i] <= begin[i] + size[i] <= Di for i in [0, n)
Traits: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Operands:
Operand | Description |
---|---|
input | tensor of 32-bit float or 32-bit signless integer or 64-bit signless integer or 8-bit signless integer or 8-bit unsigned integer or 32-bit unsigned integer or 1-bit signless integer or TFLite string type or QI8 type or QUI8 type or TFLite quint8 type or QI16 type values |
begin | tensor of 32/64-bit signless integer values |
size | tensor of 32/64-bit signless integer values |
Résultats:
Résultat | Description |
---|---|
output | tensor of 32-bit float or 32-bit signless integer or 64-bit signless integer or 8-bit signless integer or 8-bit unsigned integer or 32-bit unsigned integer or 1-bit signless integer or TFLite string type or QI8 type or QUI8 type or TFLite quint8 type or QI16 type values |
tfl.softmax
(TFL::SoftmaxOp)
Softmax operator
Computes element-wise softmax activations with the following formula
exp(input) / tf.reduce_sum(exp(input * beta), dim)
Traits: AlwaysSpeculatableImplTrait
, QuantizableResult
, SameOperandsAndResultShape
Interfaces: ConditionallySpeculatable
, FixedOutputRangeInterface
, NoMemoryEffect (MemoryEffectOpInterface)
, TflArithmeticCountOpInterface
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Attributs :
Attribut | MLIR Type | Description |
---|---|---|
beta | ::mlir::FloatAttr | 32-bit float attribute |
Operands:
Operand | Description |
---|---|
input | tensor of 32-bit float or QI8 type or QUI8 type or TFLite quint8 type or QI16 type values |
Résultats:
Résultat | Description |
---|---|
output | tensor of 32-bit float or QI8 type or QUI8 type or TFLite quint8 type or QI16 type values |
tfl.space_to_batch_nd
(TFL::SpaceToBatchNdOp)
SpaceToBatchNd operator
This operation reshapes space dimensions into the "batch" dimension 0
Traits: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Operands:
Operand | Description |
---|---|
input | tensor of 32-bit float or 32-bit signless integer or 64-bit signless integer or QI8 type or QUI8 type or TFLite quint8 type or QI16 type values |
block_shape | tensor of 32-bit signless integer values |
paddings | tensor of 32-bit signless integer values |
Résultats:
Résultat | Description |
---|---|
output | tensor of 32-bit float or 32-bit signless integer or 64-bit signless integer or QI8 type or QUI8 type or TFLite quint8 type or QI16 type values |
tfl.space_to_depth
(TFL::SpaceToDepthOp)
SpaceToDepth operator
Rearranges blocks of spatial data, into depth. More specifically, this op outputs a copy of the input tensor where values from the height
and width
dimensions are moved to the depth
dimension. block_size
indicates the input block size.
Traits: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Attributs :
Attribut | MLIR Type | Description |
---|---|---|
block_size | ::mlir::IntegerAttr | 32-bit signless integer attribute whose value is positive |
Operands:
Operand | Description |
---|---|
input | tensor of 32-bit float or 32-bit signless integer or 64-bit signless integer or QI8 type or QUI8 type or TFLite quint8 type values |
Résultats:
Résultat | Description |
---|---|
output | tensor of 32-bit float or 32-bit signless integer or 64-bit signless integer or QI8 type or QUI8 type or TFLite quint8 type values |
tfl.sparse_to_dense
(TFL::SparseToDenseOp)
Converts a sparse representation into a dense tensor.
Builds an array dense
with shape output_shape
such that
# 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]
All other values in dense
are set to default_value
. If sparse_values
is a scalar, all sparse indices are set to this single value.
Indices should be sorted in lexicographic order, and indices must not contain any repeats. If validate_indices
is true, these properties are checked during execution.
Traits: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Operands:
Operand | Description |
---|---|
sparse_indices | tensor of 32/64-bit signless integer values |
output_shape | tensor of 32/64-bit signless integer values |
sparse_values | tensor of 32-bit signless integer or 64-bit signless integer or 8-bit signless integer or QI8 type or 8-bit unsigned integer or QUI8 type or TFLite quint8 type or 32-bit float values |
default_value | tensor of 32-bit signless integer or 64-bit signless integer or 8-bit signless integer or QI8 type or 8-bit unsigned integer or QUI8 type or TFLite quint8 type or 32-bit float values |
Résultats:
Résultat | Description |
---|---|
dense | tensor of 32-bit signless integer or 64-bit signless integer or 8-bit signless integer or QI8 type or 8-bit unsigned integer or QUI8 type or TFLite quint8 type or 32-bit float values |
tfl.split
(TFL::SplitOp)
Splits a tensor into num_split
tensors along one dimension.
Splits the value
tensor along split_dim
into a number of sub-tensors with same shape as the original one, except for split_dim
. Same as tf.Split.
Traits: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Attributs :
Attribut | MLIR Type | Description |
---|---|---|
num_splits | ::mlir::IntegerAttr | 32-bit signless integer attribute whose value is positive |
Operands:
Operand | Description |
---|---|
split_dim | tensor of 32-bit signless integer values |
value | tensor of 32-bit float or 16-bit signless integer or 32-bit signless integer or 8-bit signless integer or 8-bit unsigned integer or QI8 type or QUI8 type or QI16 type values |
Résultats:
Résultat | Description |
---|---|
outputs | variadic of tensor of any type values |
tfl.split_v
(TFL::SplitVOp)
Splits a tensor into num_split
tensors along one dimension.
Splits the value
tensor along split_dim
into a number of sub-tensors with same shape as the original one, except for split_dim
. The grouping of the resultant sub-tensors is decided by size-splits
. Same as tf.SplitV.
Traits: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Attributs :
Attribut | MLIR Type | Description |
---|---|---|
num_splits | ::mlir::IntegerAttr | 32-bit signless integer attribute whose value is positive |
Operands:
Operand | Description |
---|---|
value | tensor of 32-bit float or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer or 8-bit signless integer or 8-bit unsigned integer or QI8 type or QUI8 type or QI16 type values |
size_splits | 1D tensor of 32-bit signless integer values |
split_dim | 0D tensor of 32-bit signless integer values |
Résultats:
Résultat | Description |
---|---|
outputs | variadic of tensor of any type values |
tfl.sqrt
(TFL::SqrtOp)
Square root operator
Computes element-wise Square root of input
Traits: AlwaysSpeculatableImplTrait
, InferTensorType
, TF::SameOperandsAndResultTypeResolveRef
Interfaces: ConditionallySpeculatable
, InferShapedTypeOpInterface
, InferTypeOpInterface
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Operands:
Operand | Description |
---|---|
x | tensor of 32-bit float values |
Résultats:
Résultat | Description |
---|---|
y | tensor of 32-bit float values |
tfl.square
(TFL::SquareOp)
Square operator
Computes element-wise Square of input
Traits: AlwaysSpeculatableImplTrait
, InferTensorType
, TF::SameOperandsAndResultTypeResolveRef
Interfaces: ConditionallySpeculatable
, InferShapedTypeOpInterface
, InferTypeOpInterface
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Operands:
Operand | Description |
---|---|
x | tensor of 32-bit float values |
Résultats:
Résultat | Description |
---|---|
y | tensor of 32-bit float values |
tfl.squared_difference
(TFL::SquaredDifferenceOp)
Squared difference operator
Element-wise squared difference operation.
Traits: ::mlir::OpTrait::TFLRuntimeOpTrait
, AlwaysSpeculatableImplTrait
, QuantizableResult
, ResultsBroadcastableShape
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Operands:
Operand | Description |
---|---|
lhs | tensor of 32-bit float or 32-bit signless integer or QI8 type values |
rhs | tensor of 32-bit float or 32-bit signless integer or QI8 type values |
Résultats:
Résultat | Description |
---|---|
output | tensor of 32-bit float or 32-bit signless integer or QI8 type values |
tfl.squeeze
(TFL::SqueezeOp)
Removes dimensions of size 1 from the shape of a tensor.
Given a tensor input
, this operation returns a tensor of the same type with all dimensions of size 1 removed. If you don't want to remove all size 1 dimensions, you can remove specific size 1 dimensions by specifying squeeze_dims
.
Par exemple:
# 't' is a tensor of shape [1, 2, 1, 3, 1, 1]
shape(squeeze(t)) ==> [2, 3]
Or, to remove specific size 1 dimensions:
# 't' is a tensor of shape [1, 2, 1, 3, 1, 1]
shape(squeeze(t, [2, 4])) ==> [1, 2, 3, 1]
Traits: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Attributs :
Attribut | MLIR Type | Description |
---|---|---|
squeeze_dims | ::mlir::ArrayAttr | 64-bit integer array attribute whose size is at most 8 |
Operands:
Operand | Description |
---|---|
input | tensor of any type values |
Résultats:
Résultat | Description |
---|---|
output | tensor of any type values |
tfl.strided_slice
(TFL::StridedSliceOp)
StridedSlice Op
Return a strided slice from input
.
Traits: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Attributs :
Attribut | MLIR Type | Description |
---|---|---|
begin_mask | ::mlir::IntegerAttr | 32-bit signless integer attribute |
end_mask | ::mlir::IntegerAttr | 32-bit signless integer attribute |
ellipsis_mask | ::mlir::IntegerAttr | 32-bit signless integer attribute |
new_axis_mask | ::mlir::IntegerAttr | 32-bit signless integer attribute |
shrink_axis_mask | ::mlir::IntegerAttr | 32-bit signless integer attribute |
offset | ::mlir::BoolAttr | bool attribute |
Operands:
Operand | Description |
---|---|
input | tensor of 32-bit float or 32-bit signless integer or 64-bit signless integer or 8-bit signless integer or 8-bit unsigned integer or 32-bit unsigned integer or QI8 type or QUI8 type or 1-bit signless integer or 16-bit signless integer or QI16 type or TFLite quint8 type or TFLite string type values |
begin | tensor of 32-bit signless integer values |
end | tensor of 32-bit signless integer values |
strides | tensor of 32-bit signless integer values |
Résultats:
Résultat | Description |
---|---|
output | tensor of 32-bit float or 32-bit signless integer or 64-bit signless integer or 8-bit signless integer or 8-bit unsigned integer or 32-bit unsigned integer or QI8 type or QUI8 type or 1-bit signless integer or 16-bit signless integer or QI16 type or TFLite quint8 type or TFLite string type values |
tfl.sub
(TFL::SubOp)
Subtraction operator
Element-wise subtraction operation.
Traits: ::mlir::OpTrait::TFLRuntimeOpTrait
, AlwaysSpeculatableImplTrait
, QuantizableResult
, ResultsBroadcastableShape
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflArithmeticCountOpInterface
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Attributs :
Attribut | MLIR Type | Description |
---|---|---|
fused_activation_function | ::mlir::StringAttr | string attribute whose value is NONE, or RELU, or RELU_N1_TO_1, or RELU6, or TANH, or SIGN_BIT |
Operands:
Operand | Description |
---|---|
lhs | tensor of 32-bit float or 32-bit signless integer or 64-bit signless integer or QI8 type or QUI8 type or QI16 type values |
rhs | tensor of 32-bit float or 32-bit signless integer or 64-bit signless integer or QI8 type or QUI8 type or QI16 type values |
Résultats:
Résultat | Description |
---|---|
output | tensor of 32-bit float or 32-bit signless integer or 64-bit signless integer or QI8 type or QUI8 type or QI16 type values |
tfl.sum
(TFL::SumOp)
Sum operator
Computes the sum reduction along the specified axes
Traits: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Attributs :
Attribut | MLIR Type | Description |
---|---|---|
keep_dims | ::mlir::BoolAttr | bool attribute |
Operands:
Operand | Description |
---|---|
input | tensor of 32-bit float or 32-bit signless integer or 64-bit signless integer or QI8 type or QUI8 type or TFLite quint8 type or QI16 type values |
axes | tensor of 32-bit signless integer values |
Résultats:
Résultat | Description |
---|---|
output | tensor of 32-bit float or 32-bit signless integer or 64-bit signless integer or QI8 type or QUI8 type or TFLite quint8 type or QI16 type values |
tfl.svdf
(TFL::SVDFOp)
Single value decomposition filter operator
The SVDF op is a decomposition of a densely connected op into low rank filters. For details: https://research.google.com/pubs/pub43813.html https://arxiv.org/abs/1812.02802
Traits: QuantizableResult
, quant::AccumulatorUniformScale<3, 2, 4>
Interfaces: DynamicRangeQuantizedOpInterface
, TFL_StatefulOp
, TflRuntimeVerifyOpInterface
Attributs :
Attribut | MLIR Type | Description |
---|---|---|
rank | ::mlir::IntegerAttr | 32-bit signless integer attribute whose value is positive |
fused_activation_function | ::mlir::StringAttr | string attribute whose value is NONE, or RELU, or RELU_N1_TO_1, or RELU6, or TANH, or SIGN_BIT |
asymmetric_quantize_inputs | ::mlir::BoolAttr | bool attribute |
Operands:
Operand | Description |
---|---|
input | tensor of 32-bit float or QI8 type values |
feature_weights | tensor of 32-bit float or QI8 type or QUI8 type values |
time_weights | tensor of 32-bit float or QI16 type values |
input_gate_bias | tensor of any type values or none type |
activation_state | stateful tensor |
Résultats:
Résultat | Description |
---|---|
output | tensor of 32-bit float or QI8 type values |
tfl.tanh
(TFL::TanhOp)
Hyperbolic tangent operator
Computes element-wise Hyperbolic tangent of input
Traits: AlwaysSpeculatableImplTrait
, QuantizableResult
, SameOperandsAndResultShape
Interfaces: ConditionallySpeculatable
, FixedOutputRangeInterface
, NoMemoryEffect (MemoryEffectOpInterface)
, TflArithmeticCountOpInterface
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Operands:
Operand | Description |
---|---|
input | tensor of 32-bit float or QI8 type or QUI8 type or QI16 type or TFLite quint8 type values |
Résultats:
Résultat | Description |
---|---|
output | tensor of 32-bit float or QI8 type or QUI8 type or QI16 type or TFLite quint8 type values |
tfl.tile
(TFL::TileOp)
Tile operator.
Constructs a tensor by tiling a given tensor.
This operation creates a new tensor by replicating input multiples times. The output tensor's i'th dimension has input.dims(i) * multiples[i] elements, and the values of input are replicated multiples[i] times along the 'i'th dimension. For example, tiling [abcd] by [2] produces [abcdabcd].
Traits: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Operands:
Operand | Description |
---|---|
input | tensor of 32-bit float or 1-bit signless integer or 32-bit signless integer or 64-bit signless integer or 8-bit unsigned integer or QI8 type or QUI8 type or TFLite string type values |
multiples | tensor of 32/64-bit signless integer values |
Résultats:
Résultat | Description |
---|---|
output | tensor of 32-bit float or 1-bit signless integer or 32-bit signless integer or 64-bit signless integer or 8-bit unsigned integer or QI8 type or QUI8 type or TFLite string type values |
tfl.topk_v2
(TFL::TopKV2Op)
TopK operator
Returns the top k
largest element along each last dimensional slice of input
and the indices of values within the last dimension of the input tensor.
Results are always sorted in the descending order.
Traits: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Operands:
Operand | Description |
---|---|
input | tensor of 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer or 8-bit unsigned integer or QI8 type or QUI8 type values |
k | tensor of 16-bit signless integer or 32-bit signless integer values |
Résultats:
Résultat | Description |
---|---|
values | tensor of 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer or 8-bit unsigned integer or QI8 type or QUI8 type values |
indices | tensor of 16-bit signless integer or 32-bit signless integer values |
tfl.transpose
(TFL::TransposeOp)
Transpose operator
Returns the Transpose of x
Traits: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Operands:
Operand | Description |
---|---|
input | tensor of 32-bit signless integer or 32-bit float or 8-bit signless integer or 8-bit unsigned integer or QI8 type or QUI8 type or TFLite quint8 type or 1-bit signless integer or 64-bit signless integer or QI16 type values |
perm | tensor of 32-bit signless integer values |
Résultats:
Résultat | Description |
---|---|
output | tensor of 32-bit signless integer or 32-bit float or 8-bit signless integer or 8-bit unsigned integer or QI8 type or QUI8 type or TFLite quint8 type or 1-bit signless integer or 64-bit signless integer or QI16 type values |
tfl.transpose_conv
(TFL::TransposeConvOp)
Transpose convolution operator
Performs transpose convolution operation on input.
Traits: AlwaysSpeculatableImplTrait
, QuantizableResult
, quant::AccumulatorUniformScale<3, 1, 2>
, quant::AffineOpCoefficient<0, 1>
Interfaces: AffineQuantizedOpInterface
, ConditionallySpeculatable
, DynamicRangeQuantizedOpInterface
, NoMemoryEffect (MemoryEffectOpInterface)
, TFL_SparseOp
, TflArithmeticCountOpInterface
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Attributs :
Attribut | MLIR Type | Description |
---|---|---|
padding | ::mlir::StringAttr | string attribute whose value is SAME, or VALID |
stride_h | ::mlir::IntegerAttr | 32-bit signless integer attribute whose value is positive |
stride_w | ::mlir::IntegerAttr | 32-bit signless integer attribute whose value is positive |
fused_activation_function | ::mlir::StringAttr | string attribute whose value is NONE, or RELU, or RELU_N1_TO_1, or RELU6, or TANH, or SIGN_BIT |
Operands:
Operand | Description |
---|---|
output_shape | tensor of 32-bit signless integer values |
weights | tensor of 32-bit float or QI8 type or QUI8 type or QI16 type values |
input | tensor of 32-bit float or QI8 type or QUI8 type or QI16 type values |
bias | tensor of any type values or none type |
Résultats:
Résultat | Description |
---|---|
output | tensor of 32-bit float or QI8 type or QUI8 type or QI16 type values |
tfl.unidirectional_sequence_lstm
(TFL::UnidirectionalSequenceLSTMOp)
Unidirectional sequence lstm operator
A recurrent neural network specified by an LSTM cell. This Op supports unrolling the input along the time or batch dimensions, and implements the following operation for each element in the sequence s = 1...sequence_length: outputs[s] = state = activation(LSTMOp(inputs[s]))
where LSTMOp is LSTM TF Lite Op and the “activation” is the function passed as the “fused_activation_function” argument (if not “NONE”).
Traits: QuantizableResult
Interfaces: DynamicRangeQuantizedOpInterface
, InferTypeOpInterface
, TFL_StatefulOp
, TflRuntimeVerifyOpInterface
Attributs :
Attribut | MLIR Type | Description |
---|---|---|
fused_activation_function | ::mlir::StringAttr | string attribute whose value is NONE, or RELU, or RELU_N1_TO_1, or RELU6, or TANH, or SIGN_BIT |
cell_clip | ::mlir::FloatAttr | 32-bit float attribute whose value is non-negative |
proj_clip | ::mlir::FloatAttr | 32-bit float attribute whose value is non-negative |
time_major | ::mlir::BoolAttr | bool attribute |
asymmetric_quantize_inputs | ::mlir::BoolAttr | bool attribute |
diagonal_recurrent_tensors | ::mlir::BoolAttr | bool attribute |
input_to_input_intermediate | ::mlir::TypeAttr | any type attribute |
input_to_forget_intermediate | ::mlir::TypeAttr | any type attribute |
input_to_cell_intermediate | ::mlir::TypeAttr | any type attribute |
input_to_output_intermediate | ::mlir::TypeAttr | any type attribute |
effective_hidden_scale_intermediate | ::mlir::TypeAttr | any type attribute |
Operands:
Operand | Description |
---|---|
input | tensor of 32-bit float values |
input_to_input_weights | tensor of any type values or none type |
input_to_forget_weights | tensor of 32-bit float or QI8 type values |
input_to_cell_weights | tensor of 32-bit float or QI8 type values |
input_to_output_weights | tensor of 32-bit float or QI8 type values |
recurrent_to_input_weights | tensor of any type values or none type |
recurrent_to_forget_weights | tensor of 32-bit float or QI8 type values |
recurrent_to_cell_weights | tensor of 32-bit float or QI8 type values |
recurrent_to_output_weights | tensor of 32-bit float or QI8 type values |
cell_to_input_weights | tensor of any type values or none type |
cell_to_forget_weights | tensor of any type values or none type |
cell_to_output_weights | tensor of any type values or none type |
input_gate_bias | tensor of any type values or none type |
forget_gate_bias | tensor of 32-bit float values |
cell_bias | tensor of 32-bit float values |
output_gate_bias | tensor of 32-bit float values |
projection_weights | tensor of any type values or none type |
projection_bias | tensor of any type values or none type |
input_activation_state | stateful tensor |
input_cell_state | stateful tensor |
input_layer_norm_coefficients | tensor of any type values or none type |
forget_layer_norm_coefficients | tensor of any type values or none type |
cell_layer_norm_coefficients | tensor of any type values or none type |
output_layer_norm_coefficients | tensor of any type values or none type |
Résultats:
Résultat | Description |
---|---|
output | tensor of 32-bit float or QI8 type values |
tfl.unidirectional_sequence_rnn
(TFL::UnidirectionalSequenceRNNOp)
Unidirectional sequence rnn operator
A recurrent neural network specified by an RNN cell. This Op takes in input in a format {batch_size, seq_len, input_size} or {seq_len, batch_size, input_size} if it's time-majored.
It implements the following operation for each element in the sequence s = 1...sequence_length: outputs[s] = state = activation(RNNOp(inputs[s]))
where RNNOp is RNNOp TF Lite Op and the “activation” is the function passed as the “fused_activation_function” argument (if not “NONE”).
Traits: QuantizableResult
Interfaces: DynamicRangeQuantizedOpInterface
, TFL_StatefulOp
, TflRuntimeVerifyOpInterface
Attributs :
Attribut | MLIR Type | Description |
---|---|---|
time_major | ::mlir::BoolAttr | bool attribute |
fused_activation_function | ::mlir::StringAttr | string attribute whose value is NONE, or RELU, or RELU_N1_TO_1, or RELU6, or TANH, or SIGN_BIT |
asymmetric_quantize_inputs | ::mlir::BoolAttr | bool attribute |
Operands:
Operand | Description |
---|---|
input | tensor of 32-bit float values |
input_to_input_weights | tensor of 32-bit float or QI8 type values |
recurrent_to_input_weights | tensor of 32-bit float or QI8 type values |
input_gate_bias | tensor of 32-bit float values |
hidden_state | stateful tensor |
Résultats:
Résultat | Description |
---|---|
output | tensor of 32-bit float values |
tfl.unique
(TFL::UniqueOp)
Unique Op.
This operation returns a tensor output
containing all of the unique elements of input
sorted in the same order that they occur in input
. This operation also returns a tensor idx
the same size as x
that contains the index of each value of input
in the unique output output
. Autrement dit:
Traits: AlwaysSpeculatableImplTrait
, QuantizableResult
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Attributs :
Attribut | MLIR Type | Description |
---|---|---|
idx_out_type | ::mlir::Attribute | derived attribute |
Operands:
Operand | Description |
---|---|
input | tensor of 8-bit signless integer or QI8 type or 8-bit unsigned integer or QUI8 type or 16-bit signless integer or QI16 type or 32-bit signless integer or 64-bit signless integer or 32-bit float values |
Résultats:
Résultat | Description |
---|---|
output | tensor of 8-bit signless integer or QI8 type or 8-bit unsigned integer or QUI8 type or 16-bit signless integer or QI16 type or 32-bit signless integer or 64-bit signless integer or 32-bit float values |
idx | tensor of 32/64-bit signless integer values |
tfl.unpack
(TFL::UnpackOp)
Unpacks a tensor along a dimension into multiple tensors
Unpacks a given dimension of a rank- R
tensor into num
rank- (R-1)
tensors.
Unpacks num
tensors from value
by chipping it along the axis
dimension. For example, given a tensor of shape (A, B, C, D)
;
If axis == 0
then the i'th tensor in output
is the slice value[i, :, :, :]
and each tensor in output
will have shape (B, C, D)
. (Note that the dimension unpacked along is gone, unlike split
).
If axis == 1
then the i'th tensor in output
is the slice value[:, i, :, :]
and each tensor in output
will have shape (A, C, D)
. Etc.
This is the opposite of pack
.
Traits: AlwaysSpeculatableImplTrait
, QuantizableResult
, SameOperandsAndResultElementType
Interfaces: ConditionallySpeculatable
, InferTypeOpInterface
, NoMemoryEffect (MemoryEffectOpInterface)
, SameOperandsAndResultsScale
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Attributs :
Attribut | MLIR Type | Description |
---|---|---|
num | ::mlir::IntegerAttr | 32-bit signless integer attribute whose value is non-negative |
axis | ::mlir::IntegerAttr | 32-bit signless integer attribute |
Operands:
Operand | Description |
---|---|
input | tensor of 32-bit float or 1-bit signless integer or 8-bit signless integer or 8-bit unsigned integer or 32-bit signless integer or QI8 type or QUI8 type or 16-bit signless integer or QI16 type values |
Résultats:
Résultat | Description |
---|---|
outputs | variadic of tensor of any type values |
tfl.unsorted_segment_max
(TFL::UnsortedSegmentMaxOp)
UnsortedSegmentMax operator
Computes the maximum value along segments of a tensor such that output[i] = max(data[j....]) where segment_ids[j...] = i if the maximum is empty for a given segment ID i, it outputs the smallest possible value for the specific numeric type, output[i] = numeric_limits::lowest(). Note the values of segment_ids are always validated to be less than num_segments and an error is thrown for out-of-bound indices.
Traits: AlwaysSpeculatableImplTrait
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Operands:
Operand | Description |
---|---|
input | tensor of 32-bit float or 32-bit signless integer values |
segment_ids | tensor of 32-bit signless integer values |
num_segments | tensor of 32-bit signless integer values |
Résultats:
Résultat | Description |
---|---|
output | tensor of 32-bit float or 32-bit signless integer values |
tfl.unsorted_segment_min
(TFL::UnsortedSegmentMinOp)
UnsortedSegmentMin operator
Computes the minimum value along segments of a tensor such that output[i] = min(data[j....]) where segment_ids[j...] = i if the minimum is empty for a given segment ID i, it outputs the largest possible value for the specific numeric type, output[i] = numeric_limits::max(). Note the values of segment_ids are always validated to be less than num_segments and an error is thrown for out-of-bound indices.
Traits: AlwaysSpeculatableImplTrait
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Operands:
Operand | Description |
---|---|
input | tensor of 32-bit float or 32-bit signless integer values |
segment_ids | tensor of 32-bit signless integer values |
num_segments | tensor of 32-bit signless integer values |
Résultats:
Résultat | Description |
---|---|
output | tensor of 32-bit float or 32-bit signless integer values |
tfl.unsorted_segment_prod
(TFL::UnsortedSegmentProdOp)
UnsortedSegmentProd operator
Computes the product along segments of a tensor.
Traits: AlwaysSpeculatableImplTrait
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Operands:
Operand | Description |
---|---|
input | tensor of 32-bit float or 32-bit signless integer values |
segment_ids | tensor of 32-bit signless integer values |
num_segments | tensor of 32-bit signless integer values |
Résultats:
Résultat | Description |
---|---|
output | tensor of 32-bit float or 32-bit signless integer values |
tfl.unsorted_segment_sum
(TFL::UnsortedSegmentSumOp)
UnsortedSegmentSum operator
From a tensor segmentation, computes the output
resulting from summing together elements mapped to the same segment_id. Ie output[i]
is equal to the tensor sum of all elements from the input tensor mapped to segment_id i
. If no tensors are mapped to a particular included segment_id, the output at that indice will be a zero tensor with the appropriate shape. Note the values of segment_ids are always validated to be less than num_segments and an error is thrown for out-of-bound indices
Traits: AlwaysSpeculatableImplTrait
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Operands:
Operand | Description |
---|---|
input | tensor of 32-bit float or 32-bit signless integer values |
segment_ids | tensor of 32-bit signless integer values |
num_segments | tensor of 32-bit signless integer values |
Résultats:
Résultat | Description |
---|---|
output | tensor of 32-bit float or 32-bit signless integer values |
tfl.var_handle
(TFL::VarHandleOp)
Returns a handle to a variable resource from its name.
Returns a handle for a variable resource from its name. container: the container this variable is placed in. shared_name: the name by which this variable is referred to.
Interfaces: TflRuntimeVerifyOpInterface
Attributs :
Attribut | MLIR Type | Description |
---|---|---|
container | ::mlir::StringAttr | string attribute |
shared_name | ::mlir::StringAttr | string attribute |
Résultats:
Résultat | Description |
---|---|
resource_handle | tensor of resource values |
tfl.where
(TFL::WhereOp)
Returns locations of nonzero / true values in a tensor.
This operation returns the coordinates of true elements in condition
. The coordinates are returned in a 2-D tensor where the first dimension (rows) represents the number of true elements, and the second dimension (columns) represents the coordinates of the true elements. Keep in mind, the shape of the output tensor can vary depending on how many true values there are in condition
. Indices are output in row-major order.
Traits: AlwaysSpeculatableImplTrait
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Operands:
Operand | Description |
---|---|
condition | tensor of 1-bit signless integer or 32-bit float or 32/64-bit signless integer or 8-bit signless integer or 8-bit unsigned integer or 32-bit unsigned integer values |
Résultats:
Résultat | Description |
---|---|
index | tensor of 64-bit signless integer values |
tfl.while
(TFL::WhileOp)
While loop
output = input; while (cond(output)) { output = body(output) }
While loop where all values are passes through arguments with implicit capture.
input: A list of input tensors whose types are T. output: A list of output tensors whose types are T. cond: A region that takes 'input' and returns a boolean scalar tensor. body: A region that takes a list of tensors and returns another list of tensors. Both lists have the same types.
Traits: SingleBlockImplicitTerminator<YieldOp>
, SingleBlock
Interfaces: LoopLikeOpInterface
, TflRuntimeVerifyOpInterface
Attributs :
Attribut | MLIR Type | Description |
---|---|---|
is_stateless | ::mlir::BoolAttr | bool attribute |
Operands:
Operand | Description |
---|---|
input | variadic of tensor of any type values |
Résultats:
Résultat | Description |
---|---|
output | variadic of tensor of any type values |
tfl.yield
(TFL::YieldOp)
Yield operation
The "yield" operation represents a return operation within the conditional and body of structured control flow (eg, while), and a terminator for ControlNodeOp. The operation takes a variable number of operands and produces no results. The operand number and types must match the signature of the region that contains the operation.
Traits: AlwaysSpeculatableImplTrait
, QuantizableResult
, Terminator
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Operands:
Operand | Description |
---|---|
"anonyme" | variadic of any type |
tfl.zeros_like
(TFL::ZerosLikeOp)
ZerosLike operator
Returns a tensor of zeros with the same shape and type as the input tensor.
Traits: AlwaysSpeculatableImplTrait
, SameOperandsAndResultShape
Interfaces: ConditionallySpeculatable
, NoMemoryEffect (MemoryEffectOpInterface)
, TflRuntimeVerifyOpInterface
Effects: MemoryEffects::Effect{}
Operands:
Operand | Description |
---|---|
input | tensor of 64-bit signless integer or 32-bit signless integer or 32-bit float values |
Résultats:
Résultat | Description |
---|---|
output | tensor of 64-bit signless integer or 32-bit signless integer or 32-bit float values |
Attributs
DimensionMetadataAttr
Dimension metadata.
Syntaxe:
#tfl.dimension_metadata<
::mlir::TFL::DimensionTypeAttr, # format
int32_t, # dense_size
::llvm::ArrayRef<int32_t>, # segments
::llvm::ArrayRef<int32_t> # indices
>
Paramètres :
Paramètre | C++ type | Description |
---|---|---|
format | ::mlir::TFL::DimensionTypeAttr | dimension_type |
dense_size | int32_t | |
segments | ::llvm::ArrayRef<int32_t> | |
indices | ::llvm::ArrayRef<int32_t> |
SparsityParameterAttr
Sparsity parameter.
Syntaxe:
#tfl.sparsity_parameter<
::llvm::ArrayRef<int32_t>, # traversal_order
::llvm::ArrayRef<int32_t>, # block_map
::llvm::ArrayRef<DimensionMetadataAttr> # dim_metadata
>
Paramètres :
Paramètre | C++ type | Description |
---|---|---|
traversal_order | ::llvm::ArrayRef<int32_t> | |
block_map | ::llvm::ArrayRef<int32_t> | |
dim_metadata | ::llvm::ArrayRef<DimensionMetadataAttr> |
ConstBytesAttr
A string attribute representation of compiled bytes
Syntax Examples:
#tfl<const_bytes : "0xDEADBEEF">
Paramètres :
Paramètre | C++ type | Description |
---|---|---|
valeur | ::llvm::StringRef |
DimensionTypeAttr
dimension_type
Syntaxe:
#tfl.dimension_type_attr<
::mlir::TFL::DimensionType # value
>
Enum cases:
- DENSE (
DENSE
) - SPARSE_CSR (
SPARSE_CSR
) #### Parameters:
Paramètre | C++ type | Description |
---|---|---|
valeur | ::mlir::TFL::DimensionType | an enum of type DimensionType |
LSTMKernelTypeAttr
lstm_kernel_type
Syntaxe:
#tfl.lstm_kernel_type_attr<
::mlir::TFL::LSTMKernelType # value
>
Enum cases:
- FULL (
FULL
) - BASIC (
BASIC
) #### Parameters:
Paramètre | C++ type | Description |
---|---|---|
valeur | ::mlir::TFL::LSTMKernelType | an enum of type LSTMKernelType |
MirrorPaddingTypeAttr
mirror_pad_enum
Syntaxe:
#tfl.mirror_pad_attr<
::mlir::TFL::MirrorPaddingType # value
>
Enum cases:
- REFLECT (
REFLECT
) - SYMMETRIC (
SYMMETRIC
) #### Parameters:
Paramètre | C++ type | Description |
---|---|---|
valeur | ::mlir::TFL::MirrorPaddingType | an enum of type MirrorPaddingType |
Énumérations
DimensionType
dimension_type
Cases:
Symbole | Valeur | Chaîne |
---|---|---|
DENSE | 0 | DENSE |
SPARSE_CSR | 1 | SPARSE_CSR |
LSTMKernelType
lstm_kernel_type
Cases:
Symbole | Valeur | Chaîne |
---|---|---|
COMPLET | 0 | COMPLET |
BASIQUE | 1 | BASIQUE |
MirrorPaddingType
mirror_pad_enum
Cases:
Symbole | Valeur | Chaîne |
---|---|---|
REFLÉTER | 0 | REFLÉTER |
SYMÉTRIQUE | 1 | SYMÉTRIQUE |