Questa pagina è stata tradotta dall'API Cloud Translation.
Switch to English

Dialetto & # 39; tfl & # 39; definizione

Il dialetto TensorFlow Lite.

Questo dialetto è associato alle operazioni di TensorFlow Lite.

invarianti:

  • Tutti i valori sono di tipo Tensore (in particolare, gli scalari sono rappresentati usando tensori a dimensione zero);

Definizione dell'operazione

tfl.abs (TFL :: AbsOp)

Operatore a valore assoluto

Descrizione:

Dato un tensore x , questa operazione restituisce un tensore contenente il valore assoluto di ciascun elemento in x . Ad esempio, se x è un elemento di input e y è un elemento di output, questa operazione calcola \ (y = | x | \).

operandi:

  1. x : tensore di qualsiasi valore di tipo

attributi:

risultati:

  1. y : tensore di qualsiasi valore di tipo

tfl.add_n (TFL :: AddNOp)

operatore add_n

Descrizione:

Aggiunge tutti i tensori di input in termini di elementi.

operandi:

  1. inputs : tensore di qualsiasi valore di tipo

attributi:

risultati:

  1. sum : tensore di qualsiasi valore di tipo

tfl.add (TFL :: AddOp)

Operatore di aggiunta

Descrizione:

Operazione aggiunta saggia elemento.

operandi:

  1. lhs : tensore di qualsiasi valore di tipo
  2. rhs : tensore di qualsiasi valore di tipo

attributi:

Attributo Tipo MLIR Descrizione
fused_activation_function StringAttr attributo enum attivazione fusa

risultati:

  1. output : tensore di qualsiasi valore di tipo

tfl.arg_max (TFL :: ArgMaxOp)

Operatore ArgMax

Descrizione:

Restituisce l'indice con il valore più grande tra le dimensioni di un tensore.

operandi:

  1. input : tensore di qualsiasi valore di tipo
  2. dim : tensore di qualsiasi valore di tipo

attributi:

Attributo Tipo MLIR Descrizione
output_type Attribute attributo attributo derivato

risultati:

  1. output : tensore di qualsiasi valore di tipo

tfl.arg_min (TFL :: ArgMinOp)

Operatore ArgMin

Descrizione:

Restituisce l'indice con il valore più piccolo tra le dimensioni di un tensore. "A = [1, 10, 26.9, 2.8, 166.32, 62.3] b = tf.math.argmin (input = a) c = tf.keras.backend.eval (b)

operandi:

  1. input : tensore di qualsiasi valore di tipo
  2. dim : tensore di qualsiasi valore di tipo

attributi:

Attributo Tipo MLIR Descrizione
output_type Attribute attributo attributo derivato

risultati:

  1. output : tensore di qualsiasi valore di tipo

tfl.average_pool_2d (TFL :: AveragePool2DOp)

Operatore Average_pool_2d

Descrizione:

Esegue un'operazione di pooling medio sull'input.

operandi:

  1. input : tensore di qualsiasi valore di tipo

attributi:

Attributo Tipo MLIR Descrizione
filter_height IntegerAttr Attributo dell'attributo intero a 32 bit
filter_width IntegerAttr Attributo dell'attributo intero a 32 bit
padding StringAttr attributo enum di riempimento
stride_h IntegerAttr Attributo dell'attributo intero a 32 bit
stride_w IntegerAttr Attributo dell'attributo intero a 32 bit
fused_activation_function StringAttr attributo enum attivazione fusa

risultati:

  1. output : tensore di qualsiasi valore di tipo

tfl.basic_lstm (TFL :: BasicLSTMOp)

L'operatore lstm di base

Descrizione:

Operatore di cella LSTM di base.

operandi:

  1. data_input : tensore di qualsiasi valore di tipo
  2. prev_activ_input : tensore di qualsiasi valore di tipo
  3. weights_input : tensore di qualsiasi valore di tipo
  4. biases_input : tensore di qualsiasi valore di tipo
  5. prev_state_input : tensore di qualsiasi valore di tipo

attributi:

Attributo Tipo MLIR Descrizione
fused_activation_function StringAttr attributo enum attivazione fusa
cell_clip FloatAttr Attributo dell'attributo float a 32 bit
proj_clip FloatAttr Attributo dell'attributo float a 32 bit
kernel_type StringAttr Attributo BASIC del caso enum di tipo lstm kernel

risultati:

  1. activ_output : tensore 2D di qualsiasi valore di tipo
  2. state_output : tensore 2D di qualsiasi valore di tipo
  3. concat_temp : tensore 2D di qualsiasi valore di tipo
  4. activ_temp : tensore 2D di qualsiasi valore di tipo

tfl.batch_to_space_nd (TFL :: BatchToSpaceNdOp)

Operatore BatchToSpaceNd

Descrizione:

Questa operazione rimodella la dimensione "batch" 0 in dimensioni dello spazio.

operandi:

  1. input : tensore di qualsiasi valore di tipo
  2. block_shape : tensore di qualsiasi valore di tipo
  3. indices : tensore di qualsiasi valore di tipo

attributi:

risultati:

  1. output : tensore di qualsiasi valore di tipo

tfl.cast (TFL :: CastOp)

Operatore cast

Descrizione:

Lancia l'input dal tipo di input al tipo di output.

operandi:

  1. input : tensore di qualsiasi valore di tipo

attributi:

risultati:

  1. output : tensore di qualsiasi valore di tipo

tfl.ceil (TFL :: CeilOp)

Operatore di cemento

Descrizione:

Restituisce il valore ceil dell'elemento in input.

operandi:

  1. x : tensore di qualsiasi valore di tipo

attributi:

risultati:

  1. y : tensore di qualsiasi valore di tipo

tfl.concatenation (TFL :: ConcatenationOp)

Operatore di concatenazione

Descrizione:

Concatena i tensori lungo una dimensione

operandi:

  1. values : tensore di qualsiasi tipo di valore

attributi:

Attributo Tipo MLIR Descrizione
axis IntegerAttr Attributo dell'attributo intero a 32 bit
fused_activation_function StringAttr attributo enum attivazione fusa

risultati:

  1. output : tensore di qualsiasi valore di tipo

tfl.pseudo_const (TFL :: ConstOp)

Pseudo op costante.

Descrizione:

Rappresenta un valore costante nel dialetto TensorFlow Lite. Questa non è un'operazione effettiva e verrà invece ridotta al buffer.

L'op è autorizzato ad avere tutti lo stesso tipo di attributi di tf.Const (ad esempio, sono consentiti attributi TF opachi).

operandi:

attributi:

Attributo Tipo MLIR Descrizione
value ElementsAttr attributo attributo vettore / tensore costante

risultati:

  1. output : tensore di qualsiasi valore di tipo

tfl.conv_2d (TFL :: Conv2DOp)

Operatore di convoluzione

Descrizione:

Esegue l'operazione di convoluzione sugli input.

Ingressi: inputs[0] : richiesto: gli ingressi del tensore di attivazione degli inputs[1] : richiesto: gli inputs[2] tensore del peso del filtro inputs[2] : opzionale: il tensore di polarizzazione

operandi:

  1. input : tensore di qualsiasi valore di tipo
  2. filter : tensore di qualsiasi tipo di valore
  3. bias : tensore di qualsiasi valore di tipo o nessuno di tipo

attributi:

Attributo Tipo MLIR Descrizione
dilation_h_factor IntegerAttr Attributo dell'attributo intero a 32 bit
dilation_w_factor IntegerAttr Attributo dell'attributo intero a 32 bit
fused_activation_function StringAttr attributo enum attivazione fusa
padding StringAttr attributo enum di riempimento
stride_h IntegerAttr Attributo dell'attributo intero a 32 bit
stride_w IntegerAttr Attributo dell'attributo intero a 32 bit

risultati:

  1. output : tensore di qualsiasi valore di tipo

tfl.convolution_2d_transpose_bias (TFL :: Convolution2DTransposeBiasOp)

Trasporre la convoluzione con l'operatore di polarizzazione

Descrizione:

Esegue l'operazione di convoluzione di trasposizione sugli input, con la possibilità di aggiungere un bias. Nota: si tratta di un'operazione personalizzata che non è supportata nel runtime standard.

 Inputs:
  `inputs[0]`: required: the input activation tensor
  `inputs[1]`: required: the filter weight tensor
  `inputs[2]`: optional: the bias tensor
 

operandi:

  1. input : tensore di qualsiasi valore di tipo
  2. filter : tensore di qualsiasi tipo di valore
  3. bias : tensore di qualsiasi valore di tipo o nessuno di tipo

attributi:

Attributo Tipo MLIR Descrizione
padding StringAttr attributo enum di riempimento
stride_h IntegerAttr Attributo dell'attributo intero a 32 bit
stride_w IntegerAttr Attributo dell'attributo intero a 32 bit

risultati:

  1. output : tensore di qualsiasi valore di tipo

tfl.cos (TFL :: CosOp)

Operatore Coseno

Descrizione:

Calcola il coseno dell'elemento in base agli elementi

operandi:

  1. x : tensore di qualsiasi valore di tipo

attributi:

risultati:

  1. y : tensore di qualsiasi valore di tipo

tfl.densify (TFL :: DensifyOp)

Operatore di densità

Descrizione:

Converte il tensore rado in formato denso.

operandi:

  1. input : tensore di qualsiasi valore di tipo

attributi:

risultati:

  1. output : tensore di qualsiasi valore di tipo

tfl.depth_to_space (TFL :: DepthToSpaceOp)

Operatore DepthToSpace

Descrizione:

Riorganizza i dati dalla profondità in blocchi di dati spaziali. Questa è la trasformazione inversa di SpaceToDepth. Più specificamente, questa operazione genera una copia del tensore di input in cui i valori dalla dimensione della depth vengono spostati in blocchi spaziali alle dimensioni di height e width . block_size indica la dimensione del blocco di input e il modo in cui i dati vengono spostati.

operandi:

  1. input : tensore di qualsiasi valore di tipo

attributi:

Attributo Tipo MLIR Descrizione
block_size IntegerAttr Attributo dell'attributo intero a 32 bit

risultati:

  1. output : tensore di qualsiasi valore di tipo

tfl.depthwise_conv_2d (TFL :: DepthwiseConv2DOp)

Operatore di convoluzione separabile in profondità

Descrizione:

Esegue l'operazione di convoluzione sugli input.

Ingressi: inputs[0] : richiesto: gli ingressi del tensore di attivazione degli inputs[1] : richiesto: gli inputs[2] tensore del peso del filtro inputs[2] : opzionale: il tensore di polarizzazione

operandi:

  1. input : tensore di qualsiasi valore di tipo
  2. filter : tensore di qualsiasi tipo di valore
  3. bias : tensore di qualsiasi valore di tipo o nessun tipo

attributi:

Attributo Tipo MLIR Descrizione
dilation_h_factor IntegerAttr Attributo dell'attributo intero a 32 bit
dilation_w_factor IntegerAttr Attributo dell'attributo intero a 32 bit
fused_activation_function StringAttr attributo enum attivazione fusa
padding StringAttr attributo enum di riempimento
stride_h IntegerAttr Attributo dell'attributo intero a 32 bit
stride_w IntegerAttr Attributo dell'attributo intero a 32 bit
depth_multiplier IntegerAttr Attributo dell'attributo intero a 32 bit

risultati:

  1. output : tensore di qualsiasi valore di tipo

tfl.dequantize (TFL :: DequantizeOp)

Dequantize operator

Descrizione:

Converte array quantizzato di numeri interi in virgola mobile in base ai parametri di quantizzazione.

operandi:

  1. input : tensore di qualsiasi valore di tipo

attributi:

risultati:

  1. output : tensore di qualsiasi valore di tipo

tfl.div (TFL :: DivOp)

Operatore di divisione

Descrizione:

Operazione divisione saggio elemento.

operandi:

  1. lhs : tensore di qualsiasi valore di tipo
  2. rhs : tensore di qualsiasi valore di tipo

attributi:

Attributo Tipo MLIR Descrizione
fused_activation_function StringAttr attributo enum attivazione fusa

risultati:

  1. output : tensore di qualsiasi valore di tipo

tfl.elu (TFL :: EluOp)

Operatore Unità lineare esponenziale

Descrizione:

Calcola la lineare esponenziale f (x) -> exp (x) - 1 per x <0, x per x> = 0. elemento-saggio.

operandi:

  1. x : tensore di qualsiasi valore di tipo

attributi:

risultati:

  1. y : tensore di qualsiasi valore di tipo

tfl.embedding_lookup (TFL :: EmbeddingLookupOp)

Incorporamento dell'operatore di ricerca

Descrizione:

Cerca gli ID in un elenco di tensori per l'incorporamento.

operandi:

  1. lookup : tensore di qualsiasi tipo di valore
  2. value : tensore di qualsiasi valore di tipo

attributi:

risultati:

  1. output : tensore di qualsiasi valore di tipo

tfl.equal (TFL :: EqualOp)

Pari operatore

Descrizione:

Restituisce l'elemento di verità di x == y elemento-saggio

operandi:

  1. x : tensore di qualsiasi valore di tipo
  2. y : tensore di qualsiasi valore di tipo

attributi:

risultati:

  1. output : tensore di qualsiasi valore di tipo

tfl.exp (TFL :: ExpOp)

Operatore esponenziale naturale

Descrizione:

Esegue un'operazione di esponenziazione naturale per elemento sull'input.

operandi:

  1. x : tensore di qualsiasi valore di tipo

attributi:

risultati:

  1. y : tensore di qualsiasi valore di tipo

tfl.expand_dims (TFL :: ExpandDimsOp)

Inserisce una dimensione di 1 nella forma di un tensore.

Descrizione:

Dato un input tensore, questa operazione inserisce una dimensione 1 axis dell'indice di dimensione della forma input . L' axis dell'indice di quota inizia da zero; se si specifica un numero negativo per l' axis questo viene conteggiato all'indietro dalla fine.

Questa operazione è utile se si desidera aggiungere una dimensione batch a un singolo elemento. Ad esempio, se hai una singola immagine di forma [height, width, channels] , puoi renderla un lotto di 1 immagine con expand_dims(image, 0) , che renderà la forma [1, height, width, channels] .

Altri esempi:

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

Questa operazione richiede che:

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

Questa operazione è correlata a squeeze() , che rimuove le dimensioni della dimensione 1.

operandi:

  1. input : tensore di qualsiasi valore di tipo
  2. dim : tensore di qualsiasi tipo intero

attributi:

risultati:

  1. output : tensore di qualsiasi valore di tipo

tfl.external_const (TFL :: ExternalConstOp)

Cost. Esterna op.

Descrizione:

La const esterna contiene un buffer_index che punta a una costante nel flatbuffer.

operandi:

attributi:

Attributo Tipo MLIR Descrizione
buffer_index IntegerAttr Attributo dell'attributo intero a 32 bit

risultati:

  1. output : tensore di qualsiasi valore di tipo

tfl.fake_quant (TFL :: FakeQuantOp)

Operatore FakeQuant

Descrizione:

Quantizzare in modo falso il tensore "input" di tipo float tramite scalare float min e max al tensore "output" della stessa forma degli input.

operandi:

  1. input : tensore di qualsiasi valore di tipo

attributi:

Attributo Tipo MLIR Descrizione
min FloatAttr Attributo dell'attributo float a 32 bit
max FloatAttr Attributo dell'attributo float a 32 bit
num_bits IntegerAttr Attributo dell'attributo intero a 32 bit
narrow_range BoolAttr attributo dell'attributo bool

risultati:

  1. output : tensore di qualsiasi valore di tipo

tfl.fill (TFL :: FillOp)

Riempi il tensore con un determinato valore.

Descrizione:

Riempi il tensore con un determinato valore.

operandi:

  1. dims : tensore di qualsiasi valore di tipo
  2. value : tensore di qualsiasi valore di tipo

attributi:

risultati:

  1. res : tensore di qualsiasi valore di tipo

tfl.floor_div (TFL :: FloorDivOp)

Operatore div di piano

Descrizione:

Operazione div a livello di elemento.

operandi:

  1. lhs : tensore di qualsiasi valore di tipo
  2. rhs : tensore di qualsiasi valore di tipo

attributi:

risultati:

  1. output : tensore di qualsiasi valore di tipo

tfl.floor_mod (TFL :: FloorModOp)

Promemoria divisione

Descrizione:

Operazione promemoria divisione elemento-saggio.

operandi:

  1. lhs : tensore di qualsiasi valore di tipo
  2. rhs : tensore di qualsiasi valore di tipo

attributi:

risultati:

  1. output : tensore di qualsiasi valore di tipo

tfl.floor (TFL :: FloorOp)

Operatore di piano

Descrizione:

Restituisce il valore minimo dell'elemento in base all'input.

operandi:

  1. x : tensore di qualsiasi valore di tipo

attributi:

risultati:

  1. y : tensore di qualsiasi valore di tipo

tfl.fully_connected (TFL :: FullyConnectedOp)

Op. Completamente collegato

Descrizione:

operandi:

  1. input : tensore di qualsiasi valore di tipo
  2. filter : tensore di qualsiasi tipo di valore
  3. bias : tensore di qualsiasi valore di tipo o nessuno di tipo

attributi:

Attributo Tipo MLIR Descrizione
fused_activation_function StringAttr attributo enum attivazione fusa
weights_format StringAttr attributo formato pesi opzioni completamente connesse
keep_num_dims BoolAttr attributo dell'attributo bool

risultati:

  1. output : tensore di qualsiasi valore di tipo

tfl.gather_nd (TFL :: GatherNdOp)

Operatore Gather_nd

Descrizione:

Raccogli sezioni da params in un tensore con la forma specificata dagli indices .

operandi:

  1. params : tensore di qualsiasi valore di tipo
  2. indices : tensore di qualsiasi valore di tipo

attributi:

risultati:

  1. output : tensore di qualsiasi valore di tipo

tfl.gather (TFL :: GatherOp)

Raccogliere operatore

Descrizione:

Raccogliere le fette da params asse axis secondo indices .

operandi:

  1. params : tensore di qualsiasi valore di tipo
  2. indices : tensore di qualsiasi valore di tipo

attributi:

Attributo Tipo MLIR Descrizione
axis IntegerAttr Attributo dell'attributo intero a 32 bit

risultati:

  1. output : tensore di qualsiasi valore di tipo

tfl.greater_equal (TFL :: GreaterEqualOp)

Operatore Greater_equal

Descrizione:

Operazione maggiore_equa in termini di elementi.

operandi:

  1. lhs : tensore di qualsiasi valore di tipo
  2. rhs : tensore di qualsiasi valore di tipo

attributi:

risultati:

  1. output : tensore di qualsiasi valore di tipo

tfl.greater (TFL :: GreaterOp)

Operatore maggiore

Descrizione:

Operazione maggiore dal punto di vista degli elementi.

operandi:

  1. lhs : tensore di qualsiasi valore di tipo
  2. rhs : tensore di qualsiasi valore di tipo

attributi:

risultati:

  1. output : tensore di qualsiasi valore di tipo

tfl.hard_swish (TFL :: HardSwishOp)

Funzione di attivazione Hardswish.

Descrizione:

Calcola la funzione di attivazione hard-swish f (x) -> (x * relu6 (x + 3)) / 6 elemento-saggio.

operandi:

  1. input : tensore di qualsiasi valore di tipo

attributi:

risultati:

  1. out : tensore di qualsiasi valore di tipo

tfl.l2_normalization (TFL :: L2NormalizationOp)

Operatore Normalizza L2

Descrizione:

Normalizzazione L2 op

operandi:

  1. input : tensore di qualsiasi valore di tipo

attributi:

Attributo Tipo MLIR Descrizione
fused_activation_function StringAttr attributo enum attivazione fusa

risultati:

  1. output : tensore di qualsiasi valore di tipo

tfl.lstm (TFL :: LSTMOp)

L'operatore lstm completo

Descrizione:

Livello di rete ricorrente di unità di memoria a breve termine (LSTM) a lungo termine. L'implementazione predefinita non spioncino si basa su: http://deeplearning.cs.cmu.edu/pdfs/Hochreiter97_lstm.pdf S. Hochreiter e J. Schmidhuber. "Memoria a breve termine". Neural Computation, 9 (8): 1735-1780, 1997. L'implementazione dello spioncino si basa su: https://research.google.com/pubs/archive/43905.pdf Hasim Sak, Andrew Senior e Francoise Beaufays. "Architetture di reti neurali ricorrenti a memoria a lungo termine per la modellazione acustica su larga scala. INTERSPEECH, 2014. L'accoppiamento di input and forget gate (CIFG) si basa su: http://arxiv.org/pdf/1503.04069.pdf Greff et al "LSTM: un'odissea nello spazio di ricerca" La normalizzazione dei livelli si basa su: https://arxiv.org/pdf/1607.06450.pdf Ba et al. “Normalizzazione dei livelli”

operandi:

  1. input : tensore di qualsiasi valore di tipo
  2. input_to_input_weights : tensore di qualsiasi valore di tipo o nessuno di tipo
  3. input_to_forget_weights : tensore di qualsiasi valore di tipo
  4. input_to_cell_weights : tensore di qualsiasi valore di tipo
  5. input_to_output_weights : tensore di qualsiasi valore di tipo
  6. recurrent_to_input_weights : tensore di qualsiasi valore di tipo o nessuno di tipo
  7. recurrent_to_forget_weights : tensore di qualsiasi valore di tipo
  8. recurrent_to_cell_weights : tensore di qualsiasi valore di tipo
  9. recurrent_to_output_weights : tensore di qualsiasi valore di tipo
  10. cell_to_input_weights : tensore di qualsiasi valore di tipo o nessuno di tipo
  11. cell_to_forget_weights : tensore di qualsiasi valore o tipo
  12. cell_to_output_weights : tensore di qualsiasi valore di tipo o nessuno di tipo
  13. input_gate_bias : tensore di qualsiasi valore di tipo o nessuno di tipo
  14. forget_gate_bias : tensore di qualsiasi valore di tipo
  15. cell_bias : tensore di qualsiasi valore di tipo
  16. output_gate_bias : tensore di qualsiasi valore di tipo
  17. projection_weights : tensore di qualsiasi valore di tipo o nessuno di tipo
  18. projection_bias : tensore di qualsiasi valore di tipo o nessuno di tipo
  19. input_activation_state : tensore di stato
  20. input_cell_state : tensore di stato
  21. input_layer_norm_coefficients : tensore di qualsiasi valore di tipo o nessuno di tipo
  22. forget_layer_norm_coefficients : tensore di qualsiasi valore di tipo o nessuno di tipo
  23. cell_layer_norm_coefficients : tensore di qualsiasi valore di tipo o nessuno di tipo
  24. output_layer_norm_coefficients : tensore di qualsiasi valore di tipo o nessuno di tipo

attributi:

Attributo Tipo MLIR Descrizione
fused_activation_function StringAttr attributo enum attivazione fusa
cell_clip FloatAttr Attributo dell'attributo float a 32 bit
proj_clip FloatAttr Attributo dell'attributo float a 32 bit
kernel_type StringAttr Attributo FULL del caso enum di tipo lstm kernel

risultati:

  1. output : tensore di qualsiasi valore di tipo

tfl.leaky_relu (TFL :: LeakyReluOp)

Operatore Leaky Relu

Descrizione:

Operatore ReLU che perde elementi x -> x> = 0? x: (alfa * x)

operandi:

  1. input : tensore di qualsiasi valore di tipo

attributi:

Attributo Tipo MLIR Descrizione
alpha FloatAttr Attributo dell'attributo float a 32 bit

risultati:

  1. output : tensore di qualsiasi valore di tipo

tfl.less_equal (TFL :: LessEqualOp)

Operatore Less_equal

Descrizione:

Operazione less_equal in termini di elementi.

operandi:

  1. lhs : tensore di qualsiasi valore di tipo
  2. rhs : tensore di qualsiasi valore di tipo

attributi:

risultati:

  1. output : tensore di qualsiasi valore di tipo

tfl.less (TFL :: LessOp)

Meno operatore

Descrizione:

Meno operazioni dal punto di vista degli elementi.

operandi:

  1. lhs : tensore di qualsiasi valore di tipo
  2. rhs : tensore di qualsiasi valore di tipo

attributi:

risultati:

  1. output : tensore di qualsiasi valore di tipo

tfl.local_response_normalization (TFL :: LocalResponseNormalizationOp)

Normalizzazione della risposta locale.

Descrizione:

Il tensore di input 4-D viene trattato come un array 3-D di vettori 1-D (lungo l'ultima dimensione) e ogni vettore viene normalizzato in modo indipendente. All'interno di un dato vettore, ciascun componente è diviso per la somma quadrata ponderata degli input all'interno di depth_radius . In dettaglio,

 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
 

Per i dettagli, vedere Krizhevsky et al., Classificazione ImageNet con reti neurali convoluzionali profonde (NIPS 2012) .

operandi:

  1. input : tensore di qualsiasi valore di tipo

attributi:

Attributo Tipo MLIR Descrizione
radius IntegerAttr Attributo dell'attributo intero a 32 bit
bias FloatAttr Attributo dell'attributo float a 32 bit
alpha FloatAttr Attributo dell'attributo float a 32 bit
beta FloatAttr Attributo dell'attributo float a 32 bit

risultati:

  1. output : tensore di qualsiasi valore di tipo

tfl.log (TFL :: LogOp)

Operatore logaritmo naturale

Descrizione:

Esegue un'operazione di logaritmo naturale per elemento sull'input.

operandi:

  1. x : tensore di qualsiasi valore di tipo

attributi:

risultati:

  1. y : tensore di qualsiasi valore di tipo

tfl.log_softmax (TFL :: LogSoftmaxOp)

Log operatore softmax

Descrizione:

Calcola le attivazioni del softmax del log in base agli elementi con la seguente formula

input - log (reduce_sum (exp (input), dim))

operandi:

  1. input : tensore di qualsiasi valore di tipo

attributi:

risultati:

  1. output : tensore di qualsiasi valore di tipo

tfl.logical_and (TFL :: LogicalAndOp)

Operatore AND logico

Descrizione:

Operazione logica AND basata sull'elemento.

operandi:

  1. lhs : tensore di qualsiasi valore di tipo
  2. rhs : tensore di qualsiasi valore di tipo

attributi:

risultati:

  1. output : tensore di qualsiasi valore di tipo

tfl.logical_not (TFL :: LogicalNotOp)

Operatore logico NOT

Descrizione:

Operazione logica NON basata sull'elemento.

operandi:

  1. lhs : tensore di qualsiasi valore di tipo

attributi:

risultati:

  1. output : tensore di qualsiasi valore di tipo

tfl.logical_or (TFL :: LogicalOrOp)

Operatore logico OR

Descrizione:

Operazione OR logica basata sull'elemento.

operandi:

  1. lhs : tensore di qualsiasi valore di tipo
  2. rhs : tensore di qualsiasi valore di tipo

attributi:

risultati:

  1. output : tensore di qualsiasi valore di tipo

tfl.logistic (TFL :: LogisticOp)

Operatore logistico

Descrizione:

Calcola il Sigmoid in termini di elementi di input

operandi:

  1. x : tensore di qualsiasi valore di tipo

attributi:

risultati:

  1. y : tensore di qualsiasi valore di tipo

tfl.matrix_diag (TFL :: MatrixDiagOp)

 Returns a tensor with the provided diagonal and everything else padded with zeros.
 

Descrizione:

Data una diagonale, restituisce un tensore con la diagonale e tutto il resto imbottito di zeri. Supponiamo che la diagonale abbia k dimensioni [I, J, K, ..., N] , quindi l'output è un tensore del rango k+1 con dimensioni [I, J, K, ..., N, N] dove: output[i, j, k, ..., m, n] = 1{m=n} * diagonal[i, j, k, ..., n].

operandi:

  1. diagonal : tensore di qualsiasi tipo di valore

attributi:

risultati:

  1. output : tensore di qualsiasi valore di tipo

tfl.matrix_set_diag (TFL :: MatrixSetDiagOp)

 Returns a batched matrix tensor with new batched diagonal values.
 

Descrizione:

Dato input e diagonal , questa operazione restituisce un tensore con la stessa forma e valori input , ad eccezione della diagonale principale delle matrici più interne. Questi saranno sovrascritti dai valori in diagonal .

operandi:

  1. input : tensore del float a 32 bit o intero a 32 bit o intero a 64 bit o intero a 8 bit o intero a 8 bit o tipo QI8 o tipo QI16 o tipo QUI8 o tipo TFIite o tipo uint8 o tipo TFLite quint8
  2. diagonal : tensore di float a 32 bit o intero a 32 bit o intero a 64 bit o intero a 8 bit o intero a 8 bit o tipo QI8 o tipo QI16 o tipo QUI8 o tipo TFIite o tipo uint8 TFLite o tipo quint8 TFLite

attributi:

risultati:

  1. output : tensore di float a 32 bit o intero a 32 bit o intero a 64 bit o intero a 8 bit o intero a 8 bit o tipo QI8 o tipo QI16 o tipo QUI8 o tipo TFIite o tipo uint8 o tipo TFLite quint8

tfl.max_pool_2d (TFL :: MaxPool2DOp)

Max Pool 2D op

Descrizione:

Esegue il pool 2D massimo sull'input.

Ingressi: inputs[0] : richiesto: il tensore degli ingressi

operandi:

  1. input : tensore di qualsiasi valore di tipo

attributi:

Attributo Tipo MLIR Descrizione
padding StringAttr attributo enum di riempimento
stride_w IntegerAttr Attributo dell'attributo intero a 32 bit
stride_h IntegerAttr Attributo dell'attributo intero a 32 bit
filter_width IntegerAttr Attributo dell'attributo intero a 32 bit
filter_height IntegerAttr Attributo dell'attributo intero a 32 bit
fused_activation_function StringAttr attributo enum attivazione fusa

risultati:

  1. output : tensore di qualsiasi valore di tipo

tfl.max_pooling_with_argmax_2d (TFL :: MaxPoolingWithArgMax2DOp)

Max Pool 2D con argmax op

Descrizione:

Esegue il pooling massimo sull'input e genera sia valori massimi che indici. Ogni indice è un indice appiattito in un sotto-array di dimensioni "filter_w" x "filter_h" Nota: si tratta di un'operazione personalizzata che non è supportata nel runtime standard.

Ingressi: inputs[0] : richiesto: il tensore di attivazione degli ingressi

operandi:

  1. input : tensore di qualsiasi valore di tipo

attributi:

Attributo Tipo MLIR Descrizione
padding StringAttr attributo enum di riempimento
stride_w IntegerAttr Attributo dell'attributo intero a 32 bit
stride_h IntegerAttr Attributo dell'attributo intero a 32 bit
filter_w IntegerAttr Attributo dell'attributo intero a 32 bit
filter_h IntegerAttr Attributo dell'attributo intero a 32 bit

risultati:

  1. value : tensore di qualsiasi valore di tipo
  2. indices : tensore di qualsiasi valore di tipo

tfl.max_unpooling_2d (TFL :: MaxUnpooling2DOp)

Max Unpool 2D

Descrizione:

Esegue l'operazione di sblocco massima. In una certa misura si tratta dell'operazione inversa del pooling massimo: gli elementi nel tensore di attivazione dell'ingresso vengono memorizzati nella posizione specificata dagli indici di ingresso. Nota: si tratta di un'operazione personalizzata che non è supportata nel runtime standard.

Ingressi: inputs[0] : richiesto: gli ingressi tensore dell'attivazione degli inputs[1] : richiesto: gli indici degli ingressi

operandi:

  1. input : tensore di qualsiasi valore di tipo
  2. indices : tensore di qualsiasi valore di tipo

attributi:

Attributo Tipo MLIR Descrizione
padding StringAttr attributo enum di riempimento
stride_w IntegerAttr Attributo dell'attributo intero a 32 bit
stride_h IntegerAttr Attributo dell'attributo intero a 32 bit
filter_w IntegerAttr Attributo dell'attributo intero a 32 bit
filter_h IntegerAttr Attributo dell'attributo intero a 32 bit

risultati:

  1. outputs : tensore di qualsiasi valore di tipo

tfl.ma maximum (TFL :: MaximumOp)

Operatore max

Descrizione:

Operazione massima dal punto di vista degli elementi.

operandi:

  1. lhs : tensore di qualsiasi valore di tipo
  2. rhs : tensore di qualsiasi valore di tipo

attributi:

risultati:

  1. max : tensore di qualsiasi valore di tipo

tfl.mean (TFL :: MeanOp)

Operatore medio

Descrizione:

Calcola la media degli elementi attraverso le dimensioni di un tensore. Riduce input_tensor lungo le dimensioni indicate in asse. A meno che keepdims sia vero, il grado del tensore è ridotto di 1 per ogni voce nell'asse. Se keepdims è vero, le dimensioni ridotte vengono mantenute con la lunghezza 1.

operandi:

  1. input : tensore di qualsiasi valore di tipo
  2. axis : tensore di qualsiasi valore di tipo

attributi:

Attributo Tipo MLIR Descrizione
keep_dims BoolAttr attributo dell'attributo bool

risultati:

  1. output : tensore di qualsiasi valore di tipo

tfl.minimum (TFL :: MinimumOp)

Operatore minimo

Descrizione:

Operazione minima dal punto di vista degli elementi.

operandi:

  1. lhs : tensore di qualsiasi valore di tipo
  2. rhs : tensore di qualsiasi valore di tipo

attributi:

risultati:

  1. min : tensore di qualsiasi valore di tipo

tfl.mirror_pad (TFL :: MirrorPadOp)

Operatore MirrorPad. Riempie un tensore con valori speculari.

Descrizione:

Questa operazione riempie un input con valori speculari in base alle imbottiture specificate. paddings è un tensore intero con forma [n, 2], dove n è il grado di input. Per ogni dimensione D dell'input, i padding [D, 0] indicano quanti valori aggiungere prima del contenuto dell'input in quella dimensione e il padding [D, 1] indica quanti valori aggiungere dopo il contenuto dell'input in quella dimensione.

Sia i padding [D, 0] che quelli [D, 1] non devono essere maggiori di input.dim_size (D) (o input.dim_size (D) - 1) se copy_border è vero (se falso, rispettivamente).

La dimensione imbottita di ogni dimensione D dell'output è:

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

operandi:

  1. input : tensore di qualsiasi valore di tipo
  2. pad : tensore di qualsiasi tipo di valore

attributi:

Attributo Tipo MLIR Descrizione
mode StringAttr Attributo enum pad specchio

risultati:

  1. output : tensore di qualsiasi valore di tipo

tfl.mul (TFL :: MulOp)

Operatore di moltiplicazione

Descrizione:

Operazione di moltiplicazione degli elementi.

operandi:

  1. lhs : tensore di qualsiasi valore di tipo
  2. rhs : tensore di qualsiasi valore di tipo

attributi:

Attributo Tipo MLIR Descrizione
fused_activation_function StringAttr attributo enum attivazione fusa

risultati:

  1. output : tensore di qualsiasi valore di tipo

tfl.neg (TFL :: NegOp)

Operatore di negazione

Descrizione:

Calcola la negazione dell'elemento in termini di elementi

operandi:

  1. x : tensore di qualsiasi valore di tipo

attributi:

risultati:

  1. y : tensore di qualsiasi valore di tipo

tfl.non_max_suppression_v4 (TFL :: NonMaxSuppressionV4Op)

Seleziona avidamente un sottoinsieme di riquadri di delimitazione in ordine decrescente di punteggio,

Descrizione:

le caselle di potatura che hanno un alto intersezione su unione (IOU) si sovrappongono alle caselle precedentemente selezionate. Le caselle di delimitazione con punteggio inferiore a score_threshold vengono rimosse. Le caselle di delimitazione sono fornite come [y1, x1, y2, x2], dove (y1, x1) e (y2, x2) sono le coordinate di qualsiasi coppia diagonale di angoli della scatola e le coordinate possono essere fornite come normalizzate (ovvero, giacendo in l'intervallo [0, 1]) o assoluto. Si noti che questo algoritmo è indipendente da dove si trova l'origine nel sistema di coordinate e più in generale è invariante rispetto alle trasformazioni ortogonali e alle traduzioni del sistema di coordinate; in tal modo la traduzione o le riflessioni del sistema di coordinate comportano la selezione delle stesse caselle dall'algoritmo. L'output di questa operazione è un insieme di numeri interi indicizzati nella raccolta di input di riquadri di delimitazione che rappresentano i riquadri selezionati. Le coordinate del rettangolo di selezione corrispondenti agli indici selezionati possono quindi essere ottenute mediante l' tf.gather operation . Ad esempio: selected_indices = tf.image.non_max_suppression_v2 (box, score, max_output_size, iou_threshold, score_threshold) selected_boxes = tf.gather (box, selected_indices)

operandi:

  1. boxes : tensore di qualsiasi tipo di valore
  2. scores : tensore di qualsiasi tipo di valore
  3. max_output_size : tensore di qualsiasi valore di tipo
  4. iou_threshold : tensore di qualsiasi valore di tipo
  5. score_threshold : tensore di qualsiasi valore di tipo

attributi:

risultati:

  1. selected_indices : tensore di qualsiasi valore di tipo
  2. valid_outputs : tensore di qualsiasi valore di tipo

tfl.non_max_suppression_v5 (TFL :: NonMaxSuppressionV5Op)

Seleziona avidamente un sottoinsieme di riquadri di delimitazione in ordine decrescente di punteggio,

Descrizione:

le caselle di potatura che hanno un alto intersezione su unione (IOU) si sovrappongono alle caselle precedentemente selezionate. Le caselle di delimitazione con punteggio inferiore a score_threshold vengono rimosse. Le caselle di delimitazione sono fornite come [y1, x1, y2, x2], dove (y1, x1) e (y2, x2) sono le coordinate di qualsiasi coppia diagonale di angoli della scatola e le coordinate possono essere fornite come normalizzate (ovvero, giacendo in l'intervallo [0, 1]) o assoluto. Si noti che questo algoritmo è indipendente da dove si trova l'origine nel sistema di coordinate e più in generale è invariante rispetto alle trasformazioni ortogonali e alle traduzioni del sistema di coordinate; in tal modo la traduzione o le riflessioni del sistema di coordinate comportano la selezione delle stesse caselle dall'algoritmo. L'output di questa operazione è un insieme di numeri interi indicizzati nella raccolta di input di riquadri di delimitazione che rappresentano i riquadri selezionati. Le coordinate del rettangolo di selezione corrispondenti agli indici selezionati possono quindi essere ottenute mediante l' 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.

Operands:

  1. boxes : tensor of any type values
  2. scores : tensor of any type values
  3. max_output_size : tensor of any type values
  4. iou_threshold : tensor of any type values
  5. score_threshold : tensor of any type values
  6. soft_nms_sigma : tensor of any type values

Attributes:

Results:

  1. selected_indices : tensor of any type values
  2. selected_scores : tensor of any type values
  3. valid_outputs : tensor of any type values

tfl.not_equal (TFL::NotEqualOp)

Not_equal operator

Description:

Element-wise not_equal operation.

Operands:

  1. lhs : tensor of any type values
  2. rhs : tensor of any type values

Attributes:

Results:

  1. output : tensor of any type values

tfl.NumericVerify (TFL::NumericVerifyOp)

Verifies the numericals of the two operands

Description:

The NumericVerify op is a debugging op to verify the numericals of the two activations. It is a custom op in TFLite.

Operands:

  1. input : tensor of any type values
  2. ref : tensor of any type values

Attributes:

Attribute MLIR Type Description
tolerance FloatAttr 32-bit float attribute attribute

Results:

tfl.one_hot (TFL::OneHotOp)

OneHot operator

Description:

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).

Operands:

  1. indices : tensor of any type values
  2. depth : tensor of any type values
  3. on_value : tensor of any type values
  4. off_value : tensor of any type values

Attributes:

Attribute MLIR Type Description
axis IntegerAttr 32-bit integer attribute attribute

Results:

  1. output : tensor of any type values

tfl.prelu (TFL::PReluOp)

Parameterized Relu operator

Description:

Parameterized Relu operator x -> x >= 0 ? x : (alpha * x) where alpha is a trainable tensor. alpha should have one less rank than the input as it doesn't have the batch dimension, and the other dimensions either should be the same size as input or size 1, where it is broadcasted in the second case.

Operands:

  1. input : tensor of any type values
  2. alpha : tensor of any type values

Attributes:

Results:

  1. output : tensor of any type values

tfl.pack (TFL::PackOp)

Packs a list of tensors along a dimension into one tensor

Description:

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.

For example:

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

Operands:

  1. values : tensor of any type values

Attributes:

Attribute MLIR Type Description
values_count IntegerAttr 32-bit integer attribute attribute
axis IntegerAttr 32-bit integer attribute attribute

Results:

  1. output : tensor of any type values

tfl.pad (TFL::PadOp)

Padding operator

Description:

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)

For example:

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

Operands:

  1. input : tensor of any type values
  2. padding : tensor of any type values

Attributes:

Results:

  1. output : tensor of any type values

tfl.padv2 (TFL::PadV2Op)

Padding operator v2

Description:

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)

For example:

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

Operands:

  1. input : tensor of any type values
  2. padding : tensor of any type values
  3. constant_values : tensor of any type values

Attributes:

Results:

  1. output : tensor of any type values

tfl.pow (TFL::PowOp)

Power operator

Description:

Element-wise power operation.

Operands:

  1. lhs : tensor of any type values
  2. rhs : tensor of any type values

Attributes:

Results:

  1. output : tensor of any type values

tfl.pseudo_qconst (TFL::QConstOp)

Quantized constant pseudo op

Description:

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.

Operands:

Attributes:

Attribute MLIR Type Description
qtype TypeAttr Tensor type attribute attribute
value ElementsAttr constant vector/tensor attribute attribute

Results:

  1. output : tensor of any type values

tfl.quantize (TFL::QuantizeOp)

Quantize operator

Description:

Converts floating point tensors to quantized integer tensors according to the quantization parameters defined in the type attribute.

Operands:

  1. input : tensor of any type values

Attributes:

Attribute MLIR Type Description
qtype TypeAttr Tensor type attribute attribute

Results:

  1. output : tensor of any type values

tfl.range (TFL::RangeOp)

Range operator

Description:

Returns a 1D tensor defined by a sequence from start to limit with a given delta .

Operands:

  1. start : tensor of any type values
  2. limit : tensor of any type values
  3. delta : tensor of any type values

Attributes:

Results:

  1. result : tensor of any type values

tfl.rank (TFL::RankOp)

Rank operator.

Description:

Returns the rank of a tensor.

Operands:

  1. input : tensor of any type values

Attributes:

Results:

  1. output : tensor of any integer type

tfl.reduce_any (TFL::ReduceAnyOp)

Computes the "logical or" of elements across dimensions of a tensor.

Description:

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.

Operands:

  1. input : tensor of any type values
  2. reduction_indices : tensor of any type values

Attributes:

Attribute MLIR Type Description
keep_dims BoolAttr bool attribute attribute

Results:

  1. output : tensor of any type values

tfl.reduce_max (TFL::ReduceMaxOp)

Max-reduction operator

Description:

Computes the max reduction along the specified axes

Operands:

  1. input : tensor of any type values
  2. axes : tensor of any type values

Attributes:

Attribute MLIR Type Description
keep_dims BoolAttr bool attribute attribute

Results:

  1. «unnamed»: tensor of any type values

tfl.reduce_min (TFL::ReduceMinOp)

Min-reduction operator

Description:

Computes the min reduction along the specified axes

Operands:

  1. input : tensor of any type values
  2. axes : tensor of any type values

Attributes:

Attribute MLIR Type Description
keep_dims BoolAttr bool attribute attribute

Results:

  1. «unnamed»: tensor of any type values

tfl.reduce_prod (TFL::ReduceProdOp)

Prod-reduction operator

Description:

Computes the product along the specified axes

Operands:

  1. input : tensor of any type values
  2. axes : tensor of any type values

Attributes:

Attribute MLIR Type Description
keep_dims BoolAttr bool attribute attribute

Results:

  1. «unnamed»: tensor of any type values

tfl.relu_n1_to_1 (TFL::Relu1Op)

Relu1 operator

Description:

Element-wise Relu1 operator x -> max(-1, min(1, x))

Operands:

  1. x : tensor of any type values

Attributes:

Results:

  1. y : tensor of any type values

tfl.relu6 (TFL::Relu6Op)

Relu6 operator

Description:

Element-wise Relu6 operator x -> max(0, min(6, x))

Operands:

  1. x : tensor of any type values

Attributes:

Results:

  1. y : tensor of any type values

tfl.relu (TFL::ReluOp)

Relu operator

Description:

Element-wise Relu operator x -> max(0, x)

Operands:

  1. x : tensor of any type values

Attributes:

Results:

  1. y : tensor of any type values

tfl.reshape (TFL::ReshapeOp)

Reshape operator

Description:

Produces a tensor with the same values but different static shape defined by the output type.

Operands:

  1. input : tensor of any type values
  2. shape : tensor of any type values

Attributes:

Results:

  1. output : tensor of any type values

tfl.resize_bilinear (TFL::ResizeBilinearOp)

ResizeBilinear Op

Description:

Resize images to size using bilinear interpolation.

Operands:

  1. input : tensor of any type values
  2. size : tensor of any type values

Attributes:

Attribute MLIR Type Description
align_corners BoolAttr bool attribute attribute
half_pixel_centers BoolAttr bool attribute attribute

Results:

  1. output : tensor of any type values

tfl.resize_nearest_neighbor (TFL::ResizeNearestNeighborOp)

ResizeNearestNeighbor Op

Description:

Resize images to size using nearest neighbor interpolation.

Operands:

  1. input : tensor of any type values
  2. size : tensor of any type values

Attributes:

Attribute MLIR Type Description
align_corners BoolAttr bool attribute attribute

Results:

  1. output : tensor of any type values

tfl.reverse_sequence (TFL::ReverseSequenceOp)

Reverses variable length slices.

Description:

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.

Operands:

  1. input : tensor of any type values
  2. seq_lengths : tensor of any type values

Attributes:

Attribute MLIR Type Description
seq_dim IntegerAttr 32-bit integer attribute attribute
batch_dim IntegerAttr 32-bit integer attribute attribute

Results:

  1. output : tensor of any type values

tfl.reverse_v2 (TFL::ReverseV2Op)

ReverseV2 Operator

Description:

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, 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.

Operands:

  1. input : tensor of any type values
  2. axis : tensor of any type values

Attributes:

Results:

  1. output : tensor of any type values

tfl.round (TFL::RoundOp)

Round operator

Description:

Rounds the values of a tensor to the nearest integer, element-wise.

Operands:

  1. x : tensor of any type values

Attributes:

Results:

  1. y : tensor of any type values

tfl.rsqrt (TFL::RsqrtOp)

Reciprocal of square root operator

Description:

Computes element-wise reverse square root of input

Operands:

  1. x : tensor of any type values

Attributes:

Results:

  1. y : tensor of any type values

tfl.svdf (TFL::SVDFOp)

Single value decomposition filter operator

Description:

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

Operands:

  1. input : tensor of any type values
  2. feature_weights : tensor of any type values
  3. time_weights : tensor of any type values
  4. input_gate_bias : tensor of any type values or none type
  5. activation_state : stateful tensor

Attributes:

Attribute MLIR Type Description
rank IntegerAttr 32-bit integer attribute attribute
fused_activation_function StringAttr fused activation enum attribute

Results:

  1. output : tensor of any type values

tfl.segment_sum (TFL::SegmentSumOp)

SegmentSum operator

Description:

Computes the sum along segments of a tensor.

Operands:

  1. data : tensor of any type values
  2. segment_ids : tensor of any type values

Attributes:

Results:

  1. output : tensor of any type values

tfl.select (TFL::SelectOp)

Select operator

Description:

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:

  1. Either the same shape (in which case the select is elementwise), or
  2. condition must be Rank 1 and match over the first dimension.

Operands:

  1. condition : tensor of any type values
  2. x : tensor of any type values
  3. y : tensor of any type values

Attributes:

Results:

  1. output : tensor of any type values

tfl.select_v2 (TFL::SelectV2Op)

SelectV2 operator

Description:

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:

  1. Either the same shape (in which case the select is elementwise), or
  2. Broadcastable shapes between 'condition', 'x' and 'y'.

Operands:

  1. condition : tensor of any type values
  2. x : tensor of any type values
  3. y : tensor of any type values

Attributes:

Results:

  1. output : tensor of any type values

tfl.shape (TFL::ShapeOp)

Shape operator

Description:

Returns the shape of a tensor.

Operands:

  1. input : tensor of any type values

Attributes:

Attribute MLIR Type Description
out_type Attribute derived attribute attribute

Results:

  1. output : tensor of any type values

tfl.sin (TFL::SinOp)

Sine operator

Description:

Computes element-wise Sine of input

Operands:

  1. x : tensor of any type values

Attributes:

Results:

  1. y : tensor of any type values

tfl.slice (TFL::SliceOp)

Return a slice from 'input'.

Description:

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)

Operands:

  1. input : tensor of any type values
  2. begin : tensor of any type values
  3. size : tensor of any type values

Attributes:

Results:

  1. output : tensor of any type values

tfl.softmax (TFL::SoftmaxOp)

Softmax operator

Description:

Computes element-wise softmax activations with the following formula

exp(input) / tf.reduce_sum(exp(input * beta), dim)

Operands:

  1. input : tensor of any type values

Attributes:

Attribute MLIR Type Description
beta FloatAttr 32-bit float attribute attribute

Results:

  1. output : tensor of any type values

tfl.space_to_batch_nd (TFL::SpaceToBatchNdOp)

SpaceToBatchNd operator

Description:

This operation reshapes space dimensions into the "batch" dimension 0

Operands:

  1. input : tensor of any type values
  2. block_shape : tensor of any type values
  3. paddings : tensor of any type values

Attributes:

Results:

  1. output : tensor of any type values

tfl.space_to_depth (TFL::SpaceToDepthOp)

SpaceToDepth operator

Description:

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.

Operands:

  1. input : tensor of any type values

Attributes:

Attribute MLIR Type Description
block_size IntegerAttr 32-bit integer attribute attribute

Results:

  1. output : tensor of any type values

tfl.pseudo_sparse_const (TFL::SparseConstOp)

Sparse constant pseudo op.

Description:

Represents a sparse constant value in TensorFlow Lite dialect. This is not an actual operation and it will be lowered to buffer instead.

Operands:

Attributes:

Attribute MLIR Type Description
value ElementsAttr constant vector/tensor attribute attribute
s_param TFL::SparsityParameterAttr Sparsity parameter. attribute

Results:

  1. output : tensor of any type values

tfl.pseudo_sparse_qconst (TFL::SparseQConstOp)

Sparse quantized constant pseudo op

Description:

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.

Operands:

Attributes:

Attribute MLIR Type Description
qtype TypeAttr Tensor type attribute attribute
value ElementsAttr constant vector/tensor attribute attribute
s_param TFL::SparsityParameterAttr Sparsity parameter. attribute

Results:

  1. output : tensor of any type values

tfl.sparse_to_dense (TFL::SparseToDenseOp)

Converts a sparse representation into a dense tensor.

Description:

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.

Operands:

  1. sparse_indices : tensor of any type values
  2. output_shape : tensor of any type values
  3. sparse_values : tensor of any type values
  4. default_value : tensor of any type values

Attributes:

Results:

  1. dense : tensor of any type values

tfl.split (TFL::SplitOp)

Splits a tensor into num_split tensors along one dimension.

Description:

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.

Operands:

  1. split_dim : tensor of any type values
  2. value : tensor of any type values

Attributes:

Attribute MLIR Type Description
num_splits IntegerAttr positive 32-bit integer attribute attribute

Results:

  1. outputs : tensor of any type values

tfl.split_v (TFL::SplitVOp)

Splits a tensor into num_split tensors along one dimension.

Description:

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.

Operands:

  1. value : tensor of any type values
  2. size_splits : 1D tensor of 32-bit integer values
  3. split_dim : 0D tensor of 32-bit integer values

Attributes:

Attribute MLIR Type Description
num_splits IntegerAttr positive 32-bit integer attribute attribute

Results:

  1. outputs : tensor of any type values

tfl.sqrt (TFL::SqrtOp)

Square root operator

Description:

Computes element-wise Square root of input

Operands:

  1. x : tensor of any type values

Attributes:

Results:

  1. y : tensor of any type values

tfl.square (TFL::SquareOp)

Square operator

Description:

Computes element-wise Square of input

Operands:

  1. x : tensor of any type values

Attributes:

Results:

  1. y : tensor of any type values

tfl.squared_difference (TFL::SquaredDifferenceOp)

Squared difference operator

Description:

Element-wise squared difference operation.

Operands:

  1. lhs : tensor of any type values
  2. rhs : tensor of any type values

Attributes:

Results:

  1. output : tensor of any type values

tfl.squeeze (TFL::SqueezeOp)

Removes dimensions of size 1 from the shape of a tensor.

Description:

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 axis .

For example:

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

Operands:

  1. input : tensor of any type values

Attributes:

Attribute MLIR Type Description
squeeze_dims ArrayAttr 64-bit integer array attribute attribute

Results:

  1. output : tensor of any type values

tfl.strided_slice (TFL::StridedSliceOp)

StridedSlice Op

Description:

Return a strided slice from input .

Operands:

  1. input : tensor of any type values
  2. begin : tensor of any type values
  3. end : tensor of any type values
  4. strides : tensor of any type values

Attributes:

Attribute MLIR Type Description
begin_mask IntegerAttr 32-bit integer attribute attribute
end_mask IntegerAttr 32-bit integer attribute attribute
ellipsis_mask IntegerAttr 32-bit integer attribute attribute
new_axis_mask IntegerAttr 32-bit integer attribute attribute
shrink_axis_mask IntegerAttr 32-bit integer attribute attribute

Results:

  1. output : tensor of any type values

tfl.sub (TFL::SubOp)

Subtraction operator

Description:

Element-wise subtraction operation.

Operands:

  1. lhs : tensor of any type values
  2. rhs : tensor of any type values

Attributes:

Attribute MLIR Type Description
fused_activation_function StringAttr fused activation enum attribute

Results:

  1. output : tensor of any type values

tfl.sum (TFL::SumOp)

Sum operator

Description:

Computes the sum reduction along the specified axes

Operands:

  1. input : tensor of any type values
  2. axes : tensor of any type values

Attributes:

Attribute MLIR Type Description
keep_dims BoolAttr bool attribute attribute

Results:

  1. «unnamed»: tensor of any type values

tfl.tanh (TFL::TanhOp)

Hyperbolic tangent operator

Description:

Computes element-wise Hyperbolic tangent of input

Operands:

  1. x : tensor of any type values

Attributes:

Results:

  1. y : tensor of any type values

tfl.tile (TFL::TileOp)

Tile operator.

Description:

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

Operands:

  1. input : tensor of any type values
  2. multiples : tensor of any type values

Attributes:

Results:

  1. output : tensor of any type values

tfl.topk_v2 (TFL::TopKV2Op)

TopK operator

Description:

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.

Operands:

  1. input : tensor of any type values
  2. k : tensor of any type values

Attributes:

Results:

  1. values : tensor of any type values
  2. indices : tensor of any type values

tfl.transpose_conv (TFL::TransposeConvOp)

Transpose convolution operator

Description:

Performs transpose convolution operation on input.

Operands:

  1. output_shape : 1D tensor of any type values
  2. weights : tensor of any type values
  3. input : tensor of any type values

Attributes:

Attribute MLIR Type Description
padding StringAttr padding enum attribute
stride_h IntegerAttr 32-bit integer attribute attribute
stride_w IntegerAttr 32-bit integer attribute attribute

Results:

  1. output : tensor of any type values

tfl.transpose (TFL::TransposeOp)

Transpose operator

Description:

Returns the Transpose of x

Operands:

  1. x : tensor of any type values
  2. perm : tensor of any type values

Attributes:

Results:

  1. y : tensor of any type values

tfl.unidirectional_sequence_lstm (TFL::UnidirectionalSequenceLSTMOp)

Unidirectional sequence lstm operator

Description:

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”).

Operands:

  1. input : tensor of any type values
  2. input_to_input_weights : tensor of any type values or none type
  3. input_to_forget_weights : tensor of any type values
  4. input_to_cell_weights : tensor of any type values
  5. input_to_output_weights : tensor of any type values
  6. recurrent_to_input_weights : tensor of any type values or none type
  7. recurrent_to_forget_weights : tensor of any type values
  8. recurrent_to_cell_weights : tensor of any type values
  9. recurrent_to_output_weights : tensor of any type values
  10. cell_to_input_weights : tensor of any type values or none type
  11. cell_to_forget_weights : tensor of any type values or none type
  12. cell_to_output_weights : tensor of any type values or none type
  13. input_gate_bias : tensor of any type values or none type
  14. forget_gate_bias : tensor of any type values
  15. cell_bias : tensor of any type values
  16. output_gate_bias : tensor of any type values
  17. projection_weights : tensor of any type values or none type
  18. projection_bias : tensor of any type values or none type
  19. input_activation_state : stateful tensor
  20. input_cell_state : stateful tensor
  21. input_layer_norm_coefficients : tensor of any type values or none type
  22. forget_layer_norm_coefficients : tensor of any type values or none type
  23. cell_layer_norm_coefficients : tensor of any type values or none type
  24. output_layer_norm_coefficients : tensor of any type values or none type

Attributes:

Attribute MLIR Type Description
fused_activation_function StringAttr fused activation enum attribute
cell_clip FloatAttr 32-bit float attribute attribute
proj_clip FloatAttr 32-bit float attribute attribute
time_major BoolAttr bool attribute attribute

Results:

  1. output : tensor of any type values

tfl.unidirectional_sequence_rnn (TFL::UnidirectionalSequenceRNNOp)

Unidirectional sequence rnn operator

Description:

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”).

Operands:

  1. input : tensor of any type values
  2. input_to_input_weights : tensor of any type values
  3. recurrent_to_input_weights : tensor of any type values
  4. input_gate_bias : tensor of any type values
  5. hidden_state : stateful tensor

Attributes:

Attribute MLIR Type Description
time_major BoolAttr bool attribute attribute
fused_activation_function StringAttr fused activation enum attribute

Results:

  1. output : tensor of any type values

tfl.unique (TFL::UniqueOp)

Unique Op.

Description:

This operation returns a tensor y containing all of the unique elements of x sorted in the same order that they occur in x . This operation also returns a tensor idx the same size as x that contains the index of each value of x in the unique output y . In other words:

Operands:

  1. input : tensor of any type values

Attributes:

Attribute MLIR Type Description
idx_out_type Attribute derived attribute attribute

Results:

  1. output : tensor of any type values
  2. idx : tensor of any type values

tfl.unpack (TFL::UnpackOp)

Unpacks a tensor along a dimension into multiple tensors

Description:

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 .

Operands:

  1. input : tensor of any type values

Attributes:

Attribute MLIR Type Description
num IntegerAttr 32-bit integer attribute attribute
axis IntegerAttr 32-bit integer attribute attribute

Results:

  1. outputs : tensor of any type values

tfl.where (TFL::WhereOp)

Returns locations of nonzero / true values in a tensor.

Description:

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.

Operands:

  1. input : tensor of any type values

Attributes:

Results:

  1. index : tensor of any type values

tfl.while (TFL::WhileOp)

While loop

Description:

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 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.

Operands:

  1. input : tensor of any type values

Attributes:

Attribute MLIR Type Description
is_stateless BoolAttr bool attribute attribute

Results:

  1. output : tensor of any type values

tfl.yield (TFL::YieldOp)

Yield operation

Description:

The "yield" operation represents a return operation within the conditional and body of structured control flow (eg, while). The operation takes variable number of operands and produces no results. The operand number and types must match the signature of the region that contains the operation.

Operands:

  1. operands : any type

Attributes:

Results:

tfl.zeros_like (TFL::ZerosLikeOp)

ZerosLike operator

Description:

Returns a tensor of zeros with the same shape and type as the input tensor.

Operands:

  1. input : tensor of any type values

Attributes:

Results:

  1. output : tensor of any type values