'mhlo' Dialecto

Operaciones

mhlo.abs (mhlo::AbsOp)

Operación del ABS

Sintaxis:

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

Realiza una operación abs elemento por elemento en el tensor operand y produce un tensor result .

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

Ejemplo:

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

Rasgos: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

Efectos: MemoryEffects::Effect{}

Operandos:

Operando

Descripción

operand

tensor clasificado de un entero sin signo de 2/4/8/16/32/64 bits o de un tipo float o complejo de 4/6/8/16/32/64 bits con elementos float de 32/64 bits o de un entero con signo cuantificado uniformemente de 2/4/8/16/32 bits o de un entero con signo cuantificado uniformemente por eje de 2/4/8/16/32 bits o de un entero sin signo cuantificado uniformemente por eje de 2/4/8/16/32 bits o de valores enteros sin signo cuantificados uniformemente por eje de 2/4/8/16/32 bits

Resultados:

Resultado

Descripción

result

tensor clasificado de un entero sin signo de 2/4/8/16/32/64 bits o un entero con signo cuantificado uniforme de 4/6/8/16/32/64 bits o un entero con signo cuantificado uniforme de 2/4/8/16/32 bits o un entero con signo cuantificado uniforme de 2/4/8/16/32 bits o un entero sin signo cuantificado uniforme de 2/4/8/16/32 bits o valores enteros sin signo cuantificados uniformemente por eje de 2/4/8/16/32 bits

mhlo.acos (mhlo::AcosOp)

Operación Acos

Sintaxis:

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

Realiza una operación acos elemento por elemento sobre el tensor operand y produce un tensor result .

Ejemplo:

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

Rasgos: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Operandos:

Operando	Descripción
operand	Tensor de tipo float o complejo de 4/6/8/16/32/64 bits con valores de elementos float de 32/64 bits

Resultados:

Resultado	Descripción
result	Tensor de tipo float o complejo de 4/6/8/16/32/64 bits con valores de elementos float de 32/64 bits

mhlo.acosh (mhlo::AcoshOp)

Operación Acosh

Sintaxis:

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

Realiza una operación acosh elemento por elemento en el tensor operand y produce un tensor result .

Ejemplo:

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

Rasgos: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Operandos:

Operando	Descripción
operand	Tensor de tipo float o complejo de 4/6/8/16/32/64 bits con valores de elementos float de 32/64 bits

Resultados:

Resultado	Descripción
result	Tensor de tipo float o complejo de 4/6/8/16/32/64 bits con valores de elementos float de 32/64 bits

mhlo.add (mhlo::AddOp)

Agregar operación

Sintaxis:

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

Realiza la suma elemento por elemento de dos tensores lhs y rhs y produce un tensor result .

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

Ejemplo:

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

Rasgos: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Efectos: MemoryEffects::Effect{}

Operandos:

Operando	Descripción
lhs	Tensor clasificado de tipo float o bool de 4/6/8/16/32/64 bits o tipo entero o complejo de 2/4/8/16/32/64 bits con elementos float de 32/64 bits o valores cuantificados enteros por tensor o por eje
rhs	Tensor clasificado de tipo float o bool de 4/6/8/16/32/64 bits o tipo entero o complejo de 2/4/8/16/32/64 bits con elementos float de 32/64 bits o valores cuantificados enteros por tensor o por eje

Resultados:

Resultado	Descripción
result	Tensor clasificado de tipo float o bool de 4/6/8/16/32/64 bits o tipo entero o complejo de 2/4/8/16/32/64 bits con elementos float de 32/64 bits o valores cuantificados enteros por tensor o por eje

mhlo.add_dependency (mhlo::AddDependencyOp)

Operación AddDependency

Sintaxis:

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

Esta operación es privada del compilador XLA, por lo que aún no tiene una especificación.

Informalmente, esta operación consta de dos operandos: un operando de datos y un token. La salida de la operación es el operando de datos. Al usarse con AfterAll, esta operación permite ordenar operaciones sin efectos secundarios (aquellas que no producen valores de token).

Ejemplo:

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

Rasgos: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efectos: MemoryEffects::Effect{}

Operandos:

Operando	Descripción
operand	tensor clasificado de tipo float o bool de 4/6/8/16/32/64 bits o tipo entero o complejo de 2/4/8/16/32/64 bits con elementos float de 32/64 bits o valores cuantificados enteros por tensor o tensor clasificado de valores cuantificados enteros por eje o token o token stablehlo
token	token o token estable

Resultados:

Resultado	Descripción
output	tensor clasificado de tipo float o bool de 4/6/8/16/32/64 bits o tipo entero o complejo de 2/4/8/16/32/64 bits con elementos float de 32/64 bits o valores cuantificados enteros por tensor o tensor clasificado de valores cuantificados enteros por eje o token o token stablehlo

mhlo.after_all (mhlo::AfterAllOp)

Operación AfterAll

Sintaxis:

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

Asegura que las operaciones que producen las inputs se ejecuten antes de cualquier operación que dependa del result .

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

Ejemplo:

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

Rasgos: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efectos: MemoryEffects::Effect{}

Operandos:

Operando	Descripción
inputs	variádico de token

Resultados:

Resultado	Descripción
result	simbólico

mhlo.all_gather (mhlo::AllGatherOp)

Operación AllGather

Dentro de cada grupo de procesos de la cuadrícula de procesos, se concatenan los valores del tensor de operandos de cada proceso a lo largo de all_gather_dim y se genera un tensor de resultados. El computation se aplica por separado para cada operando en operands , generando un resultado por operando.

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

Ejemplo:

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

Rasgos: SameOperandsAndResultElementType

Atributos:

Atributo	Tipo MLIR	Descripción
all_gather_dim	::mlir::Atributo entero	Atributo entero sin signo de 64 bits cuyo valor no es negativo
replica_groups	::mlir::AtributoDeElementosDenseInt	Atributo de elementos enteros sin signo de 64 bits
channel_handle	::mlir::mhlo::Atributo del identificador de canal	dos enteros de 64 bits 'handle' y 'type'
use_global_device_ids	::mlir::Atributo de unidad	atributo de unidad

Operandos:

Operando	Descripción
operands	variádico de tensor clasificado de tipo float o bool de 4/6/8/16/32/64 bits o entero de 2/4/8/16/32/64 bits o complejo con elementos float de 32/64 bits o valores cuantificados enteros por tensor o cuantificados enteros por eje

Resultados:

Resultado	Descripción
"sin nombre"	variádico de tensor clasificado de tipo float o bool de 4/6/8/16/32/64 bits o entero de 2/4/8/16/32/64 bits o complejo con elementos float de 32/64 bits o valores cuantificados enteros por tensor o cuantificados enteros por eje

mhlo.all_reduce (mhlo::AllReduceOp)

Operación AllReduce

Dentro de cada grupo de procesos de la cuadrícula de procesos, se aplica un computation de función de reducción a los valores de un tensor de operandos de cada proceso y se genera un tensor de resultados. El computation se aplica por separado para cada operando en operands , generando un resultado por operando.

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

Ejemplo:

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

Rasgos: InferTensorType , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Atributos:

Atributo	Tipo MLIR	Descripción
replica_groups	::mlir::AtributoDeElementosDenseInt	Atributo de elementos enteros sin signo de 64 bits
channel_handle	::mlir::mhlo::Atributo del identificador de canal	dos enteros de 64 bits 'handle' y 'type'
use_global_device_ids	::mlir::Atributo de unidad	atributo de unidad

Operandos:

Operando	Descripción
operands	variádico de tensor clasificado de tipo float o bool de 4/6/8/16/32/64 bits o entero de 2/4/8/16/32/64 bits o complejo con elementos float de 32/64 bits o valores cuantificados enteros por tensor o cuantificados enteros por eje

Resultados:

Resultado	Descripción
"sin nombre"	variádico de tensor clasificado de tipo float o bool de 4/6/8/16/32/64 bits o entero de 2/4/8/16/32/64 bits o complejo con elementos float de 32/64 bits o valores cuantificados enteros por tensor o cuantificados enteros por eje

mhlo.all_to_all (mhlo::AllToAllOp)

Operación AllToAll

Dentro de cada grupo de procesos en la cuadrícula de procesos, divide los valores del tensor operand a lo largo split_dimension en partes, dispersa las partes divididas entre los procesos, concatena las partes dispersas a lo largo de concat_dimension y produce un tensor result .

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

Ejemplo:

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

Rasgos: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsElementType , SameOperandsShape , SameVariadicOperandSize

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

Efectos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descripción
split_dimension	::mlir::Atributo entero	Atributo entero sin signo de 64 bits cuyo valor no es negativo
concat_dimension	::mlir::Atributo entero	Atributo entero sin signo de 64 bits cuyo valor no es negativo
split_count	::mlir::Atributo entero	Atributo entero sin signo de 64 bits cuyo valor es positivo
replica_groups	::mlir::AtributoDeElementosDenseInt	Atributo de elementos enteros sin signo de 64 bits
channel_handle	::mlir::mhlo::Atributo del identificador de canal	dos enteros de 64 bits 'handle' y 'type'

Operandos:

Operando	Descripción
operand	variádico de tensor clasificado de tipo float o bool de 4/6/8/16/32/64 bits o entero de 2/4/8/16/32/64 bits o complejo con elementos float de 32/64 bits o valores cuantificados enteros por tensor o cuantificados enteros por eje

Resultados:

Resultado	Descripción
"sin nombre"	variádico de tensor clasificado de tipo float o bool de 4/6/8/16/32/64 bits o entero de 2/4/8/16/32/64 bits o complejo con elementos float de 32/64 bits o valores cuantificados enteros por tensor o cuantificados enteros por eje

mhlo.and (mhlo::AndOp)

Y operación

Sintaxis:

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

Realiza AND elemento por elemento de dos tensores lhs y rhs y produce un tensor result

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

Ejemplo:

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

Rasgos: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Efectos: MemoryEffects::Effect{}

Operandos:

Operando	Descripción
lhs	Tensor clasificado de valores booleanos o enteros de 2/4/8/16/32/64 bits
rhs	Tensor clasificado de valores booleanos o enteros de 2/4/8/16/32/64 bits

Resultados:

Resultado	Descripción
result	Tensor clasificado de tipo float o bool de 4/6/8/16/32/64 bits o tipo entero o complejo de 2/4/8/16/32/64 bits con elementos float de 32/64 bits o valores cuantificados enteros por tensor o por eje

mhlo.asin (mhlo::AsinOp)

Operación Asin

Sintaxis:

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

Realiza una operación asin elemento por elemento sobre el tensor operand y produce un tensor result .

Ejemplo:

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

Rasgos: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Operandos:

Operando	Descripción
operand	Tensor de tipo float o complejo de 4/6/8/16/32/64 bits con valores de elementos float de 32/64 bits

Resultados:

Resultado	Descripción
result	Tensor de tipo float o complejo de 4/6/8/16/32/64 bits con valores de elementos float de 32/64 bits

mhlo.async_done (mhlo::AsyncDoneOp)

Operación AsyncDone

Esta operación es privada del compilador XLA, por lo que aún no tiene una especificación.

De manera informal, esta operación se bloquea hasta el final de un cálculo asincrónico. Devuelve el resultado final del cálculo asincrónico.

Consulte la documentación de AsyncStart para obtener más información.

Interfaces: InferTypeOpInterface

Operandos:

Operando	Descripción
bundle	async_bundle con cualquier combinación de tensor clasificado de 4/6/8/16/32/64 bits de tipo flotante o booleano o de 2/4/8/16/32/64 bits de tipo entero o complejo con elementos flotantes de 32/64 bits o valores cuantificados enteros por tensor o valores cuantificados enteros por eje o valores de token o token stablehlo

Resultados:

Resultado

Descripción

"sin nombre"

variádico de tensor clasificado de 4/6/8/16/32/64 bits float o bool o entero de 2/4/8/16/32/64 bits o tipo complejo con elementos float de 32/64 bits o valores cuantificados enteros por tensor o token o token stablehlo o tupla anidada con cualquier combinación de tensor clasificado de 4/6/8/16/32/64 bits float o bool o entero de 2/4/8/16/32/64 bits o tipo complejo con elementos float de 32/64 bits o valores cuantificados enteros por tensor o memref de 4/6/8/16/32/64 bits float o bool o entero de 2/4/8/16/32/64 bits o tipo complejo con elementos float de 32/64 bits o valores cuantificados enteros por tensor o tensor clasificado de valores cuantificados enteros por eje o valores de token

mhlo.async_start (mhlo::AsyncStartOp)

Operación AsyncStart

Esta operación es privada del compilador XLA, por lo que aún no tiene una especificación.

De manera informal, esta operación inicia un cálculo asincrónico.

Esto se utiliza cuando existen funciones que contienen tanto esperas asincrónicas (como los DMA) como computación en el hilo. Por ejemplo, una función podría constar de un cálculo, un DMA, otro cálculo, un segundo DMA y un cálculo final. Esto se representaría como async_start seguido de async_update y async_done. Async_start realizaría el primer cálculo en el hilo y luego iniciaría el DMA. Async_update esperaría a que se completara el DMA si aún no lo había hecho, luego ejecutaría el segundo cálculo en la función e iniciaría el segundo DMA. Finalmente, async_done esperaría a este último DMA y luego ejecutaría el último cálculo que debe ejecutarse en el hilo y devolvería el resultado de ese cálculo final.

operands se pasan directamente al cómputo. called_computation es la función que se ejecutará asincrónicamente. execution_thread es el nombre del hilo en el que se ejecutará. El hilo principal se llama "main". Todos los hilos tienen nombre.

Esto devuelve todo el estado necesario entre operaciones asíncronas. Tras la asignación del búfer, los valores de retorno representan el espacio necesario para almacenar la entrada, los resultados y cualquier bloc de notas necesario o editado por la operación asíncrona.

Atributos:

Atributo	Tipo MLIR	Descripción
called_computation	::mlir::Atributo de referencia de símbolo plano	atributo de referencia de símbolo plano
execution_thread	::mlir::Atributo de cadena	atributo de cadena

Operandos:

Operando

Descripción

inputs

variádico de tensor clasificado de 4/6/8/16/32/64 bits float o bool o entero de 2/4/8/16/32/64 bits o tipo complejo con elementos float de 32/64 bits o valores cuantificados enteros por tensor o token o token stablehlo o tupla anidada con cualquier combinación de tensor clasificado de 4/6/8/16/32/64 bits float o bool o entero de 2/4/8/16/32/64 bits o tipo complejo con elementos float de 32/64 bits o valores cuantificados enteros por tensor o memref de 4/6/8/16/32/64 bits float o bool o entero de 2/4/8/16/32/64 bits o tipo complejo con elementos float de 32/64 bits o valores cuantificados enteros por tensor o tensor clasificado de valores cuantificados enteros por eje o valores de token

Resultados:

Resultado	Descripción
"sin nombre"	async_bundle con cualquier combinación de tensor clasificado de 4/6/8/16/32/64 bits de tipo flotante o booleano o de 2/4/8/16/32/64 bits de tipo entero o complejo con elementos flotantes de 32/64 bits o valores cuantificados enteros por tensor o valores cuantificados enteros por eje o valores de token o token stablehlo

mhlo.async_update (mhlo::AsyncUpdateOp)

Operación AsyncUpdate

Esta operación es privada del compilador XLA, por lo que aún no tiene una especificación.

De manera informal, esta operación bloquea un cálculo asincrónico hasta que se alcanza una barrera de sincronización. Esto devuelve bundle después de operar en él.

Consulte la documentación de AsyncStart para obtener más información.

Interfaces: InferTypeOpInterface

Operandos:

Operando	Descripción
bundle	async_bundle con cualquier combinación de tensor clasificado de 4/6/8/16/32/64 bits de tipo flotante o booleano o de 2/4/8/16/32/64 bits de tipo entero o complejo con elementos flotantes de 32/64 bits o valores cuantificados enteros por tensor o valores cuantificados enteros por eje o valores de token o token stablehlo

Resultados:

Resultado	Descripción
"sin nombre"	async_bundle con cualquier combinación de tensor clasificado de 4/6/8/16/32/64 bits de tipo flotante o booleano o de 2/4/8/16/32/64 bits de tipo entero o complejo con elementos flotantes de 32/64 bits o valores cuantificados enteros por tensor o valores cuantificados enteros por eje o valores de token o token stablehlo

mhlo.atan2 (mhlo::Atan2Op)

Operación Atan2

Sintaxis:

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

Realiza una operación atan2 elemento por elemento en el tensor lhs y rhs y produce un tensor result .

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

Ejemplo:

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

Rasgos: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Efectos: MemoryEffects::Effect{}

Operandos:

Operando	Descripción
lhs	Tensor clasificado de tipo flotante o complejo de 4/6/8/16/32/64 bits con elementos flotantes de 32/64 bits o valores cuantificados enteros por tensor
rhs	Tensor clasificado de tipo flotante o complejo de 4/6/8/16/32/64 bits con elementos flotantes de 32/64 bits o valores cuantificados enteros por tensor

Resultados:

Resultado	Descripción
result	Tensor clasificado de tipo flotante o complejo de 4/6/8/16/32/64 bits con elementos flotantes de 32/64 bits o valores cuantificados enteros por tensor

mhlo.atanh (mhlo::AtanhOp)

Operación Atanh

Sintaxis:

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

Realiza una operación atanh elemento por elemento sobre el tensor operand y produce un tensor result .

Ejemplo:

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

Rasgos: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Operandos:

Operando	Descripción
operand	Tensor de tipo float o complejo de 4/6/8/16/32/64 bits con valores de elementos float de 32/64 bits

Resultados:

Resultado	Descripción
result	Tensor de tipo float o complejo de 4/6/8/16/32/64 bits con valores de elementos float de 32/64 bits

mhlo.batch_norm_grad (mhlo::BatchNormGradOp)

Operación BatchNormGrad

Calcula gradientes de varias entradas de BatchNormTrainingOp retropropagando desde grad_output y produce tensores grad_operand , grad_scale y grad_offset .

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

Ejemplo:

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

Rasgos: AlwaysSpeculatableImplTrait , InferTensorType

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

Efectos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descripción
epsilon	::mlir::Attr flotante	atributo float de 32 bits
feature_index	::mlir::Atributo entero	Atributo entero sin signo de 64 bits cuyo valor no es negativo

Operandos:

Operando	Descripción
operand	Tensor clasificado de valores flotantes de 4/6/8/16/32/64 bits
scale	Tensor 1D de valores flotantes de 4/6/8/16/32/64 bits
mean	Tensor 1D de valores flotantes de 4/6/8/16/32/64 bits
variance	Tensor 1D de valores flotantes de 4/6/8/16/32/64 bits
grad_output	Tensor clasificado de valores flotantes de 4/6/8/16/32/64 bits

Resultados:

Resultado	Descripción
grad_operand	Tensor clasificado de valores flotantes de 4/6/8/16/32/64 bits
grad_scale	Tensor 1D de valores flotantes de 4/6/8/16/32/64 bits
grad_offset	Tensor 1D de valores flotantes de 4/6/8/16/32/64 bits

mhlo.batch_norm_inference (mhlo::InferenciaDeNormaPorLote)

Operación BatchNormInference

Normaliza el tensor operand en todas las dimensiones excepto la dimensión feature_index y produce un tensor result .

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

Ejemplo:

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

Rasgos: AlwaysSpeculatableImplTrait , InferTensorType

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

Efectos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descripción
epsilon	::mlir::Attr flotante	atributo float de 32 bits
feature_index	::mlir::Atributo entero	Atributo entero sin signo de 64 bits cuyo valor no es negativo

Operandos:

Operando	Descripción
operand	Tensor clasificado de valores flotantes de 4/6/8/16/32/64 bits
scale	Tensor 1D de valores flotantes de 4/6/8/16/32/64 bits
offset	Tensor 1D de valores flotantes de 4/6/8/16/32/64 bits
mean	Tensor 1D de valores flotantes de 4/6/8/16/32/64 bits
variance	Tensor 1D de valores flotantes de 4/6/8/16/32/64 bits

Resultados:

Resultado	Descripción
result	Tensor clasificado de valores flotantes de 4/6/8/16/32/64 bits

mhlo.batch_norm_training (mhlo::BatchNormTrainingOp)

Operación BatchNormTraining

Calcula la media y la varianza en las dimensiones espaciales y de lote y normaliza el tensor operand para cada característica en la dimensión feature_index y produce los tensores output batch_mean y batch_var .

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

Ejemplo:

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

Rasgos: AlwaysSpeculatableImplTrait , InferTensorType

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

Efectos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descripción
epsilon	::mlir::Attr flotante	atributo float de 32 bits
feature_index	::mlir::Atributo entero	Atributo entero sin signo de 64 bits cuyo valor no es negativo

Operandos:

Operando	Descripción
operand	Tensor clasificado de valores flotantes de 4/6/8/16/32/64 bits
scale	Tensor 1D de valores flotantes de 4/6/8/16/32/64 bits
offset	Tensor 1D de valores flotantes de 4/6/8/16/32/64 bits

Resultados:

Resultado	Descripción
output	Tensor clasificado de valores flotantes de 4/6/8/16/32/64 bits
batch_mean	Tensor 1D de valores flotantes de 4/6/8/16/32/64 bits
batch_var	Tensor 1D de valores flotantes de 4/6/8/16/32/64 bits

mhlo.bitcast (mhlo::BitcastOp)

Operación de bitcast

Sintaxis:

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

Esta operación es privada del compilador XLA, por lo que aún no tiene una especificación.

De manera informal, esta operación cambia la forma de la entrada de manera que la disposición física de los elementos permanece inalterada.

Esta operación necesita información de diseño para dar sentido a la "disposición física de los elementos", y el soporte de diseño en MHLO actualmente es un trabajo en progreso.

Ejemplo:

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

Rasgos: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Efectos: MemoryEffects::Effect{}

Operandos:

Operando	Descripción
operand	Tensor clasificado de tipo float o bool de 4/6/8/16/32/64 bits o tipo entero o complejo de 2/4/8/16/32/64 bits con elementos float de 32/64 bits o valores cuantificados enteros por tensor o por eje

Resultados:

Resultado	Descripción
"sin nombre"	Tensor clasificado de tipo float o bool de 4/6/8/16/32/64 bits o tipo entero o complejo de 2/4/8/16/32/64 bits con elementos float de 32/64 bits o valores cuantificados enteros por tensor o por eje

mhlo.bitcast_convert (mhlo::BitcastConvertOp)

Operación BitcastConvert

Sintaxis:

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

Realiza una operación de conversión de bits en el tensor operand y produce un tensor result donde los bits de todo el tensor operand se reinterpretan utilizando el tipo del tensor result .

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

Ejemplo:

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

Rasgos: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efectos: MemoryEffects::Effect{}

Operandos:

Operando	Descripción
operand	Tensor clasificado de tipo float o bool de 4/6/8/16/32/64 bits o tipo entero o complejo de 2/4/8/16/32/64 bits con elementos float de 32/64 bits o valores cuantificados enteros por tensor o por eje

Resultados:

Resultado	Descripción
"sin nombre"	Tensor clasificado de tipo float o bool de 4/6/8/16/32/64 bits o tipo entero o complejo de 2/4/8/16/32/64 bits con elementos float de 32/64 bits o valores cuantificados enteros por tensor o por eje

mhlo.broadcast (mhlo::BroadcastOp)

Operación de transmisión

Esta operación está saliendo de StableHLO, por lo que no está incluida en la especificación: https://github.com/openxla/stablehlo/issues/3

De manera informal, esta operación hace lo mismo que la transmisión de XLA: https://www.tensorflow.org/xla/operation_semantics#broadcast

Ejemplo:

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

Rasgos: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsAndResultElementType

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

Efectos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descripción
broadcast_sizes	::mlir::AtributoDeElementosDenseInt	Atributo de elementos enteros sin signo de 64 bits

Operandos:

Operando	Descripción
operand	Tensor clasificado de tipo float o bool de 4/6/8/16/32/64 bits o tipo entero o complejo de 2/4/8/16/32/64 bits con elementos float de 32/64 bits o valores cuantificados enteros por tensor o por eje

Resultados:

Resultado	Descripción
"sin nombre"	Tensor clasificado de tipo float o bool de 4/6/8/16/32/64 bits o tipo entero o complejo de 2/4/8/16/32/64 bits con elementos float de 32/64 bits o valores cuantificados enteros por tensor o por eje

mhlo.broadcast_in_dim (mhlo::BroadcastInDimOp)

Operación BroadcastInDim

Expande las dimensiones y/o el rango de un tensor de entrada duplicando los datos en el tensor operand y produce un tensor result .

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

Ejemplo:

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

Rasgos: AlwaysSpeculatableImplTrait , HLO_CompatibleOperandsAndResultElementType

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Efectos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descripción
broadcast_dimensions	::mlir::AtributoDeElementosDenseInt	Atributo de elementos enteros sin signo de 64 bits

Operandos:

Operando	Descripción
operand	Tensor clasificado de tipo float o bool de 4/6/8/16/32/64 bits o tipo entero o complejo de 2/4/8/16/32/64 bits con elementos float de 32/64 bits o valores cuantificados enteros por tensor o por eje

Resultados:

Resultado	Descripción
"sin nombre"	Tensor de dimensión acotada estáticamente o de forma simple de tipo float o bool de 4/6/8/16/32/64 bits o tipo entero o complejo de 2/4/8/16/32/64 bits con elementos float de 32/64 bits o valores cuantificados enteros por tensor o por eje

mhlo.case (mhlo::CaseOp)

Operación de caso

Produce la salida de ejecutar exactamente una function desde branches dependiendo del valor del index .

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

Ejemplo:

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

Rasgos: RecursiveMemoryEffects , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfaces: InferTypeOpInterface

Operandos:

Operando	Descripción
index	tensor de valores enteros sin signo de 32 bits

Resultados:

Resultado	Descripción
"sin nombre"	variádico de tensor clasificado de tipo float o bool de 4/6/8/16/32/64 bits o entero de 2/4/8/16/32/64 bits o tipo complejo con elementos float de 32/64 bits o valores cuantificados enteros por tensor o tensor clasificado de valores cuantificados enteros por eje o token

mhlo.cbrt (mhlo::CbrtOp)

Operación de TRC

Sintaxis:

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

Realiza una operación de raíz cúbica elemento por elemento en el tensor operand y produce un tensor result .

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

Ejemplo:

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

Rasgos: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Efectos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descripción
result_accuracy	::mlir::mhlo::Atributo de precisión del resultado	La precisión solicitada para operaciones unarias.

Operandos:

Operando	Descripción
operand	Tensor clasificado de tipo flotante o complejo de 4/6/8/16/32/64 bits con elementos flotantes de 32/64 bits o valores cuantificados enteros por tensor

Resultados:

Resultado	Descripción
result	Tensor clasificado de tipo flotante o complejo de 4/6/8/16/32/64 bits con elementos flotantes de 32/64 bits o valores cuantificados enteros por tensor

mhlo.ceil (mhlo::CeilOp)

Operación del techo

Sintaxis:

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

Realiza el cálculo del tensor de operand elemento por elemento y produce un tensor result .

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

Ejemplo:

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

Rasgos: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Efectos: MemoryEffects::Effect{}

Operandos:

Operando	Descripción
operand	Tensor clasificado de valores cuantificados enteros por tensor o flotantes de 4/6/8/16/32/64 bits

Resultados:

Resultado	Descripción
result	Tensor clasificado de valores cuantificados enteros por tensor o flotantes de 4/6/8/16/32/64 bits

mhlo.cholesky (mhlo::CholeskyOp)

Operación de Cholesky

Calcula la descomposición de Cholesky de un lote de matrices.

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

Ejemplo:

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

Rasgos: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsAndResultElementType

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

Efectos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descripción
lower	::mlir::Atributo booleano	atributo bool

Operandos:

Operando	Descripción
a	Tensor clasificado de tipo float o complejo de 4/6/8/16/32/64 bits con valores de elementos float de 32/64 bits

Resultados:

Resultado	Descripción
"sin nombre"	Tensor clasificado de tipo float o complejo de 4/6/8/16/32/64 bits con valores de elementos float de 32/64 bits

mhlo.clamp (mhlo::ClampOp)

Operación de abrazadera

Sintaxis:

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

Limita cada elemento del tensor de operand entre un valor mínimo y máximo y produce un tensor result .

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

Ejemplo:

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

Rasgos: AlwaysSpeculatableImplTrait , HLO_BroadcastingElementwise , InferTensorType , SameOperandsAndResultElementType

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

Efectos: MemoryEffects::Effect{}

Operandos:

Operando	Descripción
min	Tensor clasificado de tipo float o bool de 4/6/8/16/32/64 bits o tipo entero o complejo de 2/4/8/16/32/64 bits con elementos float de 32/64 bits o valores cuantificados enteros por tensor o por eje
operand	Tensor clasificado de tipo float o bool de 4/6/8/16/32/64 bits o tipo entero o complejo de 2/4/8/16/32/64 bits con elementos float de 32/64 bits o valores cuantificados enteros por tensor o por eje
max	Tensor clasificado de tipo float o bool de 4/6/8/16/32/64 bits o tipo entero o complejo de 2/4/8/16/32/64 bits con elementos float de 32/64 bits o valores cuantificados enteros por tensor o por eje

Resultados:

Resultado	Descripción
result	Tensor clasificado de tipo float o bool de 4/6/8/16/32/64 bits o tipo entero o complejo de 2/4/8/16/32/64 bits con elementos float de 32/64 bits o valores cuantificados enteros por tensor o por eje

mhlo.collective_broadcast (mhlo::CollectiveBroadcastOp)

Operación de transmisión colectiva

Dentro de cada grupo de procesos en la cuadrícula de procesos, envíe el valor del tensor operand del proceso de origen a los procesos de destino y produzca un tensor result .

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

Ejemplo:

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

Rasgos: CompatibleOperandsAndResultType

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Atributos:

Atributo	Tipo MLIR	Descripción
replica_groups	::mlir::AtributoDeElementosDenseInt	Atributo de elementos enteros sin signo de 64 bits
channel_handle	::mlir::mhlo::Atributo del identificador de canal	dos enteros de 64 bits 'handle' y 'type'

Operandos:

Operando	Descripción
operand	Tensor clasificado de tipo float o bool de 4/6/8/16/32/64 bits o tipo entero o complejo de 2/4/8/16/32/64 bits con elementos float de 32/64 bits o valores cuantificados enteros por tensor o por eje

Resultados:

Resultado	Descripción
"sin nombre"	Tensor clasificado de tipo float o bool de 4/6/8/16/32/64 bits o tipo entero o complejo de 2/4/8/16/32/64 bits con elementos float de 32/64 bits o valores cuantificados enteros por tensor o por eje

mhlo.collective_permute (mhlo::CollectivePermuteOp)

Operación de permutación colectiva

Dentro de cada grupo de procesos en la cuadrícula de procesos, envía el valor del tensor operand del proceso de origen al proceso de destino y produce un tensor result .

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

Ejemplo:

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

Rasgos: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

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

Efectos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descripción
source_target_pairs	::mlir::AtributoDeElementosDenseInt	Atributo de elementos enteros sin signo de 64 bits
channel_handle	::mlir::mhlo::Atributo del identificador de canal	dos enteros de 64 bits 'handle' y 'type'

Operandos:

Operando	Descripción
operand	Tensor clasificado de tipo float o bool de 4/6/8/16/32/64 bits o tipo entero o complejo de 2/4/8/16/32/64 bits con elementos float de 32/64 bits o valores cuantificados enteros por tensor o por eje

Resultados:

Resultado	Descripción
"sin nombre"	Tensor clasificado de tipo float o bool de 4/6/8/16/32/64 bits o tipo entero o complejo de 2/4/8/16/32/64 bits con elementos float de 32/64 bits o valores cuantificados enteros por tensor o por eje

mhlo.compare (mhlo::CompareOp)

Comparar operación

Sintaxis:

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

Realiza una comparación elemento por elemento de los tensores lhs y rhs según comparison_direction y compare_type , y produce un tensor result .

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

Ejemplo:

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

Rasgos: AlwaysSpeculatableImplTrait , Elementwise , InferTensorType , SameOperandsAndResultShape , SameOperandsElementType

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

Efectos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descripción
comparison_direction	::mlir::mhlo::AttrDirecciónDeComparación	¿Qué operación de comparación realizar?
compare_type	::mlir::mhlo::ComparisonTypeAttr	¿Qué tipo de comparación utilizar?

Operandos:

Operando	Descripción
lhs	Tensor clasificado de tipo float o bool de 4/6/8/16/32/64 bits o tipo entero o complejo de 2/4/8/16/32/64 bits con elementos float de 32/64 bits o valores cuantificados enteros por tensor o por eje
rhs	Tensor clasificado de tipo float o bool de 4/6/8/16/32/64 bits o tipo entero o complejo de 2/4/8/16/32/64 bits con elementos float de 32/64 bits o valores cuantificados enteros por tensor o por eje

Resultados:

Resultado	Descripción
"sin nombre"	tensor clasificado de valores booleanos

mhlo.complex (mhlo::ComplexOp)

Operación compleja

Sintaxis:

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

Realiza una conversión elemento por elemento a un valor complejo a partir de un par de valores reales e imaginarios, lhs y rhs , y produce un tensor result .

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

Ejemplo:

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

Rasgos: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape , SameOperandsElementType

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

Efectos: MemoryEffects::Effect{}

Operandos:

Operando	Descripción
lhs	tensor clasificado de valores flotantes de 32/64 bits
rhs	tensor clasificado de valores flotantes de 32/64 bits

Resultados:

Resultado	Descripción
result	Tensor clasificado de tipo complejo con valores de elementos flotantes de 32/64 bits

mhlo.composite (mhlo::CompositeOp)

Operación compuesta

Sintaxis:

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

Encapsula una operación compuesta por otras operaciones StableHLO, tomando inputs y composite_attributes y generando results . La semántica de la operación se implementa mediante el atributo decomposition . La operación composite se puede reemplazar con su descomposición sin cambiar la semántica del programa. Si la descomposición en línea no proporciona la misma semántica de la operación, se recomienda usar custom_call .

El campo version (por defecto 0 ) se utiliza para indicar cuándo cambia la semántica de un compuesto.

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

Ejemplo:

%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	Descripción
name	::mlir::StringAttr	atributo de cadena
composite_attributes	::mlir::DictionaryAttr	diccionario de valores de atributos con nombre
decomposition	::mlir::FlatSymbolRefAttr	atributo de referencia de símbolo plano
version	::mlir::IntegerAttr	Atributo entero sin signo de 32 bits

Operandos:

Operando

Descripción

inputs

variable de tensor clasificado de 4/6/8/16/32/64 bits flotante o bool o entero de 2/4/8/16/32/64 bits o tipo complejo con elementos flotantes de 32/64 bits o valores enteros cuantificados por tensor o enteros por eje cuantificados o token o tupla anidada con cualquier combinación de tensor clasificado de 4/6/8/16/32/64 bits flotante o bool o entero de 2/4/8/16/32/64 bits o tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados enteros por tensor o memref de 4/6/8/16/32/64 bits flotante o bool o entero de 2/4/8/16/32/64 bits o tipo complejo con elementos flotantes de 32/64 bits o por tensor valores cuantificados de números enteros o tensor clasificado de números enteros por eje valores cuantificados o valores simbólicos

Resultados:

Resultado

Descripción

"sin nombre"

variable de tensor clasificado de 4/6/8/16/32/64 bits flotante o bool o entero de 2/4/8/16/32/64 bits o tipo complejo con elementos flotantes de 32/64 bits o valores enteros cuantificados por tensor o enteros por eje cuantificados o token o tupla anidada con cualquier combinación de tensor clasificado de 4/6/8/16/32/64 bits flotante o bool o entero de 2/4/8/16/32/64 bits o tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados enteros por tensor o memref de 4/6/8/16/32/64 bits flotante o bool o entero de 2/4/8/16/32/64 bits o tipo complejo con elementos flotantes de 32/64 bits o por tensor valores cuantificados de números enteros o tensor clasificado de números enteros por eje valores cuantificados o valores simbólicos

mhlo.concatenate (mhlo::ConcatenateOp)

Operación de concatenación

Concatena un número variado de tensores en inputs a lo largo de dimension dimensión en el mismo orden que los argumentos dados y produce un tensor result .

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

Ejemplo:

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

Rasgos: AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType

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

Efectos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descripción
dimension	::mlir::IntegerAttr	Atributo entero sin signo de 64 bits cuyo valor no es negativo

Operandos:

Operando	Descripción
val	variadic de tensor clasificado de 4/6/8/16/32/64 bits flotante o bool o 2/4/8/16/32/64 bits entero o tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados enteros por tensor o enteros por eje

Resultados:

Resultado	Descripción
"sin nombre"	tensor clasificado de tipo flotante o bool de 4/6/8/16/32/64 bits o entero de 2/4/8/16/32/64 bits o de tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados de enteros por tensor o enteros por eje

mhlo.constant (mhlo::ConstantOp)

Operación constante

Produce un tensor output a partir de un value constante.

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

Ejemplo:

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

Rasgos: AlwaysSpeculatableImplTrait , ConstantLike

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efectos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descripción
value	::mlir::ElementosAttr	atributo de vector/tensor constante

Resultados:

Resultado	Descripción
output	tensor de forma estática de tipo flotante o bool de 4/6/8/16/32/64 bits o entero de 2/4/8/16/32/64 bits o de tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados enteros por tensor o enteros por eje

mhlo.convert (mhlo::ConvertOp)

Operación de conversión

Sintaxis:

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

Realiza una conversión de elementos de un tipo de elemento a otro en el tensor operand y produce un tensor result .

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

Ejemplo:

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

Rasgos: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efectos: MemoryEffects::Effect{}

Operandos:

Operando	Descripción
operand	tensor clasificado de tipo flotante o bool de 4/6/8/16/32/64 bits o entero de 2/4/8/16/32/64 bits o de tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados de enteros por tensor o enteros por eje

Resultados:

Resultado	Descripción
result	tensor clasificado de tipo flotante o bool de 4/6/8/16/32/64 bits o entero de 2/4/8/16/32/64 bits o de tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados de enteros por tensor o enteros por eje

mhlo.convolution (mhlo::ConvolutionOp)

Operación de convolución

Sintaxis:

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 productos escalares entre ventanas de lhs y sectores de rhs y produce result .

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

Ejemplo:

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

Rasgos: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Efectos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descripción
window_strides	::mlir::DenseIntElementsAttr	Atributo de elementos enteros sin signo de 64 bits
padding	::mlir::DenseIntElementsAttr	Atributo de elementos enteros sin signo de 64 bits
lhs_dilation	::mlir::DenseIntElementsAttr	Atributo de elementos enteros sin signo de 64 bits
rhs_dilation	::mlir::DenseIntElementsAttr	Atributo de elementos enteros sin signo de 64 bits
window_reversal	::mlir::DenseElementsAttr	atributo de vector/tensor booleano constante
dimension_numbers	::mlir::mhlo::ConvDimensionNumbersAttr	Estructura de información de dimensiones para conv op
feature_group_count	::mlir::IntegerAttr	Atributo entero sin signo de 64 bits cuyo valor es positivo
batch_group_count	::mlir::IntegerAttr	Atributo entero sin signo de 64 bits cuyo valor es positivo
precision_config	::mlir::ArrayAttr	Atributo de configuración de precisión

Operandos:

Operando	Descripción
lhs	tensor clasificado de tipo flotante o bool de 4/6/8/16/32/64 bits o entero de 2/4/8/16/32/64 bits o de tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados de enteros por tensor o enteros por eje
rhs	tensor clasificado de tipo flotante o bool de 4/6/8/16/32/64 bits o entero de 2/4/8/16/32/64 bits o de tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados de enteros por tensor o enteros por eje

Resultados:

Resultado	Descripción
"sin nombre"	tensor clasificado de tipo flotante o bool de 4/6/8/16/32/64 bits o entero de 2/4/8/16/32/64 bits o de tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados de enteros por tensor o enteros por eje

mhlo.copy (mhlo::CopyOp)

Operación de copia

Sintaxis:

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

Esta operación es privada del compilador XLA, por lo que aún no tiene una especificación.

Informalmente, esta operación es una copia del operand . Dependiendo de los metadatos adjuntos a la operación, puede comportarse de manera muy diferente a una operación no operativa.

Ejemplo:

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

Rasgos: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise

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

Efectos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descripción
cross_program_prefetch_index	::mlir::IntegerAttr	Atributo entero sin signo de 32 bits

Operandos:

Operando

Descripción

operand

tensor clasificado de 4/6/8/16/32/64 bits flotante o bool o entero de 2/4/8/16/32/64 bits o tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados enteros por tensor o enteros por eje cuantificados o token o tupla anidada con cualquier combinación de tensor clasificado de 4/6/8/16/32/64 bits flotante o bool o entero de 2/4/8/16/32/64 bits o tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados enteros por tensor o memref de tipo flotante o complejo de 4/6/8/16/32/64 bits o bool o entero de 2/4/8/16/32/64 bits o tipo complejo con elementos flotantes de 32/64 bits o por tensor valores cuantificados enteros o tensor clasificado de valores cuantificados enteros por eje o valores simbólicos

Resultados:

Resultado

Descripción

result

tensor clasificado de 4/6/8/16/32/64 bits flotante o bool o entero de 2/4/8/16/32/64 bits o tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados enteros por tensor o enteros por eje cuantificados o token o tupla anidada con cualquier combinación de tensor clasificado de 4/6/8/16/32/64 bits flotante o bool o entero de 2/4/8/16/32/64 bits o tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados enteros por tensor o memref de tipo flotante o complejo de 4/6/8/16/32/64 bits o bool o entero de 2/4/8/16/32/64 bits o tipo complejo con elementos flotantes de 32/64 bits o por tensor valores cuantificados enteros o tensor clasificado de valores cuantificados enteros por eje o valores simbólicos

mhlo.cosh (mhlo::CoshOp)

operación cosh

Sintaxis:

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

Realiza una operación cosh por elementos en el tensor operand y produce un tensor result .

Ejemplo:

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

Rasgos: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Operandos:

Operando	Descripción
operand	tensor de tipo flotante o complejo de 4/6/8/16/32/64 bits con valores de elementos flotantes de 32/64 bits

Resultados:

Resultado	Descripción
result	tensor de tipo flotante o complejo de 4/6/8/16/32/64 bits con valores de elementos flotantes de 32/64 bits

mhlo.cosine (mhlo::CosenoOp)

operación coseno

Sintaxis:

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

Realiza una operación de coseno por elementos en un tensor operand y produce un tensor result .

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

Ejemplo:

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

Rasgos: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Efectos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descripción
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	La precisión solicitada para operaciones unarias.

Operandos:

Operando	Descripción
operand	tensor clasificado de tipo flotante de 4/6/8/16/32/64 bits o complejo con elementos flotantes de 32/64 bits o valores cuantificados enteros por tensor

Resultados:

Resultado	Descripción
result	tensor clasificado de tipo flotante de 4/6/8/16/32/64 bits o complejo con elementos flotantes de 32/64 bits o valores cuantificados enteros por tensor

mhlo.count_leading_zeros (mhlo::ClzOp)

operación clz

Sintaxis:

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

Realiza un recuento por elementos del número de bits cero a la izquierda en el tensor operand y produce un tensor result .

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

Ejemplo:

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

Rasgos: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Efectos: MemoryEffects::Effect{}

Operandos:

Operando	Descripción
operand	tensor clasificado de valores enteros de 2/4/8/16/32/64 bits

Resultados:

Resultado	Descripción
result	tensor clasificado de valores enteros de 2/4/8/16/32/64 bits

mhlo.create_token (mhlo::CreateTokenOp)

Operación CrearToken

Sintaxis:

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

Esta operación está saliendo de StableHLO, por lo que no está incluida en la especificación: https://github.com/openxla/stablehlo/issues/3

De manera informal, esta operación hace lo mismo que AfterAllOp con 0 entradas: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#after_all

Ejemplo:

%output = mhlo.create_token : !mhlo.token

Rasgos: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efectos: MemoryEffects::Effect{}

Resultados:

Resultado	Descripción
output	simbólico

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

Operación CrossReplicaSum

Esta operación está saliendo de StableHLO, por lo que no está incluida en la especificación: https://github.com/openxla/stablehlo/issues/3

De manera informal, esta operación hace lo mismo que AllReduceOp con channel_id = 0 , use_global_device_ids = false y computation implementa la suma: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#all_reduce

Ejemplo:

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

Rasgos: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

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

Efectos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descripción
replica_groups	::mlir::DenseIntElementsAttr	Atributo de elementos enteros sin signo de 64 bits

Operandos:

Operando	Descripción
operand	tensor clasificado de tipo flotante o bool de 4/6/8/16/32/64 bits o entero de 2/4/8/16/32/64 bits o de tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados de enteros por tensor o enteros por eje

Resultados:

Resultado	Descripción
"sin nombre"	tensor clasificado de tipo flotante o bool de 4/6/8/16/32/64 bits o entero de 2/4/8/16/32/64 bits o de tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados de enteros por tensor o enteros por eje

mhlo.custom_call (mhlo::CustomCallOp)

Operación de llamada personalizada

Sintaxis:

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

Encapsula una operación definida por la implementación call_target_name que toma inputs y called_computations y produce results .

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

Ejemplo:

%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	Descripción
call_target_name	::mlir::StringAttr	atributo de cadena
has_side_effect	::mlir::BoolAttr	atributo booleano
backend_config	::mlir::Atributo	atributo de cadena o diccionario de valores de atributos con nombre
api_version	::mlir::mhlo::CustomCallApiVersionAttr	Versión de API de llamada personalizada
called_computations	::mlir::ArrayAttr	atributo de matriz de referencia de símbolo plano
custom_call_schedule	::mlir::mhlo::CustomCallScheduleAttr	Especifica el horario deseado para la llamada personalizada.
operand_layouts	::mlir::ArrayAttr	Matriz de atributos de diseño (tensor 1D de tipo índice)
result_layouts	::mlir::ArrayAttr	Matriz de atributos de diseño (tensor 1D de tipo índice)
output_operand_aliases	::mlir::ArrayAttr	Atributo de alias para salidas y operandos de CustomCall

Operandos:

Operando

Descripción

inputs

variadic de tensor de 4/6/8/16/32/64 bits flotante o bool o 2/4/8/16/32/64 bits entero o tipo complejo con elementos flotantes de 32/64 bits o valores enteros cuantificados por tensor o enteros por eje cuantificados o memref de 4/6/8/16/32/64 bits flotante o bool o Entero de 2/4/8/16/32/64 bits o tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados enteros por tensor o token o tupla anidada con cualquier combinación de tensor de 4/6/8/16/32/64 bits flotante o bool o 2/4/8/16/32/64 bits entero o tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados enteros por tensor o valores cuantificados enteros por eje o memref de Flotante o bool de 4/6/8/16/32/64 bits o entero de 2/4/8/16/32/64 bits o tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados enteros por tensor o valores simbólicos

Resultados:

Resultado

Descripción

"sin nombre"

variadic de tensor de 4/6/8/16/32/64 bits flotante o bool o 2/4/8/16/32/64 bits entero o tipo complejo con elementos flotantes de 32/64 bits o valores enteros cuantificados por tensor o enteros por eje cuantificados o memref de 4/6/8/16/32/64 bits flotante o bool o Entero de 2/4/8/16/32/64 bits o tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados enteros por tensor o token o tupla anidada con cualquier combinación de tensor de 4/6/8/16/32/64 bits flotante o bool o 2/4/8/16/32/64 bits entero o tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados enteros por tensor o valores cuantificados enteros por eje o memref de Flotante o bool de 4/6/8/16/32/64 bits o entero de 2/4/8/16/32/64 bits o tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados enteros por tensor o valores simbólicos

mhlo.divide (mhlo::DivOp)

operación división

Sintaxis:

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

Realiza la división por elementos de los tensores de dividendo lhs y divisor rhs y produce un tensor result .

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

Ejemplo:

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

Rasgos: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Efectos: MemoryEffects::Effect{}

Operandos:

Operando	Descripción
lhs	tensor clasificado de entero de 2/4/8/16/32/64 bits o flotante de 4/6/8/16/32/64 bits o tipo complejo con elementos flotantes de 32/64 bits o valores enteros cuantificados por tensor o enteros por eje cuantificados
rhs	tensor clasificado de entero de 2/4/8/16/32/64 bits o flotante de 4/6/8/16/32/64 bits o tipo complejo con elementos flotantes de 32/64 bits o valores enteros cuantificados por tensor o enteros por eje cuantificados

Resultados:

Resultado	Descripción
result	tensor clasificado de entero de 2/4/8/16/32/64 bits o flotante de 4/6/8/16/32/64 bits o tipo complejo con elementos flotantes de 32/64 bits o valores enteros cuantificados por tensor o enteros por eje cuantificados

mhlo.domain (mhlo::DomainOp)

Operación de dominio

Esta operación es privada del compilador XLA, por lo que aún no tiene una especificación.

De manera informal, estas operaciones se utilizan para agrupar instrucciones con la misma propiedad DomainMetadata. ShardingMetadata es el principal caso de uso actual para agrupar instrucciones en el mismo dispositivo. Las instrucciones de dominio brindan dos beneficios principales:

• Evite la optimización involuntaria de instrucciones entre dominios.
• Asigna automáticamente los metadatos de las instrucciones creadas en el dominio. Sin instrucciones de dominio, cada paso de optimización de HLO tendría que verificar y propagar los metadatos, lo que sería fácil pasar por alto y también agregaría complejidad al compilador. Dado que las instrucciones de dominio conectan dos dominios diferentes, cada instrucción de dominio está asociada con dos DomainMetadata: uno en el lado del operando y otro en el lado del usuario del dominio.

Rasgos: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

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

Efectos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descripción
kind	::mlir::mhlo::DomainKindAttr	Tipo de metadatos de dominio adjuntos a un dominio HLO.
entry_metadata	::mlir::StringAttr	atributo de cadena
exit_metadata	::mlir::StringAttr	atributo de cadena

Operandos:

Operando	Descripción
operand	tensor clasificado de tipo flotante o bool de 4/6/8/16/32/64 bits o entero de 2/4/8/16/32/64 bits o tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados de enteros por tensor o tensor clasificado de valores cuantificados de enteros por eje o token

Resultados:

Resultado	Descripción
result	tensor clasificado de tipo flotante o bool de 4/6/8/16/32/64 bits o entero de 2/4/8/16/32/64 bits o tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados de enteros por tensor o tensor clasificado de valores cuantificados de enteros por eje o token

mhlo.dot (mhlo::DotOp)

Operación de puntos

Esta operación está saliendo de StableHLO, por lo que no está incluida en la especificación: https://github.com/openxla/stablehlo/issues/3

De manera informal, esta operación hace lo mismo que Dot de XLA: https://www.tensorflow.org/xla/operation_semantics#dot

Ejemplo:

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

Rasgos: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Efectos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descripción
precision_config	::mlir::ArrayAttr	Atributo de configuración de precisión

Operandos:

Operando	Descripción
lhs	tensor clasificado de tipo flotante o bool de 4/6/8/16/32/64 bits o entero de 2/4/8/16/32/64 bits o de tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados de enteros por tensor o enteros por eje
rhs	tensor clasificado de tipo flotante o bool de 4/6/8/16/32/64 bits o entero de 2/4/8/16/32/64 bits o de tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados de enteros por tensor o enteros por eje

Resultados:

Resultado	Descripción
"sin nombre"	tensor clasificado de tipo flotante o bool de 4/6/8/16/32/64 bits o entero de 2/4/8/16/32/64 bits o de tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados de enteros por tensor o enteros por eje

mhlo.dot_general (mhlo::DotGeneralOp)

Operación general de puntos

Calcula productos escalares entre sectores de lhs y sectores de rhs y produce un tensor result .

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

Ejemplo:

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

Rasgos: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efectos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descripción
dot_dimension_numbers	::mlir::mhlo::DotDimensionNumbersAttr	Atributo que modela la información de dimensión del punto.
precision_config	::mlir::ArrayAttr	Atributo de configuración de precisión
algorithm	::mlir::mhlo::DotAlgorithmAttr	Atributo que modela las restricciones del algoritmo que se utilizarán para calcular el punto.

Operandos:

Operando	Descripción
lhs	tensor clasificado de tipo flotante o bool de 4/6/8/16/32/64 bits o entero de 2/4/8/16/32/64 bits o de tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados de enteros por tensor o enteros por eje
rhs	tensor clasificado de tipo flotante o bool de 4/6/8/16/32/64 bits o entero de 2/4/8/16/32/64 bits o de tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados de enteros por tensor o enteros por eje

Resultados:

Resultado	Descripción
"sin nombre"	tensor clasificado de tipo flotante o bool de 4/6/8/16/32/64 bits o entero de 2/4/8/16/32/64 bits o de tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados de enteros por tensor o enteros por eje

mhlo.dynamic_broadcast_in_dim (mhlo::DynamicBroadcastInDimOp)

Operación DynamicBroadcastInDim

Esta operación es funcionalmente idéntica a la operación broadcast_in_dim , pero la forma del resultado se especifica dinámicamente a través de output_dimensions .

También acepta atributos opcionales para expresar conocimiento estático sobre el comportamiento en expansión de las dimensiones. Si no se especifica, se supone que todas las dimensiones posiblemente se estén expandiendo. Los conjuntos de dimensiones que se sabe que se expanden y el conjunto de dimensiones que se sabe que no se expanden deben ser disjuntos y deben ser un subconjunto de las dimensiones del operando.

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

Ejemplo:

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

Rasgos: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efectos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descripción
broadcast_dimensions	::mlir::DenseIntElementsAttr	Atributo de elementos enteros sin signo de 64 bits
known_expanding_dimensions	::mlir::DenseIntElementsAttr	Atributo de elementos enteros sin signo de 64 bits
known_nonexpanding_dimensions	::mlir::DenseIntElementsAttr	Atributo de elementos enteros sin signo de 64 bits

Operandos:

Operando	Descripción
operand	tensor clasificado de tipo flotante o bool de 4/6/8/16/32/64 bits o entero de 2/4/8/16/32/64 bits o de tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados de enteros por tensor o enteros por eje
output_dimensions	Tensor 1D de índice o valores enteros de 2/4/8/16/32/64 bits

Resultados:

Resultado	Descripción
"sin nombre"	tensor clasificado de tipo flotante o bool de 4/6/8/16/32/64 bits o entero de 2/4/8/16/32/64 bits o de tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados de enteros por tensor o enteros por eje

mhlo.dynamic_conv (mhlo::DynamicConvOp)

Operación DynamicConv

Esta operación es un trabajo en progreso, por lo que aún no está incluida en la especificación: https://github.com/openxla/stablehlo/issues/8

De manera informal, esta operación hace lo mismo que ConvolutionOp excepto que padding se especifica dinámicamente mediante d_padding : https://github.com/openxla/stablehlo/blob/main/docs/spec.md#convolution

Ejemplo:

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

Rasgos: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Efectos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descripción
window_strides	::mlir::DenseIntElementsAttr	Atributo de elementos enteros sin signo de 64 bits
padding	::mlir::DenseIntElementsAttr	Atributo de elementos enteros sin signo de 64 bits
lhs_dilation	::mlir::DenseIntElementsAttr	Atributo de elementos enteros sin signo de 64 bits
rhs_dilation	::mlir::DenseIntElementsAttr	Atributo de elementos enteros sin signo de 64 bits
window_reversal	::mlir::DenseElementsAttr	atributo de vector/tensor booleano constante
dimension_numbers	::mlir::mhlo::ConvDimensionNumbersAttr	Estructura de información de dimensiones para conv op
feature_group_count	::mlir::IntegerAttr	Atributo entero sin signo de 64 bits cuyo valor es positivo
batch_group_count	::mlir::IntegerAttr	Atributo entero sin signo de 64 bits cuyo valor es positivo
precision_config	::mlir::ArrayAttr	Atributo de configuración de precisión

Operandos:

Operando	Descripción
lhs	tensor clasificado de tipo flotante o bool de 4/6/8/16/32/64 bits o entero de 2/4/8/16/32/64 bits o de tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados de enteros por tensor o enteros por eje
rhs	tensor clasificado de tipo flotante o bool de 4/6/8/16/32/64 bits o entero de 2/4/8/16/32/64 bits o de tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados de enteros por tensor o enteros por eje
d_padding	tensor clasificado de tipo flotante o bool de 4/6/8/16/32/64 bits o entero de 2/4/8/16/32/64 bits o de tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados de enteros por tensor o enteros por eje

Resultados:

Resultado	Descripción
"sin nombre"	tensor clasificado de tipo flotante o bool de 4/6/8/16/32/64 bits o entero de 2/4/8/16/32/64 bits o de tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados de enteros por tensor o enteros por eje

mhlo.dynamic_gather (mhlo::DynamicGatherOp)

Operación de recopilación dinámica

Esta operación es un trabajo en progreso, por lo que aún no está incluida en la especificación: https://github.com/openxla/stablehlo/issues/8

De manera informal, esta operación hace lo mismo que GatherOp excepto que slice_sizes se especifican dinámicamente: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#gather

Ejemplo:

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

Rasgos: AlwaysSpeculatableImplTrait , InferTensorType

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

Efectos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descripción
dimension_numbers	::mlir::mhlo::GatherDimensionNumbersAttr	Atributo que modela la información de dimensión para recopilar
indices_are_sorted	::mlir::BoolAttr	atributo booleano

Operandos:

Operando	Descripción
operand	tensor clasificado de tipo flotante o bool de 4/6/8/16/32/64 bits o entero de 2/4/8/16/32/64 bits o de tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados de enteros por tensor o enteros por eje
start_indices	tensor clasificado de valores enteros de 2/4/8/16/32/64 bits
slice_sizes	tensor entero unidimensional de forma estática de valores enteros de 2/4/8/16/32/64 bits

Resultados:

Resultado	Descripción
"sin nombre"	tensor clasificado de tipo flotante o bool de 4/6/8/16/32/64 bits o entero de 2/4/8/16/32/64 bits o de tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados de enteros por tensor o enteros por eje

mhlo.dynamic_iota (mhlo::DynamicIotaOp)

Operación dinámica de IoTa

Esta operación es funcionalmente idéntica a iota op, pero la forma del resultado se especifica dinámicamente a través de output_shape .

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

Ejemplo:

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

Rasgos: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efectos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descripción
iota_dimension	::mlir::IntegerAttr	Atributo entero sin signo de 64 bits cuyo valor no es negativo

Operandos:

Operando	Descripción
output_shape	Tensor 1D de índice o valores enteros de 2/4/8/16/32/64 bits

Resultados:

Resultado	Descripción
result	tensor clasificado de tipo flotante o bool de 4/6/8/16/32/64 bits o entero de 2/4/8/16/32/64 bits o de tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados de enteros por tensor o enteros por eje

mhlo.dynamic_pad (mhlo::DynamicPadOp)

Operación del DynamicPad

Sintaxis:

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

Rellena dinámicamente el operand , y la cantidad de relleno agregada en el extremo inferior/alto/interior se pasa a través de tensores de entrada.

Rasgos: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efectos: MemoryEffects::Effect{}

Operandos:

Operando	Descripción
operand	tensor clasificado de tipo flotante o bool de 4/6/8/16/32/64 bits o entero de 2/4/8/16/32/64 bits o de tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados de enteros por tensor o enteros por eje
padding_value	tensor clasificado de tipo flotante o bool de 4/6/8/16/32/64 bits o entero de 2/4/8/16/32/64 bits o de tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados de enteros por tensor o enteros por eje
edge_padding_low	Tensor 1D de índice o valores enteros de 2/4/8/16/32/64 bits
edge_padding_high	Tensor 1D de índice o valores enteros de 2/4/8/16/32/64 bits
interior_padding	Tensor 1D de índice o valores enteros de 2/4/8/16/32/64 bits

Resultados:

Resultado	Descripción
result	tensor clasificado de tipo flotante o bool de 4/6/8/16/32/64 bits o entero de 2/4/8/16/32/64 bits o de tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados de enteros por tensor o enteros por eje

mhlo.dynamic_reshape (mhlo::DynamicReshapeOp)

Operación de remodelación dinámica

Sintaxis:

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

Esta operación es funcionalmente idéntica a la operación de remodelación , pero la forma del resultado se especifica dinámicamente a través de output_shape .

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

Ejemplo:

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

Rasgos: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efectos: MemoryEffects::Effect{}

Operandos:

Operando	Descripción
operand	tensor de tipo flotante o bool de 4/6/8/16/32/64 bits o entero de 2/4/8/16/32/64 bits o tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados enteros por tensor o enteros por eje
output_shape	Tensor 1D de índice o valores enteros de 2/4/8/16/32/64 bits

Resultados:

Resultado	Descripción
result	tensor de tipo flotante o bool de 4/6/8/16/32/64 bits o entero de 2/4/8/16/32/64 bits o tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados enteros por tensor o enteros por eje

mhlo.dynamic_slice (mhlo::DynamicSliceOp)

Operación DynamicSlice

Extrae un segmento del operand utilizando índices iniciales calculados dinámicamente y produce un tensor result .

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

Ejemplo:

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

Rasgos: AlwaysSpeculatableImplTrait , InferTensorType

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

Efectos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descripción
slice_sizes	::mlir::DenseIntElementsAttr	Atributo de elementos enteros sin signo de 64 bits

Operandos:

Operando	Descripción
operand	tensor clasificado de tipo flotante o bool de 4/6/8/16/32/64 bits o entero de 2/4/8/16/32/64 bits o de tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados de enteros por tensor o enteros por eje
start_indices	variadic del tensor 0D de valores enteros de 2/4/8/16/32/64 bits

Resultados:

Resultado	Descripción
result	tensor clasificado de tipo flotante o bool de 4/6/8/16/32/64 bits o entero de 2/4/8/16/32/64 bits o de tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados de enteros por tensor o enteros por eje

mhlo.dynamic_update_slice (mhlo::DynamicUpdateSliceOp)

Operación DynamicUpdateSlice

Sintaxis:

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

Produce un tensor result que es igual al tensor operand excepto que el segmento que comienza en start_indices se actualiza con los valores en update .

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

Ejemplo:

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

Rasgos: AlwaysSpeculatableImplTrait , InferTensorType

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

Efectos: MemoryEffects::Effect{}

Operandos:

Operando	Descripción
operand	tensor clasificado de tipo flotante o bool de 4/6/8/16/32/64 bits o entero de 2/4/8/16/32/64 bits o de tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados de enteros por tensor o enteros por eje
update	tensor clasificado de tipo flotante o bool de 4/6/8/16/32/64 bits o entero de 2/4/8/16/32/64 bits o de tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados de enteros por tensor o enteros por eje
start_indices	variadic del tensor 0D de valores enteros de 2/4/8/16/32/64 bits

Resultados:

Resultado	Descripción
result	tensor clasificado de tipo flotante o bool de 4/6/8/16/32/64 bits o entero de 2/4/8/16/32/64 bits o de tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados de enteros por tensor o enteros por eje

mhlo.einsum (mhlo::EinsumOp)

Operación suma

Esta operación está saliendo de StableHLO, por lo que no está incluida en la especificación: https://github.com/openxla/stablehlo/issues/3

De manera informal, esta operación hace lo mismo que el einsum de TF: https://www.tensorflow.org/api_docs/python/tf/einsum

Ejemplo:

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

Rasgos: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Efectos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descripción
einsum_config	::mlir::StringAttr	atributo de cadena

Operandos:

Operando	Descripción
lhs	tensor clasificado de tipo flotante o bool de 4/6/8/16/32/64 bits o entero de 2/4/8/16/32/64 bits o de tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados de enteros por tensor o enteros por eje
rhs	tensor clasificado de tipo flotante o bool de 4/6/8/16/32/64 bits o entero de 2/4/8/16/32/64 bits o de tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados de enteros por tensor o enteros por eje

Resultados:

Resultado	Descripción
"sin nombre"	tensor clasificado de tipo flotante o bool de 4/6/8/16/32/64 bits o entero de 2/4/8/16/32/64 bits o de tipo complejo con elementos flotantes de 32/64 bits o valores cuantificados de enteros por tensor o enteros por eje

mhlo.erf (mhlo::ErfOp)

operación erfe

Sintaxis:

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

Realiza una operación erf por elementos en el tensor operand y produce un tensor result .

Ejemplo:

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

Rasgos: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Efectos: MemoryEffects::Effect{}

Operandos:

Operando	Descripción
operand	tensor clasificado de valores flotantes de 4/6/8/16/32/64 bits

Resultados:

Resultado	Descripción
result	tensor clasificado de valores flotantes de 4/6/8/16/32/64 bits

mhlo.exponential (mhlo::ExpOp)

operación exp

Sintaxis:

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

Realiza una operación exponencial de elementos en el tensor operand y produce un tensor result .

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

Ejemplo:

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

Rasgos: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Efectos: MemoryEffects::Effect{}

Atributos:

Atributo	Tipo MLIR	Descripción
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	La precisión solicitada para operaciones unarias.

Operandos:

Operando	Descripción
operand	tensor clasificado de tipo flotante de 4/6/8/16/32/64 bits o complejo con elementos flotantes de 32/64 bits o valores cuantificados enteros por tensor

Resultados:

Resultado	Descripción
result	tensor clasificado de tipo flotante de 4/6/8/16/32/64 bits o complejo con elementos flotantes de 32/64 bits o valores cuantificados enteros por tensor

mhlo.exponential_minus_one (mhlo::Expm1Op)

operación expm1

Sintaxis:

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

Realiza una operación exponencial menos uno por elementos en el tensor operand y produce un tensor result .

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

Ejemplo:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Atributos:

Atributo	MLIR Type	Descripción
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Operando	Descripción
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	Descripción
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

Ejemplo:

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

Atributos:

Atributo	MLIR Type	Descripción
fft_type	::mlir::mhlo::FftTypeAttr	XLA fast fourier transform type.
fft_length	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Operando	Descripción
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	Descripción
"sin nombre"	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

Sintaxis:

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

Ejemplo:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operando	Descripción
operand	ranked tensor of 4/6/8/16/32/64-bit float or per-tensor integer quantized values

Resultados:

Resultado	Descripción
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.

Atributos:

Atributo	MLIR Type	Descripción
fusion_kind	::mlir::mhlo::FusionKindAttr	fusion kind
output_operand_aliases	::mlir::ArrayAttr	Aliasing attribute for outputs and operands of Fusion

Operands:

Operando	Descripción
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

Descripción

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

Ejemplo:

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

Atributos:

Atributo	MLIR Type	Descripción
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	Descripción
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	Descripción
"sin nombre"	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

Ejemplo:

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

Traits: AlwaysSpeculatableImplTrait , InferTensorType

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

Effects: MemoryEffects::Effect{}

Atributos:

Atributo	MLIR Type	Descripción
dimension	::mlir::IntegerAttr	64-bit signless integer attribute whose value is non-negative

Operands:

Operando	Descripción
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	Descripción
"sin nombre"	tensor of 32-bit signless integer values

mhlo.get_tuple_element (mhlo::GetTupleElementOp)

GetTupleElement operation

Sintaxis:

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

Ejemplo:

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

Atributos:

Atributo	MLIR Type	Descripción
index	::mlir::IntegerAttr	32-bit signless integer attribute whose value is non-negative

Operands:

Operando

Descripción

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

Descripción

"sin nombre"

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	Descripción
pred	ranked tensor of bool values

Resultados:

Resultado	Descripción
"sin nombre"	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

Sintaxis:

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

Ejemplo:

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

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operando	Descripción
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

Resultados:

Resultado	Descripción
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

Ejemplo:

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

Atributos:

Atributo	MLIR Type	Descripción
infeed_config	::mlir::StringAttr	string attribute
layout	::mlir::ArrayAttr	array attribute

Operands:

Operando	Descripción
token	simbólico

Resultados:

Resultado

Descripción

"sin nombre"

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

Ejemplo:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Atributos:

Atributo	MLIR Type	Descripción
iota_dimension	::mlir::IntegerAttr	64-bit signless integer attribute whose value is non-negative

Resultados:

Resultado	Descripción
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

Sintaxis:

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

Ejemplo:

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

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operando	Descripción
x	ranked tensor of 4/6/8/16/32/64-bit float values

Resultados:

Resultado	Descripción
y	ranked tensor of bool values

mhlo.log (mhlo::LogOp)

Log operation

Sintaxis:

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

Ejemplo:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Atributos:

Atributo	MLIR Type	Descripción
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Operando	Descripción
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	Descripción
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

Sintaxis:

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

Ejemplo:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Atributos:

Atributo	MLIR Type	Descripción
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Operando	Descripción
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	Descripción
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

Sintaxis:

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

Ejemplo:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Atributos:

Atributo	MLIR Type	Descripción
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Operando	Descripción
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	Descripción
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

Ejemplo:

%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

Atributos:

Atributo	MLIR Type	Descripción
dimensions	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Operando	Descripción
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	Descripción
"sin nombre"	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

Sintaxis:

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

Ejemplo:

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

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operando	Descripción
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	Descripción
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

Sintaxis:

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

Ejemplo:

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

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operando	Descripción
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	Descripción
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

Sintaxis:

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	Descripción
shapes	variadic of 1D tensor of index values

Resultados:

Resultado	Descripción
results	variadic of 1D tensor of index values

mhlo.multiply (mhlo::MulOp)

Mul operation

Sintaxis:

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

Ejemplo:

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

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operando	Descripción
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	Descripción
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

Sintaxis:

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

Ejemplo:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operando	Descripción
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	Descripción
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

Sintaxis:

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

Ejemplo:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operando	Descripción
operand	ranked tensor of bool or 2/4/8/16/32/64-bit integer values

Resultados:

Resultado	Descripción
result	ranked tensor of bool or 2/4/8/16/32/64-bit integer values

mhlo.optimization_barrier (mhlo::OptimizationBarrierOp)

OptimizationBarrier operation

Sintaxis:

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

Ejemplo:

%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	Descripción
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	Descripción
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

Sintaxis:

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

Ejemplo:

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

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operando	Descripción
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	Descripción
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

Ejemplo:

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

Interfaces: InferTypeOpInterface

Atributos:

Atributo	MLIR Type	Descripción
outfeed_config	::mlir::StringAttr	string attribute

Operands:

Operando	Descripción
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	simbólico

Resultados:

Resultado	Descripción
"sin nombre"	simbólico

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

Ejemplo:

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

Atributos:

Atributo	MLIR Type	Descripción
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	Descripción
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	Descripción
"sin nombre"	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

Sintaxis:

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

Ejemplo:

%result = mhlo.partition_id : tensor<ui32>

Interfaces: InferTypeOpInterface

Resultados:

Resultado	Descripción
"sin nombre"	ranked tensor of 32-bit unsigned integer values

mhlo.popcnt (mhlo::PopulationCountOp)

PopulationCount operation

Sintaxis:

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

Ejemplo:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operando	Descripción
operand	ranked tensor of 2/4/8/16/32/64-bit integer values

Resultados:

Resultado	Descripción
result	ranked tensor of 2/4/8/16/32/64-bit integer values

mhlo.power (mhlo::PowOp)

Pow operation

Sintaxis:

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

Ejemplo:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operando	Descripción
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	Descripción
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{}

Atributos:

Atributo	MLIR Type	Descripción
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	Descripción
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	Descripción
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

Sintaxis:

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

Ejemplo:

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

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operando	Descripción
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

Resultados:

Resultado	Descripción
result	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.real_dynamic_slice (mhlo::RealDynamicSliceOp)

RealDynamicSlice operation

Sintaxis:

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

Ejemplo:

%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	Descripción
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	Descripción
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

Ejemplo:

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

Atributos:

Atributo	MLIR Type	Descripción
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	Descripción
token	simbólico

Resultados:

Resultado

Descripción

"sin nombre"

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

Ejemplo:

%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

Atributos:

Atributo	MLIR Type	Descripción
dimensions	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Operando	Descripción
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	Descripción
"sin nombre"	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

Sintaxis:

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

Ejemplo:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise

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

Effects: MemoryEffects::Effect{}

Atributos:

Atributo	MLIR Type	Descripción
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	Descripción
operand	ranked tensor of 4/6/8/16/32/64-bit float values

Resultados:

Resultado	Descripción
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

Ejemplo:

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

Atributos:

Atributo	MLIR Type	Descripción
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	Descripción
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	Descripción
"sin nombre"	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

Ejemplo:

%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

Atributos:

Atributo	MLIR Type	Descripción
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	Descripción
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	Descripción
"sin nombre"	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

Sintaxis:

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

Ejemplo:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operando	Descripción
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	Descripción
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

Sintaxis:

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

Ejemplo:

%result = mhlo.replica_id : tensor<ui32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Resultados:

Resultado	Descripción
"sin nombre"	ranked tensor of 32-bit unsigned integer values

mhlo.reshape (mhlo::ReshapeOp)

Reshape operation

Sintaxis:

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

Ejemplo:

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

Traits: AlwaysSpeculatableImplTrait , HLO_CompatibleOperandsAndResultElementType

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operando	Descripción
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	Descripción
"sin nombre"	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{}

Atributos:

Atributo	MLIR Type	Descripción
dimensions	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Operando	Descripción
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	Descripción
"sin nombre"	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

Ejemplo:

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

Traits: InferTensorType

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Atributos:

Atributo	MLIR Type	Descripción
rng_distribution	::mlir::mhlo::RngDistributionAttr	XLA PRNG distribution to be used.

Operands:

Operando	Descripción
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	Descripción
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

Ejemplo:

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

Atributos:

Atributo	MLIR Type	Descripción
rng_algorithm	::mlir::mhlo::RngAlgorithmAttr	XLA PRNG algorithm to be used.

Operands:

Operando	Descripción
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	Descripción
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

Sintaxis:

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

Ejemplo:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operando	Descripción
operand	ranked tensor of 4/6/8/16/32/64-bit float values

Resultados:

Resultado	Descripción
result	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.round_nearest_even (mhlo::RoundNearestEvenOp)

RoundNearestEven operation

Sintaxis:

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

Ejemplo:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operando	Descripción
operand	ranked tensor of 4/6/8/16/32/64-bit float values

Resultados:

Resultado	Descripción
result	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.rsqrt (mhlo::RsqrtOp)

Rsqrt operation

Sintaxis:

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

Ejemplo:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Atributos:

Atributo	MLIR Type	Descripción
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Operando	Descripción
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	Descripción
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

Ejemplo:

%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

Atributos:

Atributo	MLIR Type	Descripción
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	Descripción
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	Descripción
"sin nombre"	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

Sintaxis:

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

Ejemplo:

%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	Descripción
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	Descripción
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

Ejemplo:

%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

Atributos:

Atributo	MLIR Type	Descripción
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	Descripción
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	Descripción
"sin nombre"	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

Ejemplo:

%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

Atributos:

Atributo	MLIR Type	Descripción
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	Descripción
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	simbólico

Resultados:

Resultado	Descripción
"sin nombre"	simbólico

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

Ejemplo:

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

Atributos:

Atributo	MLIR Type	Descripción
dimension	::mlir::IntegerAttr	64-bit signless integer attribute whose value is non-negative

Operands:

Operando	Descripción
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	Descripción
"sin nombre"	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

Sintaxis:

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

Ejemplo:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operando	Descripción
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	Descripción
result	ranked tensor of 2/4/8/16/32/64-bit integer values

mhlo.shift_right_arithmetic (mhlo::ShiftRightArithmeticOp)

ShiftRightArithmetic operation

Sintaxis:

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

Ejemplo:

%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	Descripción
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	Descripción
result	ranked tensor of 2/4/8/16/32/64-bit integer values

mhlo.shift_right_logical (mhlo::ShiftRightLogicalOp)

ShiftRightLogical operation

Sintaxis:

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

Ejemplo:

%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	Descripción
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	Descripción
result	ranked tensor of 2/4/8/16/32/64-bit integer values

mhlo.sign (mhlo::SignOp)

Sign operation

Sintaxis:

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

Ejemplo:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operando	Descripción
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	Descripción
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

Sintaxis:

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

Ejemplo:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Atributos:

Atributo	MLIR Type	Descripción
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Operando	Descripción
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	Descripción
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

Sintaxis:

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.

Ejemplo:

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

Traits: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Operands:

Operando	Descripción
operand	tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

Resultados:

Resultado	Descripción
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

Ejemplo:

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

Atributos:

Atributo	MLIR Type	Descripción
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	Descripción
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	Descripción
"sin nombre"	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

Ejemplo:

%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

Atributos:

Atributo	MLIR Type	Descripción
dimension	::mlir::IntegerAttr	64-bit signless integer attribute
is_stable	::mlir::BoolAttr	bool attribute

Operands:

Operando	Descripción
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	Descripción
"sin nombre"	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

Sintaxis:

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

Ejemplo:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Atributos:

Atributo	MLIR Type	Descripción
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Operando	Descripción
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	Descripción
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	Descripción
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	Descripción
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

Sintaxis:

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

Ejemplo:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operando	Descripción
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	Descripción
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

Sintaxis:

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.

Ejemplo:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Atributos:

Atributo	MLIR Type	Descripción
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Operando	Descripción
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	Descripción
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

Sintaxis:

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

Ejemplo:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Atributos:

Atributo	MLIR Type	Descripción
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Operando	Descripción
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	Descripción
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

Sintaxis:

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

Ejemplo:

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

Traits: InferTensorType , RecursiveMemoryEffects

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Atributos:

Atributo	MLIR Type	Descripción
k	::mlir::IntegerAttr	64-bit signless integer attribute
largest	::mlir::BoolAttr	bool attribute

Operands:

Operando	Descripción
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	Descripción
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.

Ejemplo:

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

Atributos:

Atributo	MLIR Type	Descripción
dim	::mlir::IntegerAttr	64-bit signless integer attribute
batch_dims	::mlir::IntegerAttr	64-bit signless integer attribute

Operands:

Operando	Descripción
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	Descripción
"sin nombre"	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

Sintaxis:

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.

Ejemplo:

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

Atributos:

Atributo	MLIR Type	Descripción
tag	::mlir::StringAttr	string attribute

Operands:

Operando	Descripción
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

Ejemplo:

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

Atributos:

Atributo	MLIR Type	Descripción
permutation	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Operando	Descripción
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	Descripción
"sin nombre"	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

Ejemplo:

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

Atributos:

Atributo	MLIR Type	Descripción
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	Descripción
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	Descripción
"sin nombre"	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

Sintaxis:

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

Ejemplo:

%result = mhlo.tuple %val0, %val1 : tuple<tensor<2xf32>, tuple<tensor<i32>>>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operando

Descripción

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

Descripción

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

Sintaxis:

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

Ejemplo:

%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	Descripción
operand	ranked tensor of per-tensor integer quantized or per-axis integer quantized values

Resultados:

Resultado	Descripción
result	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.uniform_quantize (mhlo::UniformQuantizeOp)

UniformQuantize operation

Sintaxis:

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

Ejemplo:

%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	Descripción
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	Descripción
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

Ejemplo:

%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

Descripción

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

Descripción

"sin nombre"

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

Sintaxis:

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

Atributos:

Atributo	MLIR Type	Descripción
delta	::mlir::IntegerAttr	64-bit signless integer attribute

Resultados:

Resultado	Descripción
"sin nombre"	statically shaped tensor of 64-bit unsigned integer values

mhlo.xor (mhlo::XorOp)

Xor operation

Sintaxis:

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

Ejemplo:

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

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operando	Descripción
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	Descripción
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	Descripción
argTupleIndices	::llvm::ArrayRef<int64_t>	Dimensión
resultIndex	int64_t
resultTupleIndices	::llvm::ArrayRef<int64_t>	Dimensión
isMustAlias	bool

ChannelHandleAttr

Two 64-bit integers 'handle' and 'type'

Sintaxis:

#mhlo.channel_handle<
  int64_t,   # handle
  int64_t   # type
>

Parámetros:

Parámetro	C++ type	Descripción
manejar	int64_t
tipo	int64_t

ComparisonDirectionAttr

Which comparison operation to perform.

Sintaxis:

#mhlo.comparison_direction<
  ::mlir::mhlo::ComparisonDirection   # value
>

Parámetros:

Parámetro	C++ type	Descripción
valor	::mlir::mhlo::ComparisonDirection	an enum of type ComparisonDirection

ComparisonTypeAttr

Which comparison type to use.

Sintaxis:

#mhlo.comparison_type<
  ::mlir::mhlo::ComparisonType   # value
>

Parámetros:

Parámetro	C++ type	Descripción
valor	::mlir::mhlo::ComparisonType	an enum of type ComparisonType

ConvDimensionNumbersAttr

Structure of dimension information for conv op

Parámetros:

Parámetro	C++ type	Descripción
inputBatchDimension	int64_t
inputFeatureDimension	int64_t
inputSpatialDimensions	::llvm::ArrayRef<int64_t>	Dimensión
kernelInputFeatureDimension	int64_t
kernelOutputFeatureDimension	int64_t
kernelSpatialDimensions	::llvm::ArrayRef<int64_t>	Dimensión
outputBatchDimension	int64_t
outputFeatureDimension	int64_t
outputSpatialDimensions	::llvm::ArrayRef<int64_t>	Dimensión

CrossProgramPrefetchAttr

Argument that is prefetched from another program

Sintaxis:

#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 ejemplo,

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	Descripción
parámetro	int64_t
índices	::llvm::ArrayRef<int64_t>	Dimensión
compensar	std::optional<int64_t>

CustomCallScheduleAttr

Specifies the desired schedule for the custom-call.

Sintaxis:

#mhlo.custom_call_schedule<
  ::mlir::mhlo::CustomCallSchedule   # value
>

Parámetros:

Parámetro	C++ type	Descripción
valor	::mlir::mhlo::CustomCallSchedule	an enum of type CustomCallSchedule

DequantizeModeAttr

_Dequantization mode. Only MIN COMBINED is supported.

Sintaxis:

#mhlo.dequantize_mode<
  ::mlir::mhlo::DequantizeMode   # value
>

Parámetros:

Parámetro	C++ type	Descripción
valor	::mlir::mhlo::DequantizeMode	an enum of type DequantizeMode

DomainKindAttr

Kind of domain metatdata attached to an HLO domain.

Sintaxis:

#mhlo.kind<
  ::mlir::mhlo::DomainKind   # value
>

Parámetros:

Parámetro	C++ type	Descripción
valor	::mlir::mhlo::DomainKind	an enum of type DomainKind

DotAlgorithmAttr

Attribute that models the algorithm constraints to use for computing dot.

Sintaxis:

#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	Descripción
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	Descripción
lhsBatchingDimensions	::llvm::ArrayRef<int64_t>	Dimensión
rhsBatchingDimensions	::llvm::ArrayRef<int64_t>	Dimensión
lhsContractingDimensions	::llvm::ArrayRef<int64_t>	Dimensión
rhsContractingDimensions	::llvm::ArrayRef<int64_t>	Dimensión

FftTypeAttr

XLA fast fourier transform type.

Sintaxis:

#mhlo.fft_type<
  ::mlir::mhlo::FftType   # value
>

Parámetros:

Parámetro	C++ type	Descripción
valor	::mlir::mhlo::FftType	an enum of type FftType

FusionKindAttr

Fusion kind

Sintaxis:

#mhlo.fusion_kind<
  ::mlir::mhlo::FusionKind   # value
>

Parámetros:

Parámetro	C++ type	Descripción
valor	::mlir::mhlo::FusionKind	an enum of type FusionKind

GatherDimensionNumbersAttr

Attribute that models the dimension information for gather

Parámetros:

Parámetro	C++ type	Descripción
offsetDims	::llvm::ArrayRef<int64_t>	Dimensión
collapsedSliceDims	::llvm::ArrayRef<int64_t>	Dimensión
operandBatchingDims	::llvm::ArrayRef<int64_t>	Dimensión
startIndicesBatchingDims	::llvm::ArrayRef<int64_t>	Dimensión
startIndexMap	::llvm::ArrayRef<int64_t>	Dimensión
indexVectorDim	int64_t

OutputOperandAliasAttr

Attribute that models the alias relationship of output and operand of a CustomCall op

Sintaxis:

#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	Descripción
outputTupleIndices	::llvm::ArrayRef<int64_t>	Dimensión
operandIndex	int64_t
operandTupleIndices	::llvm::ArrayRef<int64_t>	Dimensión

PrecisionAttr

XLA precision for an operand. Has backend specific meaning.

Sintaxis:

#mhlo.precision<
  ::mlir::mhlo::Precision   # value
>

Parámetros:

Parámetro	C++ type	Descripción
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	Descripción
dotDimensionNumbers	::mlir::mhlo::DotDimensionNumbersAttr	Attribute that models the dimension information for dot.
lhsRaggedDimensions	::llvm::ArrayRef<int64_t>	Dimensión
rhsGroupDimensions	::llvm::ArrayRef<int64_t>	Dimensión

ResultAccuracyAttr

The requested accuracy for unary ops.

Parámetros:

Parámetro	C++ type	Descripción
atol	APFloat
rtol	APFloat
ulps	int64_t
modo	::mlir::mhlo::ResultAccuracyModeAttr	XLA result accuracy mode.

ResultAccuracyModeAttr

XLA result accuracy mode.

Sintaxis:

#mhlo.result_accuracy_mode<
  ::mlir::mhlo::ResultAccuracyMode   # value
>

Parámetros:

Parámetro	C++ type	Descripción
valor	::mlir::mhlo::ResultAccuracyMode	an enum of type ResultAccuracyMode

RngAlgorithmAttr

XLA PRNG algorithm to be used.

Sintaxis:

#mhlo.rng_algorithm<
  ::mlir::mhlo::RngAlgorithm   # value
>

Parámetros:

Parámetro	C++ type	Descripción
valor	::mlir::mhlo::RngAlgorithm	an enum of type RngAlgorithm

RngDistributionAttr

XLA PRNG distribution to be used.

Sintaxis:

#mhlo.rng_distribution<
  ::mlir::mhlo::RngDistribution   # value
>

Parámetros:

Parámetro	C++ type	Descripción
valor	::mlir::mhlo::RngDistribution	an enum of type RngDistribution

ScatterDimensionNumbersAttr

Attribute that models the dimension information for scatter

Parámetros:

Parámetro	C++ type	Descripción
updateWindowDims	::llvm::ArrayRef<int64_t>	Dimensión
insertedWindowDims	::llvm::ArrayRef<int64_t>	Dimensión
inputBatchingDims	::llvm::ArrayRef<int64_t>	Dimensión
scatterIndicesBatchingDims	::llvm::ArrayRef<int64_t>	Dimensión
scatterDimsToOperandDims	::llvm::ArrayRef<int64_t>	Dimensión
indexVectorDim	int64_t

TransposeAttr

Transpose options

Sintaxis:

#mhlo.transpose<
  ::mlir::mhlo::Transpose   # value
>

Parámetros:

Parámetro	C++ type	Descripción
valor	::mlir::mhlo::Transpose	an enum of type Transpose

TypeExtensionsAttr

Attribute that extends tensor type with MHLO type properties.

Sintaxis:

#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	Descripción
límites	::llvm::ArrayRef<int64_t>

Tipos

AsyncBundleType

Opaque collection of other types

Sintaxis:

!mhlo.async_bundle<
  ::llvm::ArrayRef<Type>   # types
>

Parámetros:

Parámetro	C++ type	Descripción
tipos	::llvm::ArrayRef<Type>

Enumeraciones

ComparisonDirection

Which comparison operation to perform.

Casos:

Símbolo	Valor	Cadena
Ecualizador	0	Ecualizador
nordeste	1	nordeste
GE	2	GE
GT	3	GT
LE	4	LE
LT	5	LT

ComparisonType

Which comparison type to use.

Casos:

Símbolo	Valor	Cadena
NOTYPE	0	NOTYPE
FLOTAR	1	FLOTAR
TOTALORDER	2	TOTALORDER
FIRMADO	3	FIRMADO
NO FIRMADO	4	NO FIRMADO

CustomCallApiVersion

Custom call API version

Casos:

Símbolo	Valor	Cadena
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	Cadena
NINGUNO	0	NINGUNO
EL ÚLTIMO	1	EL ÚLTIMO
MÁS TEMPRANO	2	MÁS TEMPRANO

DequantizeMode

_Dequantization mode. Only MIN COMBINED is supported.

Casos:

Símbolo	Valor	Cadena
MIN_COMBINED	0	MIN_COMBINED

DomainKind

Kind of domain metatdata attached to an HLO domain.

Casos:

Símbolo	Valor	Cadena
fragmentación	0	fragmentación

FftType

XLA fast fourier transform type.

Casos:

Símbolo	Valor	Cadena
FFT	0	FFT
IFFT	1	IFFT
RFFT	2	RFFT
IRFFT	3	IRFFT

FusionKind

Fusion kind

Casos:

Símbolo	Valor	Cadena
kLoop	0	kLoop
kInput	1	kInput
kOutput	2	kOutput
kCustom	3	kCustom

Precisión

XLA precision for an operand. Has backend specific meaning.

Casos:

Símbolo	Valor	Cadena
POR DEFECTO	0	POR DEFECTO
ALTO	1	ALTO
MÁS ALTO	2	MÁS ALTO

ResultAccuracyMode

XLA result accuracy mode.

Casos:

Símbolo	Valor	Cadena
POR DEFECTO	0	POR DEFECTO
MÁS ALTO	1	MÁS ALTO
TOLERANCIA	2	TOLERANCIA

RngAlgorithm

XLA PRNG algorithm to be used.

Casos:

Símbolo	Valor	Cadena
POR DEFECTO	0	POR DEFECTO
THREE_FRY	1	THREE_FRY
PHILOX	2	PHILOX

RngDistribution

XLA PRNG distribution to be used.

Casos:

Símbolo	Valor	Cadena
UNIFORME	1	UNIFORME
NORMAL	2	NORMAL

Transponer

Transpose options

Casos:

Símbolo	Valor	Cadena
TRANSPOSE_INVALID	0	TRANSPOSE_INVALID
NO_TRANSPOSE	1	NO_TRANSPOSE
TRANSPONER	2	TRANSPONER
ADJOINT	3	ADJOINT