'tfl' Dialetto

Il dialetto TensorFlow Lite.

Questo dialetto si associa alle operazioni di TensorFlow Lite.

Invarianti:

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

Operazioni

tfl.abs (TFL::AbsOp)

Operatore di valore assoluto

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 viene calcolata \(y = |x|\).

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.add (TFL::AddOp)

Operatore di addizione

Operazione di addizione per elemento.

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

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

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

tfl.add_n (TFL::AddNOp)

_Aggiungi l'operatore n

Aggiunge tutti i tensori di input per elemento.

Caratteristiche: AlwaysSpeculatableImplTrait , Commutative

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflArithmeticCountOpInterface , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.arg_max (TFL::ArgMaxOp)

Operatore ArgMax

Restituisce l'indice con il valore maggiore tra le dimensioni di un tensore.

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

tfl.arg_min (TFL::ArgMinOp)

Operatore ArgMin

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)

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

tfl.assign_variable (TFL::AssignVariableOp)

Assegna un nuovo valore a una variabile.

Qualsiasi ReadVariableOp con una dipendenza di controllo da questa operazione garantisce che restituirà questo valore o un successivo valore più recente della variabile.

Interfacce: TflRuntimeVerifyOpInterface

Operandi:

tfl.atan2 (TFL::Atan2Op)

Operazione Atan2

L'operazione "atan2" calcola l'arcotangente di y/x per elemento, rispettando i segni degli argomenti.

Caratteristiche: AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType , SameOperandsAndResultShape

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.average_pool_2d (TFL::AveragePool2DOp)

Operatore 2d _Average_pool

Esegue l'operazione di pooling medio sull'input.

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflArithmeticCountOpInterface , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

tfl.basic_lstm (TFL::BasicLSTMOp)

L'operatore lstm di base

Operatore di cella LSTM di base.

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

tfl.batch_matmul (TFL::BatchMatMulOp)

Operatore di moltiplicazione della matrice batch

Esegue una moltiplicazione di matrici batch sugli input. Segue le convenzioni di TensorFlow BatchMatMulV2, con supporto per dimensioni sconosciute nelle dimensioni batch e nella trasmissione.

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)

Caratteristiche: ::mlir::OpTrait::TFLRuntimeOpTrait , AlwaysSpeculatableImplTrait , QuantizableResult

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

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

tfl.batch_to_space_nd (TFL::BatchToSpaceNdOp)

Operatore BatchToSpaceNd

Questa operazione rimodella la dimensione "batch" 0 in dimensioni spaziali.

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

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

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.bidirectional_sequence_lstm (TFL::SequenzabidirezionaleLSTMOp)

Operatore lstm di sequenza bidirezionale

Lstm bidirezionale è essenzialmente due lstm, uno che corre in avanti e l'altro che corre all'indietro. E l'output è la concatenazione dei due lstm.

Caratteristiche: QuantizableResult

Interfacce: DynamicRangeQuantizedOpInterface , TFL_StatefulOp , TflRuntimeVerifyOpInterface

Attributi:

Operandi:

Risultati:

tfl.bitcast (TFL::BitcastOp)

Operatore Bitcast

Bitcasting un tensore da un tipo a un altro.

Tratti: AlwaysSpeculatableImplTrait

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.bitwise_xor (TFL::BitwiseXorOp)

Operatore Xor bit a bit

Elementwise calcola lo XOR bit a bit di lhs e rhs .

Caratteristiche: AlwaysSpeculatableImplTrait , Commutative , ResultsBroadcastableShape , SameOperandsAndResultElementType

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.broadcast_args (TFL::BroadcastArgsOp)

Restituisce la forma di s0 op s1 con broadcast.

Dati s0 e s1 , tensori che rappresentano le forme, calcola r0 , la forma trasmessa. s0 , s1 e r0 sono tutti vettori interi.

Tratti: AlwaysSpeculatableImplTrait

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.broadcast_to (TFL::BroadcastToOp)

Trasmetti un array per una forma compatibile.

Il broadcasting è il processo di creazione di array in modo che abbiano forme compatibili per le operazioni aritmetiche. Due forme sono compatibili se per ciascuna coppia di dimensioni sono uguali o se una di esse è una. Quando si tenta di trasmettere un tensore a una forma, si inizia con le dimensioni finali e si procede in avanti.

Per esempio,

x = tf.costante([1, 2, 3]) y = tf.broadcast_to(x, [3, 3]) print(y) tf.Tensore( [[1 2 3] [1 2 3] [1 2 3]], forma=(3, 3), dtype=int32)

Nell'esempio precedente, il tensore di input con la forma di [1, 3] viene trasmesso al tensore di output con la forma di [3, 3] .

Quando si eseguono operazioni trasmesse come la moltiplicazione di un tensore per uno scalare, la trasmissione (di solito) conferisce un vantaggio in termini di tempo o spazio, poiché il tensore trasmesso non viene mai materializzato.

Tuttavia, broadcast_to non porta con sé tali vantaggi. Il tensore appena creato prende tutta la memoria della forma trasmessa. (In un contesto grafico, broadcast_to potrebbe essere fuso con l'operazione successiva e quindi essere ottimizzato.)

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.bucketize (TFL::BucketizeOp)

Classifica gli "input" in base ai "confini".

Esempio:

Se gli input sono boundaries = [0, 10, 100] e input = [[-5, 10000][150, 10][5, 100]] , l'output sarà output = [[0, 3][3, 2][1, 3]] .

Caratteristiche: AlwaysSpeculatableImplTrait , SameOperandsAndResultShape

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

tfl.call_once (TFL::CallOnceOp)

Richiama una funzione di inizializzazione

Questa operazione richiama la funzione di inizializzazione specificata per l'inizializzatore di sessione nel dialetto del modello salvato.

Interfacce: TflRuntimeVerifyOpInterface

Attributi:

tfl.cast (TFL::CastOp)

Operatore cast

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

Caratteristiche: AlwaysSpeculatableImplTrait , SameOperandsAndResultShape

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.ceil (TFL::CeilOp)

Operatore cellulare

Restituisce il valore ceil per elemento dell'input.

Caratteristiche: AlwaysSpeculatableImplTrait , InferTensorType , TF::SameOperandsAndResultTypeResolveRef

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

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.complex_abs (TFL::ComplexAbsOp)

Calcola il valore assoluto complesso di un tensore.

Dato un tensore x di numeri complessi, questa operazione restituisce un tensore di tipo float o double che è il valore assoluto di ciascun elemento in x . Tutti gli elementi in x devono essere numeri complessi della forma \(a + bj\). Il valore assoluto viene calcolato come \( \sqrt{a^2 + b^2}\).

Caratteristiche: AlwaysSpeculatableImplTrait , SameOperandsAndResultShape

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.concatenation (TFL::ConcatenationOp)

Operatore di concatenazione

Concatena i tensori lungo una dimensione

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

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

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

tfl.control_node (TFL::ControlNodeOp)

L'operazione TFL.control_node racchiude le operazioni a blocco singolo per collegare i bordi di controllo.

Viene utilizzato per racchiudere le regioni e allegare ad esse dipendenze di controllo. In genere, ciò avverrà in uno degli ultimi passaggi prima dell'emissione del modello flatbuffer per consentire ottimizzazioni che si basano su un ordine fisso di operazioni (come la rimaterializzazione). L'esportatore flatbuffer scarterà la regione avvolta e annoterà il modello generato con metadati in modo tale che qualsiasi riordino di runtime rispetterà l'ordine dato dalle dipendenze di controllo.

Caratteristiche: HasParent<mlir::func::FuncOp> , RecursiveMemoryEffects , SingleBlockImplicitTerminator<YieldOp> , SingleBlock

Operandi:

Risultati:

tfl.conv_2d (TFL::Conv2DOp)

Operatore di convoluzione

Esegue l'operazione di convoluzione sugli input.

Ingressi: inputs[0] : richiesti: il tensore di attivazione dell'ingresso inputs[1] : richiesti: il tensore del peso del filtro inputs[2] : opzionale: il tensore di polarizzazione

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

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

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

tfl.conv_3d (TFL::Conv3DOp)

Operatore di convoluzione 3D

Esegue l'operazione di convoluzione sugli input 3D. Ingressi: inputs[0] : richiesti: il tensore di attivazione dell'ingresso inputs[1] : richiesti: il tensore del peso del filtro inputs[2] : opzionale: il tensore di polarizzazione

Caratteristiche: AlwaysSpeculatableImplTrait , quant::AccumulatorUniformScale<2, 0, 1>

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

tfl.conv_3d_transpose (TFL::Conv3DTransposeOp)

Operatore 3D di convoluzione trasposta

Esegue l'operazione di convoluzione trasposta sugli input 3D. Ingressi: inputs[0] : richiesto: la forma del tensore di uscita inputs[1] : richiesto: il tensore del peso del filtro inputs[2] : richiesto: il tensore di attivazione dell'ingresso inputs[3] : opzionale: il tensore di polarizzazione

Caratteristiche: AlwaysSpeculatableImplTrait , quant::AccumulatorUniformScale<2, 0, 1>

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

tfl.cos (TFL::CosOp)

Operatore coseno

Calcola il coseno dell'input in termini di elementi

Caratteristiche: AlwaysSpeculatableImplTrait , InferTensorType , TF::SameOperandsAndResultTypeResolveRef

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

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.cumsum (TFL::CumsumOp)

Operatore cumsum

Calcola la somma cumulativa del tensore x lungo l'asse.

Tratti: AlwaysSpeculatableImplTrait

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

tfl.custom (TFL::CustomOp)

Op. personalizzata

Un'operazione generica per qualsiasi operazione personalizzata TFLite.

input: un elenco di input nell'op originale. custom_code: una stringa utilizzata per identificare esattamente questa operazione, che corrisponde a operator_codes.custom_code nel flatbuffer. custom_option: un titolare per salvare gli attributi op in modalità byte. output: un elenco di output nell'op originale.

Interfacce: TflRuntimeVerifyOpInterface

Attributi:

Operandi:

Risultati:

tfl.custom_tf (TFL::CustomTfOp)

Operazione wrapper per operazioni personalizzate TF.

Un'operazione che racchiude qualsiasi operazione TF personalizzata. Questi includono operazioni definite utilizzando custom_opdefs o collegate che non sono definite nel dialetto TF. Questa operazione racchiude semplicemente l'operazione personalizzata all'interno di una regione. Nota n. 1, questa operazione non includerà le operazioni personalizzate TF Lite definite utilizzando CustomOp. Nota n.2, questa operazione è solo una rappresentazione interna all'interno del convertitore e non viene esposta/esportata quando il modello viene esportato in Flatbuffer.

Caratteristiche: IsolatedFromAbove , RecursiveMemoryEffects , SingleBlockImplicitTerminator<YieldOp> , SingleBlock

Interfacce: InferTypeOpInterface , TflRuntimeVerifyOpInterface

Operandi:

Risultati:

tfl.densify (TFL::DensifyOp)

Operatore di densificazione

Converte il tensore sparse in formato denso.

Tratti: AlwaysSpeculatableImplTrait

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.depth_to_space (TFL::DepthToSpaceOp)

Operatore ProfonditàToSpazio

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

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

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

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

tfl.depthwise_conv_2d (TFL::DepthwiseConv2DOp)

Operatore di convoluzione separabile in profondità

Esegue l'operazione di convoluzione sugli input.

Ingressi: inputs[0] : richiesti: il tensore di attivazione dell'ingresso inputs[1] : richiesti: il tensore del peso del filtro inputs[2] : opzionale: il tensore di polarizzazione

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

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

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

tfl.dequantize (TFL::DequantizeOp)

Operatore di dequantizzazione

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

Interfacce: NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.dilate (TFL::DilateOp)

Operatore di dilatazione

Estende un tensore aggiungendo nuovi elementi tra quelli esistenti.

Tratti: AlwaysSpeculatableImplTrait

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.div (TFL::DivOp)

Operatore di divisione

Operazione di divisione per elementi.

Tratti: ::mlir::OpTrait::TFLRuntimeOpTrait , AlwaysSpeculatableImplTrait , ResultsBroadcastableShape

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

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

tfl.dynamic_update_slice (TFL::DynamicUpdateSliceOp)

DynamicUpdateSlice.

DynamicUpdateSlice op che hanno la stessa semantica di XLA DynamicUpdateSlice. Genera un risultato che è il valore dell'operando dell'array di input, con un aggiornamento della sezione sovrascritto in start_indices.

Vedere https://www.tensorflow.org/xla/Operation_semantics#dynamicupdateslice

Tratti: AlwaysSpeculatableImplTrait

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.elu (TFL::EluOp)

Operatore di unità lineare esponenziale

Calcola l'esponenziale lineare f(x) -> exp(x) - 1 per x < 0, x per x >= 0. a livello di elemento.

Caratteristiche: AlwaysSpeculatableImplTrait , SameOperandsAndResultShape

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.embedding_lookup (TFL::EmbeddingLookupOp)

Incorporamento dell'operatore di ricerca

Cerca gli ID in un elenco di tensori di incorporamento.

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

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

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.equal (TFL::EqualOp)

Operatore uguale

Restituisce l'elemento di verità di x == y in termini di elemento

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

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.exp (TFL::ExpOp)

Operatore di esponenziazione naturale

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

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.expand_dims (TFL::ExpandDimsOp)

Inserisce una dimensione pari a 1 nella forma di un tensore.

Dato un input tensore, questa operazione inserisce una dimensione pari a 1 axis dell'indice dimensionale della forma input . L' axis dell'indice delle dimensioni inizia da zero; se si specifica un numero negativo per axis verrà conteggiato all'indietro a partire 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 batch 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 di dimensione 1.

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

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

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.external_const (TFL::ExternalConstOp)

Const esterno op.

L'operazione const esterna contiene un buffer_index che punta a una costante nel flatbuffer.

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Attributi:

Risultati:

tfl.fake_quant (TFL::FakeQuantOp)

Operatore FakeQuant

Quantizzare in modo falso il tensore degli "ingressi" di tipo float tramite gli scalari float min e max sul tensore delle "uscite" della stessa forma degli input.

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

tfl.fill (TFL::FillOp)

Riempi il tensore con il valore specificato.

Riempi il tensore con il valore specificato.

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

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

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.floor (TFL::FloorOp)

Operatore di piano

Restituisce il valore minimo dell'input per elemento.

Caratteristiche: AlwaysSpeculatableImplTrait , InferTensorType , TF::SameOperandsAndResultTypeResolveRef

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

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.floor_div (TFL::FloorDivOp)

Operatore div di piano

Operazione di divisione del pavimento in base agli elementi.

Tratti: ::mlir::OpTrait::TFLRuntimeOpTrait , AlwaysSpeculatableImplTrait , ResultsBroadcastableShape

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.floor_mod (TFL::FloorModOp)

Promemoria della divisione

Operazione di promemoria della divisione per elemento.

Tratti: ::mlir::OpTrait::TFLRuntimeOpTrait , AlwaysSpeculatableImplTrait , ResultsBroadcastableShape

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.fully_connected (TFL::FullyConnectedOp)

Completamente connesso op

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

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

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

tfl.gather (TFL::GatherOp)

Operatore di raccolta

Raccogli le sezioni axis dei params secondo indices .

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

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

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

tfl.gather_nd (TFL::GatherNdOp)

_Raccogli e operatore

Raccogli le fette dai params in un tensore con la forma specificata dagli indices .

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

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

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.gelu (TFL::GeluOp)

Funzione di attivazione GELU.

Calcola la funzione di attivazione GELU a livello di elemento.

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

tfl.greater (TFL::GreaterOp)

Operatore maggiore

Operazione maggiore dal punto di vista degli elementi.

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

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.greater_equal (TFL::GreaterEqualOp)

_Operatore uguale maggiore

Operazione maggiore_equal a livello di elemento.

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

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.hard_swish (TFL::HardSwishOp)

Funzione di attivazione Hardswish.

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

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.hashtable (TFL::HashtableOp)

Crea una tabella hash non inizializzata.

Questa operazione crea una tabella hash, specificando il tipo delle sue chiavi e valori. Prima di utilizzare la tabella dovrai inizializzarla. Dopo l'inizializzazione la tabella sarà immutabile.

Interfacce: TflRuntimeVerifyOpInterface

Attributi:

Risultati:

tfl.hashtable_find (TFL::HashtableFindOp)

Cerca le chiavi in ​​una tabella e restituisce i valori corrispondenti.

Le keys tensori devono essere dello stesso tipo delle chiavi della tavola. I values di output sono del tipo dei valori della tabella.

Il default_value scalare è il valore di output per le chiavi non presenti nella tabella. Deve inoltre essere dello stesso tipo dei valori della tabella.

Interfacce: TflRuntimeVerifyOpInterface

Operandi:

Risultati:

tfl.hashtable_import (TFL::HashtableImportOp)

Sostituisce il contenuto della tabella con le chiavi e i valori specificati.

Le keys tensori devono essere dello stesso tipo delle chiavi della tabella. I values del tensore devono essere del tipo dei valori della tabella.

Interfacce: TflRuntimeVerifyOpInterface

Operandi:

tfl.hashtable_size (TFL::HashtableSizeOp)

Calcola il numero di elementi nella tabella data.

Interfacce: TflRuntimeVerifyOpInterface

Operandi:

Risultati:

tfl.if (TFL::IfOp)

Operazione "Se-allora-altro".

L'operazione tfl.if rappresenta un costrutto if-then-else per l'esecuzione condizionale di due regioni di codice. L'operando di un'operazione if è un valore booleano. Per esempio:

tfl.if %b  {
  ...
} else {
  ...
}

tfl.if può anche restituire risultati definiti nelle sue regioni. I valori definiti sono determinati dal percorso di esecuzione intrapreso.

Esempio:

%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>
}

Le regioni tfl.if terminano sempre con "tfl.yield". Se "tfl.if" non definisce valori, "tfl.yield" può essere tralasciato e verrà inserito implicitamente. Altrimenti deve essere esplicito. Inoltre, se "tfl.if" definisce uno o più valori, il blocco "else" non può essere omesso.

Esempio:

tfl.if %b  {
  ...
}

Caratteristiche: NoRegionArguments , RecursiveMemoryEffects , SingleBlockImplicitTerminator<YieldOp> , SingleBlock

Interfacce: RegionBranchOpInterface , TflRuntimeVerifyOpInterface

Operandi:

Risultati:

tfl.imag (TFL::ImagOp)

Restituisce la parte immaginaria di un numero complesso.

Dato un tensore input di numeri complessi, questa operazione restituisce un tensore di tipo float che è la parte immaginaria di ciascun elemento in input . Tutti gli elementi in input devono essere numeri complessi del modulo \(a + bj\), dove a è la parte reale e b è la parte immaginaria restituita da questa operazione.

Caratteristiche: AlwaysSpeculatableImplTrait , SameOperandsAndResultShape

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.l2_normalization (TFL::L2NormalizationOp)

L2 Operatore Normalizza

L2Normalizzazione Op

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

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

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

tfl.leaky_relu (TFL::LeakyReluOp)

Operatore Relu che perde

Operatore Leaky ReLU a livello di elemento x -> x >= 0 ? x : (alfa * x)

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

tfl.less (TFL::LessOp)

Meno operatore

Meno operazioni in termini di elementi.

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

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.less_equal (TFL::LessEqualOp)

_Operatore meno uguale

Operazione less_equal a livello di elemento.

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

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.local_response_normalization (TFL::LocalResponseNormalizationOp)

Normalizzazione della risposta locale.

Il tensore input 4-D viene trattato come una matrice 3-D di vettori 1-D (lungo l'ultima dimensione) e ciascun vettore viene normalizzato in modo indipendente. All'interno di un dato vettore, ogni componente viene diviso per la somma ponderata e quadrata degli input all'interno di depth_radius . Nel 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) .

Caratteristiche: AlwaysSpeculatableImplTrait , InferTensorType , TF::SameOperandsAndResultTypeResolveRef

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

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

tfl.log (TFL::LogOp)

Operatore del logaritmo naturale

Esegue l'operazione del logaritmo naturale per elemento sull'input.

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.log_softmax (TFL::LogSoftmaxOp)

Registra l'operatore softmax

Calcola le attivazioni softmax del registro per elemento con la seguente formula

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

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

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

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.logical_and (TFL::LogicalAndOp)

Operatore logico AND

Operazione AND logica a livello di elemento.

Caratteristiche: AlwaysSpeculatableImplTrait , ResultsBroadcastableShape

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.logical_not (TFL::LogicalNotOp)

Operatore logico NOT

Operazione NOT logica a livello di elemento.

Caratteristiche: AlwaysSpeculatableImplTrait , SameOperandsAndResultShape

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.logical_or (TFL::LogicalOrOp)

Operatore logico OR

Operazione OR logica a livello di elemento.

Caratteristiche: AlwaysSpeculatableImplTrait , ResultsBroadcastableShape

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.logistic (TFL::LogisticOp)

Operatore logistico

Calcola il sigmoide dell'input in termini di elementi

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

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

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.lstm (TFL::LSTMOp)

L'operatore lstm completo

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

Caratteristiche: QuantizableResult

Interfacce: DynamicRangeQuantizedOpInterface , TFL_StatefulOp , TflRuntimeVerifyOpInterface

Attributi:

Operandi:

Risultati:

tfl.matrix_diag (TFL::MatrixDiagOp)

Restituisce un tensore con la diagonale fornita e tutto il resto riempito con zeri.

Data una diagonale, restituisce un tensore con la diagonale e tutto il resto riempito con zeri. Supponiamo che la diagonale abbia k dimensioni [I, J, K, ..., N] , allora l'output è un tensore di 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].

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.matrix_set_diag (TFL::MatrixSetDiagOp)

Restituisce un tensore di matrice in batch con nuovi valori diagonali in batch.

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

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.max_pool_2d (TFL::MaxPool2DOp)

Piscina Max 2D op

Esegue il pool 2D massimo in input.

Ingressi: inputs[0] : richiesto: il tensore di input

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , SameOperandsAndResultsScale , TflArithmeticCountOpInterface , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

tfl.maximum (TFL::Opzionemassima)

Operatore massimo

Funzionamento massimo in termini di elementi.

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

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

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.mean (TFL::MeanOp)

Operatore medio

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

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

tfl.minimum (TFL::MinimumOp)

Operatore minimo

Operazione minima in base agli elementi.

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

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

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.mirror_pad (TFL::MirrorPadOp)

Operatore MirrorPad. Riempie un tensore con valori specchiati.

Questa operazione riempie un input con valori specchiati in base ai riempimenti specificati. riempimenti è un tensore intero con forma [n, 2], dove n è il rango dell'input. Per ogni dimensione D dell'input, riempimenti[D, 0] indica quanti valori aggiungere prima del contenuto dell'input in quella dimensione e riempimenti[D, 1] indica quanti valori aggiungere dopo il contenuto dell'input in quella dimensione.

Sia riempimenti[D, 0] che riempimenti[D, 1] non devono essere maggiori di input.dim_size(D) (o input.dim_size(D) - 1) se copy_border è true (se false, rispettivamente).

La dimensione riempita di ciascuna dimensione D dell'output è:

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

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

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

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

tfl.mul (TFL::MulOp)

Operatore di moltiplicazione

Operazione di moltiplicazione per elementi.

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

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

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

tfl.multinomial (TFL::MultinomialeOp)

Disegna campioni da una distribuzione categorica.

I valori generati avranno una distribuzione categorica basata sui logits o sulle probabilità logaritmiche non normalizzate fornite per tutte le classi.

Interfacce: TflRuntimeVerifyOpInterface

Attributi:

Operandi:

Risultati:

tfl.neg (TFL::NegOp)

Operatore di negazione

Calcola la negazione dell'input per elemento

Caratteristiche: AlwaysSpeculatableImplTrait , InferTensorType , TF::SameOperandsAndResultTypeResolveRef

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

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.no_value (TFL::NoValueOp)

Costante che non rappresenta alcun valore.

Nessun valore costante op.

Caratteristiche: AlwaysSpeculatableImplTrait , ConstantLike

Interfacce: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Attributi:

Risultati:

tfl.non_max_suppression_v4 (TFL::NonMaxSuppressionV4Op)

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

eliminando le caselle che hanno un'elevata sovrapposizione di intersezione su unione (IOU) con le caselle precedentemente selezionate. I riquadri di delimitazione con punteggio inferiore a score_threshold vengono rimossi. I riquadri di delimitazione vengono forniti come [y1, x1, y2, x2], dove (y1, x1) e (y2, x2) sono le coordinate di qualsiasi coppia diagonale di angoli del riquadro e le coordinate possono essere fornite come normalizzate (ovvero, giacenti in l'intervallo [0, 1]) o assoluto. Si noti che questo algoritmo è indipendente dalla posizione dell'origine nel sistema di coordinate e più in generale è invariante rispetto alle trasformazioni ortogonali e alle traslazioni del sistema di coordinate; quindi la traslazione o le riflessioni del sistema di coordinate comportano la selezione delle stesse caselle da parte dell'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 riquadro di delimitazione corrispondenti agli indici selezionati possono quindi essere ottenute utilizzando l' tf.gather operation . Ad esempio: selezionato_indices = tf.image.non_max_suppression_v2(box, punteggi, max_output_size, iou_threshold, score_threshold) selezionato_boxes = tf.gather(boxes, selezionato_indices)

Tratti: AlwaysSpeculatableImplTrait

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.non_max_suppression_v5 (TFL::NonMaxSuppressionV5Op)

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

eliminando le caselle che hanno un'elevata sovrapposizione di intersezione su unione (IOU) con le caselle precedentemente selezionate. I riquadri di delimitazione con punteggio inferiore a score_threshold vengono rimossi. I riquadri di delimitazione vengono forniti come [y1, x1, y2, x2], dove (y1, x1) e (y2, x2) sono le coordinate di qualsiasi coppia diagonale di angoli del riquadro e le coordinate possono essere fornite come normalizzate (ovvero, giacenti in l'intervallo [0, 1]) o assoluto. Si noti che questo algoritmo è indipendente dalla posizione dell'origine nel sistema di coordinate e più in generale è invariante rispetto alle trasformazioni ortogonali e alle traslazioni del sistema di coordinate; quindi la traslazione o le riflessioni del sistema di coordinate comportano la selezione delle stesse caselle da parte dell'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 riquadro di delimitazione corrispondenti agli indici selezionati possono quindi essere ottenute utilizzando l' tf.gather operation . Ad esempio:selected_indices = tf.image.non_max_suppression_v2(boxes, scores, max_output_size, iou_threshold, score_threshold)selected_boxes = tf.gather(boxes,selected_indices) Questa operazione supporta anche una modalità Soft-NMS (con ponderazione gaussiana) (cfr Bodla et al , https://arxiv.org/abs/1704.04503 ) dove i riquadri riducono il punteggio di altri riquadri sovrapposti invece di provocarne direttamente la potatura. Per abilitare questa modalità Soft-NMS, impostare il parametro soft_nms_sigma su un valore maggiore di 0.

Tratti: AlwaysSpeculatableImplTrait

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.not_equal (TFL::NotEqualOp)

_Operatore non uguale

Operazione not_equal a livello di elemento.

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

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.NumericVerify (TFL::NumericVerifyOp)

Verifica i numerici dei due operandi

L'operazione NumericVerify è un'operazione di debug per verificare i numeri delle due attivazioni. È un'operazione personalizzata in TFLite. Se log_if_failed è vero, l'operazione NumericVerify calcola le statistiche sulle differenze tra attivazioni float e quantizzate, log di output, imposta differenze sui tensori di output e genera un errore se esistono errori superiori alla tolleranza. Se log_if_failed = false, non si preoccupa degli errori.

Caratteristiche: QuantizableResult , SameOperandsShape

Interfacce: TflRuntimeVerifyOpInterface

Attributi:

Operandi:

Risultati:

tfl.one_hot (TFL::OneHotOp)

Operatore OneHot

Restituisce un tensore one-hot. Le posizioni rappresentate dagli indici negli indices assumono valore on_value , mentre tutte le altre posizioni assumono valore off_value .

Se gli indices di input sono di rango N , l'output avrà rango N+1 . Il nuovo asse viene creato axis dimensione (impostazione predefinita: il nuovo asse viene aggiunto alla fine).

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

tfl.pack (TFL::PackOp)

Raggruppa un elenco di tensori lungo una dimensione in un tensore

Comprime un elenco di tensori di rango R values_count in un tensore rango (R+1) .

Comprime i tensori values_count in values in un tensore con rango uno superiore a ciascun tensore in values , comprimendoli lungo la dimensione axis .

Data una lista di tensori di forma (A, B, C) ;

se axis == 0 allora il tensore output avrà la forma (N, A, B, C) . se axis == 1 allora il tensore output avrà la forma (A, N, B, C) . Ecc.

Per esempio:

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

Questo è l'opposto di unpack .

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

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

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

tfl.pad (TFL::PadOp)

Operatore di riempimento

Questa operazione riempie un input con zeri in base ai paddings specificati. paddings è un tensore intero con forma [Dn, 2] , dove n è il rango input . Per ogni dimensione D di input , paddings[D, 0] indica quanti zeri aggiungere prima del contenuto di input in quella dimensione e paddings[D, 1] indica quanti zeri aggiungere dopo il contenuto di input in quella dimensione.

La dimensione riempita di ciascuna dimensione D dell'output è:

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

Per esempio:

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

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

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

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.padv2 (TFL::PadV2Op)

Operatore di riempimento v2

Questa operazione riempie un input in base ai paddings e constant_values specificati. paddings è un tensore intero con forma [Dn, 2] , dove n è il rango input . Per ogni dimensione D di input , paddings[D, 0] indica quanti zeri aggiungere prima del contenuto di input in quella dimensione e paddings[D, 1] indica quanti zeri aggiungere dopo il contenuto di input in quella dimensione. constant_values è un tensore scalare dello stesso tipo di input che indica il valore da utilizzare per il riempimento input .

La dimensione riempita di ciascuna dimensione D dell'output è:

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

Per esempio:

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

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

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

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.poly_call (TFL::PolyCallOp)

Chiamata poli

Avere più corpi di funzione per lo stesso calcolo. Ciò consente al compilatore/interprete del programma di scegliere una delle opzioni disponibili per eseguire il programma in base a quale è più adatta per il backend di destinazione.

input: un elenco di tensori di input i cui tipi sono T. output: un elenco di tensori di output i cui tipi sono T.

chiamata: regioni multiple, ciascuna delle quali incapsula lo stesso calcolo semantico ma in forme diverse.

Caratteristiche: SingleBlockImplicitTerminator<YieldOp> , SingleBlock

Interfacce: RegionBranchOpInterface

Operandi:

Risultati:

tfl.pow (TFL::PowOp)

Operatore di potere

Funzionamento energetico in base agli elementi.

Tratti: ::mlir::OpTrait::TFLRuntimeOpTrait , AlwaysSpeculatableImplTrait , ResultsBroadcastableShape

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.prelu (TFL::PReluOp)

Operatore Relu parametrizzato

Operatore Relu parametrizzato x -> x >= 0 ? x : (alpha * x) dove alpha è un tensore addestrabile. input e alfa dovrebbero avere le stesse dimensioni dell'input o essere trasmettibili.

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

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

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.pseudo_const (TFL::ConstOp)

Pseudoop costante.

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

L'operazione può avere tutti lo stesso tipo di attributi di tf.Const (ad esempio, sono consentiti attributi TF opachi).

Caratteristiche: AlwaysSpeculatableImplTrait , ConstantLike , FirstAttrDerivedResultType , QuantizableResult

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Attributi:

Risultati:

tfl.pseudo_qconst (TFL::QConstOp)

Costante quantizzata pseudo op

Rappresenta un valore costante quantizzato nel dialetto TensorFlow Lite. Questa non è un'operazione effettiva e verrà invece ridotta al buffer. I parametri di quantizzazione vengono memorizzati come attributo di tipo in questa costante.

Caratteristiche: AlwaysSpeculatableImplTrait , FirstAttrDerivedResultType

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Attributi:

Risultati:

tfl.pseudo_sparse_const (TFL::SparseConstOp)

Costante sparsa pseudo op.

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

Caratteristiche: AlwaysSpeculatableImplTrait , FirstAttrDerivedResultType , QuantizableResult

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Attributi:

Risultati:

tfl.pseudo_sparse_qconst (TFL::SparseQConstOp)

Costante quantizzata sparsa pseudo op

Rappresenta un valore costante quantizzato sparso nel dialetto TensorFlow Lite. Questa non è un'operazione effettiva e verrà invece ridotta al buffer. I parametri di quantizzazione vengono memorizzati come attributo di tipo in questa costante.

Caratteristiche: AlwaysSpeculatableImplTrait , FirstAttrDerivedResultType

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Attributi:

Risultati:

tfl.quantize (TFL::QuantizeOp)

Operatore quantizza

Converte tensori a virgola mobile in tensori interi quantizzati in base ai parametri di quantizzazione definiti nell'attributo type.

Caratteristiche: FirstAttrDerivedResultType , SameOperandsAndResultShape

Interfacce: NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

tfl.random_standard_normal (TFL::RandomStandardNormalOp)

Restituisce valori casuali da una distribuzione normale.

I valori generati avranno media 0 e deviazione standard 1.

Interfacce: TflRuntimeVerifyOpInterface

Attributi:

Operandi:

Risultati:

tfl.random_uniform (TFL::RandomUniformOp)

Restituisce valori casuali da una distribuzione uniforme.

I valori generati seguono una distribuzione uniforme nell'intervallo [0, 1) . Il limite inferiore 0 è incluso nell'intervallo, mentre il limite superiore 1 è escluso.

Interfacce: TflRuntimeVerifyOpInterface

Attributi:

Operandi:

Risultati:

tfl.range (TFL::RangeOp)

Operatore di intervallo

Restituisce un tensore 1D definito da una sequenza start al limit con un dato delta .

Tratti: AlwaysSpeculatableImplTrait

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.rank (TFL::RankOp)

Operatore di rango.

Restituisce il rango di un tensore.

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.read_variable (TFL::ReadVariableOp)

Legge il valore della variabile.

Leggere i dati variabili identificati da 'resource_id'.

Interfacce: TflRuntimeVerifyOpInterface

Operandi:

Risultati:

tfl.real (TFL::RealOp)

Restituisce la parte reale di un numero complesso.

Dato un tensore input di numeri complessi, questa operazione restituisce un tensore di tipo float che è la parte reale di ciascun elemento in input . Tutti gli elementi in input devono essere numeri complessi del modulo \(a + bj\), dove a è la parte reale restituita da questa operazione e b è la parte immaginaria.

Caratteristiche: AlwaysSpeculatableImplTrait , SameOperandsAndResultShape

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.reduce_all (TFL::ReduceAllOp)

Calcola la "logica e" degli elementi attraverso le dimensioni di un tensore.

Riduce input lungo le dimensioni indicate axis . A meno che keep_dims non sia vero, il rango del tensore viene ridotto di 1 per ogni voce in axis . Se keep_dims è true, le dimensioni ridotte vengono mantenute con lunghezza 1.

Tratti: AlwaysSpeculatableImplTrait

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

tfl.reduce_any (TFL::ReduceAnyOp)

Calcola l'"or logico" degli elementi attraverso le dimensioni di un tensore.

Riduce input lungo le dimensioni indicate axis . A meno che keep_dims non sia vero, il rango del tensore viene ridotto di 1 per ogni voce in axis . Se keep_dims è true, le dimensioni ridotte vengono mantenute con lunghezza 1.

Tratti: AlwaysSpeculatableImplTrait

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

tfl.reduce_max (TFL::ReduceMaxOp)

Operatore di riduzione massima

Calcola la riduzione massima lungo gli assi specificati

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

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

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

tfl.reduce_min (TFL::RiduciMinOp)

Operatore di riduzione minima

Calcola la riduzione minima lungo gli assi specificati

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

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

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

tfl.reduce_prod (TFL::ReduceProdOp)

Operatore di riduzione della produzione

Calcola il prodotto lungo gli assi specificati

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

tfl.relu (TFL::ReluOp)

Operatore Relu

Operatore Relu per elemento x -> max(0, x)

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.relu6 (TFL::Relu6Op)

Operatore Relu6

Operatore Relu6 a livello di elemento x -> max(0, min(6, x))

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.relu_0_to_1 (TFL::Relu0To1Op)

Operatore Relu0To1

Operatore Relu0To1 a livello di elemento x -> max(0, min(1, x))

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.relu_n1_to_1 (TFL::Relu1Op)

Operatore Relu1

Operatore Relu1 a livello di elemento x -> max(-1, min(1, x))

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.reshape (TFL::ReshapeOp)

Operatore di rimodellamento

Produce un tensore con gli stessi valori ma diversa forma statica definita dal tipo di output.

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

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

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.resize_bilinear (TFL::ResizeBilinearOp)

RidimensionaBilineare Op

size images utilizzando l'interpolazione bilineare.

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

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

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

tfl.resize_nearest_neighbor (TFL::ResizeNearestNeighborOp)

RidimensionaVicinoVicino Op

size images utilizzando l'interpolazione del vicino più vicino.

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

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

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

tfl.reverse_sequence (TFL::ReverseSequenceOp)

Inverte le fette di lunghezza variabile.

Questa operazione suddivide innanzitutto input lungo la dimensione batch_dim e, per ogni sezione i , inverte i primi elementi seq_lengths[i] lungo la dimensione seq_dim .

Gli elementi di seq_lengths devono obbedire seq_lengths[i] <= input.dims[seq_dim] e seq_lengths deve essere un vettore di lunghezza input.dims[batch_dim] .

La fetta di output i lungo la dimensione batch_dim viene quindi data dalla fetta di input i , con le prime fette seq_lengths[i] lungo la dimensione seq_dim invertite.

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

tfl.reverse_v2 (TFL::ReverseV2Op)

Operatore ReverseV2

Inverte le dimensioni specifiche di un tensore.

Dato un tensore e un asse tensore int32/int64 che rappresenta l'insieme di dimensioni del tensore da invertire. Questa operazione inverte ogni dimensione i per la quale esiste j st axis[j] == i.

Argomenti: tensore: Un tensore. Deve essere uno dei tipi seguenti: uint8, int8, int16, int32, int64, float32, bool Fino a 8-D.

asse: un tensore. Deve essere uno dei seguenti tipi: int32, int64. con un solo elemento che è l'indice dell'asse. DA FARE: aggiungi il supporto per più elementi.

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.rfft2d (TFL::RFFT2dOp)

Trasformata di Fourier veloce 2D a valori reali.

Calcola la trasformata discreta di Fourier bidimensionale di un segnale a valori reali sulle due dimensioni più interne input .

Poiché la DFT di un segnale reale è hermitiano-simmetrica, RFFT2D restituisce solo i componenti univoci fft_length / 2 + 1 della FFT per la dimensione più interna output : il termine a frequenza zero, seguito da fft_length / 2 a frequenza positiva termini.

Lungo ciascun asse su cui viene calcolato RFFT2D , se fft_length è inferiore alla dimensione corrispondente di input , la dimensione viene ritagliata. Se è maggiore, la dimensione viene riempita con zeri.

Tratti: AlwaysSpeculatableImplTrait

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.right_shift (TFL::RightShiftOp)

Operatore Shift destro

Elementwise calcola lo spostamento a destra bit per bit di lhs per rhs .

Caratteristiche: AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.round (TFL::RoundOp)

Operatore rotondo

Arrotonda i valori di un tensore all'intero più vicino, in base agli elementi.

Caratteristiche: AlwaysSpeculatableImplTrait , InferTensorType , TF::SameOperandsAndResultTypeResolveRef

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

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.rsqrt (TFL::RsqrtOp)

Operatore reciproco della radice quadrata

Calcola la radice quadrata inversa dell'input per elemento

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.scatter_nd (TFL::ScatterNdOp)

_Scatter e operatore

updates sparsi in un nuovo tensore in base agli indices

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

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

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.segment_sum (TFL::SegmentSumOp)

Operatore SegmentSum

Calcola la somma lungo i segmenti di un tensore.

Tratti: AlwaysSpeculatableImplTrait

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.select (TFL::SelectOp)

Seleziona operatore

Seleziona i valori di "x" se il valore corrispondente di "condizione" è vero o il valore di "y" se falso. Esistono dimensioni di input di condizioni valide:

1. O la stessa forma (nel qual caso la selezione è elementare), oppure
2. la condizione deve essere di grado 1 e corrispondere alla prima dimensione.

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

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

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.select_v2 (TFL::SelectV2Op)

Selezionare l'operatore V2

Seleziona i valori di "x" se il valore corrispondente di "condizione" è vero o il valore di "y" se falso. Esistono dimensioni di input di condizioni valide:

1. O la stessa forma (nel qual caso la selezione è elementare), oppure
2. Forme trasmissibili tra 'condizione', 'x' e 'y'.

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

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

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.shape (TFL::ShapeOp)

Operatore di forma

Restituisce la forma di un tensore.

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

tfl.sign (TFL::SignOp)

Operazione di segno

Restituisce NaN se x è NaN, 0 se x è 0, -1 se x < 0 e 1 se x > 0.

Caratteristiche: AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType , SameOperandsAndResultShape

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.sin (TFL::SinOp)

Operatore seno

Calcola il seno dell'input in base agli elementi

Caratteristiche: AlwaysSpeculatableImplTrait , InferTensorType , TF::SameOperandsAndResultTypeResolveRef

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

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.slice (TFL::SliceOp)

Restituisce una porzione da "input".

Il tensore di output è un tensore con dimensioni descritte da 'size' i cui valori vengono estratti da 'input' a partire dagli offset in 'begin'.

begin è in base zero; size è su base uno. Se dimensione[i] è -1, tutti gli elementi rimanenti nella dimensione i vengono inclusi nella sezione. In altre parole, ciò equivale a impostare: size[i] = input.dim_size(i) - Begin[i]

Requisiti : 0 <= inizio[i] <= inizio[i] + dimensione[i] <= Di for i in [0, n)

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

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

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.softmax (TFL::SoftmaxOp)

Operatore Softmax

Calcola le attivazioni softmax a livello di elemento con la seguente formula

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

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

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

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

tfl.space_to_batch_nd (TFL::SpaceToBatchNdOp)

Operatore SpaceToBatchNd

Questa operazione rimodella le dimensioni dello spazio nella dimensione "batch" 0

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

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

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.space_to_depth (TFL::SpaceToDepthOp)

Operatore SpazioToProfondità

Riorganizza i blocchi di dati spaziali, in profondità. Più specificamente, questa operazione restituisce una copia del tensore di input in cui i valori dalle dimensioni height e width vengono spostati nella dimensione depth . block_size indica la dimensione del blocco di input.

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

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

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

tfl.sparse_to_dense (TFL::SparseToDenseOp)

Converte una rappresentazione sparsa in un tensore denso.

Costruisce un array dense di forma output_shape in modo tale che

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

Tutti gli altri valori in dense sono impostati su default_value . Se sparse_values ​​è uno scalare, tutti gli indici sparsi sono impostati su questo singolo valore.

Gli indici devono essere ordinati in ordine lessicografico e non devono contenere ripetizioni. Se validate_indices è true, queste proprietà vengono controllate durante l'esecuzione.

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.split (TFL::SplitOp)

Divide un tensore in tensori num_split lungo una dimensione.

Divide il tensore value lungo split_dim in un numero di sottotensori con la stessa forma di quello originale, ad eccezione di split_dim . Uguale a tf.Split.

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

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

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

tfl.split_v (TFL::SplitVOp)

Divide un tensore in tensori num_split lungo una dimensione.

Divide il tensore value lungo split_dim in un numero di sottotensori con la stessa forma di quello originale, ad eccezione di split_dim . Il raggruppamento dei subtensori risultanti è deciso dalla size-splits . Uguale a tf.SplitV.

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

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

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

tfl.sqrt (TFL::SqrtOp)

Operatore radice quadrata

Calcola la radice quadrata dell'input in base agli elementi

Caratteristiche: AlwaysSpeculatableImplTrait , InferTensorType , TF::SameOperandsAndResultTypeResolveRef

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

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.square (TFL::SquareOp)

Operatore quadrato

Calcola il quadrato dell'input in base agli elementi

Caratteristiche: AlwaysSpeculatableImplTrait , InferTensorType , TF::SameOperandsAndResultTypeResolveRef

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

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.squared_difference (TFL::SquaredDifferenceOp)

Operatore differenza quadrata

Operazione sulla differenza quadrata degli elementi.

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

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.squeeze (TFL::SqueezeOp)

Rimuove le dimensioni di dimensione 1 dalla forma di un tensore.

Dato un input tensore, questa operazione restituisce un tensore dello stesso tipo con tutte le dimensioni di dimensione 1 rimosse. Se non desideri rimuovere tutte le dimensioni di dimensione 1, puoi rimuovere dimensioni di dimensione 1 specifiche specificando squeeze_dims .

Per esempio:

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

Oppure, per rimuovere dimensioni specifiche della dimensione 1:

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

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

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

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

tfl.strided_slice (TFL::StridedSliceOp)

Fetta Strided Op

Restituisce una sezione striata input .

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

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

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

tfl.sub (TFL::SubOp)

Operatore di sottrazione

Operazione di sottrazione per elemento.

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

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

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

tfl.sum (TFL::SumOp)

Operatore somma

Calcola la riduzione della somma lungo gli assi specificati

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

tfl.svdf (TFL::SVDFOp)

Operatore del filtro di scomposizione a valore singolo

L'operazione SVDF è una scomposizione di un'operazione densamente connessa in filtri di basso rango. Per dettagli: https://research.google.com/pubs/pub43813.html https://arxiv.org/abs/1812.02802

Caratteristiche: QuantizableResult , quant::AccumulatorUniformScale<3, 2, 4>

Interfacce: DynamicRangeQuantizedOpInterface , TFL_StatefulOp , TflRuntimeVerifyOpInterface

Attributi:

Operandi:

Risultati:

tfl.tanh (TFL::TanhOp)

Operatore tangente iperbolica

Calcola la tangente iperbolica dell'input per elemento

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

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

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.tile (TFL::TileOp)

Operatore di piastrelle.

Costruisce un tensore affiancando un dato tensore.

Questa operazione crea un nuovo tensore replicando l'input più volte. L'i-esima dimensione del tensore di output ha elementi input.dims(i) * multipli[i] e i valori di input vengono replicati multipli[i] volte lungo l'i-esima dimensione. Ad esempio, affiancando [abcd] con [2] si ottiene [abcdabcd].

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

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

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.topk_v2 (TFL::TopKV2Op)

Operatore TopK

Restituisce l'elemento più grande k in alto lungo ciascuna ultima fetta dimensionale input e gli indici dei valori all'interno dell'ultima dimensione del tensore di input.

I risultati vengono sempre ordinati in ordine decrescente.

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

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

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.transpose (TFL::TransposeOp)

Operatore di trasposizione

Restituisce la trasposizione di x

Caratteristiche: AlwaysSpeculatableImplTrait , QuantizableResult

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

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

tfl.transpose_conv (TFL::TransposeConvOp)

Operatore di convoluzione trasposta

Esegue l'operazione di trasposizione della convoluzione sull'input.

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

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

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi: