'mhlo' Dialetto

Operazioni

mhlo.abs (mhlo::AbsOp)

Operazione dell'ABS

Sintassi:

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

Esegue l'operazione ABS per elemento sul tensore operand e produce un tensore result .

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

Esempio:

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

Caratteristiche: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

mhlo.add (mhlo::AddOp)

Aggiungi operazione

Sintassi:

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

Esegue l'addizione per elemento di due tensori lhs e rhs e produce un tensore result .

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

Esempio:

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

Caratteristiche: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

mhlo.add_dependency (mhlo::AddDependencyOp)

Operazione AddDependency

Sintassi:

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

Questa operazione è privata per il compilatore XLA, quindi non ha ancora una specifica.

Informalmente, questa operazione ha due operandi: un operando dati e un token. L'output dell'operazione è l'operando dati. Se utilizzata con AfterAll, questa operazione consente di ordinare operazioni senza effetti collaterali (quelle che non producono valori token).

Esempio:

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

Tratti: AlwaysSpeculatableImplTrait

Interfacce: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

mhlo.after_all (mhlo::AfterAllOp)

Operazione AfterAll

Sintassi:

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

Garantisce che le operazioni che producono gli inputs vengano eseguite prima di qualsiasi operazione che dipenda da result .

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

Esempio:

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

Tratti: AlwaysSpeculatableImplTrait

Interfacce: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

mhlo.all_gather (mhlo::AllGatherOp)

Operazione AllGather

All'interno di ciascun gruppo di processi nella griglia dei processi, concatena i valori del tensore dell'operando di ciascun processo lungo all_gather_dim e produce un tensore del risultato. Il computation viene applicato separatamente per ciascun operando in operands , producendo un risultato per operando.

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

Esempio:

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

Caratteristiche: SameOperandsAndResultElementType

Attributi:

Operandi:

Risultati:

mhlo.all_reduce (mhlo::AllReduceOp)

Operazione AllReduce

All'interno di ciascun gruppo di processi nella griglia dei processi, applica un computation della funzione di riduzione ai valori di un tensore dell'operando di ciascun processo e produce un tensore del risultato. Il computation viene applicato separatamente per ciascun operando in operands , producendo un risultato per operando.

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

Esempio:

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

Caratteristiche: InferTensorType , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfacce: InferShapedTypeOpInterface , InferTypeOpInterface

Attributi:

Operandi:

Risultati:

mhlo.all_to_all (mhlo::AllToAllOp)

Operazione AllToAll

All'interno di ciascun gruppo di processi nella griglia dei processi, divide i valori del tensore operand lungo split_dimension in parti, distribuisce le parti divise tra i processi, concatena le parti sparse lungo concat_dimension e produce un tensore result .

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

Esempio:

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

Caratteristiche: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsElementType , SameOperandsShape , SameVariadicOperandSize

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

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

mhlo.and (mhlo::AndOp)

E funzionamento

Sintassi:

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

Esegue l'AND per elemento di due tensori lhs e rhs e produce un tensore result

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

Esempio:

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

Caratteristiche: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

mhlo.async_done (mhlo::AsyncDoneOp)

Operazione AsyncDone

Questa operazione è privata per il compilatore XLA, quindi non ha ancora una specifica.

Informalmente, questa operazione si blocca fino alla fine di un calcolo asincrono. Restituisce il risultato finale del calcolo asincrono.

Per ulteriori informazioni, consultare la documentazione di AsyncStart.

Interfacce: InferTypeOpInterface

Operandi:

Risultati:

mhlo.async_start (mhlo::AsyncStartOp)

Operazione AsyncStart

Questa operazione è privata per il compilatore XLA, quindi non ha ancora una specifica.

Informalmente, questa operazione dà il via ad un calcolo asincrono.

Viene utilizzato quando sono presenti funzioni che contengono sia attese asincrone (come DMA) che calcoli sul thread. Ad esempio, una funzione potrebbe consistere in un calcolo, un DMA, un altro calcolo, un secondo DMA e un calcolo finale. Questo verrebbe rappresentato come async_start seguito da async_update e async_done. async_start eseguirà il primo calcolo sul thread e quindi avvierà il DMA. Async_update attenderebbe il completamento del DMA se non fosse ancora stato completato, quindi eseguirebbe il secondo calcolo nella funzione e avvierebbe il secondo DMA. Infine, async_done attenderà quest'ultimo DMA, quindi eseguirà l'ultimo calcolo che deve essere eseguito sul thread e restituirà il risultato di quel calcolo finale.

operands vengono passati direttamente al calcolo called_computation è la funzione che verrà eseguita in modo asincrono execution_thread è il nome del thread in cui verrà eseguita. Il thread principale si chiama "main". Tutti i thread hanno nomi.

Ciò restituisce tutto lo stato necessario tra le operazioni asincrone. Dopo l'assegnazione del buffer, i valori restituiti rappresentano lo spazio necessario per contenere l'input, i risultati e gli eventuali appunti necessari o modificati dall'operazione asincrona.

Attributi:

Operandi:

Risultati:

mhlo.async_update (mhlo::AsyncUpdateOp)

Operazione AsyncUpdate

Questa operazione è privata per il compilatore XLA, quindi non ha ancora una specifica.

Informalmente, questa operazione si blocca su un calcolo asincrono fino a quando non si incontra una barriera di sincronizzazione. Questo restituisce bundle dopo aver operato su di esso.

Per ulteriori informazioni, consultare la documentazione di AsyncStart.

Interfacce: InferTypeOpInterface

Operandi:

Risultati:

mhlo.atan2 (mhlo::Atan2Op)

Operazione Atan2

Sintassi:

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

Esegue l'operazione atan2 a livello di elemento sui tensori lhs e rhs e produce un tensore result .

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

Esempio:

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

Caratteristiche: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

mhlo.batch_norm_grad (mhlo::BatchNormGradOp)

Operazione BatchNormGrad

Calcola i gradienti di diversi input di BatchNormTrainingOp propaganti all'indietro da grad_output e produce tensori grad_operand , grad_scale e grad_offset .

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

Esempio:

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

Caratteristiche: AlwaysSpeculatableImplTrait , InferTensorType

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

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

mhlo.batch_norm_inference (mhlo::BatchNormInferenceOp)

Operazione BatchNormInference

Normalizza il tensore operand su tutte le dimensioni ad eccezione della dimensione feature_index e produce un tensore result .

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

Esempio:

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

Caratteristiche: AlwaysSpeculatableImplTrait , InferTensorType

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

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

mhlo.batch_norm_training (mhlo::BatchNormTrainingOp)

Operazione BatchNormTraining

Calcola la media e la varianza tra le dimensioni batch e spaziali e normalizza il tensore operand per ciascuna caratteristica nella dimensione feature_index e produce tensori output , batch_mean e batch_var .

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

Esempio:

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

Caratteristiche: AlwaysSpeculatableImplTrait , InferTensorType

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

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

mhlo.bitcast (mhlo :: bitcastop)

Operazione bitcast

Sintassi:

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

Questa operazione è privata per il compilatore XLA, quindi non ha ancora una specifica.

Informalmente, questa operazione cambia la forma dell'input nel modo in cui la disposizione fisica degli elementi è invariata.

Questa operazione necessita di informazioni sul layout per dare un senso alla "disposizione fisica degli elementi" e il supporto del layout in MHLO è attualmente un lavoro in corso.

Esempio:

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

Tratti: AlwaysSpeculatableImplTrait

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

mhlo.bitcast_convert (mhlo :: bitcastConvertop)

Operazione BitcastConvert

Sintassi:

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

Esegui un'operazione bitcast sul tensore operand e produce un tensore result in cui i bit dell'intero tensore operand vengono reinterpretati usando il tipo di tensore del result .

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

Esempio:

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

Tratti: AlwaysSpeculatableImplTrait

Interfacce: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

mhlo.broadcast (MHLO :: Broadcastop)

Operazione di trasmissione

Questa operazione è uscita da StableHLO, quindi non è inclusa nella specifica: https://github.com/openxla/stablehlo/issues/3

Informalmente, questa operazione fa la stessa cosa della trasmissione di XLA: https://www.tensorflow.org/xla/operation_semantics#Broadcast

Esempio:

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

Tratti: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsAndResultElementType

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

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

mhlo.broadcast_in_dim (MHLO :: BroadcastInDimop)

Operazione di trasmissione

Espande le dimensioni e/o il rango di un tensore di input duplicando i dati nel tensore operand e produce un tensore result .

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

Esempio:

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

Tratti: AlwaysSpeculatableImplTrait , HLO_CompatibleOperandsAndResultElementType

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

mhlo.case (mhlo :: caseop)

Operazione del caso

Produce l'output dall'esecuzione esattamente di una function dai branches a seconda del valore index .

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

Esempio:

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

Tratti: RecursiveMemoryEffects , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfacce: InferTypeOpInterface

Operandi:

Risultati:

mhlo.cbrt (mhlo :: cbrtop)

Funzionamento CBRT

Sintassi:

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

Esegue il funzionamento della radice cubica a livello di elemento sul tensore operand e produce un tensore result .

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

Esempio:

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

Tratti: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType operandsandResultType, Elementwise , SameOperandsAndResultShape

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

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

mhlo.ceil (mhlo :: ceilop)

Funzionamento del CEIL

Sintassi:

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

Esegue il tetto del tessore operand e produce un tensore result .

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

Esempio:

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

Tratti: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType operandsandResultType, Elementwise , SameOperandsAndResultShape

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

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

mhlo.cholesky (mhlo :: choleskyop)

Operazione Cholesky

Calcola la decomposizione di Cholesky di un lotto di matrici.

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

Esempio:

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

Tratti: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsAndResultElementType

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

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

mhlo.clamp (MHLO :: CLAMPOP)

Operazione di morsetto

Sintassi:

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

Brampia ogni elemento del tensore operand e un valore minimo e massimo e produce un tensore result .

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

Esempio:

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

Tratti: AlwaysSpeculatableImplTrait SpeculableImplTrait, HLO_BroadcastingElementwise , InferTensorType , SameOperandsAndResultElementType

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

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

mhlo.collective_broadcast (MHLO :: CollectiveBroadcastop)

Operazione collettiva di roadcast

All'interno di ciascun gruppo di processo nella griglia di processo, inviare il valore del tensore operand dal processo di origine ai processi target e produrre un tensore result .

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

Esempio:

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

Tratti: CompatibleOperandsAndResultType

Interfacce: InferShapedTypeOpInterface , InferTypeOpInterface

Attributi:

Operandi:

Risultati:

mhlo.collective_permute (mhlo :: collettivopermuteop)

Operazione collettiva permute

All'interno di ciascun gruppo di processo nella griglia di processo, invia il valore del tensore operand dal processo di origine al processo target e produce un tensore result .

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

Esempio:

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

Tratti: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

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

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

mhlo.compare (MHLO :: ConfrontaP)

Confronta l'operazione

Sintassi:

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

Esegue il confronto a livello di elemento di tensori lhs e rhs secondo comparison_direction e compare_type e produce un tensore result .

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

Esempio:

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

Tratti: AlwaysSpeculatableImplTrait , Elementwise , InferTensorType , SameOperandsAndResultShape , SameOperandsElementType

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

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

mhlo.complex (MHLO :: Complessop)

Operazione complessa

Sintassi:

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

Esegue la conversione da elemento in un valore complesso da una coppia di valori reali e immaginari, lhs e rhs e produce un tensore result .

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

Esempio:

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

Tratti: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape , SameOperandsElementType

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

Effetti: MemoryEffects::Effect{}

Operandi:

Risultati:

mhlo.composite (MHLO :: Compositeop)

Operazione composita

Sintassi:

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

Incapsula un'operazione costituita (composta) di altre operazioni di Stablehlo, prendendo inputs e composite_attributes e producendo results . La semantica dell'OP è implementata dall'attributo decomposition . L'OP composite può essere sostituito con la sua decomposizione senza modificare la semantica del programma. Nei casi in cui in linea la decomposizione non fornisce la stessa semantica OP, preferisci l'uso di custom_call .

Il campo version (impostazione predefinita su 0 ) viene utilizzato per indicare quando la semantica di una composita cambia.

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

Esempio:

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

Interfacce: SymbolUserOpInterface

Attributi:

Operandi:

Risultati:

mhlo.concatenate (MHLO :: ConcateNateop)

Operazione concatenata

Concatena un numero variadico di tensori negli inputs lungo la dimensione dimension nello stesso ordine degli argomenti indicati e produce un tensore result .

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

Esempio:

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

Tratti: AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType

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

Effetti: MemoryEffects::Effect{}

Attributi:

Operandi:

Risultati:

mhlo.constant (MHLO :: Constantop)

Operazione costante

Produce un tensore output da un value costante.

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

Esempio:

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

Tratti: AlwaysSpeculatableImplTrait , ConstantLike

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributi:

Results:

mhlo.convert (mhlo::ConvertOp)

Convert operation

Sintassi:

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

Esempio:

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

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Results:

mhlo.convolution (mhlo::ConvolutionOp)

Convolution operation

Sintassi:

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

Esempio:

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

Attributi:

Operands:

Results:

mhlo.copy (mhlo::CopyOp)

Copy operation

Sintassi:

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.

Esempio:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise

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

Effects: MemoryEffects::Effect{}

Attributi:

Operands:

Results:

mhlo.cosine (mhlo::CosineOp)

Cosine operation

Sintassi:

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

Esempio:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Results:

mhlo.count_leading_zeros (mhlo::ClzOp)

Clz operation

Sintassi:

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

Esempio:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Results:

mhlo.create_token (mhlo::CreateTokenOp)

CreateToken operation

Sintassi:

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

Esempio:

%output = mhlo.create_token : !mhlo.token

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Results:

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

Esempio:

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

Attributi:

Operands:

Results:

mhlo.custom_call (mhlo::CustomCallOp)

CustomCall operation

Sintassi:

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

Esempio:

%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

Attributi:

Operands:

Results:

mhlo.divide (mhlo::DivOp)

Div operation

Sintassi:

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

Esempio:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Results:

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

Attributi:

Operands:

Results:

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

Esempio:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributi:

Operands:

Results:

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

Esempio:

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

Attributi:

Operands:

Results:

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

Esempio:

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

Attributi:

Operands:

Results:

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

Esempio:

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

Attributi:

Operands:

Results:

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

Esempio:

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

Attributi:

Operands:

Results:

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

Esempio:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributi:

Operands:

Results:

mhlo.dynamic_pad (mhlo::DynamicPadOp)

DynamicPad operation

Sintassi:

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:

Results:

mhlo.dynamic_reshape (mhlo::DynamicReshapeOp)

DynamicReshape operation

Sintassi:

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

Esempio:

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

Results:

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

Esempio:

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

Attributi:

Operands:

Results:

mhlo.dynamic_update_slice (mhlo::DynamicUpdateSliceOp)

DynamicUpdateSlice operation

Sintassi:

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

Esempio:

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

Results:

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

Esempio:

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

Attributi:

Operands:

Results:

mhlo.erf (mhlo::ErfOp)

Erf operation

Sintassi:

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

Esempio:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Results:

mhlo.exponential (mhlo::ExpOp)

Exp operation

Sintassi:

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

Esempio:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Results:

mhlo.exponential_minus_one (mhlo::Expm1Op)

Expm1 operation

Sintassi:

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

Esempio:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Results:

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

Esempio:

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

Attributi:

Operands:

Results:

mhlo.floor (mhlo::FloorOp)

Floor operation

Sintassi:

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

Esempio:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Results:

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.

Attributi:

Operands:

Results:

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

Esempio:

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

Attributi:

Operands:

Results:

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

Esempio:

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

Traits: AlwaysSpeculatableImplTrait , InferTensorType

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

Effects: MemoryEffects::Effect{}

Attributi:

Operands:

Results:

mhlo.get_tuple_element (mhlo::GetTupleElementOp)

GetTupleElement operation

Sintassi:

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

Esempio:

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

Attributi:

Operands:

Results:

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:

Results:

mhlo.imag (mhlo::ImagOp)

Imag operation

Sintassi:

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

Esempio:

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

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Results:

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

Esempio:

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

Attributi:

Operands:

Results:

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

Esempio:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributi:

Results:

mhlo.is_finite (mhlo::IsFiniteOp)

IsFinite operation

Sintassi:

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

Esempio:

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

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Results:

mhlo.log (mhlo::LogOp)

Log operation

Sintassi:

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

Esempio:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Results: