`mhlo` Dialekt

Operacje

mhlo.abs (mhlo::AbsOp)

Operacja brzucha

Składnia:

operation ::= `mhlo.abs` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Wykonuje operację abs na tensorze operand elementarnego i generuje tensor result .

Zobacz: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#abs

Przykład:

%result = mhlo.abs %operand : tensor<3xi32>

Cechy: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

mhlo.acos (mhlo::AcosOp)

Operacja Acos

Składnia:

operation ::= `mhlo.acos` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Wykonuje operację acos na tensorze operand elementarnego i zwraca tensor result .

Przykład:

%result = mhlo.acos %operand : tensor<2x2xf32>

Cechy: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfejsy: InferShapedTypeOpInterface , InferTypeOpInterface

Operandy:

Wyniki:

mhlo.acosh (mhlo::AcoshOp)

Operacja Acosh

Składnia:

operation ::= `mhlo.acosh` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Wykonuje operację acosh elementarną na tensorze operand i generuje tensor result .

Przykład:

%result = mhlo.acosh %operand : tensor<2x2xf32>

Cechy: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfejsy: InferShapedTypeOpInterface , InferTypeOpInterface

Operandy:

Wyniki:

mhlo.add (mhlo::AddOp)

Dodaj operację

Składnia:

operation ::= `mhlo.add` $lhs `,` $rhs attr-dict
              `:` custom<SameOperandsAndResultType>(type($lhs), type($rhs), type($result))

Wykonuje dodawanie elementarne dwóch tensorów lhs i rhs i generuje tensor result .

Zobacz: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#add

Przykład:

%result = mhlo.add %lhs, %rhs : tensor<2x2xi32>

Cechy: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

mhlo.add_dependency (mhlo::AddDependencyOp)

Operacja AddDependency

Składnia:

operation ::= `mhlo.add_dependency` operands attr-dict `:` functional-type(operands, results)

Operacja ta jest prywatna dla kompilatora XLA, więc nie ma jeszcze specyfikacji.

Nieformalnie, ta operacja ma dwa operandy: operand danych i token. Wynikiem operacji jest operand danych. W połączeniu z funkcją AfterAll, operacja ta umożliwia uporządkowanie operacji niepowodujących efektów ubocznych (czyli tych, które nie generują wartości tokenów).

Przykład:

%1 = mhlo.add_dependency %arg0, %0 : (tensor<3x4xf32>, !mhlo.token) -> tensor<3x4xf32>

Cechy: AlwaysSpeculatableImplTrait

Interfejsy: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

mhlo.after_all (mhlo::AfterAllOp)

Operacja AfterAll

Składnia:

operation ::= `mhlo.after_all` $inputs attr-dict
              `:` custom<VariadicSameOperandsAndResultType>(ref($inputs), type($inputs), type($result))

Zapewnia, że ​​operacje generujące dane inputs są wykonywane przed operacjami zależnymi od result .

Zobacz: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#after_all

Przykład:

%result = mhlo.after_all %input0, %input1 : !mhlo.token

Cechy: AlwaysSpeculatableImplTrait

Interfejsy: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

mhlo.all_gather (mhlo::AllGatherOp)

Operacja AllGather

W obrębie każdej grupy procesów w siatce procesów, funkcja łączy wartości tensora operandu z każdego procesu wzdłuż all_gather_dim i generuje tensor wynikowy. computation są przeprowadzane oddzielnie dla każdego operandu w operands , generując jeden wynik na operand.

Zobacz: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#all_gather

Przykład:

%result = "mhlo.all_gather"(%operand) {
  all_gather_dim = 1 : i64,
  replica_groups = dense<[[0, 1]]> : tensor<1x2xi64>
  // channel_id = 0
  channel_handle = #mhlo.channel_handle<handle = 0, type = 0>,
  // use_global_device_ids = false
} : (tensor<2x2xf32>) -> tensor<2x4xf32>

Cechy: SameOperandsAndResultElementType

Atrybuty:

Operandy:

Wyniki:

mhlo.all_reduce (mhlo::AllReduceOp)

Operacja AllReduce

W każdej grupie procesów w siatce procesów stosuje computation funkcji redukcji do wartości tensora operandu z każdego procesu i generuje tensor wynikowy. computation jest przeprowadzane oddzielnie dla każdego operandu w operands , generując jeden wynik na operand.

Zobacz: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#all_reduce

Przykład:

%result = "mhlo.all_reduce"(%operand) ({
  ^bb0(%arg0: tensor<f32>, %arg1: tensor<f32>):
    %0 = mhlo.add %arg1, %arg2 : tensor<f32>
    mhlo.return %0 : tensor<f32>
}) {
  replica_groups = dense<[[0, 1]]> : tensor<1x2xi64>
  // channel_id = 0
  channel_handle = #mhlo.channel_handle<handle = 0, type = 0>
  // use_global_device_ids = false
} : (tensor<4xf32>) -> tensor<4xf32>

Cechy: InferTensorType , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfejsy: InferShapedTypeOpInterface , InferTypeOpInterface

Atrybuty:

Operandy:

Wyniki:

mhlo.all_to_all (mhlo::AllToAllOp)

Operacja AllToAll

W obrębie każdej grupy procesów w siatce procesów dzieli wartości tensora operand wzdłuż split_dimension na części, rozprasza podzielone części pomiędzy procesami, łączy rozproszone części wzdłuż concat_dimension i generuje tensor result .

Zobacz: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#all_to_all

Przykład:

%result = "mhlo.all_to_all"(%operand) {
  split_dimension = 1 : i64,
  concat_dimension = 0 : i64,
  split_count = 2 : i64,
  replica_groups = dense<[[0, 1]]> : tensor<1x2xi64>
} : (tensor<2x4xf32>) -> tensor<4x2xf32>

Cechy: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsElementType , SameOperandsShape , SameVariadicOperandSize

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

mhlo.and (mhlo::AndOp)

I operacja

Składnia:

operation ::= `mhlo.and` $lhs `,` $rhs attr-dict
              `:` custom<SameOperandsAndResultType>(type($lhs), type($rhs), type($result))

Wykonuje elementarne AND dwóch tensorów lhs i rhs i generuje tensor result

Zobacz: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#and

Przykład:

%result = mhlo.and %lhs, %rhs : tensor<2x2xi32>

Cechy: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

mhlo.asin (mhlo::AsinOp)

Operacja Asin

Składnia:

operation ::= `mhlo.asin` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Wykonuje operację asin na tensorze operand elementarnego i generuje tensor result .

Przykład:

%result = mhlo.asin %operand : tensor<2x2xf32>

Cechy: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfejsy: InferShapedTypeOpInterface , InferTypeOpInterface

Operandy:

Wyniki:

mhlo.asinh (mhlo::AsinhOp)

Operacja Asinh

Składnia:

operation ::= `mhlo.asinh` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Wykonuje operację asinh na tensorze operand elementarnego i generuje tensor result .

Przykład:

%result = mhlo.asinh %operand : tensor<2x2xf32>

Cechy: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfejsy: InferShapedTypeOpInterface , InferTypeOpInterface

Operandy:

Wyniki:

mhlo.async_done (mhlo::AsyncDoneOp)

Operacja AsyncDone

Operacja ta jest prywatna dla kompilatora XLA, więc nie ma jeszcze specyfikacji.

Nieformalnie, operacja ta blokuje się do końca obliczeń asynchronicznych. Zwraca ona wynik końcowy obliczeń asynchronicznych.

Więcej informacji znajdziesz w dokumentacji AsyncStart.

Interfejsy: InferTypeOpInterface

Operandy:

Wyniki:

mhlo.async_start (mhlo::AsyncStartOp)

Operacja AsyncStart

Operacja ta jest prywatna dla kompilatora XLA, więc nie ma jeszcze specyfikacji.

Nieformalnie operacja ta rozpoczyna obliczenia asynchroniczne.

Używa się tego, gdy istnieją funkcje zawierające zarówno asynchroniczne oczekiwania (takie jak DMA), jak i obliczenia w wątku. Na przykład funkcja może składać się z obliczenia, DMA, kolejnego obliczenia, drugiego DMA i ostatecznego obliczenia. Byłoby to reprezentowane jako async_start, po którym następują async_update i async_done. Async_start wykonałby pierwsze obliczenie w wątku, a następnie uruchomiłby DMA. Async_update czekałby na zakończenie DMA, jeśli jeszcze nie zostało zakończone, a następnie wykonałby drugie obliczenie w funkcji i uruchomiłby drugie DMA. Na koniec async_done czekałby na to ostatnie DMA, a następnie uruchomiłby ostatnie obliczenie, które musi zostać wykonane w wątku i zwróciłby wynik tego ostatecznego obliczenia.

operands są przekazywane bezpośrednio do obliczeń. called_computation to funkcja, która zostanie uruchomiona asynchronicznie. execution_thread to nazwa wątku, w którym zostanie uruchomiona. Wątek główny nazywany jest „main”. Wszystkie wątki mają nazwy.

Zwraca cały stan potrzebny między operacjami asynchronicznymi. Po przypisaniu bufora, wartości zwracane reprezentują przestrzeń potrzebną do przechowywania danych wejściowych, wyników oraz wszelkich plików roboczych potrzebnych lub edytowanych przez operację asynchroniczną.

Atrybuty:

Operandy:

Wyniki:

mhlo.async_update (mhlo::AsyncUpdateOp)

Operacja AsyncUpdate

Operacja ta jest prywatna dla kompilatora XLA, więc nie ma jeszcze specyfikacji.

Nieformalnie, ta operacja blokuje obliczenia asynchroniczne do momentu wystąpienia bariery synchronizacji. Po wykonaniu operacji zwracana jest wartość bundle .

Więcej informacji znajdziesz w dokumentacji AsyncStart.

Interfejsy: InferTypeOpInterface

Operandy:

Wyniki:

mhlo.atan2 (mhlo::Atan2Op)

Operacja Atan2

Składnia:

operation ::= `mhlo.atan2` $lhs `,` $rhs attr-dict
              `:` custom<SameOperandsAndResultType>(type($lhs), type($rhs), type($result))

Wykonuje operację atan2 na elementach tensora lhs i rhs i generuje tensor result .

Zobacz: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#atan2

Przykład:

%result = mhlo.atan2 %lhs, %rhs : tensor<3xf32>

Cechy: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

mhlo.atanh (mhlo::AtanhOp)

Operacja Atanh

Składnia:

operation ::= `mhlo.atanh` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Wykonuje operację atanh elementarną na tensorze operand i generuje tensor result .

Przykład:

%result = mhlo.atanh %operand : tensor<2x2xf32>

Cechy: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfejsy: InferShapedTypeOpInterface , InferTypeOpInterface

Operandy:

Wyniki:

mhlo.batch_norm_grad (mhlo::BatchNormGradOp)

Operacja BatchNormGrad

Oblicza gradienty kilku wejść BatchNormTrainingOp, propagując wstecz od grad_output , i generuje tensory grad_operand , grad_scale i grad_offset .

Zobacz: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#batch_norm_grad

Przykład:

%grad_operand, %grad_scale, %grad_offset =
"mhlo.batch_norm_grad"(%operand, %scale, %mean, %variance, %grad_output) {
  epsilon = 0.0 : f32,
  feature_index = 2 : i64
} : (tensor<2x2x2xf32>, tensor<2xf32>, tensor<2xf32>, tensor<2xf32>,
    tensor<2x2x2xf32>) -> (tensor<2x2x2xf32>, tensor<2xf32>, tensor<2xf32>)

Cechy: AlwaysSpeculatableImplTrait , InferTensorType

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

mhlo.batch_norm_inference (mhlo::BatchNormInferenceOp)

Operacja BatchNormInference

Normalizuje tensor operand we wszystkich wymiarach, z wyjątkiem wymiaru feature_index , i generuje tensor result .

Zobacz: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#batch_norm_inference

Przykład:

%result = "mhlo.batch_norm_inference"(%operand, %scale, %offset, %mean, %variance) {
  epsilon = 0.0 : f32,
  feature_index = 2 : i64
} : (tensor<2x2x2xf32>, tensor<2xf32>, tensor<2xf32>, tensor<2xf32>, tensor<2xf32>) -> tensor<2x2x2xf32>

Cechy: AlwaysSpeculatableImplTrait , InferTensorType

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

mhlo.batch_norm_training (mhlo::BatchNormTrainingOp)

Operacja BatchNormTraining

Oblicza średnią i wariancję w wymiarach wsadowych i przestrzennych oraz normalizuje tensor operand dla każdej cechy w wymiarze feature_index i generuje output , tensory batch_mean i batch_var .

Zobacz: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#batch_norm_training

Przykład:

%output, %batch_mean, %batch_var = "mhlo.batch_norm_training"(%operand, %scale, %offset) {
  epsilon = 0.0 : f32,
  feature_index = 2 : i64
} : (tensor<2x2x2xf32>, tensor<2xf32>, tensor<2xf32>) -> (tensor<2x2x2xf32>, tensor<2xf32>, tensor<2xf32>)

Cechy: AlwaysSpeculatableImplTrait , InferTensorType

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

mhlo.bitcast (mhlo::BitcastOp)

Operacja bitcastowa

Składnia:

operation ::= `mhlo.bitcast` operands attr-dict `:` functional-type(operands, results)

Operacja ta jest prywatna dla kompilatora XLA, więc nie ma jeszcze specyfikacji.

Nieformalnie operacja ta zmienia kształt danych wejściowych w taki sposób, że fizyczny układ elementów pozostaje niezmieniony.

Operacja ta wymaga informacji o układzie, aby zrozumieć „fizyczne rozmieszczenie elementów”, a obsługa układu w MHLO jest obecnie w toku.

Przykład:

%0 = mhlo.bitcast %arg0 : (tensor<3x4xf32>) -> tensor<3x4x1xf32>

Cechy: AlwaysSpeculatableImplTrait

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

mhlo.bitcast_convert (mhlo::BitcastConvertOp)

Operacja BitcastConvert

Składnia:

operation ::= `mhlo.bitcast_convert` operands attr-dict `:` functional-type(operands, results)

Wykonuje operację bitcast na tensorze operand i generuje tensor result , w którym bity całego tensora operand są reinterpretowane przy użyciu typu tensora result .

Zobacz: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#bitcast_convert

Przykład:

%result = mhlo.bitcast_convert %operand : (tensor<2xf32>) -> tensor<2x4xi8>

Cechy: AlwaysSpeculatableImplTrait

Interfejsy: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

mhlo.broadcast (mhlo::BroadcastOp)

Operacja nadawania

Ta operacja jest już poza systemem StableHLO, dlatego nie jest uwzględniona w specyfikacji: https://github.com/openxla/stablehlo/issues/3

Nieformalnie ta operacja wykonuje to samo, co Broadcast XLA: https://www.tensorflow.org/xla/operation_semantics#broadcast

Przykład:

%result = mhlo.broadcast %operand, sizes = [1, 2] : (tensor<3xi32>) -> tensor<1x2x3xi32>

Cechy: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsAndResultElementType

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

mhlo.broadcast_in_dim (mhlo::BroadcastInDimOp)

Operacja BroadcastInDim

Rozszerza wymiary i/lub rangę tensora wejściowego poprzez duplikację danych w tensorze operand i generuje tensor result .

Zobacz: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#broadcast_in_dim

Przykład:

%result = mhlo.broadcast_in_dim %operand, dims = [2, 1] : (tensor<1x3xi32>) -> tensor<2x3x2xi32>

Cechy: AlwaysSpeculatableImplTrait , HLO_CompatibleOperandsAndResultElementType

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

mhlo.case (mhlo::CaseOp)

Operacja przypadku

Tworzy dane wyjściowe z wykonania dokładnie jednej function z branches w zależności od wartości index .

Zobacz: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#case

Przykład:

%result0, %result1 = "mhlo.case"(%index) ({
  mhlo.return %result_branch0, %result_branch0 : tensor<2xi64>, tensor<2xi64>
}, {
  mhlo.return %result_branch1, %result_branch1 : tensor<2xi64>, tensor<2xi64>
}) : (tensor<i32>) -> (tensor<2xi64>, tensor<2xi64>)

Cechy: RecursiveMemoryEffects , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfejsy: InferTypeOpInterface

Operandy:

Wyniki:

mhlo.cbrt (mhlo::CbrtOp)

Operacja CBRT

Składnia:

operation ::= `mhlo.cbrt` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Wykonuje operację pierwiastka sześciennego na tensorze operand i zwraca tensor result .

Zobacz: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#cbrt

Przykład:

%result = mhlo.cbrt %operand : tensor<4xf32>

Cechy: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

mhlo.ceil (mhlo::CeilOp)

Operacja sufitowa

Składnia:

operation ::= `mhlo.ceil` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Wykonuje elementarną funkcję tensora operand i generuje tensor result .

Zobacz: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#ceil

Przykład:

%result = mhlo.ceil %operand : tensor<5xf32>

Cechy: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

mhlo.cholesky (mhlo::ColeskyOp)

Operacja Choleskiego

Oblicza rozkład Choleskiego dla zestawu macierzy.

Zobacz: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#cholesky

Przykład:

%result = mhlo.cholesky %a, lower = true : tensor<3x3xf32>

Cechy: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsAndResultElementType

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

mhlo.clamp (mhlo::ClampOp)

Operacja zacisku

Składnia:

operation ::= `mhlo.clamp` $min `,` $operand `,` $max attr-dict
              `:` custom<SameOperandsAndResultType>(type($min), type($operand), type($max), type($result))

Zaciska każdy element tensora operand pomiędzy wartością minimalną i maksymalną i generuje tensor result .

Zobacz: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#clamp

Przykład:

%result = mhlo.clamp %min, %operand, %max : tensor<3xi32>

Cechy: AlwaysSpeculatableImplTrait , HLO_BroadcastingElementwise , InferTensorType , SameOperandsAndResultElementType

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

Efekty: MemoryEffects::Effect{}

Operandy:

Wyniki:

mhlo.collective_broadcast (mhlo::CollectiveBroadcastOp)

Operacja CollectiveBroadcast

W obrębie każdej grupy procesów w siatce procesów wyślij wartość tensora operand z procesu źródłowego do procesów docelowych i wygeneruj tensor result .

Zobacz: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#collective_broadcast

Przykład:

%result = "mhlo.collective_broadcast"(%operand) {
  replica_groups = dense<[[0, 1]]> : tensor<1x2xi64>,
  channel_handle = #mhlo.channel_handle<handle = 0, type = 0>
} : (tensor<1x2xi64>) -> tensor<1x2xi64>

Cechy: CompatibleOperandsAndResultType

Interfejsy: InferShapedTypeOpInterface , InferTypeOpInterface

Atrybuty:

Operandy:

Wyniki:

mhlo.collective_permute (mhlo::CollectivePermuteOp)

Operacja CollectivePermute

W obrębie każdej grupy procesów w siatce procesów wysyła wartość tensora operand z procesu źródłowego do procesu docelowego i generuje tensor result .

Zobacz: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#collective_permute

Przykład:

%result = "mhlo.collective_permute"(%operand) {
  source_target_pairs = dense<[[0, 1], [1, 2]]> : tensor<2x2xi64>,
  // channel_id = 0
  channel_handle = #mhlo.channel_handle<handle = 0, type = 0>
} : (tensor<4x2xf32>) -> tensor<4x2xf32>

Cechy: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

mhlo.compare (mhlo::CompareOp)

Porównaj operację

Składnia:

operation ::= `mhlo.compare` $comparison_direction `,` $lhs `,` $rhs (`,` $compare_type^)?
              attr-dict `:` functional-type(operands, results)

Wykonuje porównanie elementarne tensorów lhs i rhs zgodnie z comparison_direction i compare_type i generuje tensor result .

Zobacz: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#compare

Przykład:

%result = mhlo.compare LT, %lhs, %rhs, FLOAT : (tensor<2xf32>, tensor<2xf32>) -> tensor<2xi1>

Cechy: AlwaysSpeculatableImplTrait , Elementwise , InferTensorType , SameOperandsAndResultShape , SameOperandsElementType

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

mhlo.complex (mhlo::ComplexOp)

Złożona operacja

Składnia:

operation ::= `mhlo.complex` operands attr-dict
              `:` custom<ComplexOpType>(type($lhs), type($rhs), type($result))

Wykonuje konwersję elementarną na wartość zespoloną z pary wartości rzeczywistych i urojonych, lhs i rhs , i generuje tensor result .

Zobacz: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#complex

Przykład:

%result = mhlo.complex %lhs, %rhs : tensor<2xcomplex<f32>>

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape , SameOperandsElementType

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

Effects: MemoryEffects::Effect{}

Operands:

Wyniki:

mhlo.composite (mhlo::CompositeOp)

Composite operation

Składnia:

operation ::= `mhlo.composite` $name $inputs attr-dict `:` functional-type(operands, results)

Encapsulates an operation made up (composed) of other StableHLO operations, taking inputs and composite_attributes and producing results . The semantics of the op are implemented by the decomposition attribute. The composite op can be replaced with its decomposition without changing program semantics. In cases where inlining the decomposition does not provide the same op semantics, prefer using custom_call .

The version field (defaults to 0 ) is used to denote when a composite's semantics change.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#composite

Przykład:

%results = mhlo.composite "my.op" %arg0, %arg1 {
  decomposition = @my_op,
  composite_attributes = { my_attribute = "my_value" },
  version = 1 : i32
} : (tensor<f32>, tensor<f32>) -> tensor<f32>

Interfaces: SymbolUserOpInterface

Attributes:

Operands:

Wyniki:

mhlo.concatenate (mhlo::ConcatenateOp)

Concatenate operation

Concatenates a variadic number of tensors in inputs along dimension dimension in the same order as the given arguments and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#concatenate

Przykład:

%result = mhlo.concatenate %input0, %input1, dim = 0 : (tensor<3x2xi64>, tensor<1x2xi64>) -> tensor<4x2xi64>

Traits: AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType

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

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Wyniki:

mhlo.constant (mhlo::ConstantOp)

Constant operation

Produces an output tensor from a constant value .

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#constant

Przykład:

%output = mhlo.constant dense<[[0.0, 1.0], [2.0, 3.0]]> : tensor<2x2xf32>

Traits: AlwaysSpeculatableImplTrait , ConstantLike

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Wyniki:

mhlo.convert (mhlo::ConvertOp)

Convert operation

Składnia:

operation ::= `mhlo.convert` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs an element-wise conversion from one element type to another on operand tensor and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#convert

Przykład:

%result = mhlo.convert %operand : (tensor<3xi32>) -> tensor<3xcomplex<f32>>

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Wyniki:

mhlo.convolution (mhlo::ConvolutionOp)

Convolution operation

Składnia:

operation ::= `mhlo.convolution` `(`operands`)`
              `dim_numbers` `=` custom<ConvolutionDimensions>($dimension_numbers) `,`
              `window` `=` `{` custom<WindowAttributes>($window_strides, $padding,
              $lhs_dilation, $rhs_dilation,
              $window_reversal) `}`
              attr-dict `:` functional-type(operands, results)

Computes dot products between windows of lhs and slices of rhs and produces result .

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#convolution

Przykład:

%result = "mhlo.convolution"(%lhs, %rhs) {
  window_strides = dense<4> : tensor<2xi64>,
  padding = dense<0> : tensor<2x2xi64>,
  lhs_dilation = dense<2> : tensor<2xi64>,
  rhs_dilation = dense<1> : tensor<2xi64>,
  window_reversal = dense<false> : tensor<2xi1>,
  dimension_numbers = #mhlo.conv<[b, 0, 1, f]x[0, 1, i, o]->[b, 0, 1, f]>,
  feature_group_count = 1 : i64,
  batch_group_count = 1 : i64,
  precision_config = [#stablehlo<precision DEFAULT>, #stablehlo<precision DEFAULT>]
} : (tensor<1x4x4x1xi32>, tensor<3x3x1x1xi32>) -> tensor<1x2x2x1xi32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Wyniki:

mhlo.copy (mhlo::CopyOp)

Copy operation

Składnia:

operation ::= `mhlo.copy` operands attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

This operation is private to the XLA compiler, so it is does not yet have a specification.

Informally, this operation a copy of operand . Depending on the metadata attached to the operation, it can behave quite differently from a no-op.

Przykład:

%0 = mhlo.copy %arg0 : tensor<f32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise

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

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Wyniki:

mhlo.cosh (mhlo::CoshOp)

Cosh operation

Składnia:

operation ::= `mhlo.cosh` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise cosh operation on operand tensor and produces a result tensor.

Przykład:

%result = mhlo.cosh %operand : tensor<2x2xf32>

Traits: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Operands:

Wyniki:

mhlo.cosine (mhlo::CosineOp)

Cosine operation

Składnia:

operation ::= `mhlo.cosine` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise cosine operation on operand tensor and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#cosine

Przykład:

%result = mhlo.cosine %operand : tensor<2xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Wyniki:

mhlo.count_leading_zeros (mhlo::ClzOp)

Clz operation

Składnia:

operation ::= `mhlo.count_leading_zeros` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise count of the number of leading zero bits in the operand tensor and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#count_leading_zeros

Przykład:

%result = mhlo.count_leading_zeros %operand : tensor<2x2xi8>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Wyniki:

mhlo.create_token (mhlo::CreateTokenOp)

CreateToken operation

Składnia:

operation ::= `mhlo.create_token` attr-dict `:` type(results)

This operation is on its way out of StableHLO, so it is not included in the specification: https://github.com/openxla/stablehlo/issues/3

Informally, this operation does the same thing as AfterAllOp with 0 inputs: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#after_all

Przykład:

%output = mhlo.create_token : !mhlo.token

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Wyniki:

mhlo.cross-replica-sum (mhlo::CrossReplicaSumOp)

CrossReplicaSum operation

This operation is on its way out of StableHLO, so it is not included in the specification: https://github.com/openxla/stablehlo/issues/3

Informally, this operation does the same thing as AllReduceOp with channel_id = 0 , use_global_device_ids = false and computation implementing addition: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#all_reduce

Przykład:

%result = "mhlo.cross-replica-sum"(%operand) {
  replica_groups = dense<[[0, 1]]> : tensor<1x2xi64>
} : (tensor<4xf32>) -> tensor<4xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

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

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Wyniki:

mhlo.custom_call (mhlo::CustomCallOp)

CustomCall operation

Składnia:

operation ::= `mhlo.custom_call` custom<CustomCallTarget>($call_target_name) `(` $inputs `)`
              attr-dict `:` functional-type(operands, results)

Encapsulates an implementation-defined operation call_target_name that takes inputs and called_computations and produces results .

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#custom_call

Przykład:

%results = "mhlo.custom_call"(%input0) {
  call_target_name = "foo",
  has_side_effect = false,
  backend_config = "bar",
  api_version = 1 : i32,
  called_computations = [@foo]
} : (tensor<f32>) -> tensor<f32>

A custom call invokes code external to XLA. The `inputs` are passed to the
external code, and the external code is expected to produce a result of the
given type. The exact mechanism is backend-specific. For example, in the CPU
backend, a call instruction is emitted which targets a symbol with the name
`call_target_name`.

If XLA runtime is enabled for a backend, then custom calls use the runtime
custom call calling convention to call into the external functions. This
calling convention defines an ABI for encoding arguments, attributes and
results.

Depending on the API version there are two ways to pass extra bits of static
information to the external function:

1. For `API_VERSION_TYPED_FFI` custom calls `backend_config` must be a
   dictionary attribute, that will be encoded according to the custom call
   calling convention and passed to the external function as the attributes
   argument. External code is expected to use declarative bindings (see
   `xla/runtime/custom_call.h`) to decode them at run time. These custom
   calls are only supported if XLA uses XLA runtime.

2. For previous API versions it is the user responsibility to encode extra
   bits of static information as a string `backend_config` attribute, and
   decode it at run time.

Interfaces: MemoryEffectOpInterface

Attributes:

Operands:

Wyniki:

mhlo.divide (mhlo::DivOp)

Div operation

Składnia:

operation ::= `mhlo.divide` $lhs `,` $rhs attr-dict
              `:` custom<SameOperandsAndResultType>(type($lhs), type($rhs), type($result))

Performs element-wise division of dividend lhs and divisor rhs tensors and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#divide

Przykład:

%result = mhlo.divide %lhs, %rhs : tensor<4xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Wyniki:

mhlo.domain (mhlo::DomainOp)

Domain operation

This operation is private to the XLA compiler, so it is does not yet have a specification.

Informally, these operations are used to group instructions with the same DomainMetadata property. ShardingMetadata is the main use case today to group instructions on the same device. Domain instructions provide two major benefits:

• Prevent unintentionally optimizing instructions across domains.
• Automatically assign the metadata of the instructions created in the domain. Without domain instructions, each HLO optimization pass would have to check and propagate the metadata, which would be easy to miss and also adds complexity to the compiler. Since domain instructions connect two different domains, each domain instruction is associated with two DomainMetadata -- one on the operand side and one on the user side of the domain.

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

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

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Wyniki:

mhlo.dot (mhlo::DotOp)

Dot operation

This operation is on its way out of StableHLO, so it is not included in the specification: https://github.com/openxla/stablehlo/issues/3

Informally, this operation does the same thing as XLA's Dot: https://www.tensorflow.org/xla/operation_semantics#dot

Przykład:

%0 = mhlo.dot %arg0, %arg1 : (tensor<1x2xi32>, tensor<2x1xi32>) -> tensor<1x1xi32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Wyniki:

mhlo.dot_general (mhlo::DotGeneralOp)

DotGeneral operation

Computes dot products between slices of lhs and slices of rhs and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#dot_general

Przykład:

%result = "mhlo.dot_general"(%lhs, %rhs) {
  dot_dimension_numbers = #mhlo.dot<
    lhs_batching_dimensions = [0],
    rhs_batching_dimensions = [0],
    lhs_contracting_dimensions = [2],
    rhs_contracting_dimensions = [1]
  >,
  precision_config = [#stablehlo<precision DEFAULT>, #stablehlo<precision DEFAULT>]
} : (tensor<2x2x2xi32>, tensor<2x2x2xi32>) -> tensor<2x2x2xi32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Wyniki:

mhlo.dynamic_broadcast_in_dim (mhlo::DynamicBroadcastInDimOp)

DynamicBroadcastInDim operation

This operation is functionally identical to broadcast_in_dim op, but the result shape is specified dynamically via output_dimensions .

It also accepts optional attributes to express static knowledge about the expanding behavior of dimensions. If not specified, all dimensions are assumed to be possibly expanding. The sets of dimensions that are known to be expanding and the set of dimensions that are known to be non-expanding must be disjoint and they must be a subset of the operand's dimensions.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#dynamic_broadcast_in_dim

Przykład:

%operand = mhlo.constant dense<[[1, 2, 3]]> : tensor<1x3xi64>
%output_dimensions = mhlo.constant dense<[2, 3, 2]> : tensor<3xi64>
%result = "mhlo.dynamic_broadcast_in_dim"(%operand, %output_dimensions) {
  broadcast_dimensions = array<i64: 2, 1>,
  known_expanding_dimensions = array<i64: 0>,
  known_nonexpanding_dimensions = array<i64: 1>
} : (tensor<1x3xi64>, tensor<3xi64>) -> tensor<2x3x2xi64>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Wyniki:

mhlo.dynamic_conv (mhlo::DynamicConvOp)

DynamicConv operation

This operation is a work in progress, so it is not yet included in the specification: https://github.com/openxla/stablehlo/issues/8

Informally, this operation does the same thing as ConvolutionOp except that padding is specified dynamically via d_padding : https://github.com/openxla/stablehlo/blob/main/docs/spec.md#convolution

Przykład:

%result = "mhlo.dynamic_conv"(%lhs, %rhs, %d_padding) {
  window_strides = dense<4> : tensor<2xi64>,
  lhs_dilation = dense<2> : tensor<2xi64>,
  rhs_dilation = dense<1> : tensor<2xi64>,
  window_reversal = dense<false> : tensor<2xi1>,
  dimension_numbers = #mhlo.conv<[b, 0, 1, f]x[0, 1, i, o]->[b, 0, 1, f]>,
  feature_group_count = 1 : i64,
  batch_group_count = 1 : i64,
  precision_config = [#stablehlo<precision DEFAULT>, #stablehlo<precision DEFAULT>]
} : (tensor<1x4x4x1xi32>, tensor<3x3x1x1xi32>, tensor<2x2xi64>) -> tensor<1x2x2x1xi32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Wyniki:

mhlo.dynamic_gather (mhlo::DynamicGatherOp)

DynamicGather operation

This operation is a work in progress, so it is not yet included in the specification: https://github.com/openxla/stablehlo/issues/8

Informally, this operation does the same thing as GatherOp except that slice_sizes are specified dynamically: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#gather

Przykład:

%result = "mhlo.dynamic_gather"(%operand, %start_indices, %slice_sizes) {
  dimension_numbers = #mhlo.gather<
    offset_dims = [2, 3],
    collapsed_slice_dims = [0],
    start_index_map = [0, 2],
    index_vector_dim = 2>,
  indices_are_sorted = false
} : (tensor<3x4x2xi32>, tensor<2x3x2xi64>, tensor<3xi64>) -> tensor<2x3x2x2xi32>

Traits: AlwaysSpeculatableImplTrait , InferTensorType

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

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Wyniki:

mhlo.dynamic_iota (mhlo::DynamicIotaOp)

DynamicIota operation

This operation is functionally identical to iota op, but the result shape is specified dynamically via output_shape .

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#dynamic_iota

Przykład:

%0 = mhlo.dynamic_iota %arg0, dim = 0 : (tensor<1xindex>) -> tensor<4xi32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Wyniki:

mhlo.dynamic_pad (mhlo::DynamicPadOp)

DynamicPad operation

Składnia:

operation ::= `mhlo.dynamic_pad` operands attr-dict `:` functional-type(operands, results)

Dynamically Pads the operand , with amount of padding added at low-end/high-end/interior is passed through input tensors.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Wyniki:

mhlo.dynamic_reshape (mhlo::DynamicReshapeOp)

DynamicReshape operation

Składnia:

operation ::= `mhlo.dynamic_reshape` operands attr-dict `:` functional-type(operands, results)

This operation is functionally identical to reshape op, but the result shape is specified dynamically via output_shape .

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#dynamic_reshape

Przykład:

%output_shape = mhlo.constant dense<[3, 2]> : tensor<2xi64>
%result = mhlo.dynamic_reshape %operand, %output_shape : (tensor<2x3xi64>, tensor<2xi64>) -> tensor<3x2xi64>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Wyniki:

mhlo.dynamic_slice (mhlo::DynamicSliceOp)

DynamicSlice operation

Extracts a slice from the operand using dynamically-computed starting indices and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#dynamic_slice

Przykład:

%result = mhlo.dynamic_slice %operand, %start_indices0, %start_indices1, sizes = [2, 2]
  : (tensor<4x4xi32>, tensor<i64>, tensor<i64>) -> tensor<2x2xi32>

Traits: AlwaysSpeculatableImplTrait , InferTensorType

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

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Wyniki:

mhlo.dynamic_update_slice (mhlo::DynamicUpdateSliceOp)

DynamicUpdateSlice operation

Składnia:

operation ::= `mhlo.dynamic_update_slice` operands attr-dict `:` functional-type(operands, results)

Produces a result tensor which is equal to the operand tensor except that the slice starting at start_indices is updated with the values in update .

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#dynamic_update_slice

Przykład:

%result = mhlo.dynamic_update_slice %operand, %update, %start_indices0, %start_indices1
  : (tensor<4x4xi32>, tensor<2x2xi32>, tensor<i64>, tensor<i64>) -> tensor<4x4xi32>

Traits: AlwaysSpeculatableImplTrait , InferTensorType

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

Effects: MemoryEffects::Effect{}

Operands:

Wyniki:

mhlo.einsum (mhlo::EinsumOp)

Einsum operation

This operation is on its way out of StableHLO, so it is not included in the specification: https://github.com/openxla/stablehlo/issues/3

Informally, this operation does the same thing as TF's einsum: https://www.tensorflow.org/api_docs/python/tf/einsum

Przykład:

%result = "mhlo.einsum"(%lhs, %rhs) {
  einsum_config = "ab,bc->ac"
} : (tensor<4x16xf32>, tensor<16x4xf32>) -> tensor<4x4xf32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Wyniki:

mhlo.erf (mhlo::ErfOp)

Erf operation

Składnia:

operation ::= `mhlo.erf` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise erf operation on operand tensor and produces a result tensor.

Przykład:

%result = mhlo.erf %operand : tensor<2x2xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Wyniki:

mhlo.exponential (mhlo::ExpOp)

Exp operation

Składnia:

operation ::= `mhlo.exponential` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise exponential operation on operand tensor and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#exponential

Przykład:

%result = mhlo.exponential %operand : tensor<2x2xf64>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Wyniki:

mhlo.exponential_minus_one (mhlo::Expm1Op)

Expm1 operation

Składnia:

operation ::= `mhlo.exponential_minus_one` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise exponential minus one operation on operand tensor and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#exponential_minus_one

Przykład:

%result = mhlo.exponential_minus_one %operand : tensor<2xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Wyniki:

mhlo.fft (mhlo::FftOp)

Fft operation

Performs the forward and inverse Fourier transforms for real and complex inputs/outputs.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#fft

Przykład:

%result = mhlo.fft %operand, type = FFT, length = [4] : (tensor<4xcomplex<f32>>) -> tensor<4xcomplex<f32>>

Traits: AlwaysSpeculatableImplTrait , InferTensorType

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

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Wyniki:

mhlo.floor (mhlo::FloorOp)

Floor operation

Składnia:

operation ::= `mhlo.floor` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise floor of operand tensor and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#floor

Przykład:

%result = mhlo.floor %operand : tensor<2xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Wyniki:

mhlo.fusion (mhlo::FusionOp)

Fusion operation

This operation is private to the XLA compiler, so it is does not yet have a specification.

Informally, this operation consists of a group of basic ops (represented as a region attached to it). It serves as a hint to the backend that it is beneficial to emit the contained ops into a single loop nest or kernel.

Attributes:

Operands:

Wyniki:

mhlo.gather (mhlo::GatherOp)

Gather operation

Gathers slices from operand tensor from offsets specified in start_indices and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#gather

Przykład:

%result = "mhlo.gather"(%operand, %start_indices) {
  dimension_numbers = #stablehlo.gather<
    offset_dims = [3, 4],
    collapsed_slice_dims = [1],
    operand_batching_dims = [0],
    start_indices_batching_dims = [1],
    start_index_map = [2, 1],
    index_vector_dim = 3>,
  slice_sizes = dense<[0, 2, 2]> : tensor<3xi64>,
  indices_are_sorted = false
} : (tensor<2x3x4x2xi64>, tensor<2x2x3x2xi64>) -> tensor<2x2x3x2x2xi64>

Traits: AlwaysSpeculatableImplTrait , InferTensorType

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

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Wyniki:

mhlo.get_dimension_size (mhlo::GetDimensionSizeOp)

GetDimensionSize operation

Produces the size of the given dimension of the operand .

See https://github.com/openxla/stablehlo/blob/main/docs/spec.md#get_dimension_size

Przykład:

%result = mhlo.get_dimension_size %operand, dim = 1 : (tensor<2x3xf32>) -> tensor<i32>

Traits: AlwaysSpeculatableImplTrait , InferTensorType

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

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Wyniki:

mhlo.get_tuple_element (mhlo::GetTupleElementOp)

GetTupleElement operation

Składnia:

operation ::= `mhlo.get_tuple_element` $operand `[` $index `]` attr-dict `:` functional-type(operands, results)