'mhlo' Dialeto

Operações

mhlo.abs (mhlo::AbsOp)

Operação de abdômen

Sintaxe:

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

Executa operação abs elemento a elemento no tensor operand e produz um tensor result .

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

Exemplo:

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

Características: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

Efeitos: MemoryEffects::Effect{}

Operandos:

Operando

Descrição

operand

tensor classificado de inteiro sem sinal de 2/4/8/16/32/64 bits ou float de 4/6/8/16/32/64 bits ou tipo complexo com elementos float de 32/64 bits ou inteiro com sinal quantizado uniforme de 2/4/8/16/32 bits ou inteiro com sinal quantizado uniforme por eixo de 2/4/8/16/32 bits ou inteiro sem sinal quantizado uniforme de 2/4/8/16/32 bits ou valores inteiros sem sinal quantizados uniformes por eixo de 2/4/8/16/32 bits

Resultados:

Resultado	Descrição
result	tensor classificado de inteiro sem sinal de 2/4/8/16/32/64 bits ou float de 4/6/8/16/32/64 bits ou inteiro com sinal quantizado uniforme de 2/4/8/16/32 bits ou inteiro com sinal quantizado uniforme por eixo de 2/4/8/16/32 bits ou inteiro sem sinal quantizado uniforme de 2/4/8/16/32 bits ou inteiro sem sinal quantizado uniforme por eixo de 2/4/8/16/32 bits

mhlo.acos (mhlo::AcosOp)

Operação Acos

Sintaxe:

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

Executa a operação acos elemento a elemento no tensor operand e produz um tensor result .

Exemplo:

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

Características: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Operandos:

Operando	Descrição
operand	tensor de tipo float de 4/6/8/16/32/64 bits ou complexo com valores de elementos float de 32/64 bits

Resultados:

Resultado	Descrição
result	tensor de tipo float de 4/6/8/16/32/64 bits ou complexo com valores de elementos float de 32/64 bits

mhlo.acosh (mhlo::AcoshOp)

Operação Acosh

Sintaxe:

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

Executa a operação acosh elemento a elemento no tensor operand e produz um tensor result .

Exemplo:

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

Características: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Operandos:

Operando	Descrição
operand	tensor de tipo float de 4/6/8/16/32/64 bits ou complexo com valores de elementos float de 32/64 bits

Resultados:

Resultado	Descrição
result	tensor de tipo float de 4/6/8/16/32/64 bits ou complexo com valores de elementos float de 32/64 bits

mhlo.add (mhlo::AddOp)

Adicionar operação

Sintaxe:

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

Executa a adição elemento a elemento de dois tensores lhs e rhs e produz um tensor result .

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

Exemplo:

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

Características: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Efeitos: MemoryEffects::Effect{}

Operandos:

Operando	Descrição
lhs	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou inteiros quantizados por eixo
rhs	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou inteiros quantizados por eixo

Resultados:

Resultado	Descrição
result	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou inteiros quantizados por eixo

mhlo.add_dependency (mhlo::AddDependencyOp)

Operação AddDependency

Sintaxe:

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

Esta operação é privada do compilador XLA, portanto ainda não possui uma especificação.

Informalmente, esta operação utiliza dois operandos: um operando de dados e um token. A saída da operação é o operando de dados. Quando usada com AfterAll, esta operação permite ordenar operações sem efeitos colaterais (aquelas que não produzem valores de token).

Exemplo:

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

Traços: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efeitos: MemoryEffects::Effect{}

Operandos:

Operando	Descrição
operand	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou tensor classificado de valores inteiros quantizados por eixo ou token ou token hlo estável
token	token ou token stablehlo

Resultados:

Resultado	Descrição
output	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou tensor classificado de valores inteiros quantizados por eixo ou token ou token hlo estável

mhlo.after_all (mhlo::AfterAllOp)

Operação AfterAll

Sintaxe:

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

Garante que as operações que produzem as inputs sejam executadas antes de quaisquer operações que dependam do result .

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

Exemplo:

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

Traços: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efeitos: MemoryEffects::Effect{}

Operandos:

Operando	Descrição
inputs	variável de token

Resultados:

Resultado	Descrição
result	símbolo

mhlo.all_gather (mhlo::AllGatherOp)

Operação AllGather

Dentro de cada grupo de processos na grade de processos, concatena os valores do tensor de operando de cada processo ao longo all_gather_dim e produz um tensor de resultado. O computation é aplicado separadamente para cada operando em operands , produzindo um resultado por operando.

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

Exemplo:

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

Características: SameOperandsAndResultElementType

Atributos:

Atributo	Tipo MLIR	Descrição
all_gather_dim	::mlir::IntegerAttr	Atributo inteiro sem sinal de 64 bits cujo valor não é negativo
replica_groups	::mlir::AtributoDeElementosIntDensos	Atributo de elementos inteiros sem sinal de 64 bits
channel_handle	::mlir::mhlo::Atributo do Cabo do Canal	dois inteiros de 64 bits 'handle' e 'type'
use_global_device_ids	::mlir::Atributo da Unidade	atributo de unidade

Operandos:

Operando	Descrição
operands	variádico de tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou inteiros quantizados por eixo

Resultados:

Resultado	Descrição
«sem nome»	variádico de tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou inteiros quantizados por eixo

mhlo.all_reduce (mhlo::AllReduceOp)

Operação AllReduce

Dentro de cada grupo de processos na grade de processos, aplica-se um computation de função de redução aos valores de um tensor de operando de cada processo e produz-se um tensor de resultado. O computation é aplicado separadamente para cada operando em operands , produzindo um resultado por operando.

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

Exemplo:

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

Características: InferTensorType , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Atributos:

Atributo	Tipo MLIR	Descrição
replica_groups	::mlir::AtributoDeElementosIntDensos	Atributo de elementos inteiros sem sinal de 64 bits
channel_handle	::mlir::mhlo::Atributo do Cabo do Canal	dois inteiros de 64 bits 'handle' e 'type'
use_global_device_ids	::mlir::Atributo da Unidade	atributo de unidade

Operandos:

Operando	Descrição
operands	variádico de tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou inteiros quantizados por eixo

Resultados:

Resultado	Descrição
«sem nome»	variádico de tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou inteiros quantizados por eixo

mhlo.all_to_all (mhlo::AllToAllOp)

Operação AllToAll

Dentro de cada grupo de processos na grade de processos, divide os valores do tensor do operand ao longo split_dimension em partes, espalha as partes divididas entre os processos, concatena as partes dispersas ao longo concat_dimension e produz um tensor result .

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

Exemplo:

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

Características: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsElementType , SameOperandsShape , SameVariadicOperandSize

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

Efeitos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descrição
split_dimension	::mlir::IntegerAttr	Atributo inteiro sem sinal de 64 bits cujo valor não é negativo
concat_dimension	::mlir::IntegerAttr	Atributo inteiro sem sinal de 64 bits cujo valor não é negativo
split_count	::mlir::IntegerAttr	Atributo inteiro sem sinal de 64 bits cujo valor é positivo
replica_groups	::mlir::AtributoDeElementosIntDensos	Atributo de elementos inteiros sem sinal de 64 bits
channel_handle	::mlir::mhlo::Atributo do Cabo do Canal	dois inteiros de 64 bits 'handle' e 'type'

Operandos:

Operando	Descrição
operand	variádico de tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou inteiros quantizados por eixo

Resultados:

Resultado	Descrição
«sem nome»	variádico de tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou inteiros quantizados por eixo

mhlo.and (mhlo::AndOp)

E operação

Sintaxe:

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

Executa AND elemento a elemento de dois tensores lhs e rhs e produz um tensor result

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

Exemplo:

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

Características: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Efeitos: MemoryEffects::Effect{}

Operandos:

Operando	Descrição
lhs	tensor classificado de valores bool ou inteiros de 2/4/8/16/32/64 bits
rhs	tensor classificado de valores bool ou inteiros de 2/4/8/16/32/64 bits

Resultados:

Resultado	Descrição
result	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou inteiros quantizados por eixo

mhlo.asin (mhlo::AsinOp)

Operação Asin

Sintaxe:

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

Executa uma operação asin elemento a elemento no tensor operand e produz um tensor result .

Exemplo:

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

Características: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Operandos:

Operando	Descrição
operand	tensor de tipo float de 4/6/8/16/32/64 bits ou complexo com valores de elementos float de 32/64 bits

Resultados:

Resultado	Descrição
result	tensor de tipo float de 4/6/8/16/32/64 bits ou complexo com valores de elementos float de 32/64 bits

mhlo.async_done (mhlo::AsyncDoneOp)

Operação AsyncDone

Esta operação é privada do compilador XLA, portanto ainda não possui uma especificação.

Informalmente, esta operação bloqueia até o final de uma computação assíncrona. Ela retorna o resultado final da computação assíncrona.

Consulte a documentação do AsyncStart para obter mais informações.

Interfaces: InferTypeOpInterface

Operandos:

Operando	Descrição
bundle	async_bundle com qualquer combinação de tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou inteiros quantizados por eixo ou valores de token ou token stablehlo

Resultados:

Resultado

Descrição

«sem nome»

variádico de tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou valores inteiros quantizados por eixo ou token ou token stablehlo ou tupla aninhada com qualquer combinação de tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou memref de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou tensor classificado de inteiro por eixo valores quantizados ou valores de token

mhlo.async_start (mhlo::AsyncStartOp)

Operação AsyncStart

Esta operação é privada do compilador XLA, portanto ainda não possui uma especificação.

Informalmente, essa operação inicia uma computação assíncrona.

Isso é usado quando há funções que contêm esperas assíncronas (como DMAs) e computação on-thread. Por exemplo, uma função pode consistir em uma computação, uma DMA, outra computação, uma segunda DMA e uma computação final. Isso seria representado como um async_start seguido por um async_update e um async_done. O async_start faria a primeira computação on-thread e então iniciaria a DMA. O async_update esperaria a DMA ser concluída, caso ainda não tivesse sido concluída, então executaria a segunda computação na função e iniciaria a segunda DMA. Finalmente, o async_done esperaria por esta última DMA e então executaria a última computação que precisa ser executada on-thread e retornaria o resultado dessa computação final.

operands são passados ​​diretamente para a computação. called_computation é a função que será executada de forma assíncrona. execution_thread é o nome da thread na qual ela será executada. A thread principal é chamada de "main". Todas as threads têm nomes.

Isso retorna todo o estado necessário entre operações assíncronas. Após a atribuição do buffer, os valores retornados representam o espaço necessário para armazenar a entrada, os resultados e quaisquer blocos de anotações necessários ou editados pela operação assíncrona.

Atributos:

Atributo	Tipo MLIR	Descrição
called_computation	::mlir::Atributo de Referência de Símbolo Plano	atributo de referência de símbolo plano
execution_thread	::mlir::StringAttr	atributo de string

Operandos:

Operando

Descrição

inputs

variádico de tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou valores inteiros quantizados por eixo ou token ou token stablehlo ou tupla aninhada com qualquer combinação de tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou memref de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou tensor classificado de inteiro por eixo valores quantizados ou valores de token

Resultados:

Resultado	Descrição
«sem nome»	async_bundle com qualquer combinação de tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou inteiros quantizados por eixo ou valores de token ou token stablehlo

mhlo.async_update (mhlo::AsyncUpdateOp)

Operação AsyncUpdate

Esta operação é privada do compilador XLA, portanto ainda não possui uma especificação.

Informalmente, esta operação bloqueia uma computação assíncrona até que haja uma barreira de sincronização. Isso retorna bundle após a operação.

Consulte a documentação do AsyncStart para obter mais informações.

Interfaces: InferTypeOpInterface

Operandos:

Operando	Descrição
bundle	async_bundle com qualquer combinação de tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou inteiros quantizados por eixo ou valores de token ou token stablehlo

Resultados:

Resultado	Descrição
«sem nome»	async_bundle com qualquer combinação de tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou inteiros quantizados por eixo ou valores de token ou token stablehlo

mhlo.atan2 (mhlo::Atan2Op)

Operação Atan2

Sintaxe:

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

Executa a operação atan2 elemento a elemento nos tensores lhs e rhs e produz um tensor result .

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

Exemplo:

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

Características: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Efeitos: MemoryEffects::Effect{}

Operandos:

Operando	Descrição
lhs	tensor classificado de tipo float ou complexo de 4/6/8/16/32/64 bits com elementos float de 32/64 bits ou valores inteiros quantizados por tensor
rhs	tensor classificado de tipo float ou complexo de 4/6/8/16/32/64 bits com elementos float de 32/64 bits ou valores inteiros quantizados por tensor

Resultados:

Resultado	Descrição
result	tensor classificado de tipo float ou complexo de 4/6/8/16/32/64 bits com elementos float de 32/64 bits ou valores inteiros quantizados por tensor

mhlo.atanh (mhlo::AtanhOp)

Operação Atanh

Sintaxe:

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

Executa a operação atanh elemento a elemento no tensor operand e produz um tensor result .

Exemplo:

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

Características: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Operandos:

Operando	Descrição
operand	tensor de tipo float de 4/6/8/16/32/64 bits ou complexo com valores de elementos float de 32/64 bits

Resultados:

Resultado	Descrição
result	tensor de tipo float de 4/6/8/16/32/64 bits ou complexo com valores de elementos float de 32/64 bits

mhlo.batch_norm_grad (mhlo::BatchNormGradOp)

Operação BatchNormGrad

Calcula gradientes de várias entradas de BatchNormTrainingOp retropropagando de grad_output e produz tensores grad_operand , grad_scale e grad_offset .

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

Exemplo:

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

Características: AlwaysSpeculatableImplTrait , InferTensorType

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

Efeitos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descrição
epsilon	::mlir::AtributoFloat	Atributo float de 32 bits
feature_index	::mlir::IntegerAttr	Atributo inteiro sem sinal de 64 bits cujo valor não é negativo

Operandos:

Operando	Descrição
operand	tensor classificado de valores float de 4/6/8/16/32/64 bits
scale	Tensor 1D de valores float de 4/6/8/16/32/64 bits
mean	Tensor 1D de valores float de 4/6/8/16/32/64 bits
variance	Tensor 1D de valores float de 4/6/8/16/32/64 bits
grad_output	tensor classificado de valores float de 4/6/8/16/32/64 bits

Resultados:

Resultado	Descrição
grad_operand	tensor classificado de valores float de 4/6/8/16/32/64 bits
grad_scale	Tensor 1D de valores float de 4/6/8/16/32/64 bits
grad_offset	Tensor 1D de valores float de 4/6/8/16/32/64 bits

mhlo.batch_norm_inference (mhlo::BatchNormInferenceOp)

Operação BatchNormInference

Normaliza o tensor operand em todas as dimensões, exceto na dimensão feature_index , e produz um tensor result .

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

Exemplo:

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

Características: AlwaysSpeculatableImplTrait , InferTensorType

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

Efeitos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descrição
epsilon	::mlir::AtributoFloat	Atributo float de 32 bits
feature_index	::mlir::IntegerAttr	Atributo inteiro sem sinal de 64 bits cujo valor não é negativo

Operandos:

Operando	Descrição
operand	tensor classificado de valores float de 4/6/8/16/32/64 bits
scale	Tensor 1D de valores float de 4/6/8/16/32/64 bits
offset	Tensor 1D de valores float de 4/6/8/16/32/64 bits
mean	Tensor 1D de valores float de 4/6/8/16/32/64 bits
variance	Tensor 1D de valores float de 4/6/8/16/32/64 bits

Resultados:

Resultado	Descrição
result	tensor classificado de valores float de 4/6/8/16/32/64 bits

mhlo.batch_norm_training (mhlo::BatchNormTrainingOp)

Operação BatchNormTraining

Calcula a média e a variância entre dimensões de lote e espaciais e normaliza o tensor operand para cada recurso na dimensão feature_index e produz tensores output , batch_mean e batch_var .

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

Exemplo:

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

Características: AlwaysSpeculatableImplTrait , InferTensorType

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

Efeitos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descrição
epsilon	::mlir::AtributoFloat	Atributo float de 32 bits
feature_index	::mlir::IntegerAttr	Atributo inteiro sem sinal de 64 bits cujo valor não é negativo

Operandos:

Operando	Descrição
operand	tensor classificado de valores float de 4/6/8/16/32/64 bits
scale	Tensor 1D de valores float de 4/6/8/16/32/64 bits
offset	Tensor 1D de valores float de 4/6/8/16/32/64 bits

Resultados:

Resultado	Descrição
output	tensor classificado de valores float de 4/6/8/16/32/64 bits
batch_mean	Tensor 1D de valores float de 4/6/8/16/32/64 bits
batch_var	Tensor 1D de valores float de 4/6/8/16/32/64 bits

mhlo.bitcast (mhlo::BitcastOp)

Operação Bitcast

Sintaxe:

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

Esta operação é privada do compilador XLA, portanto ainda não possui uma especificação.

Informalmente, essa operação altera a forma da entrada de forma que o arranjo físico dos elementos permanece inalterado.

Esta operação precisa de informações de layout para dar sentido ao "arranjo físico dos elementos", e o suporte ao layout no MHLO está atualmente em andamento.

Exemplo:

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

Traços: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Efeitos: MemoryEffects::Effect{}

Operandos:

Operando	Descrição
operand	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou inteiros quantizados por eixo

Resultados:

Resultado	Descrição
«sem nome»	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou inteiros quantizados por eixo

mhlo.bitcast_convert (mhlo::BitcastConvertOp)

Operação BitcastConvert

Sintaxe:

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

Executa uma operação de bitcast no tensor operand e produz um tensor result onde os bits de todo o tensor operand são reinterpretados usando o tipo do tensor result .

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

Exemplo:

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

Traços: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efeitos: MemoryEffects::Effect{}

Operandos:

Operando	Descrição
operand	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou inteiros quantizados por eixo

Resultados:

Resultado	Descrição
«sem nome»	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou inteiros quantizados por eixo

mhlo.broadcast (mhlo::BroadcastOp)

Operação de transmissão

Esta operação está saindo do StableHLO, portanto não está incluída na especificação: https://github.com/openxla/stablehlo/issues/3

Informalmente, esta operação faz a mesma coisa que a transmissão do XLA: https://www.tensorflow.org/xla/operation_semantics#broadcast

Exemplo:

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

Características: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsAndResultElementType

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

Efeitos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descrição
broadcast_sizes	::mlir::AtributoDeElementosIntDensos	Atributo de elementos inteiros sem sinal de 64 bits

Operandos:

Operando	Descrição
operand	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou inteiros quantizados por eixo

Resultados:

Resultado	Descrição
«sem nome»	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou inteiros quantizados por eixo

mhlo.broadcast_in_dim (mhlo::BroadcastInDimOp)

Operação BroadcastInDim

Expande as dimensões e/ou classificação de um tensor de entrada duplicando os dados no tensor operand e produz um tensor result .

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

Exemplo:

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

Características: AlwaysSpeculatableImplTrait , HLO_CompatibleOperandsAndResultElementType

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Efeitos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descrição
broadcast_dimensions	::mlir::AtributoDeElementosIntDensos	Atributo de elementos inteiros sem sinal de 64 bits

Operandos:

Operando	Descrição
operand	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou inteiros quantizados por eixo

Resultados:

Resultado	Descrição
«sem nome»	tensor de dimensão limitada única ou de formato estático de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou valores inteiros quantizados por eixo

mhlo.case (mhlo::CaseOp)

Operação de caso

Produz a saída da execução de exatamente uma function de branches dependendo do valor do index .

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

Exemplo:

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

Características: RecursiveMemoryEffects , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfaces: InferTypeOpInterface

Operandos:

Operando	Descrição
index	tensor de valores inteiros sem sinal de 32 bits

Resultados:

Resultado	Descrição
«sem nome»	variádico de tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou tensor classificado de valores inteiros quantizados por eixo ou token

mhlo.cbrt (mhlo::CbrtOp)

Operação Cbrt

Sintaxe:

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

Executa operação de raiz cúbica elemento a elemento no tensor operand e produz um tensor result .

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

Exemplo:

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

Características: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Efeitos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descrição
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	A precisão solicitada para operações unárias.

Operandos:

Operando	Descrição
operand	tensor classificado de tipo float ou complexo de 4/6/8/16/32/64 bits com elementos float de 32/64 bits ou valores inteiros quantizados por tensor

Resultados:

Resultado	Descrição
result	tensor classificado de tipo float ou complexo de 4/6/8/16/32/64 bits com elementos float de 32/64 bits ou valores inteiros quantizados por tensor

mhlo.ceil (mhlo::CeilOp)

Operação de teto

Sintaxe:

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

Executa o teto do tensor operand elemento a elemento e produz um tensor result .

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

Exemplo:

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

Características: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Efeitos: MemoryEffects::Effect{}

Operandos:

Operando	Descrição
operand	tensor classificado de valores inteiros quantizados por tensor ou float de 4/6/8/16/32/64 bits

Resultados:

Resultado	Descrição
result	tensor classificado de valores inteiros quantizados por tensor ou float de 4/6/8/16/32/64 bits

mhlo.cholesky (mhlo::CholeskyOp)

Operação Cholesky

Calcula a decomposição de Cholesky de um lote de matrizes.

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

Exemplo:

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

Características: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsAndResultElementType

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

Efeitos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descrição
lower	::mlir::BoolAttr	atributo bool

Operandos:

Operando	Descrição
a	tensor classificado de tipo float de 4/6/8/16/32/64 bits ou complexo com valores de elementos float de 32/64 bits

Resultados:

Resultado	Descrição
«sem nome»	tensor classificado de tipo float de 4/6/8/16/32/64 bits ou complexo com valores de elementos float de 32/64 bits

mhlo.clamp (mhlo::ClampOp)

Operação de fixação

Sintaxe:

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

Fixa cada elemento do tensor operand entre um valor mínimo e máximo e produz um tensor result .

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

Exemplo:

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

Características: AlwaysSpeculatableImplTrait , HLO_BroadcastingElementwise , InferTensorType , SameOperandsAndResultElementType

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

Efeitos: MemoryEffects::Effect{}

Operandos:

Operando	Descrição
min	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou inteiros quantizados por eixo
operand	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou inteiros quantizados por eixo
max	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou inteiros quantizados por eixo

Resultados:

Resultado	Descrição
result	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou inteiros quantizados por eixo

mhlo.collective_broadcast (mhlo::Opção_de_transmissão_coletiva)

Operação de transmissão coletiva

Dentro de cada grupo de processos na grade de processos, envie o valor do tensor do operand do processo de origem para os processos de destino e produza um tensor result .

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

Exemplo:

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

Características: CompatibleOperandsAndResultType

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Atributos:

Atributo	Tipo MLIR	Descrição
replica_groups	::mlir::AtributoDeElementosIntDensos	Atributo de elementos inteiros sem sinal de 64 bits
channel_handle	::mlir::mhlo::Atributo do Cabo do Canal	dois inteiros de 64 bits 'handle' e 'type'

Operandos:

Operando	Descrição
operand	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou inteiros quantizados por eixo

Resultados:

Resultado	Descrição
«sem nome»	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou inteiros quantizados por eixo

mhlo.collective_permute (mhlo::CollectivePermuteOp)

Operação CollectivePermute

Dentro de cada grupo de processos na grade de processos, envia o valor do tensor do operand do processo de origem para o processo de destino e produz um tensor result .

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

Exemplo:

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

Características: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

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

Efeitos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descrição
source_target_pairs	::mlir::AtributoDeElementosIntDensos	Atributo de elementos inteiros sem sinal de 64 bits
channel_handle	::mlir::mhlo::Atributo do Cabo do Canal	dois inteiros de 64 bits 'handle' e 'type'

Operandos:

Operando	Descrição
operand	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou inteiros quantizados por eixo

Resultados:

Resultado	Descrição
«sem nome»	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou inteiros quantizados por eixo

mhlo.compare (mhlo::CompareOp)

Comparar operação

Sintaxe:

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

Executa comparação elemento a elemento dos tensores lhs e rhs de acordo com comparison_direction e compare_type e produz um tensor result .

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

Exemplo:

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

Características: AlwaysSpeculatableImplTrait , Elementwise , InferTensorType , SameOperandsAndResultShape , SameOperandsElementType

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

Efeitos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descrição
comparison_direction	::mlir::mhlo::ComparisonDirectionAttr	Qual operação de comparação executar.
compare_type	::mlir::mhlo::ComparisonTypeAttr	Qual tipo de comparação usar.

Operandos:

Operando	Descrição
lhs	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou inteiros quantizados por eixo
rhs	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou inteiros quantizados por eixo

Resultados:

Resultado	Descrição
«sem nome»	tensor classificado de valores bool

mhlo.complex (mhlo::ComplexOp)

Operação complexa

Sintaxe:

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

Executa a conversão elemento a elemento para um valor complexo a partir de um par de valores reais e imaginários, lhs e rhs , e produz um tensor result .

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

Exemplo:

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

Características: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape , SameOperandsElementType

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

Efeitos: MemoryEffects::Effect{}

Operandos:

Operando	Descrição
lhs	tensor classificado de valores float de 32/64 bits
rhs	tensor classificado de valores float de 32/64 bits

Resultados:

Resultado	Descrição
result	tensor classificado de tipo complexo com valores de elementos float de 32/64 bits

mhlo.composite (mhlo::CompositeOp)

Operação composta

Sintaxe:

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

Encapsula uma operação composta (composta) por outras operações StableHLO, pegando inputs e composite_attributes e produzindo results . A semântica da operação é implementada pelo atributo decomposition . A operação composite pode ser substituída por sua decomposição sem alterar a semântica do programa. Nos casos em que o inlining da decomposição não fornece a mesma semântica operacional, prefira usar custom_call .

O campo version (o padrão é 0 ) é usado para indicar quando a semântica de um composto muda.

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

Exemplo:

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

Interfaces: SymbolUserOpInterface

Atributos:

Atributo	Tipo MLIR	Descrição
name	::mlir::StringAttr	atributo de string
composite_attributes	::mlir::DictionaryAttr	dicionário de valores de atributos nomeados
decomposition	::mlir::FlatSymbolRefAttr	atributo de referência de símbolo plano
version	::mlir::IntegerAttr	Atributo inteiro sem sinal de 32 bits

Operandos:

Operando

Descrição

inputs

variável de tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos flutuantes de 32/64 bits ou inteiro por tensor quantizado ou valores quantizados inteiros por eixo ou token ou tupla aninhada com qualquer combinação de tensor classificado de 4/6/8/16/32/64 bits float ou bool ou Inteiro de 2/4/8/16/32/64 bits ou tipo complexo com elementos flutuantes de 32/64 bits ou valores quantizados inteiros por tensor ou memref de 4/6/8/16/32/64 bits flutuante ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos flutuantes de 32/64 bits ou valores quantizados inteiros por tensor ou tensor classificado de valores quantizados inteiros por eixo ou valores de token

Resultados:

Resultado

Descrição

«sem nome»

variável de tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos flutuantes de 32/64 bits ou inteiro por tensor quantizado ou valores quantizados inteiros por eixo ou token ou tupla aninhada com qualquer combinação de tensor classificado de 4/6/8/16/32/64 bits float ou bool ou Inteiro de 2/4/8/16/32/64 bits ou tipo complexo com elementos flutuantes de 32/64 bits ou valores quantizados inteiros por tensor ou memref de 4/6/8/16/32/64 bits flutuante ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos flutuantes de 32/64 bits ou valores quantizados inteiros por tensor ou tensor classificado de valores quantizados inteiros por eixo ou valores de token

mhlo.concatenate (mhlo::ConcatenateOp)

Operação concatenar

Concatena um número variável de tensores em inputs ao longo dimension na mesma ordem dos argumentos fornecidos e produz um tensor result .

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

Exemplo:

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

Características: AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType

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

Efeitos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descrição
dimension	::mlir::IntegerAttr	Atributo inteiro sem sinal de 64 bits cujo valor não é negativo

Operandos:

Operando	Descrição
val	variável do tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos flutuantes de 32/64 bits ou valores inteiros quantizados por tensor ou valores inteiros quantizados por eixo

Resultados:

Resultado	Descrição
«sem nome»	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou valores inteiros quantizados por eixo

mhlo.constant (mhlo::ConstantOp)

Operação constante

Produz um tensor output a partir de um value constante.

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

Exemplo:

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

Características: AlwaysSpeculatableImplTrait , ConstantLike

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efeitos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descrição
value	::mlir::ElementsAttr	atributo de vetor/tensor constante

Resultados:

Resultado	Descrição
output	tensor de formato estaticamente de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos flutuantes de 32/64 bits ou valores inteiros quantizados por tensor ou valores inteiros quantizados por eixo

mhlo.convert (mhlo::ConvertOp)

Operação de conversão

Sintaxe:

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

Executa uma conversão elemento a elemento de um tipo de elemento para outro no tensor operand e produz um tensor result .

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

Exemplo:

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

Características: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efeitos: MemoryEffects::Effect{}

Operandos:

Operando	Descrição
operand	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou valores inteiros quantizados por eixo

Resultados:

Resultado	Descrição
result	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou valores inteiros quantizados por eixo

mhlo.convolution (mhlo::ConvolutionOp)

Operação de convolução

Sintaxe:

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)

Calcula produtos escalares entre janelas de lhs e fatias de rhs e produz result .

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

Exemplo:

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

Características: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Efeitos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descrição
window_strides	::mlir::DenseIntElementsAttr	Atributo de elementos inteiros sem sinal de 64 bits
padding	::mlir::DenseIntElementsAttr	Atributo de elementos inteiros sem sinal de 64 bits
lhs_dilation	::mlir::DenseIntElementsAttr	Atributo de elementos inteiros sem sinal de 64 bits
rhs_dilation	::mlir::DenseIntElementsAttr	Atributo de elementos inteiros sem sinal de 64 bits
window_reversal	::mlir::DenseElementsAttr	atributo de vetor/tensor booleano constante
dimension_numbers	::mlir::mhlo::ConvDimensionNumbersAttr	Estrutura de informações de dimensão para operação de conversão
feature_group_count	::mlir::IntegerAttr	Atributo inteiro sem sinal de 64 bits cujo valor é positivo
batch_group_count	::mlir::IntegerAttr	Atributo inteiro sem sinal de 64 bits cujo valor é positivo
precision_config	::mlir::ArrayAttr	Atributo de configuração de precisão

Operandos:

Operando	Descrição
lhs	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou valores inteiros quantizados por eixo
rhs	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou valores inteiros quantizados por eixo

Resultados:

Resultado	Descrição
«sem nome»	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou valores inteiros quantizados por eixo

mhlo.copy (mhlo::CopyOp)

Operação de cópia

Sintaxe:

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

Esta operação é privada do compilador XLA, portanto ainda não possui especificação.

Informalmente, esta operação é uma cópia do operand . Dependendo dos metadados anexados à operação, ela pode se comportar de maneira bem diferente de um ambiente autônomo.

Exemplo:

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

Características: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise

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

Efeitos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descrição
cross_program_prefetch_index	::mlir::IntegerAttr	Atributo inteiro sem sinal de 32 bits

Operandos:

Operando

Descrição

operand

tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos flutuantes de 32/64 bits ou inteiro por tensor quantizado ou valores inteiros quantizados por eixo ou token ou tupla aninhada com qualquer combinação de tensor classificado de 4/6/8/16/32/64 bits float ou bool ou Inteiro de 2/4/8/16/32/64 bits ou tipo complexo com elementos flutuantes de 32/64 bits ou valores quantizados inteiros por tensor ou memref de 4/6/8/16/32/64 bits flutuante ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos flutuantes de 32/64 bits ou valores quantizados inteiros por tensor ou tensor classificado de valores quantizados inteiros por eixo ou valores de token

Resultados:

Resultado

Descrição

result

tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos flutuantes de 32/64 bits ou inteiro por tensor quantizado ou valores inteiros quantizados por eixo ou token ou tupla aninhada com qualquer combinação de tensor classificado de 4/6/8/16/32/64 bits float ou bool ou Inteiro de 2/4/8/16/32/64 bits ou tipo complexo com elementos flutuantes de 32/64 bits ou valores quantizados inteiros por tensor ou memref de 4/6/8/16/32/64 bits flutuante ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos flutuantes de 32/64 bits ou valores quantizados inteiros por tensor ou tensor classificado de valores quantizados inteiros por eixo ou valores de token

mhlo.cosh (mhlo::CoshOp)

Operação Cosh

Sintaxe:

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

Executa a operação cosh elemento a elemento no tensor operand e produz um tensor result .

Exemplo:

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

Características: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Operandos:

Operando	Descrição
operand	tensor de float de 4/6/8/16/32/64 bits ou tipo complexo com valores de elementos flutuantes de 32/64 bits

Resultados:

Resultado	Descrição
result	tensor de float de 4/6/8/16/32/64 bits ou tipo complexo com valores de elementos flutuantes de 32/64 bits

mhlo.cosine (mhlo::CosineOp)

Operação cosseno

Sintaxe:

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

Executa operação de cosseno elemento a elemento no tensor operand e produz um tensor result .

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

Exemplo:

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

Características: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Efeitos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descrição
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	A precisão solicitada para operações unárias.

Operandos:

Operando	Descrição
operand	tensor classificado de 4/6/8/16/32/64 bits flutuante ou tipo complexo com elementos flutuantes de 32/64 bits ou valores quantizados inteiros por tensor

Resultados:

Resultado	Descrição
result	tensor classificado de 4/6/8/16/32/64 bits flutuante ou tipo complexo com elementos flutuantes de 32/64 bits ou valores quantizados inteiros por tensor

mhlo.count_leading_zeros (mhlo::ClzOp)

Operação Clz

Sintaxe:

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

Executa a contagem elemento a elemento do número de bits zero iniciais no tensor operand e produz um tensor result .

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

Exemplo:

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

Características: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Efeitos: MemoryEffects::Effect{}

Operandos:

Operando	Descrição
operand	tensor classificado de valores inteiros de 2/4/8/16/32/64 bits

Resultados:

Resultado	Descrição
result	tensor classificado de valores inteiros de 2/4/8/16/32/64 bits

mhlo.create_token (mhlo::CreateTokenOp)

Operação CreateToken

Sintaxe:

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

Esta operação está saindo do StableHLO, portanto não está incluída na especificação: https://github.com/openxla/stablehlo/issues/3

Informalmente, esta operação faz a mesma coisa que AfterAllOp com 0 entradas: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#after_all

Exemplo:

%output = mhlo.create_token : !mhlo.token

Características: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efeitos: MemoryEffects::Effect{}

Resultados:

Resultado	Descrição
output	símbolo

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

Operação CrossReplicaSum

Esta operação está saindo do StableHLO, portanto não está incluída na especificação: https://github.com/openxla/stablehlo/issues/3

Informalmente, esta operação faz a mesma coisa que AllReduceOp com channel_id = 0 , use_global_device_ids = false e adição de implementação de computation : https://github.com/openxla/stablehlo/blob/main/docs/spec.md#all_reduce

Exemplo:

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

Características: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

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

Efeitos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descrição
replica_groups	::mlir::DenseIntElementsAttr	Atributo de elementos inteiros sem sinal de 64 bits

Operandos:

Operando	Descrição
operand	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou valores inteiros quantizados por eixo

Resultados:

Resultado	Descrição
«sem nome»	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou valores inteiros quantizados por eixo

mhlo.custom_call (mhlo::CustomCallOp)

Operação CustomCall

Sintaxe:

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

Encapsula uma operação definida pela implementação call_target_name que recebe inputs e called_computations e produz results .

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

Exemplo:

%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

Atributos:

Atributo	Tipo MLIR	Descrição
call_target_name	::mlir::StringAttr	atributo de string
has_side_effect	::mlir::BoolAttr	atributo bool
backend_config	::mlir::Atributo	atributo de string ou dicionário de valores de atributos nomeados
api_version	::mlir::mhlo::CustomCallApiVersionAttr	Versão da API de chamada personalizada
called_computations	::mlir::ArrayAttr	atributo de matriz de referência de símbolo plano
custom_call_schedule	::mlir::mhlo::CustomCallScheduleAttr	Especifica o agendamento desejado para a chamada personalizada.
operand_layouts	::mlir::ArrayAttr	Matriz de atributos de layout (tensor 1D do tipo de índice)
result_layouts	::mlir::ArrayAttr	Matriz de atributos de layout (tensor 1D do tipo de índice)
output_operand_aliases	::mlir::ArrayAttr	Atributo de alias para saídas e operandos de CustomCall

Operandos:

Operando

Descrição

inputs

variável de tensor de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou inteiro por tensor quantizado ou valores inteiros quantizados por eixo ou memref de 4/6/8/16/32/64 bits float ou bool ou Inteiro de 2/4/8/16/32/64 bits ou tipo complexo com elementos flutuantes de 32/64 bits ou valores quantizados inteiros por tensor ou token ou tupla aninhada com qualquer combinação de tensor de 4/6/8/16/32/64 bits flutuante ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos flutuantes de 32/64 bits ou inteiro por tensor valores quantizados inteiros quantizados ou por eixo ou memref de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores quantizados inteiros por tensor ou valores de token

Resultados:

Resultado

Descrição

«sem nome»

variável de tensor de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou inteiro por tensor quantizado ou valores inteiros quantizados por eixo ou memref de 4/6/8/16/32/64 bits float ou bool ou Inteiro de 2/4/8/16/32/64 bits ou tipo complexo com elementos flutuantes de 32/64 bits ou valores quantizados inteiros por tensor ou token ou tupla aninhada com qualquer combinação de tensor de 4/6/8/16/32/64 bits flutuante ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos flutuantes de 32/64 bits ou inteiro por tensor valores quantizados inteiros quantizados ou por eixo ou memref de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores quantizados inteiros por tensor ou valores de token

mhlo.divide (mhlo::DivOp)

Operação de divisão

Sintaxe:

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

Executa a divisão elemento a elemento dos tensores de dividendo lhs e divisor rhs e produz um tensor result .

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

Exemplo:

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

Características: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Efeitos: MemoryEffects::Effect{}

Operandos:

Operando	Descrição
lhs	tensor classificado de número inteiro de 2/4/8/16/32/64 bits ou flutuante de 4/6/8/16/32/64 bits ou tipo complexo com elementos flutuantes de 32/64 bits ou valores inteiros quantizados por tensor ou valores inteiros quantizados por eixo
rhs	tensor classificado de número inteiro de 2/4/8/16/32/64 bits ou flutuante de 4/6/8/16/32/64 bits ou tipo complexo com elementos flutuantes de 32/64 bits ou valores inteiros quantizados por tensor ou valores inteiros quantizados por eixo

Resultados:

Resultado	Descrição
result	tensor classificado de número inteiro de 2/4/8/16/32/64 bits ou flutuante de 4/6/8/16/32/64 bits ou tipo complexo com elementos flutuantes de 32/64 bits ou valores inteiros quantizados por tensor ou valores inteiros quantizados por eixo

mhlo.domain (mhlo::DomainOp)

Operação de domínio

Esta operação é privada do compilador XLA, portanto ainda não possui especificação.

Informalmente, essas operações são utilizadas para agrupar instruções com a mesma propriedade DomainMetadata. ShardingMetadata é o principal caso de uso hoje para agrupar instruções no mesmo dispositivo. As instruções de domínio oferecem dois benefícios principais:

• Evite a otimização acidental de instruções entre domínios.
• Atribua automaticamente os metadados das instruções criadas no domínio. Sem instruções de domínio, cada passagem de otimização HLO teria que verificar e propagar os metadados, o que seria fácil de perder e também adicionaria complexidade ao compilador. Como as instruções de domínio conectam dois domínios diferentes, cada instrução de domínio está associada a dois DomainMetadata – um no lado do operando e outro no lado do usuário do domínio.

Características: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

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

Efeitos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descrição
kind	::mlir::mhlo::DomainKindAttr	Tipo de metadados de domínio anexados a um domínio HLO.
entry_metadata	::mlir::StringAttr	atributo de string
exit_metadata	::mlir::StringAttr	atributo de string

Operandos:

Operando	Descrição
operand	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos flutuantes de 32/64 bits ou valores quantizados inteiros por tensor ou tensor classificado de valores quantizados inteiros por eixo ou token

Resultados:

Resultado	Descrição
result	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos flutuantes de 32/64 bits ou valores quantizados inteiros por tensor ou tensor classificado de valores quantizados inteiros por eixo ou token

mhlo.dot (mhlo::DotOp)

Operação de ponto

Esta operação está saindo do StableHLO, portanto não está incluída na especificação: https://github.com/openxla/stablehlo/issues/3

Informalmente, esta operação faz a mesma coisa que o Dot do XLA: https://www.tensorflow.org/xla/operation_semantics#dot

Exemplo:

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

Características: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Efeitos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descrição
precision_config	::mlir::ArrayAttr	Atributo de configuração de precisão

Operandos:

Operando	Descrição
lhs	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou valores inteiros quantizados por eixo
rhs	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou valores inteiros quantizados por eixo

Resultados:

Resultado	Descrição
«sem nome»	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou valores inteiros quantizados por eixo

mhlo.dot_general (mhlo::DotGeneralOp)

Operação DotGeneral

Calcula produtos escalares entre fatias de lhs e fatias de rhs e produz um tensor result .

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

Exemplo:

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

Características: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efeitos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descrição
dot_dimension_numbers	::mlir::mhlo::DotDimensionNumbersAttr	Atributo que modela as informações de dimensão para ponto.
precision_config	::mlir::ArrayAttr	Atributo de configuração de precisão
algorithm	::mlir::mhlo::DotAlgorithmAttr	Atributo que modela as restrições do algoritmo a serem usadas para calcular o ponto.

Operandos:

Operando	Descrição
lhs	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou valores inteiros quantizados por eixo
rhs	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou valores inteiros quantizados por eixo

Resultados:

Resultado	Descrição
«sem nome»	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou valores inteiros quantizados por eixo

mhlo.dynamic_broadcast_in_dim (mhlo::DynamicBroadcastInDimOp)

Operação DynamicBroadcastInDim

Esta operação é funcionalmente idêntica à operação broadcast_in_dim , mas a forma do resultado é especificada dinamicamente por meio de output_dimensions .

Também aceita atributos opcionais para expressar conhecimento estático sobre o comportamento de expansão das dimensões. Se não for especificado, todas as dimensões serão consideradas possivelmente em expansão. Os conjuntos de dimensões que se sabe que estão em expansão e o conjunto de dimensões que se sabe que não se expandem devem ser disjuntos e devem ser um subconjunto das dimensões do operando.

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

Exemplo:

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

Características: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efeitos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descrição
broadcast_dimensions	::mlir::DenseIntElementsAttr	Atributo de elementos inteiros sem sinal de 64 bits
known_expanding_dimensions	::mlir::DenseIntElementsAttr	Atributo de elementos inteiros sem sinal de 64 bits
known_nonexpanding_dimensions	::mlir::DenseIntElementsAttr	Atributo de elementos inteiros sem sinal de 64 bits

Operandos:

Operando	Descrição
operand	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou valores inteiros quantizados por eixo
output_dimensions	Tensor 1D de índice ou valores inteiros de 2/4/8/16/32/64 bits

Resultados:

Resultado	Descrição
«sem nome»	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou valores inteiros quantizados por eixo

mhlo.dynamic_conv (mhlo::DynamicConvOp)

Operação DynamicConv

Esta operação é um trabalho em andamento, portanto ainda não está incluída na especificação: https://github.com/openxla/stablehlo/issues/8

Informalmente, esta operação faz a mesma coisa que ConvolutionOp, exceto que o padding é especificado dinamicamente via d_padding : https://github.com/openxla/stablehlo/blob/main/docs/spec.md#convolution

Exemplo:

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

Características: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Efeitos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descrição
window_strides	::mlir::DenseIntElementsAttr	Atributo de elementos inteiros sem sinal de 64 bits
padding	::mlir::DenseIntElementsAttr	Atributo de elementos inteiros sem sinal de 64 bits
lhs_dilation	::mlir::DenseIntElementsAttr	Atributo de elementos inteiros sem sinal de 64 bits
rhs_dilation	::mlir::DenseIntElementsAttr	Atributo de elementos inteiros sem sinal de 64 bits
window_reversal	::mlir::DenseElementsAttr	atributo de vetor/tensor booleano constante
dimension_numbers	::mlir::mhlo::ConvDimensionNumbersAttr	Estrutura de informações de dimensão para operação de conversão
feature_group_count	::mlir::IntegerAttr	Atributo inteiro sem sinal de 64 bits cujo valor é positivo
batch_group_count	::mlir::IntegerAttr	Atributo inteiro sem sinal de 64 bits cujo valor é positivo
precision_config	::mlir::ArrayAttr	Atributo de configuração de precisão

Operandos:

Operando	Descrição
lhs	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou valores inteiros quantizados por eixo
rhs	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou valores inteiros quantizados por eixo
d_padding	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou valores inteiros quantizados por eixo

Resultados:

Resultado	Descrição
«sem nome»	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou valores inteiros quantizados por eixo

mhlo.dynamic_gather (mhlo::DynamicGatherOp)

Operação DynamicGather

Esta operação é um trabalho em andamento, portanto ainda não está incluída na especificação: https://github.com/openxla/stablehlo/issues/8

Informalmente, esta operação faz a mesma coisa que GatherOp, exceto que slice_sizes são especificados dinamicamente: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#gather

Exemplo:

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

Características: AlwaysSpeculatableImplTrait , InferTensorType

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

Efeitos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descrição
dimension_numbers	::mlir::mhlo::GatherDimensionNumbersAttr	Atributo que modela as informações de dimensão para coleta
indices_are_sorted	::mlir::BoolAttr	atributo bool

Operandos:

Operando	Descrição
operand	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou valores inteiros quantizados por eixo
start_indices	tensor classificado de valores inteiros de 2/4/8/16/32/64 bits
slice_sizes	tensor inteiro unidimensional de formato estático de valores inteiros de 2/4/8/16/32/64 bits

Resultados:

Resultado	Descrição
«sem nome»	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou valores inteiros quantizados por eixo

mhlo.dynamic_iota (mhlo::DynamicIotaOp)

Operação DynamicIota

Esta operação é funcionalmente idêntica à operação iota , mas a forma do resultado é especificada dinamicamente por meio de output_shape .

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

Exemplo:

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

Características: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efeitos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descrição
iota_dimension	::mlir::IntegerAttr	Atributo inteiro sem sinal de 64 bits cujo valor não é negativo

Operandos:

Operando	Descrição
output_shape	Tensor 1D de índice ou valores inteiros de 2/4/8/16/32/64 bits

Resultados:

Resultado	Descrição
result	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou valores inteiros quantizados por eixo

mhlo.dynamic_pad (mhlo::DynamicPadOp)

Operação do DynamicPad

Sintaxe:

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

Preenche dinamicamente o operand , com a quantidade de preenchimento adicionada em low-end/high-end/interior é passada através de tensores de entrada.

Características: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efeitos: MemoryEffects::Effect{}

Operandos:

Operando	Descrição
operand	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou valores inteiros quantizados por eixo
padding_value	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou valores inteiros quantizados por eixo
edge_padding_low	Tensor 1D de índice ou valores inteiros de 2/4/8/16/32/64 bits
edge_padding_high	Tensor 1D de índice ou valores inteiros de 2/4/8/16/32/64 bits
interior_padding	Tensor 1D de índice ou valores inteiros de 2/4/8/16/32/64 bits

Resultados:

Resultado	Descrição
result	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou valores inteiros quantizados por eixo

mhlo.dynamic_reshape (mhlo::DynamicReshapeOp)

Operação DynamicReshape

Sintaxe:

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

Esta operação é funcionalmente idêntica à operação de remodelação , mas a forma do resultado é especificada dinamicamente por meio de output_shape .

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

Exemplo:

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

Características: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efeitos: MemoryEffects::Effect{}

Operandos:

Operando	Descrição
operand	tensor de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou inteiro por tensor quantizado ou valores inteiros quantizados por eixo
output_shape	Tensor 1D de índice ou valores inteiros de 2/4/8/16/32/64 bits

Resultados:

Resultado	Descrição
result	tensor de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou inteiro por tensor quantizado ou valores inteiros quantizados por eixo

mhlo.dynamic_slice (mhlo::DynamicSliceOp)

Operação DynamicSlice

Extrai uma fatia do operand usando índices iniciais calculados dinamicamente e produz um tensor result .

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

Exemplo:

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

Características: AlwaysSpeculatableImplTrait , InferTensorType

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

Efeitos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descrição
slice_sizes	::mlir::DenseIntElementsAttr	Atributo de elementos inteiros sem sinal de 64 bits

Operandos:

Operando	Descrição
operand	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou valores inteiros quantizados por eixo
start_indices	variável do tensor 0D de valores inteiros de 2/4/8/16/32/64 bits

Resultados:

Resultado	Descrição
result	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou valores inteiros quantizados por eixo

mhlo.dynamic_update_slice (mhlo::DynamicUpdateSliceOp)

Operação DynamicUpdateSlice

Sintaxe:

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

Produz um tensor result que é igual ao tensor operand , exceto que a fatia que começa em start_indices é atualizada com os valores em update .

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

Exemplo:

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

Características: AlwaysSpeculatableImplTrait , InferTensorType

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

Efeitos: MemoryEffects::Effect{}

Operandos:

Operando	Descrição
operand	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou valores inteiros quantizados por eixo
update	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou valores inteiros quantizados por eixo
start_indices	variável do tensor 0D de valores inteiros de 2/4/8/16/32/64 bits

Resultados:

Resultado	Descrição
result	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou valores inteiros quantizados por eixo

mhlo.einsum (mhlo::EinsumOp)

Operação Einsum

Esta operação está saindo do StableHLO, portanto não está incluída na especificação: https://github.com/openxla/stablehlo/issues/3

Informalmente, esta operação faz a mesma coisa que o einsum do TF: https://www.tensorflow.org/api_docs/python/tf/einsum

Exemplo:

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

Características: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Efeitos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descrição
einsum_config	::mlir::StringAttr	atributo de string

Operandos:

Operando	Descrição
lhs	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou valores inteiros quantizados por eixo
rhs	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou valores inteiros quantizados por eixo

Resultados:

Resultado	Descrição
«sem nome»	tensor classificado de 4/6/8/16/32/64 bits float ou bool ou 2/4/8/16/32/64 bits inteiro ou tipo complexo com elementos float de 32/64 bits ou valores inteiros quantizados por tensor ou valores inteiros quantizados por eixo

mhlo.erf (mhlo::ErfOp)

Operação Erf

Sintaxe:

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

Executa operação erf elemento a elemento no tensor operand e produz um tensor result .

Exemplo:

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

Características: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Efeitos: MemoryEffects::Effect{}

Operandos:

Operando	Descrição
operand	tensor classificado de valores flutuantes de 4/6/8/16/32/64 bits

Resultados:

Resultado	Descrição
result	tensor classificado de valores flutuantes de 4/6/8/16/32/64 bits

mhlo.exponential (mhlo::ExpOp)

Operação Exp

Sintaxe:

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

Executa operação exponencial elemento a elemento no tensor operand e produz um tensor result .

Veja: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#exponencial

Exemplo:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributes:

Atributo	MLIR Type	Descrição
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Operando	Descrição
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

Resultados:

Resultado	Descrição
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.exponential_minus_one (mhlo::Expm1Op)

Expm1 operation

Sintaxe:

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

Exemplo:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributes:

Atributo	MLIR Type	Descrição
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Operando	Descrição
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

Resultados:

Resultado	Descrição
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

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

Exemplo:

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

Atributo	MLIR Type	Descrição
fft_type	::mlir::mhlo::FftTypeAttr	XLA fast fourier transform type.
fft_length	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Operando	Descrição
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Resultados:

Resultado	Descrição
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.floor (mhlo::FloorOp)

Floor operation

Sintaxe:

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

Exemplo:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operando	Descrição
operand	ranked tensor of 4/6/8/16/32/64-bit float or per-tensor integer quantized values

Resultados:

Resultado	Descrição
result	ranked tensor of 4/6/8/16/32/64-bit float or per-tensor integer quantized values

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:

Atributo	MLIR Type	Descrição
fusion_kind	::mlir::mhlo::FusionKindAttr	fusion kind
output_operand_aliases	::mlir::ArrayAttr	Aliasing attribute for outputs and operands of Fusion

Operands:

Operando	Descrição
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token

Resultados:

Resultado

Descrição

results

variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values or nested tuple with any combination of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token values

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

Exemplo:

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

Atributo	MLIR Type	Descrição
dimension_numbers	::mlir::mhlo::GatherDimensionNumbersAttr	Attribute that models the dimension information for gather
slice_sizes	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
indices_are_sorted	::mlir::BoolAttr	bool attribute

Operands:

Operando	Descrição
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
start_indices	ranked tensor of 2/4/8/16/32/64-bit integer values

Resultados:

Resultado	Descrição
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

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

Exemplo:

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

Atributo	MLIR Type	Descrição
dimension	::mlir::IntegerAttr	64-bit signless integer attribute whose value is non-negative

Operands:

Operando	Descrição
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Resultados:

Resultado	Descrição
«unnamed»	tensor of 32-bit signless integer values

mhlo.get_tuple_element (mhlo::GetTupleElementOp)

GetTupleElement operation

Sintaxe:

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

Exemplo:

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

Atributo	MLIR Type	Descrição
index	::mlir::IntegerAttr	32-bit signless integer attribute whose value is non-negative

Operands:

Operando

Descrição

operand

nested tuple with any combination of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token values

Resultados:

Resultado

Descrição

«unnamed»

ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values or token or nested tuple with any combination of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values

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:

Operando	Descrição
pred	ranked tensor of bool values

Resultados:

Resultado	Descrição
«unnamed»	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token

mhlo.imag (mhlo::ImagOp)

Imag operation

Sintaxe:

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

Exemplo:

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

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operando	Descrição
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

Resultados:

Resultado	Descrição
result	ranked tensor of 4/6/8/16/32/64-bit float values

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

Exemplo:

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

Attributes:

Atributo	MLIR Type	Descrição
infeed_config	::mlir::StringAttr	string attribute
layout	::mlir::ArrayAttr	array attribute

Operands:

Operando	Descrição
token	símbolo

Resultados:

Resultado

Descrição

«unnamed»

variadic of statically shaped tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or statically shaped tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values or token

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

Exemplo:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Atributo	MLIR Type	Descrição
iota_dimension	::mlir::IntegerAttr	64-bit signless integer attribute whose value is non-negative

Resultados:

Resultado	Descrição
output	statically shaped tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

mhlo.is_finite (mhlo::IsFiniteOp)

IsFinite operation

Sintaxe:

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

Exemplo:

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

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operando	Descrição
x	ranked tensor of 4/6/8/16/32/64-bit float values

Resultados:

Resultado	Descrição
y	ranked tensor of bool values

mhlo.log (mhlo::LogOp)

Log operation

Sintaxe:

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

Exemplo:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributes:

Atributo	MLIR Type	Descrição
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Operando	Descrição
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

Resultados:

Resultado	Descrição
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.log_plus_one (mhlo::Log1pOp)

Log1p operation

Sintaxe:

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

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

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

Exemplo:

%result = mhlo.log_plus_one %operand : tensor<6xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributes:

Atributo	MLIR Type	Descrição
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Operando	Descrição
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

Resultados:

Resultado	Descrição
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.logistic (mhlo::LogisticOp)

Logistic operation

Sintaxe:

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

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

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

Exemplo:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributes:

Atributo	MLIR Type	Descrição
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Operando	Descrição
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

Resultados:

Resultado	Descrição
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.map (mhlo::MapOp)

Map operation

Applies a map function computation to inputs along the dimensions and produces a result tensor.

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

Exemplo:

%result = "mhlo.map"(%input0, %input1) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = mhlo.multiply %arg0, %arg1 : tensor<i32>
    mhlo.return %0 : tensor<i32>
}) {
  dimensions = dense<[0, 1]> : tensor<2xi64>
} : (tensor<2x2xi32>, tensor<2x2xi32>) -> tensor<2x2xi32>

Traits: InferTensorType , RecursiveMemoryEffects , SameOperandsAndResultShape , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Attributes:

Atributo	MLIR Type	Descrição
dimensions	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Operando	Descrição
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Resultados:

Resultado	Descrição
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.maximum (mhlo::MaxOp)

Max operation

Sintaxe:

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

Performs element-wise max operation on tensors lhs and rhs and produces a result tensor.

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

Exemplo:

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

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operando	Descrição
lhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Resultados:

Resultado	Descrição
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.minimum (mhlo::MinOp)

Min operation

Sintaxe:

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

Performs element-wise min operation on tensors lhs and rhs and produces a result tensor.

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

Exemplo:

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

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operando	Descrição
lhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Resultados:

Resultado	Descrição
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.minimum_broadcast_shapes (mhlo::MinimumBroadcastShapesOp)

Minimizes the rank of two or more shapes to be broadcasted

Sintaxe:

operation ::= `mhlo.minimum_broadcast_shapes` $shapes attr-dict `:` type($shapes) `->` type($results)

Given two or more 1D tensors representing shapes, returns one 1D tensor for each operand, where operand i corresponds to output i .

The returned tensors have the property that they specify a shape which is a reshape of the corresponding input shape, and the broadcasted output shape (using shape::BroadcastOp) of the returned shapes is a reshape of the broadcasted output shape of the input shapes. Among all possibilities with this property, the one is chosen which minimizes the rank of each returned shape.

The general idea of this op is that it can be used for ops which have a broadcasting semantic to operate on shapes with a possibly smaller rank while preserving equivalence of the computed values. After computing the result of the op using reshaped operands, the result can be reshaped to the result that would have been originally computed.

Here is an example with two input shapes:

mhlo.minimum_broadcast_shapes [1, 2, 3, 1, 2, 1],
                                 [1, 1, 1, 2, 3] -> [6, 2, 1], [2, 3]

The broadcasted output shape of the operands is [1, 2, 3, 1, 2, 3], the broadcasted output shape of the outputs is [6, 2, 3]. These two shapes are reshapes of each other, and also each output is a reshape of the corresponding input.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operando	Descrição
shapes	variadic of 1D tensor of index values

Resultados:

Resultado	Descrição
results	variadic of 1D tensor of index values

mhlo.multiply (mhlo::MulOp)

Mul operation

Sintaxe:

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

Performs element-wise product of two tensors lhs and rhs and produces a result tensor.

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

Exemplo:

%result = mhlo.multiply %lhs, %rhs : tensor<2xi32>

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operando	Descrição
lhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Resultados:

Resultado	Descrição
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.negate (mhlo::NegOp)

Neg operation

Sintaxe:

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

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

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

Exemplo:

%result = mhlo.negate %operand : tensor<2x3xi32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operando	Descrição
operand	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Resultados:

Resultado	Descrição
result	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.not (mhlo::NotOp)

Not operation

Sintaxe:

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

Performs element-wise NOT of tensor operand of type integer and produces a result tensor.

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

Exemplo:

%result = mhlo.not %operand : tensor<5x3x1xi1>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operando	Descrição
operand	ranked tensor of bool or 2/4/8/16/32/64-bit integer values

Resultados:

Resultado	Descrição
result	ranked tensor of bool or 2/4/8/16/32/64-bit integer values

mhlo.optimization_barrier (mhlo::OptimizationBarrierOp)

OptimizationBarrier operation

Sintaxe:

operation ::= `mhlo.optimization_barrier` attr-dict ($operand^ `:` custom<PairwiseOpType>(type($operand), type($result))):(`(` `)`)?

Ensures that the operations that produce the operand are executed before any operations that depend on the result and prevents compiler transformations from moving operations across the barrier. Other than that, the operation is an identity, ie result = operand .

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

Exemplo:

%result0, %result1 = mhlo.optimization_barrier %operand0, %operand1 : tensor<f32>, tensor<f32>

Traits: AlwaysSpeculatableImplTrait , HLO_PairwiseSameOperandAndResultType

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operando	Descrição
operand	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token

Resultados:

Resultado	Descrição
result	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token

mhlo.or (mhlo::OrOp)

Or operation

Sintaxe:

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

Performs element-wise OR of two tensors lhs and rhs and produces a result tensor.

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

Exemplo:

%result = mhlo.or %lhs, %rhs : tensor<2xi1>

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operando	Descrição
lhs	ranked tensor of bool or 2/4/8/16/32/64-bit integer values
rhs	ranked tensor of bool or 2/4/8/16/32/64-bit integer values

Resultados:

Resultado	Descrição
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.outfeed (mhlo::OutfeedOp)

Outfeed operation

Writes inputs to the outfeed and produces a result token.

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

Exemplo:

%result = "mhlo.outfeed"(%input0, %token) {
  outfeed_config = ""
} : (tensor<3x3x3xi32>, !mhlo.token) -> !mhlo.token

Interfaces: InferTypeOpInterface

Attributes:

Atributo	MLIR Type	Descrição
outfeed_config	::mlir::StringAttr	string attribute

Operands:

Operando	Descrição
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
token	símbolo

Resultados:

Resultado	Descrição
«unnamed»	símbolo

mhlo.pad (mhlo::PadOp)

Pad operation

Expands operand by padding around the tensor as well as between the elements of the tensor with the given padding_value .

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

Exemplo:

%0 = mhlo.pad %arg0, %arg1, low = [0, 1], high = [2, 1], interior = [1, 2]
  : (tensor<2x3xi32>, tensor<i32>) -> tensor<5x9xi32>

Traits: AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType

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

Effects: MemoryEffects::Effect{}

Attributes:

Atributo	MLIR Type	Descrição
edge_padding_low	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
edge_padding_high	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
interior_padding	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Operando	Descrição
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
padding_value	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Resultados:

Resultado	Descrição
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.partition_id (mhlo::PartitionIdOp)

PartitionId operation

Sintaxe:

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

Produces partition_id of the current process.

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

Exemplo:

%result = mhlo.partition_id : tensor<ui32>

Interfaces: InferTypeOpInterface

Resultados:

Resultado	Descrição
«unnamed»	ranked tensor of 32-bit unsigned integer values

mhlo.popcnt (mhlo::PopulationCountOp)

PopulationCount operation

Sintaxe:

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

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

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

Exemplo:

%result = mhlo.popcnt %operand : tensor<4xi8>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operando	Descrição
operand	ranked tensor of 2/4/8/16/32/64-bit integer values

Resultados:

Resultado	Descrição
result	ranked tensor of 2/4/8/16/32/64-bit integer values

mhlo.power (mhlo::PowOp)

Pow operation

Sintaxe:

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

Performs element-wise exponentiation of lhs tensor by rhs tensor and produces a result tensor.

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

Exemplo:

%result = mhlo.power %lhs, %rhs : tensor<6xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operando	Descrição
lhs	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Resultados:

Resultado	Descrição
result	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.ragged_dot (mhlo::RaggedDotOp)

Ragged matrix multiplication over a single ragged dimension

This operation takes three tensor args---lhs, rhs, and group_sizes---and a "ragged_dot_dimension_numbers" attribute. Like dot_general, the lhs and rhs are allowed arbitrary batch and contracting dimensions. Additionally, the lhs is required to have one ragged dimension, and the rhs may have at most one group dimension. The op has three modes, depending on the kind of the lhs ragged dimension.

In mode 1, the shape-signature is [b,m,k], [g,b,k,n], [b,g] -> [b,m,n] . Here the ragged dimension is an lhs non-contracting dimension ( m ). The dimensions b and k represent batch and contracting dimensions respectively. The rhs is required to have a group dimension ( g ).

In mode 2, the shape-signature is [b,m,k], [b,k,n], [b,g] -> [g,b,m,n] . Here the ragged dimension is an lhs/rhs contracting dimension ( k ).

In mode 3, the shape-signature is [b,m,k], [b,k,n], [g] -> [b,m,n] . Here the ragged dimension is an lhs/rhs batch dimension ( b ).

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Atributo	MLIR Type	Descrição
ragged_dot_dimension_numbers	::mlir::mhlo::RaggedDotDimensionNumbersAttr	Attribute that models the dimension information for ragged dot.
precision_config	::mlir::ArrayAttr	Precision Config attribute

Operands:

Operando	Descrição
lhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
group_sizes	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Resultados:

Resultado	Descrição
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.real (mhlo::RealOp)

Real operation

Sintaxe:

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

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

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

Exemplo:

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

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operando	Descrição
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

Resultados:

Resultado	Descrição
result	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.real_dynamic_slice (mhlo::RealDynamicSliceOp)

RealDynamicSlice operation

Sintaxe:

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

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 SliceOp except that start_indices , limit_indices and strides are specified dynamically: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#slice

Exemplo:

%result = mhlo.real_dynamic_slice %operand,
            %start_indices, %limit_indices, %strides
       : (tensor<256x?xf32>, tensor<2xindex>, tensor<2xindex>, tensor<2xindex>) -> tensor<256x?xf32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operando	Descrição
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
start_indices	1D tensor of index or 2/4/8/16/32/64-bit integer values
limit_indices	1D tensor of index or 2/4/8/16/32/64-bit integer values
strides	1D tensor of index or 2/4/8/16/32/64-bit integer values

Resultados:

Resultado	Descrição
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.recv (mhlo::RecvOp)

Recv operation

Receives data from a channel with channel_id and produces results .

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

Exemplo:

%results:2 = "mhlo.recv"(%token) {
  // channel_id = 5 : i64,
  // channel_type = #stablehlo<channel_type DEVICE_TO_DEVICE>,
  channel_handle = #mhlo.channel_handle<handle = 5, type = 1>,
  is_host_transfer = false,
  source_target_pairs = dense<[[0, 1], [1, 2]]> : tensor<2x2xi64>
} : (!mhlo.token) -> (tensor<3x4xi32>, !mhlo.token)

Attributes:

Atributo	MLIR Type	Descrição
channel_handle	::mlir::mhlo::ChannelHandleAttr	two 64-bit integers 'handle' and 'type'
is_host_transfer	::mlir::BoolAttr	bool attribute
source_target_pairs	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Operando	Descrição
token	símbolo

Resultados:

Resultado

Descrição

«unnamed»

variadic of statically shaped tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or statically shaped tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values or token

mhlo.reduce (mhlo::ReduceOp)

Reduce operation

Applies a reduction function body to inputs and init_values along the dimensions and produces a result tensor.

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

Exemplo:

%result = "mhlo.reduce"(%input, %init_value) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = "mhlo.add"(%arg0, %arg1) : (tensor<i32>, tensor<i32>) -> tensor<i32>
    "mhlo.return"(%0) : (tensor<i32>) -> ()
}) {
  dimensions = dense<1> : tensor<1xi64>
} : (tensor<1x6xi32>, tensor<i32>) -> tensor<1xi32>

Traits: InferTensorType , RecursiveMemoryEffects , SameVariadicOperandSize , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Attributes:

Atributo	MLIR Type	Descrição
dimensions	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Operando	Descrição
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
init_values	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Resultados:

Resultado	Descrição
«unnamed»	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.reduce_precision (mhlo::ReducePrecisionOp)

ReducePrecision operation

Sintaxe:

operation ::= `mhlo.reduce_precision` $operand `,` `format` `=` custom<ExponentMantissa>($exponent_bits, $mantissa_bits)
              attr-dict `:` custom<SameOperandsAndResultType>(type($operand), type($output))

Performs element-wise conversion of operand to another floating-point type that uses exponent_bits and mantissa_bits and back to the original floating-point type and produces an output tensor.

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

Exemplo:

%output = mhlo.reduce_precision %operand, format = e5m2 : tensor<6xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise

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

Effects: MemoryEffects::Effect{}

Attributes:

Atributo	MLIR Type	Descrição
exponent_bits	::mlir::IntegerAttr	32-bit signless integer attribute whose value is positive
mantissa_bits	::mlir::IntegerAttr	32-bit signless integer attribute whose value is non-negative

Operands:

Operando	Descrição
operand	ranked tensor of 4/6/8/16/32/64-bit float values

Resultados:

Resultado	Descrição
output	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.reduce_scatter (mhlo::ReduceScatterOp)

ReduceScatter operation

Within each process group in the process grid, performs reduction, using computations , over the values of the operand tensor from each process, splits the reduction result along scatter_dimension into parts, and scatters the split parts between the processes to produce the result .

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

Exemplo:

%result = "mhlo.reduce_scatter"(%operand) ({
  ^bb0(%arg0: tensor<f32>, %arg1: tensor<f32>):
  %0 = mhlo.add %arg0, %arg1 : tensor<f32>
  mhlo.return %0 : tensor<f32>
}) {
  scatter_dimension = 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<2x4xf32>) -> tensor<2x2xf32>

Attributes:

Atributo	MLIR Type	Descrição
scatter_dimension	::mlir::IntegerAttr	64-bit signless integer attribute whose value is non-negative
replica_groups	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
channel_handle	::mlir::mhlo::ChannelHandleAttr	two 64-bit integers 'handle' and 'type'
use_global_device_ids	::mlir::UnitAttr	unit attribute

Operands:

Operando	Descrição
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Resultados:

Resultado	Descrição
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.reduce_window (mhlo::ReduceWindowOp)

ReduceWindow operation

Applies a reduction function body to windows of inputs and init_values and produces results .

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

Exemplo:

%result = "mhlo.reduce_window"(%input, %init_value) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = mhlo.add %arg0, %arg1 : tensor<i32>
    mhlo.return %0 : tensor<i32>
}) {
  window_dimensions = dense<[2, 1]> : tensor<2xi64>,
  window_strides = dense<[4, 1]> : tensor<2xi64>,
  base_dilations = dense<[2, 1]> : tensor<2xi64>,
  window_dilations = dense<[3, 1]> : tensor<2xi64>,
  padding = dense<[[2, 1], [0, 0]]> : tensor<2x2xi64>
} : (tensor<3x2xi32>, tensor<i32>) -> tensor<2x2xi32>

Traits: InferTensorType , RecursiveMemoryEffects , SameVariadicOperandSize , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Attributes:

Atributo	MLIR Type	Descrição
window_dimensions	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
window_strides	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
base_dilations	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
window_dilations	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
padding	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Operando	Descrição
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
init_values	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Resultados:

Resultado	Descrição
«unnamed»	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.remainder (mhlo::RemOp)

Rem operation

Sintaxe:

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

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

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

Exemplo:

%result = mhlo.remainder %lhs, %rhs : tensor<4xi64>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operando	Descrição
lhs	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Resultados:

Resultado	Descrição
result	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.replica_id (mhlo::ReplicaIdOp)

ReplicaId operation

Sintaxe:

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

Produces replica_id of the current process.

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

Exemplo:

%result = mhlo.replica_id : tensor<ui32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Resultados:

Resultado	Descrição
«unnamed»	ranked tensor of 32-bit unsigned integer values

mhlo.reshape (mhlo::ReshapeOp)

Reshape operation

Sintaxe:

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

Performs reshape of operand tensor to a result tensor.

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

Exemplo:

%result = mhlo.reshape %operand : (tensor<2xf32>) -> tensor<1x2xf32>

Traits: AlwaysSpeculatableImplTrait , HLO_CompatibleOperandsAndResultElementType

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operando	Descrição
operand	tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Resultados:

Resultado	Descrição
«unnamed»	statically shaped or single bounded dimension tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.return (mhlo::ReturnOp)

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

Informally, this operation serves as a terminator for regions defined by
the StableHLO ops. Non-StableHLO ops, e.g. `func.func`, have their own
terminators, e.g. `func.return`.

Example:

    ```mlir
    %result = "mhlo.reduce"(%input, %init_value) ({
      ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
        %0 = "mhlo.add"(%arg0, %arg1) : (tensor<i32>, tensor<i32>) -> tensor<i32>
        "mhlo.return"(%0) : (tensor<i32>) -> ()
    }) {
      dimensions = dense<1> : tensor<1xi64>
    } : (tensor<1x6xi32>, tensor<i32>) -> tensor<1xi32>
    ```_

Syntax:

```

operation ::= mhlo.return $results attr-dict ( : type($results)^)?

Traits: `AlwaysSpeculatableImplTrait`, `Terminator`

Interfaces: `ConditionallySpeculatable`, `NoMemoryEffect (MemoryEffectOpInterface)`

Effects: `MemoryEffects::Effect{}`

#### Operands:

| Operand | Description |
| :-----: | ----------- |
| `results` | variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values or token or nested tuple with any combination of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values |



### `mhlo.reverse` (mhlo::ReverseOp)

_Reverse operation_

Reverses the order of elements in the `operand` along the specified
`dimensions` and produces a `result` tensor.

See:
<a href="https://github.com/openxla/stablehlo/blob/main/docs/spec.md#reverse">https://github.com/openxla/stablehlo/blob/main/docs/spec.md#reverse</a>

Example:
```mlir
%result = mhlo.reverse %operand, dims = [1] : tensor<3x2xi32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

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

Effects: MemoryEffects::Effect{}

Attributes:

Atributo	MLIR Type	Descrição
dimensions	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Operando	Descrição
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Resultados:

Resultado	Descrição
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.rng (mhlo::RngOp)

Rng operation

Generates random numbers using the rng_distribution algorithm and produces a result tensor of a given shape shape .

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

Exemplo:

%result = mhlo.rng %a, %b, %shape, distribution = NORMAL : (tensor<i32>, tensor<i32>, tensor<2xi64>) -> tensor<3x3xi32>

Traits: InferTensorType

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Attributes:

Atributo	MLIR Type	Descrição
rng_distribution	::mlir::mhlo::RngDistributionAttr	XLA PRNG distribution to be used.

Operands:

Operando	Descrição
a	0D tensor of bool or 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float values
b	0D tensor of bool or 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float values
shape	1D tensor of index or 2/4/8/16/32/64-bit integer values

Resultados:

Resultado	Descrição
result	ranked tensor of bool or 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float values

mhlo.rng_bit_generator (mhlo::RngBitGeneratorOp)

RngBitGenerator operation

Returns an output filled with uniform random data and an updated output state output_state given an initial state initial_state using the pseudorandom number generator algorithm rng_algorithm .

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

Exemplo:

%output_state, %output = mhlo.rng_bit_generator %initial_state, algorithm = THREE_FRY : (tensor<2xui64>) -> (tensor<2xui64>, tensor<2x2xui64>)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Atributo	MLIR Type	Descrição
rng_algorithm	::mlir::mhlo::RngAlgorithmAttr	XLA PRNG algorithm to be used.

Operands:

Operando	Descrição
initial_state	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float values

Resultados:

Resultado	Descrição
output_state	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float values
output	statically shaped tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float values

mhlo.round_nearest_afz (mhlo::RoundOp)

Round operation

Sintaxe:

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

Performs element-wise rounding towards the nearest integer, breaking ties away from zero, on the operand tensor and produces a result tensor.

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

Exemplo:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operando	Descrição
operand	ranked tensor of 4/6/8/16/32/64-bit float values

Resultados:

Resultado	Descrição
result	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.round_nearest_even (mhlo::RoundNearestEvenOp)

RoundNearestEven operation

Sintaxe:

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

Performs element-wise rounding towards the nearest integer, breaking ties towards the even integer, on the operand tensor and produces a result tensor.

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

Exemplo:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operando	Descrição
operand	ranked tensor of 4/6/8/16/32/64-bit float values

Resultados:

Resultado	Descrição
result	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.rsqrt (mhlo::RsqrtOp)

Rsqrt operation

Sintaxe:

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

Performs element-wise reciprocal square root operation on operand tensor and produces a result tensor, implementing the rSqrt operation from the IEEE-754 specification.

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

Exemplo:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributes:

Atributo	MLIR Type	Descrição
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Operando	Descrição
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

Resultados:

Resultado	Descrição
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.scatter (mhlo::ScatterOp)

Scatter operation

Produces results tensors which are equal to inputs tensors except that several slices specified by scatter_indices are updated with the values updates using update_computation .

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

Exemplo:

%result = "mhlo.scatter"(%input, %scatter_indices, %update) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = mhlo.add %arg0, %arg1 : tensor<i32>
    mhlo.return %0 : tensor<i32>
}) {
  scatter_dimension_numbers = #mhlo.scatter<
    update_window_dims = [3, 4],
    inserted_window_dims = [1],
    input_batching_dims = [0],
    scatter_indices_batching_dims = [1],
    scatter_dims_to_operand_dims = [2, 1],
    index_vector_dim = 3>,
  indices_are_sorted = false,
  unique_indices = false
} : (tensor<2x3x4x2xi64>, tensor<2x2x3x2xi64>, tensor<2x2x3x2x2xi64>) -> tensor<2x3x4x2xi64>

Traits: RecursiveMemoryEffects , SameVariadicOperandSize

Interfaces: InferTypeOpInterface

Attributes:

Atributo	MLIR Type	Descrição
scatter_dimension_numbers	::mlir::mhlo::ScatterDimensionNumbersAttr	Attribute that models the dimension information for scatter
indices_are_sorted	::mlir::BoolAttr	bool attribute
unique_indices	::mlir::BoolAttr	bool attribute

Operands:

Operando	Descrição
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
scatter_indices	ranked tensor of integer or index values
updates	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Resultados:

Resultado	Descrição
«unnamed»	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.select (mhlo::SelectOp)

Select operation

Sintaxe:

operation ::= `mhlo.select` operands attr-dict `:`
              custom<SelectOpType>(type($pred), type($on_true), type($on_false), type($result))

Produces a result tensor where each element is selected from on_true or on_false tensor based on the value of the corresponding element of pred .

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

Exemplo:

%result = mhlo.select %pred, %on_true, %on_false : tensor<2x2xi1>, tensor<2x2xi32>

Traits: AlwaysSpeculatableImplTrait , HLO_BroadcastingElementwise , InferTensorType

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

Effects: MemoryEffects::Effect{}

Operands:

Operando	Descrição
pred	ranked tensor of bool values
on_true	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
on_false	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Resultados:

Resultado	Descrição
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.select_and_scatter (mhlo::SelectAndScatterOp)

SelectAndScatter operation

Scatters the values from the source tensor using scatter based on the outcome of reduce_window of the input tensor using select and produces a result tensor.

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

Exemplo:

%result = "mhlo.select_and_scatter"(%operand, %source, %init_value) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = "mhlo.compare"(%arg0, %arg1) {
      comparison_direction = #stablehlo<comparison_direction GE>
    } : (tensor<i32>, tensor<i32>) -> tensor<i1>
    "mhlo.return"(%0) : (tensor<i1>) -> ()
}, {
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = "mhlo.add"(%arg0, %arg1) : (tensor<i32>, tensor<i32>) -> tensor<i32>
    "mhlo.return"(%0) : (tensor<i32>) -> ()
}) {
  window_dimensions = dense<[3, 1]> : tensor<2xi64>,
  window_strides = dense<[2, 1]> : tensor<2xi64>,
  padding = dense<[[0, 1], [0, 0]]> : tensor<2x2xi64>
} : (tensor<4x2xi32>, tensor<2x2xi32>, tensor<i32>) -> tensor<4x2xi32>

Traits: RecursiveMemoryEffects

Interfaces: InferTypeOpInterface

Attributes:

Atributo	MLIR Type	Descrição
window_dimensions	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
window_strides	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
padding	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Operando	Descrição
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
source	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
init_value	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Resultados:

Resultado	Descrição
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.send (mhlo::SendOp)

Send operation

Sends inputs to a channel channel_id and produces a result token.

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

Exemplo:

%result = "mhlo.send"(%operand, %token) {
  // channel_id = 5 : i64,
  // channel_type = #stablehlo<channel_type DEVICE_TO_DEVICE>,
  channel_handle = #mhlo.channel_handle<handle = 5, type = 1>,
  is_host_transfer = false,
  source_target_pairs = dense<[[0, 1], [1, 2]]> : tensor<2x2xi64>
} : (tensor<3x4xi32>, !mhlo.token) -> !mhlo.token

Interfaces: InferTypeOpInterface

Attributes:

Atributo	MLIR Type	Descrição
channel_handle	::mlir::mhlo::ChannelHandleAttr	two 64-bit integers 'handle' and 'type'
is_host_transfer	::mlir::BoolAttr	bool attribute
source_target_pairs	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Operando	Descrição
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
token	símbolo

Resultados:

Resultado	Descrição
«unnamed»	símbolo

mhlo.set_dimension_size (mhlo::SetDimensionSizeOp)

SetDimensionSize 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 XLA's SetDimensionSize: https://www.tensorflow.org/xla/operation_semantics#setdimensionsize

Exemplo:

%0 = mhlo.set_dimension_size %arg0, %arg1, dim = 1 : (tensor<4x2xf32>, tensor<i32>) -> tensor<4x2xf32>

Traits: AlwaysSpeculatableImplTrait , InferTensorType

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

Effects: MemoryEffects::Effect{}

Attributes:

Atributo	MLIR Type	Descrição
dimension	::mlir::IntegerAttr	64-bit signless integer attribute whose value is non-negative

Operands:

Operando	Descrição
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
size	tensor of 32-bit signless integer values

Resultados:

Resultado	Descrição
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.shift_left (mhlo::ShiftLeftOp)

ShiftLeft operation

Sintaxe:

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

Performs element-wise left-shift operation on the lhs tensor by rhs number of bits and produces a result tensor.

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

Exemplo:

%result = mhlo.shift_left %lhs, %rhs : tensor<6xi8>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operando	Descrição
lhs	ranked tensor of 2/4/8/16/32/64-bit integer values
rhs	ranked tensor of 2/4/8/16/32/64-bit integer values

Resultados:

Resultado	Descrição
result	ranked tensor of 2/4/8/16/32/64-bit integer values

mhlo.shift_right_arithmetic (mhlo::ShiftRightArithmeticOp)

ShiftRightArithmetic operation

Sintaxe:

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

Performs element-wise arithmetic right-shift operation on the lhs tensor by rhs number of bits and produces a result tensor.

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

Exemplo:

%result = mhlo.shift_right_arithmetic %lhs, %rhs : tensor<6xi8>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operando	Descrição
lhs	ranked tensor of 2/4/8/16/32/64-bit integer values
rhs	ranked tensor of 2/4/8/16/32/64-bit integer values

Resultados:

Resultado	Descrição
result	ranked tensor of 2/4/8/16/32/64-bit integer values

mhlo.shift_right_logical (mhlo::ShiftRightLogicalOp)

ShiftRightLogical operation

Sintaxe:

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

Performs element-wise logical right-shift operation on the lhs tensor by rhs number of bits and produces a result tensor.

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

Exemplo:

%result = mhlo.shift_right_logical %lhs, %rhs : tensor<6xi8>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operando	Descrição
lhs	ranked tensor of 2/4/8/16/32/64-bit integer values
rhs	ranked tensor of 2/4/8/16/32/64-bit integer values

Resultados:

Resultado	Descrição
result	ranked tensor of 2/4/8/16/32/64-bit integer values

mhlo.sign (mhlo::SignOp)

Sign operation

Sintaxe:

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

Returns the sign of the operand element-wise and produces a result tensor.

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

Exemplo:

%result = mhlo.sign %operand : tensor<7xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operando	Descrição
operand	ranked tensor of 2/4/8/16/32/64-bit signless integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

Resultados:

Resultado	Descrição
result	ranked tensor of 2/4/8/16/32/64-bit signless integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.sine (mhlo::SineOp)

Sine operation

Sintaxe:

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

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

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

Exemplo:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributes:

Atributo	MLIR Type	Descrição
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Operando	Descrição
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

Resultados:

Resultado	Descrição
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.sinh (mhlo::SinhOp)

Sinh operation

Sintaxe:

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

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

Exemplo:

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

Traits: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Operands:

Operando	Descrição
operand	tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

Resultados:

Resultado	Descrição
result	tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

mhlo.slice (mhlo::SliceOp)

Slice operation

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

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

Exemplo:

%result = "mhlo.slice" (%operand) {
  start_indices = dense<[1, 2]> : tensor<2xi64>,
  limit_indices = dense<[3, 4]> : tensor<2xi64>,
  strides = dense<1> : tensor<2xi64>
} : (tensor<3x4xi64>) -> tensor<2x2xi64>

Traits: AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Atributo	MLIR Type	Descrição
start_indices	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
limit_indices	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
strides	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Operando	Descrição
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Resultados:

Resultado	Descrição
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.sort (mhlo::SortOp)

Sort operation

Sorts a variadic number of tensors in inputs together, according to a custom comparator , along the given dimension and produces a variadic number of tensors as results .

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

Exemplo:

%result0, %result1 = "mhlo.sort"(%input0, %input1) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>, %arg2: tensor<i32>, %arg3: tensor<i32>):
    %predicate = "mhlo.compare"(%arg0, %arg1) {
      comparison_direction = #stablehlo<comparison_direction GT>
      } : (tensor<i32>, tensor<i32>) -> tensor<i1>
    "mhlo.return"(%predicate) : (tensor<i1>) -> ()
}) {
  dimension = 0 : i64,
  is_stable = true
} : (tensor<2x3xi32>, tensor<2x3xi32>) -> (tensor<2x3xi32>, tensor<2x3xi32>)

Traits: InferTensorType , RecursiveMemoryEffects , SameOperandsAndResultShape

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Attributes:

Atributo	MLIR Type	Descrição
dimension	::mlir::IntegerAttr	64-bit signless integer attribute
is_stable	::mlir::BoolAttr	bool attribute

Operands:

Operando	Descrição
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Resultados:

Resultado	Descrição
«unnamed»	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.sqrt (mhlo::SqrtOp)

Sqrt operation

Sintaxe:

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

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

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

Exemplo:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributes:

Atributo	MLIR Type	Descrição
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Operando	Descrição
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

Resultados:

Resultado	Descrição
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.stochastic_convert (mhlo::StochasticConvertOp)

StochasticConvert operation

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

Informally, this operation performs element-wise conversion of values from a bigger type to a smaller one with stochastic rounding using the random number passed in.

Traits: AlwaysSpeculatableImplTrait , Elementwise

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operando	Descrição
operand	ranked tensor of 4/6/8/16/32/64-bit float values
random	ranked tensor of 2/4/8/16/32/64-bit unsigned integer values

Resultados:

Resultado	Descrição
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.subtract (mhlo::SubtractOp)

Subtract operation

Sintaxe:

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

Performs element-wise subtraction of two tensors lhs and rhs and produces a result tensor.

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

Exemplo:

%result = mhlo.subtract %lhs, %rhs : tensor<2xi32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operando	Descrição
lhs	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Resultados:

Resultado	Descrição
result	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.tan (mhlo::TanOp)

Tan operation

Sintaxe:

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

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

Informally, this operation returns Tan(operand) element-wise.

Exemplo:

%0 = mhlo.tan %arg0 : tensor<2xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributes:

Atributo	MLIR Type	Descrição
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Operando	Descrição
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

Resultados:

Resultado	Descrição
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.tanh (mhlo::TanhOp)

Tanh operation

Sintaxe:

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

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

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

Exemplo:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributes:

Atributo	MLIR Type	Descrição
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Operando	Descrição
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

Resultados:

Resultado	Descrição
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.topk (mhlo::TopKOp)

TopK operation

Sintaxe:

operation ::= `mhlo.topk` `(`$operand `,` `k` `=` $k (`,` `largest` `=` $largest^)? `)` attr-dict `:`
              type($operand) `->` `(`type($values)`,` type($indices)`)`

Returns top k values and their indices, along the last dimension of the operand if largest=true or the bottom k values if largest=false .

See: https://www.tensorflow.org/xla/operation_semantics#top-k

Exemplo:

%values, %indices = mhlo.topk(%operand, k=5, largest=true)
  : tensor<100xf32> -> (tensor<5xf32>, tensor<5xi32>)

Traits: InferTensorType , RecursiveMemoryEffects

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Attributes:

Atributo	MLIR Type	Descrição
k	::mlir::IntegerAttr	64-bit signless integer attribute
largest	::mlir::BoolAttr	bool attribute

Operands:

Operando	Descrição
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Resultados:

Resultado	Descrição
values	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
indices	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.torch_index_select (mhlo::TorchIndexSelectOp)

TorchIndexSelect 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 PyTorch's index_select, augmented with support for batch dimensions: https://pytorch.org/docs/stable/generated/torch.index_select.html

The batch_dims attribute specifies the number of major batch dimensions (0 or more) that act like a multidimensional loop over both the operand and the index.

Exemplo:

%result = "mhlo.torch_index_select"(%operand, %index) {
  dim = 2 : i64,
  batch_dims = 1 : i64
} : (tensor<8x128x3072x64xf32>, tensor<8x16x1024xi32>) -> tensor<8x128x16x1024x64xf32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Atributo	MLIR Type	Descrição
dim	::mlir::IntegerAttr	64-bit signless integer attribute
batch_dims	::mlir::IntegerAttr	64-bit signless integer attribute

Operands:

Operando	Descrição
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
index	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Resultados:

Resultado	Descrição
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.trace (mhlo::TraceOp)

Trace operation

Sintaxe:

operation ::= `mhlo.trace` $operand `,` $tag attr-dict `:` type($operand)

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

It is not used by JAX, PyTorch or TensorFlow, so it looks like we should've classified it as "Private to XLA" and not included it in StableHLO in the first place. With that in mind, its semantics will not be documented here.

Exemplo:

mhlo.trace %arg0, "In test code." : tensor<5x1x5xi32>

Attributes:

Atributo	MLIR Type	Descrição
tag	::mlir::StringAttr	string attribute

Operands:

Operando	Descrição
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.transpose (mhlo::TransposeOp)

Transpose operation

Permutes the dimensions of operand tensor using permutation and produces a result tensor.

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

Exemplo:

%0 = mhlo.transpose %arg0, dims = [2, 1, 0] : (tensor<1x2x3xi32>) -> tensor<3x2x1xi32>

Traits: AlwaysSpeculatableImplTrait , HLO_CompatibleOperandsAndResultElementType

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

Effects: MemoryEffects::Effect{}

Attributes:

Atributo	MLIR Type	Descrição
permutation	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Operando	Descrição
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Resultados:

Resultado	Descrição
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.triangular_solve (mhlo::TriangularSolveOp)

TriangularSolve operation

Solves batches of systems of linear equations with lower or upper triangular coefficient matrices.

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

Exemplo:

%result = "mhlo.triangular_solve"(%a, %b) {
  left_side = true,
  lower = true,
  unit_diagonal = false,
  transpose_a = #stablehlo<transpose NO_TRANSPOSE>
} : (tensor<3x3xf32>, tensor<3x3xf32>) -> tensor<3x3xf32>

Traits: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsAndResultElementType

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

Effects: MemoryEffects::Effect{}

Attributes:

Atributo	MLIR Type	Descrição
left_side	::mlir::BoolAttr	bool attribute
lower	::mlir::BoolAttr	bool attribute
unit_diagonal	::mlir::BoolAttr	bool attribute
transpose_a	::mlir::mhlo::TransposeAttr	Transpose options

Operands:

Operando	Descrição
a	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values
b	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

Resultados:

Resultado	Descrição
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

mhlo.tuple (mhlo::TupleOp)

Tuple operation

Sintaxe:

operation ::= `mhlo.tuple` $val attr-dict `:` custom<TupleOpType>(type($val), type($result))

Produces a result tuple from values val .

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

Exemplo:

%result = mhlo.tuple %val0, %val1 : tuple<tensor<2xf32>, tuple<tensor<i32>>>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operando

Descrição

val

variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values or token or nested tuple with any combination of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values

Resultados:

Resultado

Descrição

result

nested tuple with any combination of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token values

mhlo.uniform_dequantize (mhlo::UniformDequantizeOp)

UniformDequantize operation

Sintaxe:

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

Performs element-wise conversion of quantized tensor operand to a floating-point tensor result according to the quantization parameters defined by the operand type.

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

Exemplo:

%result = mhlo.uniform_dequantize %operand : (tensor<16x16x!quant.uniform<i8:f32, 34.0:16>>) -> tensor<16x16xf32>

Traits: AlwaysSpeculatableImplTrait , Elementwise , InferTensorType , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operando	Descrição
operand	ranked tensor of per-tensor integer quantized or per-axis integer quantized values

Resultados:

Resultado	Descrição
result	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.uniform_quantize (mhlo::UniformQuantizeOp)

UniformQuantize operation

Sintaxe:

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

Performs element-wise conversion of floating-point tensor or quantized tensor operand to a quantized tensor result according to the quantization parameters defined by the result type.

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

Exemplo:

%result = mhlo.uniform_quantize %operand : (tensor<16x16xf32>) -> tensor<16x16x!quant.uniform<ui8:f32, 34.0:16>>

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operando	Descrição
operand	ranked tensor of 4/6/8/16/32/64-bit float or 2/4/8/16/32-bit uniform quantized signed integer or 2/4/8/16/32-bit uniform quantized per axis signed integer or 2/4/8/16/32-bit uniform quantized unsigned integer or 2/4/8/16/32-bit uniform quantized per axis unsigned integer values

Resultados:

Resultado	Descrição
result	ranked tensor of per-tensor integer quantized or per-axis integer quantized values

mhlo.while (mhlo::WhileOp)

While operation

Produces the output from executing body function 0 or more times while the cond function outputs true .

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

Exemplo:

%results0, %results1 = "mhlo.while"(%operand0, %operand1) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = "mhlo.compare"(%arg0, %arg1) {
      comparison_direction = #stablehlo<comparison_direction LT>
    } : (tensor<i32>, tensor<i32>) -> tensor<i1>
    "mhlo.return"(%0) : (tensor<i1>) -> ()
}, {
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = "mhlo.add"(%arg0, %constant0) : (tensor<i32>, tensor<i32>) -> tensor<i32>
    "mhlo.return"(%0, %arg1) : (tensor<i32>, tensor<i32>) -> ()
}) : (tensor<i32>, tensor<i32>) -> (tensor<i32>, tensor<i32>)

Traits: RecursiveMemoryEffects , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfaces: InferTypeOpInterface , OpAsmOpInterface

Operands:

Operando

Descrição

operand

variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values

Resultados:

Resultado

Descrição

«unnamed»

variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.xla.rng_get_and_update_state (mhlo::XlaRngGetAndUpdateStateOp)

XlaRngGetAndUpdateState operation

Sintaxe:

operation ::= `mhlo.xla.rng_get_and_update_state` attr-dict

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

Informally, this operation represents the change of the global random number generator state for rng instructions. The global state is incremented by delta and the old state is returned.

The output is currently defined for a single output type. If this changes in the future to support multiple types, lowering to use of a global memref must ensure that a single memref is still used and updated appropriately.

Interfaces: InferTypeOpInterface

Attributes:

Atributo	MLIR Type	Descrição
delta	::mlir::IntegerAttr	64-bit signless integer attribute

Resultados:

Resultado	Descrição
«unnamed»	statically shaped tensor of 64-bit unsigned integer values

mhlo.xor (mhlo::XorOp)

Xor operation

Sintaxe:

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

Performs element-wise XOR of two tensors lhs and rhs and produces a result tensor.

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

Exemplo:

%result = mhlo.xor %lhs, %rhs : tensor<2xi32>

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operando	Descrição
lhs	ranked tensor of bool or 2/4/8/16/32/64-bit integer values
rhs	ranked tensor of bool or 2/4/8/16/32/64-bit integer values

Resultados:

Resultado	Descrição
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Atributos

ArgResultAliasAttr

Attribute that models the alias relationship of entry function argument

This attribute captures the alias relationship of an MHLO main function argument to one of the results, denoted by resultIndex . The argTupleIndices and resultTupleIndices are used to index into nested tuples in operand and result respectively. If isMustAlias is true then the operand-result pair must alias.

This is meant to be used as an attribute on a function argument in MHLO. For example, in the following code it expresses that %arg1 may alias 0-th result.

func @main(%arg0: tensor<2xf32>, %arg1: tensor<3xf32> {mhlo.result_alias =
    mhlo.result_alias<result_index = [2], ...>}
  ) -> tensor<2xf32>, tensor<3xf32> {
  // function body ...
}

Parâmetros:

Parâmetro	C++ type	Descrição
argTupleIndices	::llvm::ArrayRef<int64_t>	Dimensão
resultIndex	int64_t
resultTupleIndices	::llvm::ArrayRef<int64_t>	Dimensão
isMustAlias	bool

ChannelHandleAttr

Two 64-bit integers 'handle' and 'type'

Sintaxe:

#mhlo.channel_handle<
  int64_t,   # handle
  int64_t   # type
>

Parâmetros:

Parâmetro	C++ type	Descrição
lidar	int64_t
tipo	int64_t

ComparisonDirectionAttr

Which comparison operation to perform.

Sintaxe:

#mhlo.comparison_direction<
  ::mlir::mhlo::ComparisonDirection   # value
>

Parâmetros:

Parâmetro	C++ type	Descrição
valor	::mlir::mhlo::ComparisonDirection	an enum of type ComparisonDirection

ComparisonTypeAttr

Which comparison type to use.

Sintaxe:

#mhlo.comparison_type<
  ::mlir::mhlo::ComparisonType   # value
>

Parâmetros:

Parâmetro	C++ type	Descrição
valor	::mlir::mhlo::ComparisonType	an enum of type ComparisonType

ConvDimensionNumbersAttr

Structure of dimension information for conv op

Parâmetros:

Parâmetro	C++ type	Descrição
inputBatchDimension	int64_t
inputFeatureDimension	int64_t
inputSpatialDimensions	::llvm::ArrayRef<int64_t>	Dimensão
kernelInputFeatureDimension	int64_t
kernelOutputFeatureDimension	int64_t
kernelSpatialDimensions	::llvm::ArrayRef<int64_t>	Dimensão
outputBatchDimension	int64_t
outputFeatureDimension	int64_t
outputSpatialDimensions	::llvm::ArrayRef<int64_t>	Dimensão

CrossProgramPrefetchAttr

Argument that is prefetched from another program

Sintaxe:

#mhlo.cross_program_prefetch<
  int64_t,   # parameter
  ::llvm::ArrayRef<int64_t>,   # indices
  std::optional<int64_t>   # offset
>

This attribute captures an argument that is prefetched from another program. For a given CrossProgramPrefetchAttr , parameter tells us which argument of the main function of the module is prefetched, and indices is a shape index telling us what subshape of that argument is prefetched.

A shape has a subshape iff it is a tuple. In that case, the subshape of the tuple by indices is the shape achieved after indexing by each element of indices in turn. For example, the [1,0] subshape of tuple<tuple<token, token>, tuple<tensor<i32>, token>> is tensor<i32> .

An empty value for indices means the whole shape is prefetched.

Por exemplo,

module attributes { mhlo.cross_program_prefetch = [ #mhlo.cross_program_prefetch< parameter = 0, indices = [0]> ]} {
  func.func @copy(%arg0 : tuple<tensor<2x3xi32>, tensor<i32>>) -> tuple<tensor<2x3xi32>, tensor<i32>> {
    %0 = "mhlo.copy"(%arg0) {is_cross_program_prefetch}
    return %0 : tuple<tensor<2x3xi32>, tensor<i32>>
  }
  func.func @main(%arg0 : tuple<tensor<2x3xi32>, tensor<i32>>) -> tuple<tensor<2x3xi32>, tensor<i32>> {
    %1 = "mhlo.async_start"(%arg0) {called_computation=@copy}
    %2 = "mhlo.async_done"(%1) {called_computation=@copy}
    return %2 : tuple<tensor<2x3xi32>, tensor<i32>>
  }
}

The parameter = 0 tells us that the async copy of the 0 th parameter is a cross_program_prefetch , while the index of [0] tells us that the 0 th element of the tuple is prefetched while the other element of the tuple is not.

Parâmetros:

Parâmetro	C++ type	Descrição
parâmetro	int64_t
índices	::llvm::ArrayRef<int64_t>	Dimensão
desvio	std::optional<int64_t>

CustomCallScheduleAttr

Specifies the desired schedule for the custom-call.

Sintaxe:

#mhlo.custom_call_schedule<
  ::mlir::mhlo::CustomCallSchedule   # value
>

Parâmetros:

Parâmetro	C++ type	Descrição
valor	::mlir::mhlo::CustomCallSchedule	an enum of type CustomCallSchedule

DequantizeModeAttr

_Dequantization mode. Only MIN COMBINED is supported.

Sintaxe:

#mhlo.dequantize_mode<
  ::mlir::mhlo::DequantizeMode   # value
>

Parâmetros:

Parâmetro	C++ type	Descrição
valor	::mlir::mhlo::DequantizeMode	an enum of type DequantizeMode

DomainKindAttr

Kind of domain metatdata attached to an HLO domain.

Sintaxe:

#mhlo.kind<
  ::mlir::mhlo::DomainKind   # value
>

Parâmetros:

Parâmetro	C++ type	Descrição
valor	::mlir::mhlo::DomainKind	an enum of type DomainKind

DotAlgorithmAttr

Attribute that models the algorithm constraints to use for computing dot.

Sintaxe:

#mhlo.dot_algorithm<
  Type,   # lhsPrecisionType
  Type,   # rhsPrecisionType
  Type,   # accumulationType
  int64_t,   # lhsComponentCount
  int64_t,   # rhsComponentCount
  int64_t,   # numPrimitiveOperations
  bool   # allowImpreciseAccumulation
>

Parâmetros:

Parâmetro	C++ type	Descrição
lhsPrecisionType	Type
rhsPrecisionType	Type
accumulationType	Type
lhsComponentCount	int64_t
rhsComponentCount	int64_t
numPrimitiveOperations	int64_t
allowImpreciseAccumulation	bool

DotDimensionNumbersAttr

Attribute that models the dimension information for dot.

Parâmetros:

Parâmetro	C++ type	Descrição
lhsBatchingDimensions	::llvm::ArrayRef<int64_t>	Dimensão
rhsBatchingDimensions	::llvm::ArrayRef<int64_t>	Dimensão
lhsContractingDimensions	::llvm::ArrayRef<int64_t>	Dimensão
rhsContractingDimensions	::llvm::ArrayRef<int64_t>	Dimensão

FftTypeAttr

XLA fast fourier transform type.

Sintaxe:

#mhlo.fft_type<
  ::mlir::mhlo::FftType   # value
>

Parâmetros:

Parâmetro	C++ type	Descrição
valor	::mlir::mhlo::FftType	an enum of type FftType

FusionKindAttr

Fusion kind

Sintaxe:

#mhlo.fusion_kind<
  ::mlir::mhlo::FusionKind   # value
>

Parâmetros:

Parâmetro	C++ type	Descrição
valor	::mlir::mhlo::FusionKind	an enum of type FusionKind

GatherDimensionNumbersAttr

Attribute that models the dimension information for gather

Parâmetros:

Parâmetro	C++ type	Descrição
offsetDims	::llvm::ArrayRef<int64_t>	Dimensão
collapsedSliceDims	::llvm::ArrayRef<int64_t>	Dimensão
operandBatchingDims	::llvm::ArrayRef<int64_t>	Dimensão
startIndicesBatchingDims	::llvm::ArrayRef<int64_t>	Dimensão
startIndexMap	::llvm::ArrayRef<int64_t>	Dimensão
indexVectorDim	int64_t

OutputOperandAliasAttr

Attribute that models the alias relationship of output and operand of a CustomCall op

Sintaxe:

#mhlo.output_operand_alias<
  ::llvm::ArrayRef<int64_t>,   # outputTupleIndices
  int64_t,   # operandIndex
  ::llvm::ArrayRef<int64_t>   # operandTupleIndices
>

This attribute captures the alias relationship of the output to one of the operands for a CustomCall op, denoted by operand_index . The output_tuple_indices and operand_tuple_indices are used to index into output and operand types. These indices lists are empty if the corresponding types are not tuple types, and can be arbitrarily long in case of arbitrarily nested tuple types.

See https://www.tensorflow.org/xla/aliasing

Example when used as array with in mhlo.custom-call:

%0 = "mhlo.custom_call"(%arg0, %arg1) {
  // other attributes
  output_operand_alias = [
    #mhlo.output_operand_alias<output_tuple_indices = [0],
                               operand_index = 0,
                               operand_tuple_indices = [1]>
  ]
} : (tuple<tensor<1x1xf32>, tensor<2x3xf32>>, tensor<5x5xf32>) -> tuple<tensor<2x3xf32>>

The output and the 0th operand are both tuples. The aliasing shows the
relationship between the 0th element in output tuple with the 1st element in
the 0th operand. And both of them are of the same type: tensor<2x3xf32>.

Parâmetros:

Parâmetro	C++ type	Descrição
outputTupleIndices	::llvm::ArrayRef<int64_t>	Dimensão
operandIndex	int64_t
operandTupleIndices	::llvm::ArrayRef<int64_t>	Dimensão

PrecisionAttr

XLA precision for an operand. Has backend specific meaning.

Sintaxe:

#mhlo.precision<
  ::mlir::mhlo::Precision   # value
>

Parâmetros:

Parâmetro	C++ type	Descrição
valor	::mlir::mhlo::Precision	an enum of type Precision

RaggedDotDimensionNumbersAttr

Attribute that models the dimension information for ragged dot.

Parâmetros:

Parâmetro	C++ type	Descrição
dotDimensionNumbers	::mlir::mhlo::DotDimensionNumbersAttr	Attribute that models the dimension information for dot.
lhsRaggedDimensions	::llvm::ArrayRef<int64_t>	Dimensão
rhsGroupDimensions	::llvm::ArrayRef<int64_t>	Dimensão

ResultAccuracyAttr

The requested accuracy for unary ops.

Parâmetros:

Parâmetro	C++ type	Descrição
atol	APFloat
rtol	APFloat
ulps	int64_t
modo	::mlir::mhlo::ResultAccuracyModeAttr	XLA result accuracy mode.

ResultAccuracyModeAttr

XLA result accuracy mode.

Sintaxe:

#mhlo.result_accuracy_mode<
  ::mlir::mhlo::ResultAccuracyMode   # value
>

Parâmetros:

Parâmetro	C++ type	Descrição
valor	::mlir::mhlo::ResultAccuracyMode	an enum of type ResultAccuracyMode

RngAlgorithmAttr

XLA PRNG algorithm to be used.

Sintaxe:

#mhlo.rng_algorithm<
  ::mlir::mhlo::RngAlgorithm   # value
>

Parâmetros:

Parâmetro	C++ type	Descrição
valor	::mlir::mhlo::RngAlgorithm	an enum of type RngAlgorithm

RngDistributionAttr

XLA PRNG distribution to be used.

Sintaxe:

#mhlo.rng_distribution<
  ::mlir::mhlo::RngDistribution   # value
>

Parâmetros:

Parâmetro	C++ type	Descrição
valor	::mlir::mhlo::RngDistribution	an enum of type RngDistribution

ScatterDimensionNumbersAttr

Attribute that models the dimension information for scatter

Parâmetros:

Parâmetro	C++ type	Descrição
updateWindowDims	::llvm::ArrayRef<int64_t>	Dimensão
insertedWindowDims	::llvm::ArrayRef<int64_t>	Dimensão
inputBatchingDims	::llvm::ArrayRef<int64_t>	Dimensão
scatterIndicesBatchingDims	::llvm::ArrayRef<int64_t>	Dimensão
scatterDimsToOperandDims	::llvm::ArrayRef<int64_t>	Dimensão
indexVectorDim	int64_t

TransposeAttr

Transpose options

Sintaxe:

#mhlo.transpose<
  ::mlir::mhlo::Transpose   # value
>

Parâmetros:

Parâmetro	C++ type	Descrição
valor	::mlir::mhlo::Transpose	an enum of type Transpose

TypeExtensionsAttr

Attribute that extends tensor type with MHLO type properties.

Sintaxe:

#mhlo.type_extensions<
  ::llvm::ArrayRef<int64_t>   # bounds
>

This attribute is used to extend MLIR tensor type with MHLO tensor specific properties. These properties aren't modeled in the MLIR type. This attribute is set in the encoding field of the tensor type.

See HLO_BoundedAttrInterface for documentation for bounds .

Parâmetros:

Parâmetro	C++ type	Descrição
limites	::llvm::ArrayRef<int64_t>

Tipos

AsyncBundleType

Opaque collection of other types

Sintaxe:

!mhlo.async_bundle<
  ::llvm::ArrayRef<Type>   # types
>

Parâmetros:

Parâmetro	C++ type	Descrição
tipos	::llvm::ArrayRef<Type>

Enumerações

ComparisonDirection

Which comparison operation to perform.

Casos:

Símbolo	Valor	Corda
EQ	0	EQ
NE	1	NE
GE	2	GE
GT	3	GT
LE	4	LE
Tenente	5	Tenente

ComparisonType

Which comparison type to use.

Casos:

Símbolo	Valor	Corda
NOTYPE	0	NOTYPE
FLUTUADOR	1	FLUTUADOR
TOTALORDER	2	TOTALORDER
ASSINADO	3	ASSINADO
UNSIGNED	4	UNSIGNED

CustomCallApiVersion

Custom call API version

Casos:

Símbolo	Valor	Corda
API_VERSION_UNSPECIFIED	0	API_VERSION_UNSPECIFIED
API_VERSION_ORIGINAL	1	API_VERSION_ORIGINAL
API_VERSION_STATUS_RETURNING	2	API_VERSION_STATUS_RETURNING
API_VERSION_STATUS_RETURNING_UNIFIED	3	API_VERSION_STATUS_RETURNING_UNIFIED
API_VERSION_TYPED_FFI	4	API_VERSION_TYPED_FFI

CustomCallSchedule

Specifies the desired schedule for the custom-call.

Casos:

Símbolo	Valor	Corda
NENHUM	0	NENHUM
MAIS RECENTE	1	MAIS RECENTE
EARLIEST	2	EARLIEST

DequantizeMode

_Dequantization mode. Only MIN COMBINED is supported.

Casos:

Símbolo	Valor	Corda
MIN_COMBINED	0	MIN_COMBINED

DomainKind

Kind of domain metatdata attached to an HLO domain.

Casos:

Símbolo	Valor	Corda
fragmentação	0	fragmentação

FftType

XLA fast fourier transform type.

Casos:

Símbolo	Valor	Corda
FFT	0	FFT
IFFT	1	IFFT
RFFT	2	RFFT
IRFFT	3	IRFFT

FusionKind

Fusion kind

Casos:

Símbolo	Valor	Corda
kLoop	0	kLoop
kInput	1	kInput
kOutput	2	kOutput
kCustom	3	kCustom

Precisão

XLA precision for an operand. Has backend specific meaning.

Casos:

Símbolo	Valor	Corda
PADRÃO	0	PADRÃO
ALTO	1	ALTO
MAIS ALTO	2	MAIS ALTO

ResultAccuracyMode

XLA result accuracy mode.

Casos:

Símbolo	Valor	Corda
PADRÃO	0	PADRÃO
MAIS ALTO	1	MAIS ALTO
TOLERÂNCIA	2	TOLERÂNCIA

RngAlgorithm

XLA PRNG algorithm to be used.

Casos:

Símbolo	Valor	Corda
PADRÃO	0	PADRÃO
THREE_FRY	1	THREE_FRY
PHILOX	2	PHILOX

RngDistribution

XLA PRNG distribution to be used.

Casos:

Símbolo	Valor	Corda
UNIFORME	1	UNIFORME
NORMAL	2	NORMAL

Transpor

Transpose options

Casos:

Símbolo	Valor	Corda
TRANSPOSE_INVALID	0	TRANSPOSE_INVALID
NO_TRANSPOSE	1	NO_TRANSPOSE
TRANSPOR	2	TRANSPOR
ADJOINT	3	ADJOINT