`tfl` Dialekt

Dialekt TensorFlow Lite.

Ten dialekt jest mapowany na operacje TensorFlow Lite.

Niezmienniki:

• Wszystkie wartości są typu Tensor (w szczególności skalary są reprezentowane za pomocą tensorów zerowymiarowych);

Operacje

tfl.abs (TFL::AbsOp)

Operator wartości bezwzględnej

Biorąc pod uwagę tensor x , operacja ta zwraca tensor zawierający wartość bezwzględną każdego elementu w x . Na przykład, jeśli x jest elementem wejściowym, a y jest elementem wyjściowym, ta operacja jest obliczana \(y = |x|\).

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.add (TFL::AddOp)

Operator dodawania

Operacja dodawania elementowego.

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

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.add_n (TFL::AddNOp)

_Dodaj operator n

Dodaje wszystkie tensory wejściowe elementarnie.

Cechy: AlwaysSpeculatableImplTrait , Commutative

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

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.arg_max (TFL::ArgMaxOp)

Operator ArgMax

Zwraca indeks o największej wartości spośród wszystkich wymiarów tensora.

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.arg_min (TFL::ArgMinOp)

Operator ArgMin

Zwraca indeks o najmniejszej wartości spośród wymiarów tensora. a = [1, 10, 26,9, 2,8, 166,32, 62,3] b = tf.math.argmin(input = a) c = tf.keras.backend.eval(b)

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.assign_variable (TFL::AssignVariableOp)

Przypisuje nową wartość do zmiennej.

Każda operacja ReadVariableOp z zależnością kontrolną od tej operacji gwarantuje zwrócenie tej wartości lub kolejnej, nowszej wartości zmiennej.

Interfejsy: TflRuntimeVerifyOpInterface

Operandy:

tfl.atan2 (TFL::Atan2Op)

Operacja Atan2

Operacja „atan2” oblicza arcus tangens y/x elementowo, uwzględniając znaki argumentów.

Cechy: AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType , SameOperandsAndResultShape

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.average_pool_2d (TFL::AveragePool2DOp)

_Średni_pula Operator 2d

Wykonuje operację uśredniania puli na wejściu.

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.basic_lstm (TFL::BasicLSTMop)

Podstawowy operator lstm

podstawowy operator komórkowy LSTM.

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.batch_matmul (TFL::BatchMatMulOp)

Operator mnożenia macierzy wsadowej

Wykonuje wsadowe mnożenie macierzy na wejściach. Jest zgodny z konwencjami TensorFlow BatchMatMulV2, z obsługą nieznanych wymiarów w wymiarach wsadowych i transmisji.

Inputs:
  `inputs[0]`: required: input LHS
  `inputs[1]`: required: input RHS
  `adjoint_lhs`: optional: Transpose LHS (default false)
  `adjoint_rhs`: optional: Transpose RHS (default false)

Cechy: ::mlir::OpTrait::TFLRuntimeOpTrait , AlwaysSpeculatableImplTrait , QuantizableResult

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.batch_to_space_nd (TFL::BatchToSpaceNdOp)

Operator BatchToSpaceNd

Ta operacja przekształca wymiar „wsadowy” 0 w wymiary przestrzenne.

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

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

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.bidirectional_sequence_lstm (TFL::BidirectionSequenceLSTMop)

Dwukierunkowy operator lstm sekwencji

Dwukierunkowy lstm to zasadniczo dwa lstm, jeden biegnący do przodu, a drugi biegnący do tyłu. Wynikiem jest połączenie dwóch lstm.

Cechy: QuantizableResult

Interfejsy: DynamicRangeQuantizedOpInterface , TFL_StatefulOp , TflRuntimeVerifyOpInterface

Atrybuty:

Operandy:

Wyniki:

tfl.bitcast (TFL::BitcastOp)

Operator transmisji bitowej

Przesyła bitcast tensora z jednego typu na inny.

Cechy: AlwaysSpeculatableImplTrait

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.bitwise_xor (TFL::BitwiseXorOp)

Bitowy operator Xor

Elementwise oblicza bitowy XOR lhs i rhs .

Cechy: AlwaysSpeculatableImplTrait , Commutative , ResultsBroadcastableShape , SameOperandsAndResultElementType

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.broadcast_args (TFL::BroadcastArgsOp)

Zwróć kształt s0 op s1 za pomocą transmisji.

Mając s0 i s1 , tensory reprezentujące kształty, obliczamy r0 , emitowany kształt. Wszystkie s0 , s1 i r0 są wektorami całkowitymi.

Cechy: AlwaysSpeculatableImplTrait

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.broadcast_to (TFL::BroadcastToOp)

Rozgłaszaj tablicę dla zgodnego kształtu.

Rozgłaszanie to proces tworzenia tablic, które mają kształty zgodne z operacjami arytmetycznymi. Dwa kształty są zgodne, jeśli dla każdej pary wymiarów są one równe lub jeden z nich jest jeden. Próba rozgłaszania Tensora do kształtu rozpoczyna się od wymiarów końcowych i przesuwa się dalej.

Na przykład,

x = tf.constant([1, 2, 3]) y = tf.broadcast_to(x, [3, 3]) print(y) tf.Tensor( [[1 2 3] [1 2 3] [1 2 3]], kształt=(3, 3), dtyp=int32)

W powyższym przykładzie wejściowy Tensor o kształcie [1, 3] jest rozgłaszany do Tensora wyjściowego o kształcie [3, 3] .

Podczas wykonywania operacji rozgłaszania, takich jak mnożenie tensora przez skalar, rozgłaszanie (zwykle) zapewnia pewną korzyść czasową lub przestrzenną, ponieważ nadawany tensor nigdy się nie materializuje.

Jednak broadcast_to nie niesie ze sobą żadnych takich korzyści. Nowo utworzony tensor przejmuje pełną pamięć nadawanego kształtu. (Jednak w kontekście wykresu broadcast_to może zostać połączone z kolejnymi operacjami, a następnie zoptymalizowane.)

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.bucketize (TFL::BucketizeOp)

Podział danych wejściowych na podstawie „granic”.

Przykład:

Jeśli wejściami są boundaries = [0, 10, 100] i input = [[-5, 10000][150, 10][5, 100]] , wówczas na wyjściu zostanie output = [[0, 3][3, 2][1, 3]] .

Cechy: AlwaysSpeculatableImplTrait , SameOperandsAndResultShape

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.call_once (TFL::CallOnceOp)

Wywołuje funkcję inicjującą

Ta operacja wywołuje daną funkcję inicjującą dla inicjatora sesji w dialekcie zapisanego modelu tf.

Interfejsy: TflRuntimeVerifyOpInterface

Atrybuty:

tfl.cast (TFL::CastOp)

Operator obsady

Rzutuje dane wejściowe z typu wejściowego na typ wyjściowy.

Cechy: AlwaysSpeculatableImplTrait , SameOperandsAndResultShape

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.ceil (TFL::CeilOp)

Operator sufitu

Zwraca elementową wartość ceil wejścia.

Cechy: AlwaysSpeculatableImplTrait , InferTensorType , TF::SameOperandsAndResultTypeResolveRef

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

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.complex_abs (TFL::ComplexAbsOp)

Oblicza zespoloną wartość bezwzględną tensora.

Biorąc pod uwagę tensor x liczb zespolonych, ta operacja zwraca tensor typu float lub double , który jest wartością bezwzględną każdego elementu w x . Wszystkie elementy w x muszą być liczbami zespolonymi postaci \(a + bj\). Wartość bezwzględną oblicza się jako \( \sqrt{a^2 + b^2}\).

Cechy: AlwaysSpeculatableImplTrait , SameOperandsAndResultShape

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.concatenation (TFL::ConcatenationOp)

Operator konkatenacji

Łączy tensory wzdłuż jednego wymiaru

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.control_node (TFL::ControlNodeOp)

Operacja TFL.control_node zawija operacje na pojedynczym bloku w celu dołączenia krawędzi sterujących.

Służy do zawijania regionów i dołączania do nich zależności sterujących. Zwykle dzieje się to w jednym z ostatnich kroków przed emisją modelu z płaskim buforem, aby umożliwić optymalizacje oparte na ustalonej kolejności operacji (takich jak rematerializacja). Eksporter z płaskim buforem rozpakuje zawinięty region i opatrzy wygenerowany model metadanymi tak, że wszelkie zmiany kolejności w czasie wykonywania będą zgodne z kolejnością podaną przez zależności sterujące.

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

Operandy:

Wyniki:

tfl.conv_2d (TFL::Conv2DOp)

Operator splotu

Wykonuje operację splotu na wejściach.

Wejścia: inputs[0] : wymagane: tensor aktywacji wejścia inputs[1] : wymagane: tensor wagi filtra, inputs[2] : opcjonalnie: tensor polaryzacji

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

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.conv_3d (TFL::Conv3Dop)

Operator splotu 3D

Wykonuje operację splotu na wejściach 3D. Wejścia: inputs[0] : wymagane: tensor aktywacji wejścia inputs[1] : wymagane: tensor wagi filtra, inputs[2] : opcjonalnie: tensor polaryzacji

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

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.conv_3d_transpose (TFL::Conv3DTransposeOp)

Transponowany operator Convolution 3D

Wykonuje transponowaną operację splotu na wejściach 3D. Wejścia: inputs[0] : wymagane: kształt tensora wyjściowego inputs[1] : wymagane: tensor wagi filtra inputs[2] : wymagane: tensor aktywacji wejścia inputs[3] : opcjonalnie: tensor polaryzacji

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

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.cos (TFL::CosOp)

Operator cosinus

Oblicza elementarny cosinus danych wejściowych

Cechy: AlwaysSpeculatableImplTrait , InferTensorType , TF::SameOperandsAndResultTypeResolveRef

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

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.cumsum (TFL::CumsumOp)

Operator Cumsum

Oblicz skumulowaną sumę tensora x wzdłuż osi.

Cechy: AlwaysSpeculatableImplTrait

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.custom (TFL::CustomOp)

Opcja niestandardowa

Ogólna opcja dla dowolnej niestandardowej operacji TFLite.

wejście: lista wejść w oryginalnym op. kod_niestandardowy: Ciąg używany do określenia, która dokładnie jest ta operacja, co odpowiada kodom_operatora.kodowi_niestandardowemu w buforze płaskim. opcja_niestandardowa: uchwyt do zapisywania atrybutów op w formie bajtów. wyjście: Lista wyników w oryginalnym op.

Interfejsy: TflRuntimeVerifyOpInterface

Atrybuty:

Operandy:

Wyniki:

tfl.custom_tf (TFL::CustomTfOp)

Opakowania dla niestandardowych operacji TF.

Operacja otaczająca dowolną niestandardową operację TF. Należą do nich operacje zdefiniowane przy użyciu custom_opdefs lub połączone, które nie są zdefiniowane w dialekcie TF. Ta operacja po prostu otacza niestandardową operację wewnątrz regionu. Uwaga nr 1, ta operacja nie będzie obejmować niestandardowych operacji TF Lite zdefiniowanych za pomocą CustomOp. Uwaga nr 2, ta operacja jest po prostu wewnętrzną reprezentacją wewnątrz konwertera i nie jest eksponowana/eksportowana, gdy model jest eksportowany do Flatbuffer.

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

Interfejsy: InferTypeOpInterface , TflRuntimeVerifyOpInterface

Operandy:

Wyniki:

tfl.densify (TFL::DensifyOp)

Operator zagęszczania

Konwertuje tensor rzadki na format gęsty.

Cechy: AlwaysSpeculatableImplTrait

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.depth_to_space (TFL::DepthToSpaceOp)

Operator DepthToSpace

Przestawia dane z głębi na bloki danych przestrzennych. Jest to odwrotna transformacja SpaceToDepth. Mówiąc dokładniej, ta operacja generuje kopię tensora wejściowego, w którym wartości z wymiaru depth są przenoszone w blokach przestrzennych do wymiarów height i width . Atrybut block_size wskazuje rozmiar bloku wejściowego i sposób przenoszenia danych.

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.depthwise_conv_2d (TFL::DepthwiseConv2DOp)

Operator splotu rozdzielany wgłębnie

Wykonuje operację splotu na wejściach.

Wejścia: inputs[0] : wymagane: tensor aktywacji wejścia inputs[1] : wymagane: tensor wagi filtra, inputs[2] : opcjonalnie: tensor polaryzacji

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

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.dequantize (TFL::DekwantyzacjaOp)

Operator dekwantyzacji

Konwertuje skwantowaną tablicę liczb całkowitych na liczby zmiennoprzecinkowe zgodnie z parametrami kwantyzacji.

Interfejsy: NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.dilate (TFL::DilateOp)

Operator dylatacji

Rozszerza tensor, dodając nowe elementy pomiędzy istniejącymi.

Cechy: AlwaysSpeculatableImplTrait

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.div (TFL::DivOp)

Operator podziału

Operacja dzielenia elementarnego.

Cechy: ::mlir::OpTrait::TFLRuntimeOpTrait , AlwaysSpeculatableImplTrait , ResultsBroadcastableShape

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.dynamic_update_slice (TFL::DynamicUpdateSliceOp)

DynamicUpdateSlice.

Opcja DynamicUpdateSlice, która ma tę samą semantykę co XLA DynamicUpdateSlice. Generuje wynik będący wartością operandu tablicy wejściowej, z nadpisaniem aktualizacji wycinka w start_indices.

Zobacz https://www.tensorflow.org/xla/operative_semantics#dynamicupdateslice

Cechy: AlwaysSpeculatableImplTrait

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.elu (TFL::EluOp)

Operator wykładniczej jednostki liniowej

Oblicza wykładniczą liniową f(x) -> exp(x) - 1 dla x < 0, x dla x >= 0. elementarnie.

Cechy: AlwaysSpeculatableImplTrait , SameOperandsAndResultShape

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.embedding_lookup (TFL::EmbeddingLookupOp)

Osadzanie operatora wyszukiwania

Wyszukuje identyfikatory na liście tensorów osadzania.

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

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

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.equal (TFL::EqualOp)

Operator równości

Zwraca element prawdy x == y elementowo

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

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.exp (TFL::ExpOp)

Naturalny operator potęgowania

Wykonuje na wejściu elementarną operację naturalnego potęgowania.

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.expand_dims (TFL::ExpandDimsOp)

Wstawia wymiar 1 do kształtu tensora.

Mając input tensora, operacja ta wstawia wymiar 1 na axis indeksu wymiaru kształtu danych input . axis indeksu wymiaru zaczyna się od zera; jeśli określisz liczbę ujemną dla axis będzie ona liczona wstecz od końca.

Ta operacja jest przydatna, jeśli chcesz dodać wymiar wsadowy do pojedynczego elementu. Na przykład, jeśli masz pojedynczy obraz kształtu [height, width, channels] , możesz utworzyć z niego partię 1 obrazu za pomocą expand_dims(image, 0) , która utworzy kształt [1, height, width, channels] .

Inne przykłady:

# 't' is a tensor of shape [2]
shape(expand_dims(t, 0)) ==> [1, 2]
shape(expand_dims(t, 1)) ==> [2, 1]
shape(expand_dims(t, -1)) ==> [2, 1]

# 't2' is a tensor of shape [2, 3, 5]
shape(expand_dims(t2, 0)) ==> [1, 2, 3, 5]
shape(expand_dims(t2, 2)) ==> [2, 3, 1, 5]
shape(expand_dims(t2, 3)) ==> [2, 3, 5, 1]

Ta operacja wymaga, aby:

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

Ta operacja jest powiązana z squeeze() , która usuwa wymiary o rozmiarze 1.

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

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

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.external_const (TFL::ExternalConstOp)

Zewnętrzna stała op.

Zewnętrzna operacja const przechowuje buffer_index , który wskazuje stałą w buforze płaskim.

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Atrybuty:

Wyniki:

tfl.fake_quant (TFL::FakeQuantOp)

Operator FakeQuant

Fałszywie kwantyzuj tensor „wejściowy” typu float za pomocą skalarów zmiennoprzecinkowych min i max do tensora „wyjściowego” o tym samym kształcie co dane wejściowe.

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.fill (TFL::FillOp)

Wypełnij tensor podaną wartością.

Wypełnij tensor podaną wartością.

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

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

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.floor (TFL::FloorOp)

Operator piętra

Zwraca elementową wartość minimalną danych wejściowych.

Cechy: AlwaysSpeculatableImplTrait , InferTensorType , TF::SameOperandsAndResultTypeResolveRef

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

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.floor_div (TFL::FloorDivOp)

Operator div piętra

Operacja div podłogowa oparta na elementach.

Cechy: ::mlir::OpTrait::TFLRuntimeOpTrait , AlwaysSpeculatableImplTrait , ResultsBroadcastableShape

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.floor_mod (TFL::FloorModOp)

Przypomnienie o podziale

Operacja przypomnienia o dzieleniu elementowym.

Cechy: ::mlir::OpTrait::TFLRuntimeOpTrait , AlwaysSpeculatableImplTrait , ResultsBroadcastableShape

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.fully_connected (TFL::FullyConnectedOp)

W pełni podłączony op

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

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.gather (TFL::GatherOp)

Zbierz operatora

Zbierz wycinki z axis osi params zgodnie z indices .

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.gather_nd (TFL::GatherNdOp)

_Zbierz operator

Zbierz wycinki z params do Tensora o kształcie określonym przez indices .

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

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

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.gelu (TFL::GeluOp)

Funkcja aktywacji GELU.

Oblicza funkcję aktywacji GELU według elementów.

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.greater (TFL::WiększyOp)

Większy operator

Lepsze działanie pod względem elementów.

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

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.greater_equal (TFL::GreaterEqualOp)

_Większy operator równości

Operacja „większa_równa” na elementach.

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

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.hard_swish (TFL::HardSwishOp)

Funkcja aktywacji Hardswish.

Oblicza funkcję aktywacji twardego ruchu f(x) -> (x * relu6(x+3))/6 według elementu.

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.hashtable (TFL::HashtableOp)

Tworzy niezainicjowaną tabelę skrótów.

Ta operacja tworzy tabelę mieszającą, określając typ jej kluczy i wartości. Przed użyciem tabeli należy ją zainicjować. Po inicjalizacji tabela będzie niezmienna.

Interfejsy: TflRuntimeVerifyOpInterface

Atrybuty:

Wyniki:

tfl.hashtable_find (TFL::HashtableFindOp)

Wyszukuje klucze w tabeli i wyświetla odpowiednie wartości.

keys tensorowe muszą być tego samego typu co klucze tabeli. values wyjściowe są typu wartości tabelarycznych.

Skalarna default_value to wartość wyjściowa dla kluczy, których nie ma w tabeli. Musi być również tego samego typu co wartości w tabeli.

Interfejsy: TflRuntimeVerifyOpInterface

Operandy:

Wyniki:

tfl.hashtable_import (TFL::HashtableImportOp)

Zastępuje zawartość tabeli określonymi kluczami i wartościami.

keys tensorowe muszą być tego samego typu co klucze tabeli. values tensora muszą być typu wartości tabeli.

Interfejsy: TflRuntimeVerifyOpInterface

Operandy:

tfl.hashtable_size (TFL::HashtableSizeOp)

Oblicza liczbę elementów w podanej tabeli.

Interfejsy: TflRuntimeVerifyOpInterface

Operandy:

Wyniki:

tfl.if (TFL::IfOp)

Operacja „jeśli-to-inaczej”.

Operacja tfl.if reprezentuje konstrukcję if-then-else służącą do warunkowego wykonania dwóch regionów kodu. Operand operacji if jest wartością logiczną. Na przykład:

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

tfl.if może również zwracać wyniki zdefiniowane w jego regionach. Zdefiniowane wartości są określane na podstawie ścieżki wykonania.

Przykład:

%x, %y = tfl.if %b -> (tensor<f32>, tensor<f32>) {
  %x_true = ...
  %y_true = ...
  tfl.yield %x_true, %y_true : tensor<f32>, tensor<f32>
} else {
  %x_false = ...
  %y_false = ...
  tfl.yield %x_false, %y_false : tensor<f32>, tensor<f32>
}

Regiony tfl.if są zawsze zakończone ciągiem „tfl.yield”. Jeśli „tfl.if” nie definiuje żadnych wartości, „tfl.yield” można pominąć i zostanie ono wstawione domyślnie. W przeciwnym razie musi to być wyraźne. Ponadto, jeśli „tfl.if” definiuje jedną lub więcej wartości, nie można pominąć bloku „else”.

Przykład:

tfl.if %b  {
  ...
}

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

Interfejsy: RegionBranchOpInterface , TflRuntimeVerifyOpInterface

Operandy:

Wyniki:

tfl.imag (TFL::ImagOp)

Zwraca część urojoną liczby zespolonej.

Mając na input tensor liczb zespolonych, operacja ta zwraca tensor typu float , który jest częścią urojoną każdego elementu na input . Wszystkie elementy na input muszą być liczbami zespolonymi postaci \(a + bj\), gdzie a jest częścią rzeczywistą, a b jest częścią urojoną zwracaną przez tę operację.

Cechy: AlwaysSpeculatableImplTrait , SameOperandsAndResultShape

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.l2_normalization (TFL::L2NormalizationOp)

Operator normalizacji L2

L2Normalizacja op

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.leaky_relu (TFL::LeakyReluOp)

Nieszczelny operator Relu

Elementarny operator Leaky ReLU x -> x >= 0? x : (alfa * x)

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.less (TFL::LessOp)

Mniej operatora

Elementarnie mniej operacji.

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

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.less_equal (TFL::LessEqualOp)

_Mniejszy operator równości

Elementowa operacja less_equal.

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

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.local_response_normalization (TFL::LocalResponseNormalizationOp)

Normalizacja odpowiedzi lokalnej.

Tensor input 4-D jest traktowany jako tablica 3-D wektorów 1-D (wzdłuż ostatniego wymiaru), a każdy wektor jest normalizowany niezależnie. W obrębie danego wektora każdy składnik jest dzielony przez ważoną kwadratową sumę danych wejściowych w promieniu depth_radius . Szczegółowo,

sqr_sum[a, b, c, d] =
    sum(input[a, b, c, d - depth_radius : d + depth_radius + 1] ** 2)
output = input / (bias + alpha * sqr_sum) ** beta

Aby uzyskać szczegółowe informacje, zobacz Krizhevsky i in., Klasyfikacja ImageNet z głębokimi splotowymi sieciami neuronowymi (NIPS 2012) .

Cechy: AlwaysSpeculatableImplTrait , InferTensorType , TF::SameOperandsAndResultTypeResolveRef

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.log (TFL::LogOp)

Operator logarytmu naturalnego

Wykonuje na wejściu elementarną operację logarytmu naturalnego.

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.log_softmax (TFL::LogSoftmaxOp)

Zaloguj operatora softmax

Oblicza elementarne aktywacje softmax za pomocą następującego wzoru

wejście - log(reduce_sum(exp(input), dim))

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

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

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.logical_and (TFL::LogicalAndOp)

Operator logiczny AND

Elementowa logiczna operacja AND.

Cechy: AlwaysSpeculatableImplTrait , ResultsBroadcastableShape

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.logical_not (TFL::LogicalNotOp)

Operator logiczny NOT

Elementarna logiczna operacja NOT.

Cechy: AlwaysSpeculatableImplTrait , SameOperandsAndResultShape

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.logical_or (TFL::LogicalOrOp)

Operator logiczny OR

Elementowa logiczna operacja OR.

Cechy: AlwaysSpeculatableImplTrait , ResultsBroadcastableShape

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.logistic (TFL::LogisticOp)

Operator logistyczny

Oblicza elementarną sigmoidę danych wejściowych

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

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

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.lstm (TFL::LSTMop)

Pełny operator lstm

Warstwa sieci rekurencyjnej długiej jednostki pamięci krótkotrwałej (LSTM). Domyślna implementacja bez wizjera oparta jest na: http://deeplearning.cs.cmu.edu/pdfs/Hochreiter97_lstm.pdf S. Hochreitera i J. Schmidhubera. „Długa pamięć krótkotrwała”. Neural Computation, 9(8):1735-1780, 1997. Implementacja wizjera opiera się na: https://research.google.com/pubs/archive/43905.pdf Hasim Sak, Andrew Senior i Francoise Beaufays. „Architektury sieci neuronowych rekurencyjnych z pamięcią długoterminową do modelowania akustycznego na dużą skalę”. INTERSPEECH, 2014. Sprzężenie bramki wejściowej i zapominającej (CIFG) opiera się na: http://arxiv.org/pdf/1503.04069.pdf Greff et al. „LSTM: Odyseja kosmiczna poszukiwań” Normalizacja warstw opiera się na: https://arxiv.org/pdf/1607.06450.pdf Ba et al. „Normalizacja warstw”

Cechy: QuantizableResult

Interfejsy: DynamicRangeQuantizedOpInterface , TFL_StatefulOp , TflRuntimeVerifyOpInterface

Atrybuty:

Operandy:

Wyniki:

tfl.matrix_diag (TFL::MatrixDiagOp)

Zwraca tensor z podaną przekątną i wszystko inne dopełnione zerami.

Biorąc pod uwagę przekątną, zwraca tensor z przekątną i wszystko inne dopełnione zerami. Załóżmy, że przekątna ma k wymiarów [I, J, K, ..., N] , wówczas wynikiem jest tensor rzędu k+1 o wymiarach [I, J, K, ..., N, N] gdzie: output[i, j, k, ..., m, n] = 1{m=n} * diagonal[i, j, k, ..., n].

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.matrix_set_diag (TFL::MatrixSetDiagOp)

Zwraca tensor macierzy wsadowej z nowymi wsadowymi wartościami przekątnej.

Biorąc pod uwagę input i diagonal , operacja ta zwraca tensor o tym samym kształcie i wartościach co input , z wyjątkiem głównej przekątnej najbardziej wewnętrznych macierzy. Zostaną one nadpisane przez wartości w diagonal .

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.max_pool_2d (TFL::MaxPool2DOp)

Max Pool 2D op

Wykonuje na wejściu maksymalną pulę 2D.

Wejścia: inputs[0] : wymagane: tensor wejściowy

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.maximum (TFL::MaximumOp)

Maksymalny operator

Maksymalne działanie według elementów.

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

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

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.mean (TFL::MeanOp)

Średni operator

Oblicza średnią elementów w wymiarach tensora. Zmniejsza tensor wejściowy wzdłuż wymiarów podanych na osi. O ile keepdims nie ma wartości true, stopień tensora jest zmniejszany o 1 dla każdego wpisu w osi. Jeśli opcja keepdim ma wartość true, zmniejszone wymiary zostaną zachowane z długością 1.

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.minimum (TFL::MinimumOp)

Minimalny operator

Minimalna operacja elementarna.

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

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

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.mirror_pad (TFL::MirrorPadOp)

Operator MirrorPada. Wypełnia tensor wartościami lustrzanymi.

Ta operacja wypełnia dane wejściowe wartościami lustrzanymi zgodnie z określonymi dopełnieniami. paddings to tensor liczb całkowitych o kształcie [n, 2], gdzie n jest stopniem wejścia. Dla każdego wymiaru D danych wejściowych dopełnienia[D, 0] wskazują, ile wartości należy dodać przed zawartością danych wejściowych w tym wymiarze, a dopełnienia[D, 1] wskazują, ile wartości należy dodać po zawartości danych wejściowych w tym wymiarze.

Zarówno paddings[D, 0], jak i paddings[D, 1] nie mogą być większe niż input.dim_size(D) (lub input.dim_size(D) - 1), jeśli copy_border ma wartość true (jeśli odpowiednio false).

Wyściełany rozmiar każdego wymiaru D wyniku to:

dopełnienia(D, 0) + input.dim_size(D) + dopełnienia(D, 1)

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.mul (TFL::MulOp)

Operator mnożenia

Operacja mnożenia elementarnego.

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

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.multinomial (TFL::MultinomialOp)

Rysuje próbki z rozkładu kategorycznego.

Wygenerowane wartości będą miały rozkład kategoryczny oparty na logits lub nieznormalizowanych logarytmicznych prawdopodobieństwach podanych dla wszystkich klas.

Interfejsy: TflRuntimeVerifyOpInterface

Atrybuty:

Operandy:

Wyniki:

tfl.neg (TFL::NegOp)

Operator negacji

Oblicza elementarną negację danych wejściowych

Cechy: AlwaysSpeculatableImplTrait , InferTensorType , TF::SameOperandsAndResultTypeResolveRef

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

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.no_value (TFL::NoValueOp)

Stała reprezentująca brak wartości.

Brak stałej wartości op.

Cechy: AlwaysSpeculatableImplTrait , ConstantLike

Interfejsy: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efekty: MemoryEffects::Effect{}

Atrybuty:

Wyniki:

tfl.non_max_suppression_v4 (TFL::NonMaxSuppressionV4Op)

Chciwie wybiera podzbiór obwiedni w malejącej kolejności punktów,

przycinanie skrzynek, które mają wysoki współczynnik przecięcia nad związkiem (IOU), nakładają się na wcześniej wybrane pola. Ramki ograniczające z wynikiem mniejszym niż score_threshold są usuwane. Ramki ograniczające są dostarczane jako [y1, x1, y2, x2], gdzie (y1, x1) i (y2, x2) są współrzędnymi dowolnej pary przekątnych narożników prostokątów, a współrzędne mogą być podane jako znormalizowane (tzn. leżące w przedział [0, 1]) lub bezwzględny. Należy zauważyć, że ten algorytm jest niezależny od tego, gdzie początek znajduje się w układzie współrzędnych i, bardziej ogólnie, jest niezmienny w stosunku do transformacji ortogonalnych i translacji układu współrzędnych; w ten sposób tłumaczenie lub odbicia układu współrzędnych powodują, że algorytm wybiera te same pola. Wynikiem tej operacji jest zbiór liczb całkowitych indeksowanych w zbiorze wejściowym ramek ograniczających reprezentujących wybrane ramki. Współrzędne ramki ograniczającej odpowiadające wybranym indeksom można następnie uzyskać za pomocą tf.gather operation . Na przykład: wybrane_indices = tf.image.non_max_suppression_v2(boxy, scores, max_output_size, iou_threshold, score_threshold) wybrane_boxy = tf.gather(boxes, wybrane_indices)

Cechy: AlwaysSpeculatableImplTrait

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.non_max_suppression_v5 (TFL::NonMaxSuppressionV5Op)

Chciwie wybiera podzbiór obwiedni w malejącej kolejności punktów,

przycinanie skrzynek, które mają wysoki współczynnik przecięcia nad związkiem (IOU), nakładają się na wcześniej wybrane pola. Ramki ograniczające z wynikiem mniejszym niż score_threshold są usuwane. Ramki ograniczające są dostarczane jako [y1, x1, y2, x2], gdzie (y1, x1) i (y2, x2) są współrzędnymi dowolnej pary przekątnych narożników prostokątów, a współrzędne mogą być podane jako znormalizowane (tzn. leżące w przedział [0, 1]) lub bezwzględny. Należy zauważyć, że ten algorytm jest niezależny od tego, gdzie początek znajduje się w układzie współrzędnych i, bardziej ogólnie, jest niezmienny w stosunku do transformacji ortogonalnych i translacji układu współrzędnych; w ten sposób tłumaczenie lub odbicia układu współrzędnych powodują, że algorytm wybiera te same pola. Wynikiem tej operacji jest zbiór liczb całkowitych indeksowanych w zbiorze wejściowym ramek ograniczających reprezentujących wybrane ramki. Współrzędne ramki ograniczającej odpowiadające wybranym indeksom można następnie uzyskać za pomocą tf.gather operation . Na przykład: wybrane_indices = tf.image.non_max_suppression_v2(boxs, scores, max_output_size, iou_threshold, score_threshold) wybrane_boxes = tf.gather(boxes, wybrane_indices) Ta opcja obsługuje również tryb Soft-NMS (z ważeniem Gaussa) (por. Bodla i in. , https://arxiv.org/abs/1704.04503 ), gdzie pola zmniejszają wynik innych nakładających się pól, zamiast bezpośrednio powodować ich przycinanie. Aby włączyć ten tryb Soft-NMS, ustaw parametr soft_nms_sigma na większy niż 0.

Cechy: AlwaysSpeculatableImplTrait

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.not_equal (TFL::NotEqualOp)

_Nie równy operator

Elementowa operacja not_equal.

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

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.NumericVerify (TFL::NumericVerifyOp)

Weryfikuje wartości liczbowe dwóch operandów

Operacja NumericVerify to opcja debugowania służąca do weryfikacji wartości liczbowych dwóch aktywacji. Jest to niestandardowa opcja w TFLite. Jeśli log_if_failed ma wartość true, operacja NumericVerify oblicza statystyki dotyczące różnic między aktywacjami zmiennoprzecinkowymi i skwantowanymi, dzienniki wyjściowe, ustawia różnice w tensorach wyjściowych i zgłasza błąd, jeśli istnieją błędy przekraczające tolerancję. Jeśli log_if_failed = false, to nie przejmuje się błędami.

Cechy: QuantizableResult , SameOperandsShape

Interfejsy: TflRuntimeVerifyOpInterface

Atrybuty:

Operandy:

Wyniki:

tfl.one_hot (TFL::OneHotOp)

Operator OneHot

Zwraca tensor jednego gorącego. Lokalizacje reprezentowane przez indeksy w indices przyjmują wartość on_value , podczas gdy wszystkie inne lokalizacje przyjmują wartość off_value .

Jeśli indices wejściowe mają rangę N , wyjście będzie miało rangę N+1 . Nowa oś tworzona jest na axis wymiaru (domyślnie: nowa oś jest dodawana na końcu).

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.pack (TFL::PackOp)

Pakuje listę tensorów wzdłuż wymiaru do jednego tensora

Pakuje listę values_count tensorów rangi R do jednego tensora rangi (R+1) .

Pakuje tensory values_count w values do tensora o randze o jeden wyższej niż każdy tensor w values , pakując je wzdłuż wymiaru axis .

Biorąc pod uwagę listę tensorów kształtu (A, B, C) ;

jeśli axis == 0 to tensor output będzie miał postać (N, A, B, C) . jeśli axis == 1 to tensor output będzie miał postać (A, N, B, C) . Itp.

Na przykład:

# 'x' is [1, 4]
# 'y' is [2, 5]
# 'z' is [3, 6]
pack([x, y, z]) => [[1, 4], [2, 5], [3, 6]]  # Pack along first dim.
pack([x, y, z], axis=1) => [[1, 2, 3], [4, 5, 6]]

Jest to przeciwieństwo unpack .

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.pad (TFL::PadOp)

Operator dopełniający

Ta operacja uzupełnia dane input zerami zgodnie z określonymi paddings . paddings to tensor liczb całkowitych o kształcie [Dn, 2] , gdzie n jest stopniem input . Dla każdego wymiaru D danych input paddings[D, 0] wskazuje, ile zer należy dodać przed zawartością danych input w tym wymiarze, a paddings[D, 1] wskazuje, ile zer należy dodać po zawartości danych input w tym wymiarze.

Wyściełany rozmiar każdego wymiaru D wyniku to:

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

Na przykład:

# 't' is [[1, 1], [2, 2]]
# 'paddings' is [[1, 1], [2, 2]]
# rank of 't' is 2
pad(t, paddings) ==> [[0, 0, 0, 0, 0, 0]
                      [0, 0, 1, 1, 0, 0]
                      [0, 0, 2, 2, 0, 0]
                      [0, 0, 0, 0, 0, 0]]

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

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

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.padv2 (TFL::PadV2Op)

Operator dopełniania v2

Ta operacja uzupełnia dane input zgodnie z określonymi paddings i constant_values . paddings to tensor liczb całkowitych o kształcie [Dn, 2] , gdzie n jest stopniem input . Dla każdego wymiaru D danych input paddings[D, 0] wskazuje, ile zer należy dodać przed zawartością danych input w tym wymiarze, a paddings[D, 1] wskazuje, ile zer należy dodać po zawartości danych input w tym wymiarze. constant_values ​​to tensor skalarny tego samego typu co input , który wskazuje wartość, która ma zostać użyta do input wejściowych.

Wyściełany rozmiar każdego wymiaru D wyniku to:

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

Na przykład:

# 't' is [[1, 1], [2, 2]]
# 'paddings' is [[1, 1], [2, 2]]
# rank of 't' is 2
pad(t, paddings) ==> [[0, 0, 0, 0, 0, 0]
                      [0, 0, 1, 1, 0, 0]
                      [0, 0, 2, 2, 0, 0]
                      [0, 0, 0, 0, 0, 0]]

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

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

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.poly_call (TFL::PolyCallOp)

Połączenie poli

Mieć wiele ciał funkcji dla tego samego obliczenia. Pozwala to kompilatorowi/interpreterowi programu wybrać jedną z dostępnych opcji wykonania programu, w oparciu o tę, która jest najbardziej odpowiednia dla docelowego backendu.

wejście: lista tensorów wejściowych, których typy to T. wyjście: lista tensorów wyjściowych, których typy to T.

wywołanie: wiele regionów, z których każdy zawiera te same obliczenia semantyczne, ale w różnych formach.

Cechy: SingleBlockImplicitTerminator<YieldOp> , SingleBlock

Interfejsy: RegionBranchOpInterface

Operandy:

Wyniki:

tfl.pow (TFL::PowOp)

Operator mocy

Elementarne działanie mocy.

Cechy: ::mlir::OpTrait::TFLRuntimeOpTrait , AlwaysSpeculatableImplTrait , ResultsBroadcastableShape

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.prelu (TFL::PReluOp)

Sparametryzowany operator Relu

Sparametryzowany operator Relu x -> x >= 0 ? x : (alfa * x) gdzie alfa jest tensorem, który można trenować. input i alfa powinny mieć ten sam rozmiar co input lub nadawać się do transmisji.

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

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

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.pseudo_const (TFL::ConstOp)

Stała pseudoop.

Reprezentuje stałą wartość w dialekcie TensorFlow Lite. To nie jest rzeczywista operacja i zamiast tego zostanie obniżona do bufora.

Op może mieć ten sam typ atrybutów co tf.Const (np. dozwolone są nieprzezroczyste atrybuty TF).

Cechy: AlwaysSpeculatableImplTrait , ConstantLike , FirstAttrDerivedResultType , QuantizableResult

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Atrybuty:

Wyniki:

tfl.pseudo_qconst (TFL::QConstOp)

Kwantowana stała pseudo op

Reprezentuje skwantyzowaną stałą wartość w dialekcie TensorFlow Lite. To nie jest rzeczywista operacja i zamiast tego zostanie obniżona do bufora. Parametry kwantyzacji są przechowywane jako atrybut typu w tej stałej.

Cechy: AlwaysSpeculatableImplTrait , FirstAttrDerivedResultType

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Efekty: MemoryEffects::Effect{}

Atrybuty:

Wyniki:

tfl.pseudo_sparse_const (TFL::SparseConstOp)

Rzadka stała pseudo op.

Reprezentuje rzadką stałą wartość w dialekcie TensorFlow Lite. To nie jest rzeczywista operacja i zamiast tego zostanie obniżona do bufora.

Cechy: AlwaysSpeculatableImplTrait , FirstAttrDerivedResultType , QuantizableResult

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Atrybuty:

Wyniki:

tfl.pseudo_sparse_qconst (TFL::SparseQConstOp)

Rzadka skwantowana stała pseudo op

Reprezentuje rzadką skwantowaną stałą wartość w dialekcie TensorFlow Lite. To nie jest rzeczywista operacja i zamiast tego zostanie obniżona do bufora. Parametry kwantyzacji są przechowywane jako atrybut typu w tej stałej.

Cechy: AlwaysSpeculatableImplTrait , FirstAttrDerivedResultType

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Atrybuty:

Wyniki:

tfl.quantize (TFL::QuantizeOp)

Operator kwantyzacji

Konwertuje tensory zmiennoprzecinkowe na skwantowane tensory całkowite zgodnie z parametrami kwantyzacji zdefiniowanymi w atrybucie type.

Cechy: FirstAttrDerivedResultType , SameOperandsAndResultShape

Interfejsy: NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.random_standard_normal (TFL::RandomStandardNormalOp)

Wyprowadza losowe wartości z rozkładu normalnego.

Wygenerowane wartości będą miały średnią 0 i odchylenie standardowe 1.

Interfejsy: TflRuntimeVerifyOpInterface

Atrybuty:

Operandy:

Wyniki:

tfl.random_uniform (TFL::RandomUniformOp)

Wyprowadza losowe wartości z rozkładu równomiernego.

Wygenerowane wartości mają rozkład równomierny w przedziale [0, 1) . Dolna granica 0 jest uwzględniona w zakresie, natomiast górna granica 1 jest wykluczona.

Interfejsy: TflRuntimeVerifyOpInterface

Atrybuty:

Operandy:

Wyniki:

tfl.range (TFL::RangeOp)

Operator zakresu

Zwraca tensor 1D zdefiniowany przez sekwencję od start do limit z daną delta .

Cechy: AlwaysSpeculatableImplTrait

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.rank (TFL::RankOp)

Operator rangi.

Zwraca rangę tensora.

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.read_variable (TFL::ReadVariableOp)

Odczytuje wartość zmiennej.

Odczytaj zmienne dane identyfikowane przez „resource_id”.

Interfejsy: TflRuntimeVerifyOpInterface

Operandy:

Wyniki:

tfl.real (TFL::RealOp)

Zwraca część rzeczywistą liczby zespolonej.

Mając na input tensor liczb zespolonych, operacja ta zwraca tensor typu float , który jest częścią rzeczywistą każdego elementu na input . Wszystkie elementy na input muszą być liczbami zespolonymi postaci \(a + bj\), gdzie a jest częścią rzeczywistą zwróconą przez tę operację, a b jest częścią urojoną.

Cechy: AlwaysSpeculatableImplTrait , SameOperandsAndResultShape

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.reduce_all (TFL::ReduceAllOp)

Oblicza „logiczne i” elementów w różnych wymiarach tensora.

Zmniejsza input wzdłuż wymiarów podanych w axis . O ile keep_dims nie ma wartości true, stopień tensora jest zmniejszany o 1 dla każdego wpisu w axis . Jeśli keep_dims ma wartość true, zmniejszone wymiary zostaną zachowane z długością 1.

Cechy: AlwaysSpeculatableImplTrait

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.reduce_any (TFL::ReduceAnyOp)

Oblicza „logiczne lub” elementów w wymiarach tensora.

Zmniejsza input wzdłuż wymiarów podanych w axis . O ile keep_dims nie ma wartości true, stopień tensora jest zmniejszany o 1 dla każdego wpisu w axis . Jeśli keep_dims ma wartość true, zmniejszone wymiary zostaną zachowane z długością 1.

Cechy: AlwaysSpeculatableImplTrait

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.reduce_max (TFL::ReduceMaxOp)

Operator maksymalnej redukcji

Oblicza maksymalną redukcję wzdłuż określonych osi

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.reduce_min (TFL::ReduceMinOp)

Operator redukcji minimalnej

Oblicza minimalną redukcję wzdłuż określonych osi

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.reduce_prod (TFL::ReduceProdOp)

Operator redukcji produktu

Oblicza iloczyn wzdłuż określonych osi

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.relu (TFL::ReluOp)

Operator Relu

Elementarny operator Relu x -> max(0, x)

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.relu6 (TFL::Relu6Op)

Operator Relu6

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

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.relu_0_to_1 (TFL::Relu0To1Op)

Operator Relu0To1

Elementowy operator Relu0To1 x -> max(0, min(1, x))

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.relu_n1_to_1 (TFL::Relu1Op)

Operator Relu1

Elementarny operator Relu1 x -> max(-1, min(1, x))

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.reshape (TFL::ReshapeOp)

Zmień kształt operatora

Tworzy tensor o tych samych wartościach, ale o innym kształcie statycznym zdefiniowanym przez typ wyjściowy.

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

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

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.resize_bilinear (TFL::ResizeBilinearOp)

Zmień rozmiarBilinear op

Zmień size images , używając interpolacji dwuliniowej.

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.resize_nearest_neighbor (TFL::ResizeNearestNeighborOp)

Zmień rozmiar Najbliższy sąsiad op

Zmień rozmiar images do size za pomocą interpolacji najbliższego sąsiada.

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.reverse_sequence (TFL::ReverseSequenceOp)

Odwraca plasterki o zmiennej długości.

Ta opcja najpierw dzieli input wzdłuż wymiaru batch_dim i dla każdego wycinka i odwraca pierwsze elementy seq_lengths[i] wzdłuż wymiaru seq_dim .

Elementy seq_lengths muszą być zgodne z seq_lengths[i] <= input.dims[seq_dim] , a seq_lengths muszą być wektorem długości input.dims[batch_dim] .

Wycinek wyjściowy i wzdłuż wymiaru batch_dim jest następnie podawany przez wycinek wejściowy i , przy czym pierwsze wycinki seq_lengths[i] wzdłuż wymiaru seq_dim są odwrócone.

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.reverse_v2 (TFL::ReverseV2Op)

Operator ReverseV2

Odwraca określone wymiary tensora.

Biorąc pod uwagę tensor i oś tensora int32/int64 reprezentującą zbiór wymiarów tensora do odwrócenia. Ta operacja odwraca każdy wymiar i, dla którego istnieje j oś [j] == i.

Argumenty: tensor: Tensor. Musi to być jeden z następujących typów: uint8, int8, int16, int32, int64, float32, bool Do 8-D.

oś: Tensor. Musi to być jeden z następujących typów: int32, int64. z tylko 1 elementem, który jest indeksem osi. DO ZROBIENIA: Dodaj obsługę wielu elementów.

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.rfft2d (TFL::RFFT2dOp)

Szybka transformata Fouriera o wartościach rzeczywistych 2D.

Oblicza dwuwymiarową dyskretną transformatę Fouriera sygnału o wartościach rzeczywistych w dwóch najbardziej wewnętrznych wymiarach input .

Ponieważ DFT sygnału rzeczywistego jest hermitowsko-symetryczna, RFFT2D zwraca tylko fft_length / 2 + 1 unikalne składowe FFT dla najbardziej wewnętrznego wymiaru sygnału output : składnik o zerowej częstotliwości, po którym następuje fft_length / 2 częstotliwość dodatnia warunki.

Wzdłuż każdej osi obliczany jest RFFT2D , jeśli fft_length jest mniejsza niż odpowiedni wymiar input , wymiar jest przycinany. Jeśli jest większy, wymiar jest uzupełniany zerami.

Cechy: AlwaysSpeculatableImplTrait

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.right_shift (TFL::RightShiftOp)

Prawy operator Shift

Elementwise oblicza bitowe przesunięcie w prawo lhs o rhs .

Cechy: AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.round (TFL::RoundOp)

Operator okrągły

Zaokrągla wartości tensora do najbliższej liczby całkowitej, według elementów.

Cechy: AlwaysSpeculatableImplTrait , InferTensorType , TF::SameOperandsAndResultTypeResolveRef

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

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.rsqrt (TFL::RsqrtOp)

Odwrotność operatora pierwiastkowego

Oblicza elementarnie odwrotny pierwiastek kwadratowy z danych wejściowych

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.scatter_nd (TFL::ScatterNdOp)

_Operator rozproszenia i

updates rozproszone do nowego tensora zgodnie z indices

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

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

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.segment_sum (TFL::SegmentSumOp)

Operator SegmentSum

Oblicza sumę wzdłuż segmentów tensora.

Cechy: AlwaysSpeculatableImplTrait

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.select (TFL::SelectOp)

Wybierz operatora

Wybierz wartości „x”, jeśli odpowiadająca wartość „warunku” jest prawdziwa, lub wartość „y”, jeśli jest fałszywa. Istnieją prawidłowe rozmiary danych wejściowych warunku:

1. Albo ten sam kształt (w tym przypadku wybór odbywa się elementarnie), albo
2. warunek musi mieć rangę 1 i odpowiadać pierwszemu wymiarowi.

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

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

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.select_v2 (TFL::SelectV2Op)

Wybierz operatora V2

Wybierz wartości „x”, jeśli odpowiadająca wartość „warunku” jest prawdziwa, lub wartość „y”, jeśli jest fałszywa. Istnieją prawidłowe rozmiary danych wejściowych warunku:

1. Albo ten sam kształt (w tym przypadku wybór odbywa się elementarnie), albo
2. Kształty nadające się do nadawania pomiędzy „stanem”, „x” i „y”.

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

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

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.shape (TFL::ShapeOp)

Operator kształtu

Zwraca kształt tensora.

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.sign (TFL::SignOp)

Operacja podpisania

Zwraca NaN, jeśli x wynosi NaN, 0, jeśli x wynosi 0, -1, jeśli x < 0 i 1, jeśli x > 0.

Cechy: AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType , SameOperandsAndResultShape

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.sin (TFL::SinOp)

Operator sinus

Oblicza elementarny sinus wejściowy

Cechy: AlwaysSpeculatableImplTrait , InferTensorType , TF::SameOperandsAndResultTypeResolveRef

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

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.slice (TFL::SliceOp)

Zwróć kawałek z „wejściowego”.

Tensor wyjściowy to tensor o wymiarach opisanych przez „rozmiar”, którego wartości są pobierane z „wejściowego”, zaczynając od przesunięć w „begin”.

begin jest liczony od zera; size jest oparty na jednym. Jeśli rozmiar[i] wynosi -1, wszystkie pozostałe elementy wymiaru i są uwzględnione w wycinku. Innymi słowy, jest to równoznaczne z ustawieniem: size[i] = input.dim_size(i) - Begin[i]

Wymagania : 0 <= początek[i] <= początek[i] + rozmiar[i] <= Di dla i w [0, n)

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

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

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.softmax (TFL::SoftmaxOp)

Operator Softmax

Oblicza elementarne aktywacje softmax za pomocą następującego wzoru

exp(wejście) / tf.reduce_sum(exp(wejście * beta), dim)

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.space_to_batch_nd (TFL::SpaceToBatchNdOp)

Operator SpaceToBatchNd

Ta operacja zmienia kształt wymiarów przestrzeni na wymiar „wsadowy” 0

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

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

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.space_to_depth (TFL::SpaceToDepthOp)

Operator SpaceToDepth

Porządkuje bloki danych przestrzennych w głąb. Mówiąc dokładniej, ta operacja generuje kopię tensora wejściowego, w którym wartości z wymiarów height i width są przenoszone do wymiaru depth . block_size wskazuje rozmiar bloku wejściowego.

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.sparse_to_dense (TFL::SparseToDenseOp)

Konwertuje rzadką reprezentację na gęsty tensor.

Tworzy tablicę dense o kształcie output_shape taką, że

# If sparse_indices is scalar
dense[i] = (i == sparse_indices ? sparse_values : default_value)

# If sparse_indices is a vector, then for each i
dense[sparse_indices[i]] = sparse_values[i]

# If sparse_indices is an n by d matrix, then for each i in [0, n)
dense[sparse_indices[i][0], ..., sparse_indices[i][d-1]] = sparse_values[i]

Wszystkie inne wartości dense są ustawione na default_value . Jeśli sparse_values ​​jest skalarem, wszystkie rzadkie indeksy są ustawiane na tę pojedynczą wartość.

Indeksy należy posortować w porządku leksykograficznym i nie mogą one zawierać powtórzeń. Jeśli validate_indices ma wartość true, te właściwości są sprawdzane podczas wykonywania.

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.split (TFL::SplitOp)

Dzieli tensor na tensory num_split wzdłuż jednego wymiaru.

Dzieli tensor value wzdłuż split_dim na kilka podtensorów o takim samym kształcie jak pierwotny, z wyjątkiem split_dim . To samo co tf.Split.

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.split_v (TFL::SplitVOp)

Dzieli tensor na tensory num_split wzdłuż jednego wymiaru.

Dzieli tensor value wzdłuż split_dim na kilka podtensorów o takim samym kształcie jak pierwotny, z wyjątkiem split_dim . O grupowaniu wynikowych podtensorów decydują size-splits . To samo co tf.SplitV.

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.sqrt (TFL::SqrtOp)

Operator pierwiastkowy

Oblicza elementarnie pierwiastek kwadratowy z danych wejściowych

Cechy: AlwaysSpeculatableImplTrait , InferTensorType , TF::SameOperandsAndResultTypeResolveRef

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

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.square (TFL::SquareOp)

Operator kwadratowy

Oblicza elementarnie kwadrat danych wejściowych

Cechy: AlwaysSpeculatableImplTrait , InferTensorType , TF::SameOperandsAndResultTypeResolveRef

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

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.squared_difference (TFL::SquaredDifferenceOp)

Operator różnicy kwadratowej

Operacja różnicowa kwadratowa elementarna.

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

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.squeeze (TFL::SqueezeOp)

Usuwa wymiary o rozmiarze 1 z kształtu tensora.

Mając input tensora, operacja ta zwraca tensor tego samego typu, po usunięciu wszystkich wymiarów o rozmiarze 1. Jeśli nie chcesz usuwać wszystkich wymiarów rozmiaru 1, możesz usunąć określone wymiary rozmiaru 1, określając squeeze_dims .

Na przykład:

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

Lub, aby usunąć określone wymiary rozmiaru 1:

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

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.strided_slice (TFL::StridedSliceOp)

StridedSlice op

Zwróć plasterek krokowy z input .

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.sub (TFL::SubOp)

Operator odejmowania

Operacja odejmowania elementarnego.

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

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.sum (TFL::SumOp)

Operator sumy

Oblicza redukcję sumy wzdłuż określonych osi

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.svdf (TFL::SVDFOp)

Operator filtra dekompozycji pojedynczej wartości

Operacja SVDF jest rozkładem gęsto połączonej operacji na filtry o niskiej randze. Szczegóły: https://research.google.com/pubs/pub43813.html https://arxiv.org/abs/1812.02802

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

Interfejsy: DynamicRangeQuantizedOpInterface , TFL_StatefulOp , TflRuntimeVerifyOpInterface

Atrybuty:

Operandy:

Wyniki:

tfl.tanh (TFL::TanhOp)

Operator tangensu hiperbolicznego

Oblicza elementarnie tangens hiperboliczny danych wejściowych

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

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

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.tile (TFL::TileOp)

Operator płytek.

Konstruuje tensor, dzieląc dany tensor.

Ta operacja tworzy nowy tensor poprzez wielokrotną replikację danych wejściowych. I-ty wymiar tensora wyjściowego zawiera elementy input.dims(i) * multiples[i], a wartości wejściowe są replikowane wielokrotności[i] razy wzdłuż „i-tego wymiaru. Na przykład ułożenie [abcd] przez [2] daje [abcdabcd].

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

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

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.topk_v2 (TFL::TopKV2Op)

Operator TopK

Zwraca k największego górnego elementu wzdłuż każdego ostatniego wymiaru wycinka input oraz indeksy wartości w obrębie ostatniego wymiaru tensora wejściowego.

Wyniki są zawsze sortowane w kolejności malejącej.

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

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

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.transpose (TFL::TransposeOp)

Operator transpozycji

Zwraca transpozycję x

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

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

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.transpose_conv (TFL::TransposeConvOp)

Transpozycja operatora splotu

Wykonuje operację splotu transpozycji na wejściu.

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

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy: