'tfl' Dialecte

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 :

Résultats:

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 :

Opérandes :

Résultats:

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 :

Résultats:

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 :

Opérandes :

Résultats:

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 :

Opérandes :

Résultats:

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 :

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 :

Résultats:

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 :

Opérandes :

Résultats:

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 :

Opérandes :

Résultats:

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_rhs`: optional: Transpose RHS (default false)

Traits : ::mlir::OpTrait::TFLRuntimeOpTrait , AlwaysSpeculatableImplTrait , QuantizableResult

Interfaces : ConditionallySpeculatable , DynamicRangeQuantizedOpInterface , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats:

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 :

Résultats:

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 :

Opérandes :

Résultats:

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 :

Résultats:

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 :

Résultats:

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 :

Résultats:

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 :

Résultats:

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 :

Opérandes :

Résultats:

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 :

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 :

Résultats:

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 :

Résultats:

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 :

Résultats:

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 :

Opérandes :

Résultats:

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 :

Résultats:

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 :

Opérandes :

Résultats:

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 :

Opérandes :

Résultats:

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 :

Opérandes :

Résultats:

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 :

Résultats:

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 :

Opérandes :

Résultats:

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 :

Opérandes :

Résultats:

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 :

Résultats:

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 :

Résultats:

tfl.depth_to_space (TFL :: ProfondeurToSpaceOp)

Opérateur DepthToSpace

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 :

Opérandes :

Résultats:

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 :

Opérandes :

Résultats:

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 :

Résultats:

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 :

Résultats:

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 :

Opérandes :

Résultats:

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 :

Résultats:

tfl.elu (TFL::EluOp)

Opérateur d'unité linéaire exponentielle

Calcule le linéaire exponentiel f(x) -> exp(x) - 1 pour x < 0, x pour x >= 0. par élément.

Traits : AlwaysSpeculatableImplTrait , SameOperandsAndResultShape

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.embedding_lookup (TFL::EmbeddingLookupOp)

Opérateur de recherche d'intégration

Recherche les identifiants dans une liste de tenseurs d'intégration.

Traits : AlwaysSpeculatableImplTrait , QuantizableResult

Interfaces : AffineQuantizedOpInterface , ConditionallySpeculatable , DynamicRangeQuantizedOpInterface , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

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 , AlwaysSpeculatableImplTrait , Commutative , QuantizableResult , ResultsBroadcastableShape

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.exp (TFL::ExpOp)

Opérateur d'exponentiation naturelle

Effectue une opération d’exponentiation naturelle par élément en entrée.

Traits : AlwaysSpeculatableImplTrait , QuantizableResult

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.expand_dims (TFL :: ExpandDimsOp)

Insère une dimension de 1 dans la forme d'un tenseur.

Étant donné un tenseur input , cette opération insère une dimension de 1 sur l' axis d'index de dimension de la forme de input . L' axis d'index de dimension commence à zéro ; si vous spécifiez un nombre négatif pour axis il est compté à rebours à partir 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) , ce qui créera 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 taille 1.

Traits : AlwaysSpeculatableImplTrait , QuantizableResult

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.external_const (TFL::ExternalConstOp)

Op. const externe.

L'opération const 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 :

Résultats:

tfl.fake_quant (TFL::FakeQuantOp)

Opérateur FakeQuant

Fausse quantifier le tenseur des « entrées » de type float via les scalaires float min et max en tenseur « sorties » de même forme que les entrées.

Traits : AlwaysSpeculatableImplTrait , QuantizableResult

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats:

tfl.fill (TFL::FillOp)

Remplissez le tenseur avec la valeur donnée.

Remplissez le tenseur avec la valeur donnée.

Traits : AlwaysSpeculatableImplTrait , QuantizableResult

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.floor (TFL::FloorOp)

Opérateur d'étage

Renvoie la valeur plancher par élément de l’entrée.

Traits : AlwaysSpeculatableImplTrait , InferTensorType , TF::SameOperandsAndResultTypeResolveRef

Interfaces : ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.floor_div (TFL::FloorDivOp)

Opérateur de division d'étage

Opération de division au sol par élément.

Traits : ::mlir::OpTrait::TFLRuntimeOpTrait , AlwaysSpeculatableImplTrait , ResultsBroadcastableShape

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.floor_mod (TFL::FloorModOp)

Rappel de division

Opération de rappel de division par élément.

Traits : ::mlir::OpTrait::TFLRuntimeOpTrait , AlwaysSpeculatableImplTrait , ResultsBroadcastableShape

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.fully_connected (TFL::FullyConnectedOp)

Opération entièrement connectée

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 :

Opérandes :

Résultats:

tfl.gather (TFL::GatherOp)

Opérateur de collecte

Rassemblez les tranches de axis des params en fonction indices .

Traits : AlwaysSpeculatableImplTrait , QuantizableResult

Interfaces : ConditionallySpeculatable , DynamicRangeQuantizedOpInterface , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats:

tfl.gather_nd (TFL::GatherNdOp)

_Gather et opérateur

Rassemblez les tranches des params dans un Tensor avec une forme spécifiée par indices .

Traits : AlwaysSpeculatableImplTrait , QuantizableResult

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.gelu (TFL::GeluOp)

Fonction d'activation GELU.

Calcule la fonction d'activation GELU par élément.

Traits : AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats:

tfl.greater (TFL::GreaterOp)

Un plus grand opérateur

Fonctionnement plus efficace au niveau des éléments.

Traits : ::mlir::OpTrait::TFLRuntimeOpTrait , AlwaysSpeculatableImplTrait , QuantizableResult , ResultsBroadcastableShape

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.greater_equal (TFL::GreaterEqualOp)

_Plus grand opérateur égal

Opération Greater_equal par élément.

Traits : ::mlir::OpTrait::TFLRuntimeOpTrait , AlwaysSpeculatableImplTrait , QuantizableResult , ResultsBroadcastableShape

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.hard_swish (TFL::HardSwishOp)

Fonction d'activation Hardswish.

Calcule la fonction d'activation hard-swish f(x) -> (x * relu6(x+3))/6 par élément.

Traits : AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.hashtable (TFL::HashtableOp)

Crée une table de hachage non initialisée.

Cette opération crée une table de hachage, spécifiant le type de ses clés et valeurs. Avant d'utiliser la table, vous devrez l'initialiser. Après initialisation, la table sera immuable.

Interfaces : TflRuntimeVerifyOpInterface

Attributs :

Résultats:

tfl.hashtable_find (TFL :: HashtableFindOp)

Recherche les clés dans un tableau, affiche les valeurs correspondantes.

Les keys tensorielles doivent être du même type que les clés de la table. Les values de sortie sont du type des valeurs du tableau.

La valeur scalaire default_value est la valeur de sortie pour les clés non présentes dans la table. Il doit également être du même type que les valeurs du tableau.

Interfaces : TflRuntimeVerifyOpInterface

Opérandes :

Résultats:

tfl.hashtable_import (TFL :: HashtableImportOp)

Remplace le contenu de la table par les clés et valeurs spécifiées.

Les keys tensorielles 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 :

tfl.hashtable_size (TFL::HashtableSizeOp)

Calcule le nombre d'éléments dans la table donnée.

Interfaces : TflRuntimeVerifyOpInterface

Opérandes :

Résultats:

tfl.if (TFL::IfOp)

Opération si-alors-sinon

L'opération tfl.if représente une construction if-then-else pour l'exécution conditionnelle de deux régions de code. L'opérande d'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 le chemin d'exécution emprunté.

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 se terminent toujours par "tfl.yield". Si "tfl.if" ne définit aucune valeur, "tfl.yield" peut être laissé de côté et sera inséré implicitement. Sinon, il faut que ce soit 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 :

Résultats:

tfl.imag (TFL::ImagOp)

Renvoie la partie imaginaire d'un nombre complexe.

Étant donné une input tensorielle de nombres complexes, cette opération renvoie un tenseur de type float 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 :

Résultats:

tfl.l2_normalization (TFL :: L2NormalizationOp)

Opérateur de normalisation L2

Opération de normalisation L2

Traits : AlwaysSpeculatableImplTrait , QuantizableResult

Interfaces : ConditionallySpeculatable , FixedOutputRangeInterface , NoMemoryEffect (MemoryEffectOpInterface) , TflArithmeticCountOpInterface , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats:

tfl.leaky_relu (TFL::LeakyReluOp)

Opérateur Leaky Relu

Opérateur Leaky ReLU par élément x -> x >= 0 ? x : (alpha * x)

Traits : AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats:

tfl.less (TFL::LessOp)

Moins d'opérateur

Moins de fonctionnement au niveau des éléments.

Traits : ::mlir::OpTrait::TFLRuntimeOpTrait , AlwaysSpeculatableImplTrait , QuantizableResult , ResultsBroadcastableShape

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.less_equal (TFL :: LessEqualOp)

_Moins d'opérateur égal

Opération less_equal par élément.

Traits : ::mlir::OpTrait::TFLRuntimeOpTrait , AlwaysSpeculatableImplTrait , QuantizableResult , ResultsBroadcastableShape

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.local_response_normalization (TFL :: LocalResponseNormalizationOp)

Normalisation de la réponse locale.

Le tenseur input 4D est traité comme un tableau 3D de vecteurs 1D (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 carrée pondéré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., Classification ImageNet avec réseaux de neurones convolutifs profonds (NIPS 2012) .

Traits : AlwaysSpeculatableImplTrait , InferTensorType , TF::SameOperandsAndResultTypeResolveRef

Interfaces : ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats:

tfl.log (TFL :: LogOp)

Opérateur de logarithme naturel

Effectue une opération de logarithme naturel par élément en entrée.

Traits : AlwaysSpeculatableImplTrait , QuantizableResult

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.log_softmax (TFL :: LogSoftmaxOp)

Journaliser l'opérateur softmax

Calcule les activations softmax du journal par élément avec la formule suivante

entrée - log(reduce_sum(exp(input), dim))

Traits : AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

Interfaces : ConditionallySpeculatable , FixedOutputRangeInterface , NoMemoryEffect (MemoryEffectOpInterface) , TflArithmeticCountOpInterface , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.logical_and (TFL :: LogicalAndOp)

Opérateur ET logique

Opération logique ET par élément.

Traits : AlwaysSpeculatableImplTrait , ResultsBroadcastableShape

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.logical_not (TFL :: LogicalNotOp)

Opérateur NON logique

Opération NON logique par élément.

Traits : AlwaysSpeculatableImplTrait , SameOperandsAndResultShape

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.logical_or (TFL :: LogicalOrOp)

Opérateur OU logique

Opération OU logique par élément.

Traits : AlwaysSpeculatableImplTrait , ResultsBroadcastableShape

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.logistic (TFL::LogisticOp)

Opérateur logistique

Calcule le sigmoïde d'entrée par élément

Traits : AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

Interfaces : ConditionallySpeculatable , FixedOutputRangeInterface , NoMemoryEffect (MemoryEffectOpInterface) , TflArithmeticCountOpInterface , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.lstm (TFL::LSTMOp)

L'opérateur lstm complet

Couche réseau récurrente d'unité de mémoire à long terme (LSTM). L'implémentation par défaut sans judas est basée sur : http://deeplearning.cs.cmu.edu/pdfs/Hochreiter97_lstm.pdf S. Hochreiter et J. Schmidhuber. « Mémoire à long terme et à court terme ». Neural Computation, 9(8):1735-1780, 1997. L'implémentation du judas est basée sur : https://research.google.com/pubs/archive/43905.pdf Hasim Sak, Andrew Senior et Françoise Beaufays. «Architectures de réseaux neuronaux récurrents à mémoire longue et à court terme pour la modélisation acoustique à grande échelle.» INTERSPEECH, 2014. Le couplage des portes d'entrée et d'oubli (CIFG) est basé sur : http://arxiv.org/pdf/1503.04069.pdf Greff et al. « LSTM : A Search Space Odyssey » La normalisation des couches est basée sur : https://arxiv.org/pdf/1607.06450.pdf Ba et al. 'Normalisation des couches'

Traits : QuantizableResult

Interfaces : DynamicRangeQuantizedOpInterface , TFL_StatefulOp , TflRuntimeVerifyOpInterface

Attributs :

Opérandes :

Résultats:

tfl.matrix_diag (TFL::MatrixDiagOp)

Renvoie un tenseur avec la diagonale fournie et tout le reste complété par des zéros.

Étant donné une diagonale, renvoie un tenseur avec la diagonale et tout le reste complété par des 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 :

Résultats:

tfl.matrix_set_diag (TFL::MatrixSetDiagOp)

Renvoie un tenseur matriciel par lots avec de nouvelles valeurs diagonales par lots.

Étant donné input et diagonal , cette opération renvoie un tenseur avec la même forme et les mêmes valeurs que input , à l'exception de la diagonale principale des matrices les plus internes. Celles-ci seront écrasées par les valeurs en diagonal .

Traits : AlwaysSpeculatableImplTrait , QuantizableResult

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.max_pool_2d (TFL::MaxPool2DOp)

Opération Max Pool 2D

Effectue un pool maximum 2D en 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 :

Opérandes :

Résultats:

tfl.maximum (TFL::MaximumOp)

Opérateur maximum

Opération maximale par élément.

Traits : ::mlir::OpTrait::TFLRuntimeOpTrait , AlwaysSpeculatableImplTrait , Commutative , QuantizableResult , ResultsBroadcastableShape

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.mean (TFL::MeanOp)

Opérateur moyen

Calcule la moyenne des éléments sur les dimensions d'un tenseur. Réduit input_tensor le long des dimensions données dans l'axe. Sauf si keepdims est 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 une longueur de 1.

Traits : AlwaysSpeculatableImplTrait , QuantizableResult

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats:

tfl.minimum (TFL::MinimumOp)

Opérateur minimum

Opération minimale par élément.

Traits : ::mlir::OpTrait::TFLRuntimeOpTrait , AlwaysSpeculatableImplTrait , Commutative , QuantizableResult , ResultsBroadcastableShape

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.mirror_pad (TFL::MirrorPadOp)

Opérateur MirrorPad. Remplit un tenseur avec des valeurs en miroir.

Cette opération remplit une entrée avec des valeurs en miroir en fonction des remplissages que vous spécifiez. paddings est un tenseur entier de forme [n, 2], où n est le rang de l'entrée. Pour chaque dimension D de l'entrée, paddings[D, 0] indique le nombre de valeurs à ajouter avant le contenu de l'entrée dans cette dimension, et paddings[D, 1] indique le nombre de valeurs à ajouter après le contenu de l'entrée dans cette dimension.

paddings[D, 0] et paddings[D, 1] ne doivent pas être supérieurs à input.dim_size(D) (ou input.dim_size(D) - 1) si copy_border est vrai (si faux, respectivement).

La taille complétée de chaque dimension D de la sortie est :

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

Traits : AlwaysSpeculatableImplTrait , QuantizableResult

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats:

tfl.mul (TFL::MulOp)

Opérateur de multiplication

Opération de multiplication par éléments.

Traits : ::mlir::OpTrait::TFLRuntimeOpTrait , AlwaysSpeculatableImplTrait , Commutative , QuantizableResult , ResultsBroadcastableShape

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflArithmeticCountOpInterface , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats:

tfl.multinomial (TFL::MultinomialOp)

Tire des échantillons à partir d’une distribution catégorielle.

Les valeurs générées auront une distribution catégorielle basée sur les logits ou les probabilités logarithmiques non normalisées fournies pour toutes les classes.

Interfaces : TflRuntimeVerifyOpInterface

Attributs :

Opérandes :

Résultats:

tfl.neg (TFL::NegOp)

Opérateur de négation

Calcule la négation de l'entrée par élément

Traits : AlwaysSpeculatableImplTrait , InferTensorType , TF::SameOperandsAndResultTypeResolveRef

Interfaces : ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.no_value (TFL :: NoValueOp)

Constante ne représentant aucune valeur.

Aucune valeur constante op.

Traits : AlwaysSpeculatableImplTrait , ConstantLike

Interfaces : ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effets : MemoryEffects::Effect{}

Attributs :

Résultats:

tfl.non_max_suppression_v4 (TFL :: NonMaxSuppressionV4Op)

Sélectionne goulûment un sous-ensemble de boîtes englobantes par ordre décroissant de score,

élaguer les cases qui ont un chevauchement élevé d'intersection sur union (IOU) avec les cases précédemment sélectionnées. Les cadres de délimitation dont le score est inférieur à score_threshold sont supprimés. Les boîtes englobantes sont fournies sous la forme [y1, x1, y2, x2], où (y1, x1) et (y2, x2) sont les coordonnées de toute paire diagonale de coins de boîte et les coordonnées peuvent être fournies sous forme normalisée (c'est-à-dire situées dans l'intervalle [0, 1]) ou absolu. Notez que cet algorithme est indépendant de l'endroit où se trouve l'origine dans le système de coordonnées et plus généralement est invariant aux transformations orthogonales et aux traductions du système de coordonnées ; ainsi, la traduction ou les réflexions du système de coordonnées entraînent la sélection des mêmes cases par l'algorithme. Le résultat de cette opération est un ensemble d’entiers indexés dans la collection d’entrée de cadres englobants représentant les cadres sélectionnés. Les coordonnées de la boîte englobante correspondant aux indices sélectionnés peuvent ensuite être obtenues à l'aide de l' tf.gather operation . Par exemple : 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

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.non_max_suppression_v5 (TFL :: NonMaxSuppressionV5Op)

Sélectionne goulûment un sous-ensemble de boîtes englobantes par ordre décroissant de score,

élaguer les cases qui ont un chevauchement élevé d'intersection sur union (IOU) avec les cases précédemment sélectionnées. Les cadres de délimitation dont le score est inférieur à score_threshold sont supprimés. Les boîtes englobantes sont fournies sous la forme [y1, x1, y2, x2], où (y1, x1) et (y2, x2) sont les coordonnées de toute paire diagonale de coins de boîte et les coordonnées peuvent être fournies sous forme normalisée (c'est-à-dire situées dans l'intervalle [0, 1]) ou absolu. Notez que cet algorithme est indépendant de l'endroit où se trouve l'origine dans le système de coordonnées et plus généralement est invariant aux transformations orthogonales et aux traductions du système de coordonnées ; ainsi, la traduction ou les réflexions du système de coordonnées entraînent la sélection des mêmes cases par l'algorithme. Le résultat de cette opération est un ensemble d’entiers indexés dans la collection d’entrée de cadres englobants représentant les cadres sélectionnés. Les coordonnées de la boîte englobante correspondant aux indices sélectionnés peuvent ensuite être obtenues à l'aide de l' tf.gather operation . Par exemple : selected_indices = tf.image.non_max_suppression_v2( boxes, scores, max_output_size, iou_threshold, score_threshold) selected_boxes = tf.gather(boxes, selected_indices) Cette opération supporte également un mode Soft-NMS (avec pondération gaussienne) (cf Bodla et al , https://arxiv.org/abs/1704.04503 ) où les boîtes réduisent le score des autres boîtes qui se chevauchent au lieu de provoquer directement leur élagage. Pour activer ce mode Soft-NMS, définissez le paramètre soft_nms_sigma sur une valeur supérieure à 0.

Traits : AlwaysSpeculatableImplTrait

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.not_equal (TFL::NotEqualOp)

_Opérateur différent

Opération not_equal par élément.

Traits : ::mlir::OpTrait::TFLRuntimeOpTrait , AlwaysSpeculatableImplTrait , Commutative , ResultsBroadcastableShape

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.NumericVerify (TFL::NumericVerifyOp)

Vérifie les numériques des deux opérandes

L'opération NumericVerify est une opération de débogage pour vérifier les chiffres des deux activations. Il s'agit d'une opération personnalisée dans TFLite. Si log_if_failed est vrai, l'opération NumericVerify calcule des statistiques sur les différences entre les activations flottantes et quantifiées, génère des journaux, définit les différences dans les tenseurs de sortie et renvoie une erreur si des erreurs supérieures à la tolérance existent. Si log_if_failed = false, alors il ne se soucie pas des erreurs.

Traits : QuantizableResult , SameOperandsShape

Interfaces : TflRuntimeVerifyOpInterface

Attributs :

Opérandes :

Résultats:

tfl.one_hot (TFL::OneHotOp)

Opérateur OneHot

Renvoie un tenseur unique. Les emplacements représentés par des indices dans indices prennent la valeur on_value , tandis que tous les autres emplacements prennent la valeur off_value .

Si les indices d'entrée sont de rang N , la sortie aura le rang N+1 , Le nouvel axe est créé au niveau de axis de dimension (par défaut : le nouvel axe est ajouté à la fin).

Traits : AlwaysSpeculatableImplTrait , QuantizableResult

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats:

tfl.pack (TFL::PackOp)

Regroupe une liste de tenseurs le long d'une dimension en un seul tenseur

Regroupe une liste de tenseurs de rang R values_count dans un tenseur de rang (R+1) .

Emballe les tenseurs values_count dans values ​​dans un tenseur de rang supérieur de un à chaque tenseur In values ​​, en les regroupant le long de la dimension axis .

Étant donné une liste de tenseurs de forme (A, B, C) ;

si axis == 0 alors le tenseur output aura la forme (N, A, B, C) . si axis == 1 alors le tenseur output aura la forme (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]]

C'est le contraire de unpack .

Traits : AlwaysSpeculatableImplTrait , QuantizableResult

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats:

tfl.pad (TFL::PadOp)

Opérateur de remplissage

Cette opération complète une input avec des zéros en fonction des paddings que vous spécifiez. paddings est un tenseur entier de forme [Dn, 2] , où n est le rang de input . Pour chaque dimension D de input , paddings[D, 0] indique le nombre de zéros à ajouter avant le contenu de input dans cette dimension, et paddings[D, 1] indique le nombre de zéros à ajouter après le contenu de input dans cette dimension.

La taille complétée de chaque dimension D de la sortie est :

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

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.padv2 (TFL :: PadV2Op)

Opérateur de remplissage v2

Cette opération remplit une input en fonction des paddings et constant_values ​​que vous spécifiez. paddings est un tenseur entier de forme [Dn, 2] , où n est le rang de input . Pour chaque dimension D de input , paddings[D, 0] indique le nombre de zéros à ajouter avant le contenu de input dans cette dimension, et paddings[D, 1] indique le nombre de zéros à ajouter après le contenu de input dans cette dimension. constant_values ​​est un tenseur scalaire du même type que input qui indique la valeur à utiliser pour le remplissage input .

La taille complétée de chaque dimension D de la sortie est :

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

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.poly_call (TFL :: PolyCallOp)

Appel poly

Avoir plusieurs corps de fonctions pour le même calcul. Cela permet à un compilateur/interprète de programme de choisir l'une des options disponibles pour exécuter le programme en fonction de celle qui convient le mieux au backend cible.

input : Une liste de tenseurs d’entrée dont les types sont T. output : Une liste de tenseurs de sortie dont les types sont T.

appel : plusieurs régions, dont chacune encapsule le même calcul sémantique mais sous des formes différentes.

Caractéristiques : SingleBlockImplicitTerminator<YieldOp> , SingleBlock

Interfaces : RegionBranchOpInterface

Opérandes :

Résultats:

tfl.pow (TFL::PowOp)

Opérateur électrique

Fonctionnement électrique par élément.

Traits : ::mlir::OpTrait::TFLRuntimeOpTrait , AlwaysSpeculatableImplTrait , ResultsBroadcastableShape

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.prelu (TFL::PReluOp)

Opérateur Relu paramétré

Opérateur Relu paramétré x -> x >= 0 ? x : (alpha * x) où alpha est un tenseur entraînable. L'entrée et l'alpha doivent avoir la même taille que l'entrée ou être diffusables.

Traits : ::mlir::OpTrait::TFLRuntimeOpTrait , AlwaysSpeculatableImplTrait , QuantizableResult , ResultsBroadcastableShape , quant::AffineOpCoefficient<-1, 1>

Interfaces : AffineQuantizedOpInterface , ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.pseudo_const (TFL::ConstOp)

Pseudo-op constant.

Représente une valeur constante dans le dialecte TensorFlow Lite. Il ne s’agit pas d’une opération réelle et elle sera plutôt réduite à la mémoire tampon.

L'opération est autorisée à avoir le même type d'attributs que tf.Const (par exemple, les attributs TF opaques sont autorisés).

Traits : AlwaysSpeculatableImplTrait , ConstantLike , FirstAttrDerivedResultType , QuantizableResult

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Attributs :

Résultats:

tfl.pseudo_qconst (TFL::QConstOp)

Pseudo-opération constante quantifiée

Représente une valeur constante quantifiée dans le dialecte TensorFlow Lite. Il ne s’agit pas d’une opération réelle et elle sera plutôt réduite à la mémoire tampon. Les paramètres de quantification sont stockés comme attribut de type dans cette constante.

Traits : AlwaysSpeculatableImplTrait , FirstAttrDerivedResultType

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effets : MemoryEffects::Effect{}

Attributs :

Résultats:

tfl.pseudo_sparse_const (TFL :: SparseConstOp)

Pseudo-op constant et clairsemé.

Représente une valeur constante clairsemée dans le dialecte TensorFlow Lite. Il ne s’agit pas d’une opération réelle et elle sera plutôt réduite à la mémoire tampon.

Traits : AlwaysSpeculatableImplTrait , FirstAttrDerivedResultType , QuantizableResult

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Attributs :

Résultats:

tfl.pseudo_sparse_qconst (TFL :: SparseQConstOp)

Pseudo-opération constante quantifiée clairsemée

Représente une valeur constante quantifiée clairsemée dans le dialecte TensorFlow Lite. Il ne s’agit pas d’une opération réelle et elle sera plutôt réduite à la mémoire tampon. Les paramètres de quantification sont stockés comme attribut de type dans cette constante.

Traits : AlwaysSpeculatableImplTrait , FirstAttrDerivedResultType

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Attributs :

Résultats:

tfl.quantize (TFL::QuantizeOp)

Opérateur de quantification

Convertit les tenseurs à virgule flottante en tenseurs entiers quantifiés selon les paramètres de quantification définis dans l'attribut type.

Traits : FirstAttrDerivedResultType , SameOperandsAndResultShape

Interfaces : NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats:

tfl.random_standard_normal (TFL::RandomStandardNormalOp)

Produit des valeurs aléatoires à partir d’une distribution normale.

Les valeurs générées auront une moyenne de 0 et un écart type de 1.

Interfaces : TflRuntimeVerifyOpInterface

Attributs :

Opérandes :

Résultats:

tfl.random_uniform (TFL::RandomUniformOp)

Génère des valeurs aléatoires à partir d’une distribution uniforme.

Les valeurs générées suivent une distribution uniforme dans la plage [0, 1) . La limite inférieure 0 est incluse dans la plage, tandis que la limite supérieure 1 est exclue.

Interfaces : TflRuntimeVerifyOpInterface

Attributs :

Opérandes :

Résultats:

tfl.range (TFL::RangeOp)

Opérateur de gamme

Renvoie un tenseur 1D défini par une séquence du start à limit avec un delta donné.

Traits : AlwaysSpeculatableImplTrait

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.rank (TFL::RankOp)

Opérateur de classement.

Renvoie le rang d'un tenseur.

Traits : AlwaysSpeculatableImplTrait , QuantizableResult

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.read_variable (TFL :: ReadVariableOp)

Lit la valeur de la variable.

Lire les données variables identifiées par 'resource_id'.

Interfaces : TflRuntimeVerifyOpInterface

Opérandes :

Résultats:

tfl.real (TFL::RealOp)

Renvoie la partie réelle d'un nombre complexe.

Étant donné une input tensorielle de nombres complexes, cette opération renvoie un tenseur de type float qui est la partie réelle de chaque élément dans input . Tous les éléments en input doivent être des nombres complexes de la forme \(a + bj\), où a est la partie réelle renvoyée par cette opération et b est la partie imaginaire.

Traits : AlwaysSpeculatableImplTrait , SameOperandsAndResultShape

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.reduce_all (TFL::ReduceAllOp)

Calcule le « et logique » des éléments sur les dimensions d'un tenseur.

Réduit input le long des dimensions indiquées dans axis . Sauf si keep_dims est vrai, le rang du tenseur est réduit de 1 pour chaque entrée dans axis . Si keep_dims est vrai, les dimensions réduites sont conservées avec une longueur de 1.

Traits : AlwaysSpeculatableImplTrait

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats:

tfl.reduce_any (TFL::ReduceAnyOp)

Calcule le « ou logique » des éléments sur les dimensions d'un tenseur.

Réduit input le long des dimensions indiquées dans axis . Sauf si keep_dims est vrai, le rang du tenseur est réduit de 1 pour chaque entrée dans axis . Si keep_dims est vrai, les dimensions réduites sont conservées avec une longueur de 1.

Traits : AlwaysSpeculatableImplTrait

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats:

tfl.reduce_max (TFL::ReduceMaxOp)

Opérateur de réduction maximale

Calcule la réduction maximale le long des axes spécifiés

Traits : AlwaysSpeculatableImplTrait , QuantizableResult

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats:

tfl.reduce_min (TFL::ReduceMinOp)

Opérateur de réduction min

Calcule la réduction minimale le long des axes spécifiés

Traits : AlwaysSpeculatableImplTrait , QuantizableResult

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats:

tfl.reduce_prod (TFL::ReduceProdOp)

Opérateur de réduction de production

Calcule le produit le long des axes spécifiés

Traits : AlwaysSpeculatableImplTrait , QuantizableResult

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats:

tfl.relu (TFL::ReluOp)

Opérateur Relu

Opérateur Relu par élément x -> max(0, x)

Traits : AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.relu6 (TFL::Relu6Op)

Opérateur Relu6

Opérateur Relu6 par élément x -> max(0, min(6, x))

Traits : AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.relu_0_to_1 (TFL :: Relu0To1Op)

Opérateur Relu0To1

Opérateur Relu0To1 par élément x -> max(0, min(1, x))

Traits : AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.relu_n1_to_1 (TFL :: Relu1Op)

Opérateur Relu1

Opérateur Relu1 par élément x -> max(-1, min(1, x))

Traits : AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.reshape (TFL::ReshapeOp)

Opérateur de remodelage

Produit un tenseur avec les mêmes valeurs mais une forme statique différente définie par le type de sortie.

Traits : AlwaysSpeculatableImplTrait , QuantizableResult

Interfaces : ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.resize_bilinear (TFL :: ResizeBilinearOp)

ResizeOpération bilinéaire

Redimensionnez images à size à l'aide de l'interpolation bilinéaire.

Traits : AlwaysSpeculatableImplTrait , QuantizableResult

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats:

tfl.resize_nearest_neighbor (TFL :: ResizeNearestNeighborOp)

Redimensionner l'opération du voisin le plus proche

Redimensionnez images à size en utilisant l'interpolation du voisin le plus proche.

Traits : AlwaysSpeculatableImplTrait , QuantizableResult

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats:

tfl.reverse_sequence (TFL::ReverseSequenceOp)

Inverse les tranches de longueur variable.

Cette opération coupe d'abord input le long de la dimension batch_dim , et pour chaque tranche i , inverse les premiers éléments seq_lengths[i] le long de la dimension seq_dim .

Les éléments de seq_lengths doivent obéir seq_lengths[i] <= input.dims[seq_dim] , et seq_lengths doit être un vecteur de longueur input.dims[batch_dim] .

La tranche de sortie i le long de la dimension batch_dim est ensuite donnée par la tranche d'entrée i , les premières tranches seq_lengths[i] le long de la dimension seq_dim étant inversées.

Traits : AlwaysSpeculatableImplTrait , QuantizableResult

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats:

tfl.reverse_v2 (TFL::ReverseV2Op)

Opérateur ReverseV2

Inverse les dimensions spécifiques d'un tenseur.

Étant donné un tenseur et un axe tenseur int32/int64 représentant l'ensemble des dimensions du tenseur à inverser. Cette opération inverse chaque dimension i pour laquelle il existe j st axis[j] == i.

Args : tenseur : un tenseur. Doit être l'un des types suivants : uint8, int8, int16, int32, int64, float32, bool Jusqu'à 8-D.

axe : un tenseur. Doit être l'un des types suivants : int32, int64. avec seulement 1 élément qui est l'index de l'axe. À FAIRE : Ajouter la prise en charge de plusieurs éléments.

Traits : AlwaysSpeculatableImplTrait , QuantizableResult

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.rfft2d (TFL::RFFT2dOp)

Transformation de Fourier rapide 2D à valeur réelle.

Calcule la transformée de Fourier discrète bidimensionnelle d'un signal à valeur réelle sur les 2 dimensions les plus internes de input .

Puisque la DFT d'un signal réel est symétrique hermitienne, RFFT2D renvoie uniquement les composantes uniques fft_length / 2 + 1 de la FFT pour la dimension la plus interne de output : le terme de fréquence nulle, suivi de la fréquence positive fft_length / 2 termes.

Le long de chaque axe, RFFT2D est calculé, si fft_length est plus petit que la dimension correspondante de input , la dimension est rognée. Si elle est plus grande, la dimension est complétée par des zéros.

Traits : AlwaysSpeculatableImplTrait

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.right_shift (TFL :: RightShiftOp)

Opérateur de décalage vers la droite

Elementwise calcule le décalage vers la droite au niveau du bit de lhs par rhs .

Traits : AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.round (TFL::RoundOp)

Opérateur rond

Arrondit les valeurs d'un tenseur à l'entier le plus proche, élément par élément.

Traits : AlwaysSpeculatableImplTrait , InferTensorType , TF::SameOperandsAndResultTypeResolveRef

Interfaces : ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.rsqrt (TFL::RsqrtOp)

Réciproque de l'opérateur racine carrée

Calcule la racine carrée inverse de l'entrée par élément

Traits : AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.scatter_nd (TFL::ScatterNdOp)

_Scatter et opérateur

Scatter updates dans un nouveau tenseur selon indices

Traits : AlwaysSpeculatableImplTrait , QuantizableResult

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.segment_sum (TFL::SegmentSumOp)

Opérateur SegmentSum

Calcule la somme le long des segments d'un tenseur.

Traits : AlwaysSpeculatableImplTrait

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.select (TFL :: SelectOp)

Sélectionnez l'opérateur

Sélectionnez les valeurs de « x » si la valeur correspondante de « condition » est vraie ou la valeur de « y » si elle est fausse. Il existe des tailles d'entrée de condition valides :

1. Soit la même forme (auquel cas la sélection se fait par élément), soit
2. la condition doit être de rang 1 et correspondre à la première dimension.

Traits : AlwaysSpeculatableImplTrait , QuantizableResult

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.select_v2 (TFL :: SelectV2Op)

Opérateur SelectV2

Sélectionnez les valeurs de « x » si la valeur correspondante de « condition » est vraie ou la valeur de « y » si elle est fausse. Il existe des tailles d'entrée de condition valides :

1. Soit la même forme (auquel cas la sélection se fait par élément), soit
2. Formes diffusables entre « condition », « x » et « y ».

Traits : ::mlir::OpTrait::TFLRuntimeOpTrait , AlwaysSpeculatableImplTrait , QuantizableResult , ResultsBroadcastableShape

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.shape (TFL::ShapeOp)

Opérateur de forme

Renvoie la forme d'un tenseur.

Traits : AlwaysSpeculatableImplTrait , QuantizableResult

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats:

tfl.sign (TFL::SignOp)

Opération de signature

Renvoie NaN si x est NaN, 0 si x est 0, -1 si x < 0 et 1 si x > 0.

Traits : AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType , SameOperandsAndResultShape

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.sin (TFL::SinOp)

Opérateur sinus

Calcule le sinus d'entrée par élément

Traits : AlwaysSpeculatableImplTrait , InferTensorType , TF::SameOperandsAndResultTypeResolveRef

Interfaces : ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.slice (TFL::SliceOp)

Renvoie une tranche de « entrée ».

Le tenseur de sortie est un tenseur dont les dimensions sont décrites par « taille » dont les valeurs sont extraites de « entrée » en commençant par les décalages de « début ».

begin est de base zéro ; size est basée sur un. Si size[i] est -1, tous les éléments restants de la dimension i sont inclus dans la tranche. En d'autres termes, cela équivaut à définir : size[i] = input.dim_size(i) - start[i]

Exigences : 0 <= commencer[i] <= début[i] + taille[i] <= Di pour i dans [0, n)

Traits : AlwaysSpeculatableImplTrait , QuantizableResult

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.softmax (TFL::SoftmaxOp)

Opérateur Softmax

Calcule les activations softmax par élément avec la formule suivante

exp(entrée) / tf.reduce_sum(exp(entrée * bêta), faible)

Traits : AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

Interfaces : ConditionallySpeculatable , FixedOutputRangeInterface , NoMemoryEffect (MemoryEffectOpInterface) , TflArithmeticCountOpInterface , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats:

tfl.space_to_batch_nd (TFL :: SpaceToBatchNdOp)

Opérateur SpaceToBatchNd

Cette opération remodèle les dimensions de l'espace en dimension "lot" 0

Traits : AlwaysSpeculatableImplTrait , QuantizableResult

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.space_to_depth (TFL :: SpaceToDepthOp)

Opérateur EspaceVers Profondeur

Réorganise les blocs de données spatiales, en profondeur. Plus précisément, cette opération génère une copie du tenseur d'entrée où les valeurs des dimensions height et width sont déplacées vers la dimension depth . block_size indique la taille du bloc d'entrée.

Traits : AlwaysSpeculatableImplTrait , QuantizableResult

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats:

tfl.sparse_to_dense (TFL :: SparseToDenseOp)

Convertit une représentation clairsemée en un tenseur dense.

Construit un tableau dense avec une forme output_shape telle que

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

Toutes les autres valeurs dense sont définies sur default_value . Si sparse_values ​​est un scalaire, tous les indices clairsemés sont définis sur cette valeur unique.

Les index doivent être triés par ordre lexicographique et ne doivent contenir aucune répétition. Si validate_indices est vrai, ces propriétés sont vérifiées lors de l'exécution.

Traits : AlwaysSpeculatableImplTrait , QuantizableResult

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.split (TFL::SplitOp)

Divise un tenseur en tenseurs num_split le long d'une dimension.

Divise le tenseur value le long split_dim en un certain nombre de sous-tenseurs ayant la même forme que celui d'origine, à l'exception de split_dim . Identique à tf.Split.

Traits : AlwaysSpeculatableImplTrait , QuantizableResult

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats:

tfl.split_v (TFL::SplitVOp)

Divise un tenseur en tenseurs num_split le long d'une dimension.

Divise le tenseur value le long split_dim en un certain nombre de sous-tenseurs ayant la même forme que celui d'origine, à l'exception de split_dim . Le regroupement des sous-tenseurs résultants est décidé par size-splits . Identique à tf.SplitV.

Traits : AlwaysSpeculatableImplTrait , QuantizableResult

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats:

tfl.sqrt (TFL::SqrtOp)

Opérateur racine carrée

Calcule la racine carrée de l'entrée par élément

Traits : AlwaysSpeculatableImplTrait , InferTensorType , TF::SameOperandsAndResultTypeResolveRef

Interfaces : ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.square (TFL::SquareOp)

Opérateur carré

Calcule le carré d'entrée par élément

Traits : AlwaysSpeculatableImplTrait , InferTensorType , TF::SameOperandsAndResultTypeResolveRef

Interfaces : ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.squared_difference (TFL :: SquaredDifferenceOp)

Opérateur de différence au carré

Opération de différence carrée par élément.

Traits : ::mlir::OpTrait::TFLRuntimeOpTrait , AlwaysSpeculatableImplTrait , QuantizableResult , ResultsBroadcastableShape

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.squeeze (TFL :: SqueezeOp)

Supprime les dimensions de taille 1 de la forme d'un tenseur.

Étant donné une input de tenseur, cette opération renvoie un tenseur du même type avec toutes les dimensions de taille 1 supprimées. Si vous ne souhaitez pas supprimer toutes les dimensions de taille 1, vous pouvez supprimer des dimensions spécifiques de taille 1 en spécifiant squeeze_dims .

Par exemple:

# 't' is a tensor of shape [1, 2, 1, 3, 1, 1]
shape(squeeze(t)) ==> [2, 3]

Ou, pour supprimer des dimensions spécifiques de taille 1 :

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

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats:

tfl.strided_slice (TFL :: StridedSliceOp)

Opération StridedSlice

Renvoie une tranche striée depuis input .

Traits : AlwaysSpeculatableImplTrait , QuantizableResult

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats:

tfl.sub (TFL::SubOp)

Opérateur de soustraction

Opération de soustraction par élément.

Traits : ::mlir::OpTrait::TFLRuntimeOpTrait , AlwaysSpeculatableImplTrait , QuantizableResult , ResultsBroadcastableShape

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflArithmeticCountOpInterface , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats:

tfl.sum (TFL::SumOp)

Opérateur de somme

Calcule la réduction de somme le long des axes spécifiés

Traits : AlwaysSpeculatableImplTrait , QuantizableResult

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats:

tfl.svdf (TFL::SVDFOp)

Opérateur de filtre de décomposition à valeur unique

L'opération SVDF est une décomposition d'une opération densément connectée en filtres de bas rang. Pour plus de détails : 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 :

Opérandes :

Résultats:

tfl.tanh (TFL::TanhOp)

Opérateur tangent hyperbolique

Calcule la tangente hyperbolique de l'entrée par élément

Traits : AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

Interfaces : ConditionallySpeculatable , FixedOutputRangeInterface , NoMemoryEffect (MemoryEffectOpInterface) , TflArithmeticCountOpInterface , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.tile (TFL :: TileOp)

Opérateur de tuiles.

Construit un tenseur en mosaïque un tenseur donné.

Cette opération crée un nouveau tenseur en répliquant l'entrée plusieurs fois. La i'ième dimension du tenseur de sortie a des éléments input.dims(i) * multiples[i], et les valeurs d'entrée sont répliquées plusieurs fois[i] le long de la 'i'ième dimension. Par exemple, mosaïquer [abcd] par [2] produit [abcdabcd].

Traits : AlwaysSpeculatableImplTrait , QuantizableResult

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.topk_v2 (TFL :: TopKV2Op)

Opérateur TopK

Renvoie le k plus grand élément le long de chaque dernière tranche dimensionnelle de input et les indices des valeurs dans la dernière dimension du tenseur d'entrée.

Les résultats sont toujours triés par ordre décroissant.

Traits : AlwaysSpeculatableImplTrait , QuantizableResult

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.transpose (TFL::TransposeOp)

Opérateur de transposition

Renvoie la transposition de x

Traits : AlwaysSpeculatableImplTrait , QuantizableResult

Interfaces : ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats:

tfl.transpose_conv (TFL::TransposeConvOp)

Opérateur de convolution de transposition

Effectue une opération de convolution de transposition en entrée.

Traits : AlwaysSpeculatableImplTrait , QuantizableResult , quant::AccumulatorUniformScale<3, 1, 2> , quant::AffineOpCoefficient<0, 1>

Interfaces : AffineQuantizedOpInterface , ConditionallySpeculatable , DynamicRangeQuantizedOpInterface , NoMemoryEffect (MemoryEffectOpInterface) , TFL_SparseOp , TflArithmeticCountOpInterface , TflRuntimeVerifyOpInterface

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :