`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 oblicza \(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_lhs`: optional: Transpose LHS (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 , 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 w postaci \(a + bj\). Wartość bezwzględna jest obliczana jako \( \sqrt{a^2 + b^2}\).

Cechy: AlwaysSpeculatableImplTrait , SameOperandsAndResultShape

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.concatenation (TFL::ConcatenationOp)

Operator łączenia

Łą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 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: 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 input tensor liczb zespolonych, operacja ta zwraca tensor typu float , który jest częścią urojoną każdego elementu na input . Wszystkie elementy input muszą być liczbami zespolonymi w postaci \(a + bj\), gdzie a to część rzeczywista, a b to część urojona zwrócona 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 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

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

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: A Search Space Odyssey” 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żeli opcja keepdims 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ą punktację 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 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 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 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 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 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 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 wypełnienia danych input .

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ły pseudo op.

Reprezentuje stałą wartość w dialekcie Tensorflow Lite. To nie jest faktyczna operacja i zamiast tego zostanie obniżona do buforowania.

OP może mieć ten sam typ atrybutów, co TF.CONST (np. Nieprawte atrybuty TF są dozwolone).

Cechy: AlwaysSpeculatableImplTrait , ConstantLike , FirstAttrDerivedResultType , QuantizableResult

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Atrybuty:

Wyniki:

tfl.pseudo_qconst (tfl :: qConstop)

Kwantyzowane stałe pseudo op

Reprezentuje kwantyczną stałą wartość w dialekcie Tensorflow Lite. To nie jest faktyczna operacja i zamiast tego zostanie obniżona do buforowania. 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)

Rzadkie stałe pseudo op.

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

Cechy: AlwaysSpeculatableImplTrait , FirstAttrDerivedResultType , QuantizableResult

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Atrybuty:

Wyniki:

tfl.pseudo_sparse_qconst (tfl :: steargeqConstop)

Rzadkie kwantyzowane stałe pseudo op

Reprezentuje rzadką kwantyczną wartość stałą w dialekcie Tensorflow Lite. To nie jest faktyczna operacja i zamiast tego zostanie obniżona do buforowania. 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 :: kwantizeop)

Kwantyza operatora

Przekształca tensory zmiennoprzecinkowe na kwantyzowane tensory całkowite zgodnie z parametrami kwantyzacji zdefiniowanymi w atrybucie typu.

Cechy: FirstAttrDerivedResultType , SameOperandsAndResultShape

Interfejsy: NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.random_standard_normal (tfl :: Randomstandnormalop)

Wyświetla 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 :: land ImpandUmiform)

Wyświetla losowe wartości z jednolitego rozkładu.

Wygenerowane wartości są zgodne z jednolitym rozkładem w zakresie [0, 1) . Dolna granica 0 jest zawarta w zakresie, podczas gdy górna granica 1 jest wykluczona.

Interfejsy: TflRuntimeVerifyOpInterface

Atrybuty:

Operandy:

Wyniki:

tfl.range (TFL :: RangeP)

Operator zasięgu

Zwraca tensor 1D zdefiniowany przez sekwencję od start do limit za pomocą danej delta .

Cechy: AlwaysSpeculatableImplTrait

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.rank (tfl :: rankop)

Operator rangi.

Zwraca stopień tensora.

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.read_variable (tfl :: readvarableop)

Odczytuje wartość zmienną.

Odczyt dane zmiennych zidentyfikowane przez „Resource_id”.

Interfejsy: TflRuntimeVerifyOpInterface

Operandy:

Wyniki:

tfl.real (tfl :: realop)

Zwraca prawdziwą część złożonej liczby.

Biorąc pod uwagę input tensora liczb złożonych, operacja ta zwraca tensor typu float , który jest prawdziwą częścią każdego elementu na input . Wszystkie elementy w input muszą być złożonymi liczbami formularza \(a + bj\), gdzie A jest prawdziwą częścią zwróconą przez tę operację, a B jest częścią wyobrażoną.

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 . Chyba że keep_dims nie jest prawdziwy, ranga tensor jest zmniejszona o 1 dla każdego wpisu w axis . Jeśli keep_dims jest prawdziwy, zmniejszone wymiary są zachowywane z długością 1.

Cechy: AlwaysSpeculatableImplTrait

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.reduce_any (tfl :: reduceaneop)

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

Zmniejsza input wzdłuż wymiarów podanych w axis . Chyba że keep_dims nie jest prawdziwy, ranga tensor jest zmniejszona o 1 dla każdego wpisu w axis . Jeśli keep_dims jest prawdziwy, zmniejszone wymiary są zachowywane z długością 1.

Cechy: AlwaysSpeculatableImplTrait

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.reduce_max (tfl :: reduceMaxop)

Operator maksymalnego 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 min

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

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

tfl.reduce_prod (tfl :: redukujprodop)

Operator redukcji produkcji

Oblicza produkt wzdłuż określonych osi

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operands:

Wyniki:

tfl.relu (tfl :: reluop)

Operator relU

Element -Wise operator X -> Max (0, x)

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operands:

Wyniki:

tfl.relu6 (tfl :: relu6op)

Operator RELU6

Element -Wise Operator X -> Max (0, min (6, x))

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operands:

Wyniki:

tfl.relu_0_to_1 (tfl :: relu0to1op)

Operator RELU0TO1

Element -Wise operator relU0to1 x -> max (0, min (1, x))

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operands:

Wyniki:

tfl.relu_n1_to_1 (tfl :: relu1op)

Operator RELU1

Element-Wise Operator X-> Max (-1, min (1, x))

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operands:

Wyniki:

tfl.reshape (tfl :: reshapeop)

Operator przekształcenia

Wytwarza tensor o tych samych wartościach, ale inny kształt statyczny zdefiniowany przez typ wyjściowy.

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

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

Efekty: MemoryEffects::Effect{}

Operands:

Wyniki:

tfl.resize_bilinear (tfl :: reseBilinearop)

Zmiana resizebilinear op

Zmień rozmiar images na size za pomocą interpolacji dwustronnej.

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operands:

Wyniki:

tfl.resize_nearest_neighbor (tfl :: resizenearestneighborop)

Resizeenearestneighbor op

Zmień rozmiar images na size za pomocą interpolacji najbliższych sąsiadów.

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operands:

Wyniki:

tfl.reverse_sequence (tfl :: reversesequenceop)

Odwraca plastry o zmiennej długości.

Ten OP najpierw przecina input wzdłuż wymiaru batch_dim i dla każdego plastra i odwraca pierwsze elementy seq_lengths[i] wzdłuż wymiaru seq_dim .

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

Wyjście wyjściowe i wzdłuż wymiaru batch_dim jest następnie podawane przez pokrój wejściowy i , z pierwszymi seq_lengths[i] wzdłuż wymiaru seq_dim .

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operands:

Wyniki:

tfl.reverse_v2 (tfl :: reversev2op)

Operator reversev2

Odwraca określone wymiary tensora.

Biorąc pod uwagę tensor i oś tensor INT32/INT64 reprezentująca zestaw wymiarów tensor do odwrócenia. Ta operacja odwraca każdy wymiar i, dla którego istnieje oś st [j] == i.

Args: Tensor: Tensor. Musi być jednym z następujących typów: uint8, int8, int16, int32, int64, float32, bool do 8-d.

Oś: tensor. Musi być jednym z następujących typów: INT32, INT64. z tylko 1 elementem, który jest wskaźnikiem osi. TODO: Dodaj obsługę wielu elementów.

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operands:

Wyniki:

tfl.rfft2d (tfl :: rfft2dop)

2D rzeczywistą szybką transformację Fouriera.

Oblicza 2-wymiarową dyskretną transformację Fouriera sygnału według wartości rzeczywistej w wysokości 2 wymiarów input .

Ponieważ DFT rzeczywistego output jest hermitańsko-symetryczna, RFFT2D zwraca jedynie unikalne elementy FFT_LOGNE fft_length / 2 fft_length / 2 + 1 warunki.

Wzdłuż każdej osi RFFT2D jest obliczany na, jeśli fft_length jest mniejszy niż odpowiedni wymiar input , wymiar jest przycięty. Jeśli jest większy, wymiar jest wyściełany zerami.

Cechy: AlwaysSpeculatableImplTrait

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.right_shift (tfl :: rightshiftop)

PRAWY Operator zmiany

ElementWise oblicza przesunięcie Bitwise lhs przez rhs .

Cechy: AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operands:

Wyniki:

tfl.round (tfl :: Roundop)

Okrągły operator

Okrąża wartości tensora do najbliższej liczby całkowitej, pod względem elementu.

Cechy: AlwaysSpeculatableImplTrait , InferTensorType , TF::SameOperandsAndResultTypeResolveRef

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

Efekty: MemoryEffects::Effect{}

Operands:

Wyniki:

tfl.rsqrt (tfl :: rsqrtop)

Wzajemne operatora pierwiastków kwadratowych

Oblicza elementowy odwrotny pierwiastek kwadratowy wejścia

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operands:

Wyniki:

tfl.scatter_nd (tfl :: scatterndop)

_ Operator ND

updates rozproszenia w nowym tensor zgodnie z indices

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

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

Efekty: MemoryEffects::Effect{}

Operands:

Wyniki:

tfl.segment_sum (tfl :: segmentsumop)

Operator segmentów

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

Cechy: AlwaysSpeculatableImplTrait

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operands:

Wyniki:

tfl.select (tfl :: selectop)

Wybierz operatora

Wybierz wartości „x”, jeśli odpowiednia wartość „warunku” jest prawdziwa lub wartość „y”, jeśli fałsz. Istnieją prawidłowe rozmiary wprowadzania stanu:

1. Albo ten sam kształt (w którym to przypadku wybrane jest elementWise), lub
2. Warunek musi być ranking 1 i pasował do pierwszego wymiaru.

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

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

Efekty: MemoryEffects::Effect{}

Operands:

Wyniki:

tfl.select_v2 (tfl :: selectv2op)

Operator SelectV2

Wybierz wartości „x”, jeśli odpowiednia wartość „warunku” jest prawdziwa lub wartość „y”, jeśli fałsz. Istnieją prawidłowe rozmiary wprowadzania stanu:

1. Albo ten sam kształt (w którym to przypadku wybrane jest elementWise), lub
2. Nadawane kształty między „warunkiem”, „x” i „y”.

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

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

Efekty: MemoryEffects::Effect{}

Operands:

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 podpisu

Zwraca nan, jeśli x to nan, 0, jeśli x to 0, -1 Jeśli x <0 i 1, jeśli x> 0.

Cechy: AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType , SameOperandsAndResultShape

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operands:

Wyniki:

tfl.sin (tfl :: sinop)

Operator sinusoidalny

Oblicza sinus pod względem elementów wejściowych

Cechy: AlwaysSpeculatableImplTrait , InferTensorType , TF::SameOperandsAndResultTypeResolveRef

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

Efekty: MemoryEffects::Effect{}

Operands:

Wyniki:

tfl.slice (tfl :: sliceop)

Zwróć plasterek z „wejścia”.

Tensor wyjściowy jest tensor o wymiarach opisanych przez „rozmiar”, którego wartości są wyodrębnione z „wejścia”, zaczynając od przesunięć w „początek”.

begin jest oparty na zero; size jest jeden. Jeśli rozmiar [i] wynosi -1, wszystkie pozostałe elementy wymiaru I są zawarte w plasterze. Innymi słowy, jest to równoważne ustawienie: rozmiar [i] = input.dim_size (i) - początek [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{}

Operands:

Wyniki:

tfl.softmax (tfl :: softmaxop)

Operator Softmax

Oblicza aktywacje miękka z elementami z następującym wzorem

exp (wejście) / tf.rereduce_sum (exp (input * beta), DIM)

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operands:

Wyniki:

tfl.space_to_batch_nd (tfl :: spacetobatchndop)

Operator SpacetObatchnd

Ta operacja przekształca wymiary przestrzeni w wymiar „partii” 0

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

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

Efekty: MemoryEffects::Effect{}

Operands:

Wyniki:

tfl.space_to_depth (tfl :: spacetodepthop)

Operator spacetodepth

Zatrudnia bloki danych przestrzennych na głębokość. Mówiąc dokładniej, ten OP przedstawia 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:

Operands:

Wyniki:

tfl.sparse_to_dense (tfl :: sparsetodenseop)

Przekształca rzadką reprezentację w gęsty tensor.

Buduje tablicę dense z kształtem output_shape

# 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 pozostałe wartości w dense są ustawione na default_value . Jeśli sparse_values są skalarne, wszystkie rzadkie wskaźniki są ustawione na tę pojedynczą wartość.

Wskaźniki powinny być sortowane w kolejności leksykograficznej, a wskaźniki nie mogą zawierać żadnych powtórzeń. Jeśli validate_indices jest prawdą, właściwości te są sprawdzane podczas wykonywania.

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operands:

Wyniki:

tfl.split (tfl :: splitop)

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

Dzieli tensor value wzdłuż split_dim na liczbę podrzędnych o tym samym kształcie co oryginalny, z wyjątkiem split_dim . Tak samo jak tf.split.

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operands:

Wyniki:

tfl.split_v (tfl :: splitvop)

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

Dzieli tensor value wzdłuż split_dim na liczbę podrzędnych o tym samym kształcie co oryginalny, z wyjątkiem split_dim . Grupowanie powstałych podrzędnych jest decydowane według size-splits . Tak samo jak TF.splitv.

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operands:

Wyniki:

tfl.sqrt (tfl :: sqrtop)

Operator root kwadratowych

Oblicza pierwiastek kwadratowy wejścia

Cechy: AlwaysSpeculatableImplTrait , InferTensorType , TF::SameOperandsAndResultTypeResolveRef

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

Efekty: MemoryEffects::Effect{}

Operands:

Wyniki:

tfl.square (tfl :: SquareP)

Operator kwadratowy

Oblicza kwadrat elementarnego wejścia

Cechy: AlwaysSpeculatableImplTrait , InferTensorType , TF::SameOperandsAndResultTypeResolveRef

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

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.squared_difference (tfl :: squredDifferenceP)

Operator różnic kwadratowych

Pod względem elementowym operacja różnicy kwadratowej.

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

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Operands:

Wyniki:

tfl.squeeze (tfl :: squezeop)

Usuwa wymiary rozmiaru 1 z kształtu tensora.

Biorąc pod uwagę input tensora, operacja ta zwraca tensor tego samego typu z usuniętymi wymiarami rozmiaru 1. Jeśli nie chcesz usunąć wszystkich wymiarów rozmiaru 1, możesz usunąć określony rozmiar 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ślony rozmiar 1 Wymiary:

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

Operands:

Wyniki:

tfl.strided_slice (tfl :: stridedSliceop)

StridedSlice op

Zwróć kropkę z input .

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operands:

Wyniki:

tfl.sub (tfl :: subop)

Operator odejmowania

Operacja odejmowania elementu.

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

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operands:

Wyniki:

tfl.sum (tfl :: sumop)

Operator suma

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

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface) , TflRuntimeVerifyOpInterface

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operands:

Wyniki:

tfl.svdf (tfl :: svdfop)

Operator filtru rozkładu pojedynczej wartości

SVDF OP jest rozkładem gęsto połączonego OP w filtry o niskiej randze. Szczegółowe informacje: 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:

Operands:

Wyniki:

tfl.tanh (tfl :: tanhop)

Hiperboliczny operator stycznej

Oblicza elementarne hiperboliczne styczne wejściowe

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult , SameOperandsAndResultShape

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

Efekty: MemoryEffects::Effect{}

Operands:

Wyniki:

tfl.tile (tfl :: tileop)

Operator płytek.

Konstruuje tensor poprzez kafelowanie danego tensora.

Ta operacja tworzy nowy tensor poprzez powtórzenie czasów mnożników wejściowych. Wymiar mocy tensor ma wejście.dims (i) * mnożnie elementy [i], a wartości wejściowe są replikowanymi wielokrotnościami [i] razy wzdłuż wymiaru „I'th”. Na przykład kafelki [ABCD] przez [2] produkuje [ABCDABCD].

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

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

Efekty: MemoryEffects::Effect{}

Operands:

Wyniki:

tfl.topk_v2 (tfl :: topkv2op)

Operator TOPK

Zwraca górny k element wzdłuż każdego ostatniego wymiarowego wycinka input i wskaźniki wartości w ostatnim wymiarze tensora wejściowego.

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

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

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

Efekty: MemoryEffects::Effect{}

Operands:

Wyniki:

tfl.transpose (tfl :: transposeop)

Operator transponowania

Zwraca transpozycję x

Cechy: AlwaysSpeculatableImplTrait , QuantizableResult

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

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

tfl.transpose_conv (tfl :: TransposeConvop)

Transpose operator splotu

Wykonuje operację splotu Transpose przy 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:

Operands:

Wyniki:

tfl.unidirectional_sequence_lstm (tfl :: UnitirectionalSeCenceLstmop)

Operator LSTM sekwencji jednokierunkowej

Powtarzająca się sieć neuronowa określona przez komórkę LSTM. Ten OP obsługuje rozwinięcie danych wejściowych wzdłuż wymiarów czasu lub okresu i implementuje następującą operację dla każdego elementu w sekwencji s = 1 ... sekwencyjna długość: wyjścia [s] = stan = aktywacja (LSTMOP (wejścia [s]))

gdzie LSTMOP jest LSTM TF Lite OP, a „aktywacja” jest funkcją przekazaną jako argument „fed_activation_function” (jeśli nie „brak”).

Cechy: QuantizableResult

Interfejsy: DynamicRangeQuantizedOpInterface , InferTypeOpInterface , TFL_StatefulOp , TflRuntimeVerifyOpInterface

Atrybuty:

Operands:

Wyniki:

tfl.unidirectional_sequence_rnn (tfl :: UnitirectionalSeCernnop)

Operator sekwencji jednokierunkowej RNN

Powtarzająca się sieć neuronowa określona przez komórkę RNN. Ten OP przyjmuje dane wejściowe w formacie {Batch_Size, SEQ_LEN, INPUT_SIZE} lub {seq_len, batch_size, input_size}, jeśli jest to zamieszane w czasie.

Wdraża następującą operację dla każdego elementu w sekwencji s = 1 ... sekwencyjna długość: wyjścia [s] = stan = aktywacja (rnnop (wejścia [s]))))

gdzie RNNOP jest RNNOP TF Lite OP, a „aktywacja” jest funkcją przekazywaną jako argument „fed_activation_function” (jeśli nie „brak”).

Cechy: QuantizableResult

Interfejsy: DynamicRangeQuantizedOpInterface , TFL_StatefulOp , TflRuntimeVerifyOpInterface

Atrybuty:

Operands:

Wyniki:

tfl.unique (tfl :: unikalny)

Unikalny op.

Ta operacja zwraca output tensora zawierające wszystkie unikalne elementy input posortowane w tej samej kolejności, w której występują na input . Ta operacja zwraca również idx tensor tego samego rozmiaru co x , który zawiera indeks każdej wartości input w unikalnym output wyjściowym. Innymi słowy: