`mhlo` Dialekt

Operacje

mhlo.abs (mhlo::AbsOp)

Operacja ABS

Składnia:

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

Wykonuje elementarną operację abs na tensorze operand 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.add (mhlo::AddOp)

Dodaj operację

Składnia:

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

Wykonuje elementarne dodawanie dwóch tensorów lhs i rhs i tworzy 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)

Ta operacja jest prywatna dla kompilatora XLA, więc nie ma jeszcze specyfikacji.

Nieformalnie ta operacja składa się z dwóch operandów: operandu danych i tokenu. Wynikiem operacji jest operand danych. W przypadku użycia z AfterAll ta operacja umożliwia porządkowanie operacji, które nie powodują skutków ubocznych (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)

Po całej operacji

Składnia:

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

Zapewnia, że ​​operacje generujące inputs zostaną wykonane przed jakimikolwiek 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 każdej grupie procesów w siatce procesów łączy wartości tensora operandu z każdego procesu wzdłuż all_gather_dim i tworzy tensor wynikowy. computation są stosowane oddzielnie dla każdego operandu w operands , dając jeden wynik na każdy 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 obrębie każdej grupy procesów w siatce procesów stosuje computation funkcji redukcji do wartości tensora argumentu z każdego procesu i tworzy tensor wynikowy. computation są stosowane oddzielnie dla każdego operandu w operands , dając jeden wynik na każdy 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 tworzy 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 tworzy 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.async_done (mhlo::AsyncDoneOp)

Operacja AsyncDone

Ta operacja jest prywatna dla kompilatora XLA, więc nie ma jeszcze specyfikacji.

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

Aby uzyskać więcej informacji, zobacz dokumentację AsyncStart.

Interfejsy: InferTypeOpInterface

Operandy:

Wyniki:

mhlo.async_start (mhlo::AsyncStartOp)

Operacja AsyncStart

Ta operacja jest prywatna dla kompilatora XLA, więc nie ma jeszcze specyfikacji.

Nieformalnie ta operacja rozpoczyna obliczenia asynchroniczne.

Jest to używane, gdy istnieją funkcje, które zawierają zarówno oczekiwania asynchroniczne (takie jak DMA), jak i obliczenia w wątku. Na przykład funkcja może składać się z obliczenia, DMA, innego obliczenia, drugiego DMA i obliczenia końcowego. Byłoby to reprezentowane jako async_start, po którym następują async_update i async_done. Async_start wykona pierwsze obliczenia w wątku, a następnie uruchomi DMA. Async_update będzie czekać na zakończenie DMA, jeśli nie zostało to jeszcze zrobione, następnie wykona drugie obliczenie w funkcji i uruchomi drugie DMA. Na koniec funkcja async_done zaczeka na ostatnie DMA, a następnie uruchomi ostatnie obliczenia, które należy wykonać w wątku, i zwróci wynik tego końcowego 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 ona uruchomiona. Główny wątek nazywany jest „głównym”. Wszystkie wątki mają nazwy.

Zwraca to cały stan potrzebny między operacjami asynchronicznymi. Po przypisaniu bufora zwracane wartości reprezentują miejsce potrzebne do przechowywania danych wejściowych, wyników i wszelkich notatników potrzebnych lub edytowanych przez operację asynchroniczną.

Atrybuty:

Operandy:

Wyniki:

mhlo.async_update (mhlo::AsyncUpdateOp)

Operacja AsyncUpdate

Ta operacja jest prywatna dla kompilatora XLA, więc nie ma jeszcze specyfikacji.

Nieformalnie ta operacja blokuje obliczenia asynchroniczne aż do bariery synchronizacji. Zwraca bundle po wykonaniu na nim operacji.

Aby uzyskać więcej informacji, zobacz dokumentację 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 elementarną operację atan2 na tensorze 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.batch_norm_grad (mhlo::BatchNormGradOp)

Operacja BatchNormGrad

Oblicza gradienty kilku danych wejściowych BatchNormTrainingOp propagujące wstecznie z grad_output i tworzy 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 tworzy 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 funkcji w wymiarze feature_index i tworzy tensory output , 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 bitccast

Składnia:

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

Ta operacja jest prywatna dla kompilatora XLA, więc nie ma jeszcze specyfikacji.

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

Ta operacja 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)

Effects: MemoryEffects::Effect{}

Operands:

Wyniki:

mhlo.bitcast_convert (MHLO :: BitcastConvertop)

Operacja bitcastConvert

Składnia:

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

Wykonuje operację bitowanego w tensorze operand i wytwarza tensor result , w którym bity całego tensora operand są ponownie interpretowane 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)

Effects: MemoryEffects::Effect{}

Operands:

Wyniki:

mhlo.broadcast (Mhlo :: Broadcastop)

Operacja transmisji

Ta operacja jest w drodze ze StableHlo, więc nie jest zawarta w specyfikacji: https://github.com/openxla/stablehlo/issues/3

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

Przykład:

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

Cechy: AlwaysSpeculatableImplTrait spekulatibleimpltrait, InferTensorType , SameOperandsAndResultElementType

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

Effects: MemoryEffects::Effect{}

Atrybuty:

Operands:

Wyniki:

mhlo.broadcast_in_dim (MHLO :: BroadcastIndimop)

Operacja transmisji

Rozszerza wymiary i/lub ranga tensor wejściowego poprzez powielanie danych w tensorze operand i wytwarza 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)

Effects: MemoryEffects::Effect{}

Atrybuty:

Operands:

Wyniki:

mhlo.case (Mhlo :: caseop)

Operacja sprawy

Wytwarza dane wyjściowe z wykonywania 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

Operands:

Wyniki:

mhlo.cbrt (Mhlo :: CBRTOP)

Operacja CBRT

Składnia:

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

Wykonuje elementarne działanie korzeni sześciennych na tensor operand i wytwarza tensor result .

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

Przykład:

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

Cechy: AlwaysSpeculatableImplTrait spekulatibleImpltrait, CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Wyniki:

mhlo.ceil (Mhlo :: Ceilop)

Operacja CEIL

Składnia:

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

Wykonuje elementowy CEIL Tensor operand i wytwarza tensor result .

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

Przykład:

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

Cechy: AlwaysSpeculatableImplTrait spekulatibleImpltrait, CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Wyniki:

mhlo.cholesky (Mhlo :: Choleskyop)

Cholesky Operacja

Oblicza rozkład choleski partii 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 spekulatibleimpltrait, InferTensorType , SameOperandsAndResultElementType

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

Effects: MemoryEffects::Effect{}

Atrybuty:

Operands:

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

Zacisuje każdy element tensor operand między minimalną a maksymalną wartością i wytwarza 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 spekulatibleImpltrait, HLO_BroadcastingElementwise , InferTensorType , SameOperandsAndResultElementType

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

Effects: MemoryEffects::Effect{}

Operands:

Wyniki:

mhlo.collective_broadcast (MHLO :: CollectiveBroadcastop)

Operacja CollectiveBroadcast

W każdej grupie procesu w siatce procesowej wyślij wartość tensor operand z procesu źródłowego do procesów docelowych i wytworzyć 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:

Operands:

Wyniki:

mhlo.collective_permute (Mhlo :: CollectivePermuteop)

Działanie zbiorowe

W każdej grupie procesu w sieci procesowej wysyła wartość tensor operand z procesu źródłowego do procesu docelowego i wytwarza 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 spekulatibleImpltrait, CompatibleOperandsAndResultType

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

Effects: MemoryEffects::Effect{}

Atrybuty:

Operands:

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 elementarne porównanie tensorów lhs i rhs zgodnie z comparison_direction i compare_type , i wytwarza tensor result .

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

Przykład:

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

Cechy: AlwaysSpeculatableImplTrait spekulatibleimpltrait, Elementwise , InferTensorType , SameOperandsAndResultShape , SameOperandsElementType

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

Effects: MemoryEffects::Effect{}

Atrybuty:

Operands:

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 elementarną konwersję na złożoną wartość z pary rzeczywistych i wyobrażonych wartości, lhs i rhs , i wytwarza tensor result .

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

Przykład:

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

Cechy: AlwaysSpeculatableImplTrait spekulatibleImpltrait, Elementwise , SameOperandsAndResultShape , SameOperandsElementType

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

Effects: MemoryEffects::Effect{}

Operands:

Wyniki:

mhlo.composite (MHLO :: compositeop)

Operacja złożona

Składnia:

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

Ekapsuluje wykonaną (skomponowaną) (skomponowane) innych operacji stabilnych, przyjmując inputs i composite_attributes oraz results . Semantyka OP są wdrażane przez atrybut decomposition . composite OP można zastąpić rozkładem bez zmiany semantyki programowej. W przypadkach, w których inlinowanie rozkładu nie zapewnia takiej samej semantyki OP, wolą użyć custom_call .

Pole version (domyślnie do 0 ) służy do oznaczenia, gdy zmienia się semantyka kompozytowa.

Zobacz: 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>

Interfejsy: SymbolUserOpInterface

Atrybuty:

Operands:

Wyniki:

mhlo.concatenate (Mhlo :: conatenateop)

Operacja związana

Łączy zmienadową liczbę tensorów w inputs wzdłuż wymiaru dimension w tej samej kolejności co podane argumenty i wytwarza tensor result .

Zobacz: 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>

Cechy: AlwaysSpeculatableImplTrait spekulatibleimpltrait, SameOperandsAndResultElementType

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

Effects: MemoryEffects::Effect{}

Atrybuty:

Operands:

Wyniki:

mhlo.constant (Mhlo :: Constantop)

Stała operacja

Wytwarza tensor output ze stałej value .

Zobacz: 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>

Cechy: AlwaysSpeculatableImplTrait ConstantLike

Interfejsy: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Atrybuty:

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

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.

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

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

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

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)

Extracts element at index position of the operand tuple and produces a result .

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

Przykład:

%result = mhlo.get_tuple_element %operand[0] : (tuple<tensor<2xf32>, tuple<tensor<i32>>>) -> tensor<2xf32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

Wyniki:

mhlo.if (mhlo::IfOp)

If operation

Produces the output from executing exactly one branch from true_branch or false_branch depending on the value of pred .

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

Example: %result = "mhlo.if"(%pred) ({ "mhlo.return"(%result_true_branch) : (tensor ) -> () }, { "mhlo.return"(%result_false_branch) : (tensor ) -> () }) : (tensor ) -> tensor

Traits: RecursiveMemoryEffects , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfaces: InferTypeOpInterface

Operands:

Wyniki:

mhlo.imag (mhlo::ImagOp)

Imag operation

Składnia:

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

Extracts the imaginary part, element-wise, from the operand and produces a result tensor.

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

Przykład:

%result = mhlo.imag %operand : (tensor<2xcomplex<f32>>) -> tensor<2xf32>

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Wyniki:

mhlo.infeed (mhlo::InfeedOp)

Infeed operation

Reads data from the infeed and produces results .

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

Przykład:

%results:2 = "mhlo.infeed"(%token) {
  infeed_config = ""
} : (!mhlo.token) -> (tensor<3x3x3xi32>, !mhlo.token)

Attributes:

Operands:

Wyniki:

mhlo.iota (mhlo::IotaOp)

Iota operation

Fills an output tensor with values in increasing order starting from zero along the iota_dimension dimension.

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

Przykład:

%output = mhlo.iota dim = 0 : tensor<4x5xi32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Wyniki:

mhlo.is_finite (mhlo::IsFiniteOp)

IsFinite operation

Składnia:

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

Performs element-wise check whether the value in x is finite (ie is neither +Inf, -Inf, nor NaN) and produces a y tensor.

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

Przykład:

%y = mhlo.is_finite %x : (tensor<7xf32>) -> tensor<7xi1>

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Wyniki:

mhlo.log (mhlo::LogOp)

Log operation

Składnia:

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

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

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

Przykład:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Wyniki: