Dialeto 'chlo'

Operações de HLO do cliente

Esse dialeto contém operações que se alinham muito com a área de superfície da API XlaBuilder C++, em que essas operações têm semântica que vai além do que existe nos dialetos de nível mais baixo (como stablehlo). Essencialmente, sempre que a biblioteca de cliente usa açúcar sintático ou composição de várias operações para uma chamada de API, esse dialeto tenta modelar a chamada de API e fornecer padrões de conversão para se materializar totalmente em dialetos de nível mais baixo.

Operações

chlo._asin_acos_kernel (chlo::AsinAcosKernelOp)

Operador AsinAcosKernel

Sintaxe:

operation ::= `chlo._asin_acos_kernel` $operand attr-dict `:` type($operand) `->` type($result)

Retorna AsinAcosKernel(operand) elemento a elemento.

If
  w = _asin_acos_kernel(z)
  w' = _asin_acos_kernel(I * z)
Then
  asin(z) = complex(atan2(z.real, w.real), sign(z.imag) * w.imag)
  acos(z) = complex(atan2(w.real, z.real), -sign(z.imag) * w.imag)
  asinh(z) = complex(sign(z.real) * w'.imag, atan2(z.imag, w'.real))
  acosh(z) = complex(w.imag, sign(z.imag) * atan2(w.real, z.real))

Essa operação é usada como um valor intermediário em decomposições e nunca deve ser construída diretamente por frameworks ou consumida por back-ends.

Traços: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Efeitos: MemoryEffects::Effect{}

Operandos:

Resultados:

chlo.acos (chlo::AcosOp)

Operador ACOS

Sintaxe:

operation ::= `chlo.acos` $operand attr-dict `:` type($operand) `->` type($result)

Retorna Acos(operand) elemento a elemento.

\[ \acos(x) = 2 * \atan(\sqrt(1 - x^2) / (1 + x)) if x != -1 = pi if x == -1 \]

Traços: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Efeitos: MemoryEffects::Effect{}

Operandos:

Resultados:

chlo.acosh (chlo::AcoshOp)

Operação Acosh

Sintaxe:

operation ::= `chlo.acosh` $operand attr-dict `:` type($operand) `->` type($result)

Retorna Acosh(operand) elemento a elemento.

\[ \acosh(x) = log(x + sqrt(x^2 - 1)) if x >= -1 \acosh(x) = nan if x < -1 \]

Traços: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Efeitos: MemoryEffects::Effect{}

Operandos:

Resultados:

chlo.asin (chlo::AsinOp)

Operador de ASIN

Sintaxe:

operation ::= `chlo.asin` $operand attr-dict `:` type($operand) `->` type($result)

Retorna Asin(operand) elemento a elemento.

\[ \asin(x) = 2 * atan(x / (1 + sqrt(1 - x^2))) \]

Traços: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Efeitos: MemoryEffects::Effect{}

Operandos:

Resultados:

chlo.asinh (chlo::AsinhOp)

Operação de asinh

Sintaxe:

operation ::= `chlo.asinh` $operand attr-dict `:` type($operand) `->` type($result)

Retorna Asinh(operand) elemento a elemento.

\[ \asinh(x) = log(x + sqrt(x^2 + 1)) \]

Traços: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Efeitos: MemoryEffects::Effect{}

Operandos:

Resultados:

chlo.atan (chlo::AtanOp)

Operador Atan

Sintaxe:

operation ::= `chlo.atan` $operand attr-dict `:` type($operand) `->` type($result)

Retorna Atan(operand) elemento a elemento.

\[ \atan(x) = \atan2(x, 1) \]

Traços: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Efeitos: MemoryEffects::Effect{}

Operandos:

Resultados:

chlo.atanh (chlo::AtanhOp)

Operador atanh

Sintaxe:

operation ::= `chlo.atanh` $operand attr-dict `:` type($operand) `->` type($result)

Retorna Atanh(operand) elemento a elemento.

\[ \atanh(x) = 0.5 * log((1 + x) / (1 - x)) if abs(x) <= 1 = nan otherwise \]

Traços: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Efeitos: MemoryEffects::Effect{}

Operandos:

Resultados:

chlo.bessel_i1e (chlo::BesselI1eOp)

Função de Bessel de ordem 1

Sintaxe:

operation ::= `chlo.bessel_i1e` $operand attr-dict `:` type($operand) `->` type($result)

Retorna bessel_i1e(operand) elemento a elemento.

Traços: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Efeitos: MemoryEffects::Effect{}

Operandos:

Resultados:

chlo.broadcast_add (chlo::BroadcastAddOp)

Operador de adição (com transmissão opcional)

Sintaxe:

operation ::= `chlo.broadcast_add` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

Retorna lhs + rhs elemento a elemento.

Consulte https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

Características: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, HLO_CompatibleOperandsAndResultElementType, InferTensorType

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

Efeitos: MemoryEffects::Effect{}

Atributos:

Operandos:

Resultados:

chlo.broadcast_and (chlo::BroadcastAndOp)

Operador lógico "e" (com transmissão opcional)

Sintaxe:

operation ::= `chlo.broadcast_and` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

Retorna logical_and(lhs, rhs) elemento a elemento.

Consulte https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

Características: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, InferTensorType

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

Efeitos: MemoryEffects::Effect{}

Atributos:

Operandos:

Resultados:

chlo.broadcast_atan2 (chlo::BroadcastAtan2Op)

Operador Atan2 (com transmissão opcional)

Sintaxe:

operation ::= `chlo.broadcast_atan2` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

Retorna atan2(lhs/rhs) elemento a elemento.

Consulte https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

Características: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Efeitos: MemoryEffects::Effect{}

Atributos:

Operandos:

Resultados:

chlo.broadcast_compare (chlo::BroadcastCompareOp)

Operador de comparação (com transmissão opcional)

Sintaxe:

operation ::= `chlo.broadcast_compare` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

Compara lhs e rhs elemento a elemento de acordo com comparison_direction e compare_type. Se não for especificado, compare_type será FLOAT para tipos de elementos de ponto flutuante, SIGNED para tipos de elementos assinados e UNSIGNED para tipos de elementos não assinados.

Consulte https://www.tensorflow.org/xla/operation_semantics#element-wise_comparison_operations

Traços: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType

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

Efeitos: MemoryEffects::Effect{}

Atributos:

Operandos:

Resultados:

chlo.broadcast_complex (chlo::BroadcastComplexOp)

Operador complexo (com transmissão opcional)

Sintaxe:

operation ::= `chlo.broadcast_complex` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

Realiza a conversão de elemento a elemento de um par de valores reais e imaginários em um valor complexo.

Traços: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType

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

Efeitos: MemoryEffects::Effect{}

Atributos:

Operandos:

Resultados:

chlo.broadcast_divide (chlo::BroadcastDivOp)

Operador de divisão (com transmissão opcional)

Sintaxe:

operation ::= `chlo.broadcast_divide` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

Retorna lhs / rhs elemento a elemento.

Consulte https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

Características: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Efeitos: MemoryEffects::Effect{}

Atributos:

Operandos:

Resultados:

chlo.broadcast_maximum (chlo::BroadcastMaxOp)

Operador máximo (com transmissão opcional)

Sintaxe:

operation ::= `chlo.broadcast_maximum` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

Retorna max(lhs, rhs) elemento a elemento.

Consulte https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

Características: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, HLO_CompatibleOperandsAndResultElementType, InferTensorType

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

Efeitos: MemoryEffects::Effect{}

Atributos:

Operandos:

Resultados:

chlo.broadcast_minimum (chlo::BroadcastMinOp)

Operador mínimo (com transmissão opcional)

Sintaxe:

operation ::= `chlo.broadcast_minimum` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

Retorna min(lhs, rhs) elemento a elemento.

Consulte https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

Características: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, HLO_CompatibleOperandsAndResultElementType, InferTensorType

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

Efeitos: MemoryEffects::Effect{}

Atributos:

Operandos:

Resultados:

chlo.broadcast_multiply (chlo::BroadcastMulOp)

Operador de multiplicação (com transmissão opcional)

Sintaxe:

operation ::= `chlo.broadcast_multiply` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

Retorna lhs * rhs elemento a elemento.

Consulte https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

Características: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Efeitos: MemoryEffects::Effect{}

Atributos:

Operandos:

Resultados:

chlo.broadcast_next_after (chlo::BroadcastNextAfterOp)

Operador std::nextafter (com transmissão opcional)

Sintaxe:

operation ::= `chlo.broadcast_next_after` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

Retorna o próximo valor representável de lhs na direção de rhs, elemento por elemento. Ele também pode retornar um número subnormal.

Equivalente à função std::nextafter do C++.

Características: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Efeitos: MemoryEffects::Effect{}

Atributos:

Operandos:

Resultados:

chlo.broadcast_or (chlo::BroadcastOrOp)

Operador lógico "ou" (com transmissão opcional)

Sintaxe:

operation ::= `chlo.broadcast_or` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

Retorna logical_or(lhs, rhs) elemento a elemento.

Consulte https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

Características: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, InferTensorType

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

Efeitos: MemoryEffects::Effect{}

Atributos:

Operandos:

Resultados:

chlo.broadcast_polygamma (chlo::BroadcastPolygammaOp)

Função poligamma (com transmissão opcional)

Sintaxe:

operation ::= `chlo.broadcast_polygamma` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

Retorna Polygamma(operand, operand) elemento a elemento.

Características: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Efeitos: MemoryEffects::Effect{}

Atributos:

Operandos:

Resultados:

chlo.broadcast_power (chlo::BroadcastPowOp)

Operador de potência (com transmissão opcional)

Sintaxe:

operation ::= `chlo.broadcast_power` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

Retorna lhs ^ rhs elemento a elemento.

Consulte https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

Características: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Efeitos: MemoryEffects::Effect{}

Atributos:

Operandos:

Resultados:

chlo.broadcast_remainder (chlo::BroadcastRemOp)

Operador de resto (com transmissão opcional)

Sintaxe:

operation ::= `chlo.broadcast_remainder` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

Retorna lhs % rhs elemento a elemento.

Consulte https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

Características: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Efeitos: MemoryEffects::Effect{}

Atributos:

Operandos:

Resultados:

chlo.broadcast_select (chlo::BroadcastSelectOp)

Selecionar operador (com transmissão opcional no estilo numpy)

Sintaxe:

operation ::= `chlo.broadcast_select` $pred `,` $on_true `,` $on_false attr-dict `:`
              `(` type($pred) `,` type($on_true) `,` type($on_false) `)` `->` type(results)

Cria uma matriz de saída com base nos elementos de duas matrizes de entrada, de acordo com os valores de uma matriz de predicado.

Consulte https://www.tensorflow.org/xla/operation_semantics#select

Traços: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType

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

Efeitos: MemoryEffects::Effect{}

Operandos:

Resultados:

chlo.broadcast_shift_left (chlo::BroadcastShiftLeftOp)

Operador de deslocamento para a esquerda (com transmissão opcional)

Sintaxe:

operation ::= `chlo.broadcast_shift_left` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

Retorna lhs << rhs elemento a elemento.

Consulte https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

Características: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Efeitos: MemoryEffects::Effect{}

Atributos:

Operandos:

Resultados:

chlo.broadcast_shift_right_arithmetic (chlo::BroadcastShiftRightArithmeticOp)

Operador aritmético de deslocamento à direita (com transmissão opcional)

Sintaxe:

operation ::= `chlo.broadcast_shift_right_arithmetic` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

Retorna lhs >> rhs elemento a elemento.

Consulte https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

Características: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Efeitos: MemoryEffects::Effect{}

Atributos:

Operandos:

Resultados:

chlo.broadcast_shift_right_logical (chlo::BroadcastShiftRightLogicalOp)

Operador lógico de deslocamento à direita (com transmissão opcional)

Sintaxe:

operation ::= `chlo.broadcast_shift_right_logical` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

Retorna lhs >> rhs elemento a elemento.

Consulte https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

Características: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Efeitos: MemoryEffects::Effect{}

Atributos:

Operandos:

Resultados:

chlo.broadcast_subtract (chlo::BroadcastSubOp)

Operador de subtração (com transmissão opcional)

Sintaxe:

operation ::= `chlo.broadcast_subtract` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

Retorna lhs - rhs elemento a elemento.

Consulte https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

Características: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Efeitos: MemoryEffects::Effect{}

Atributos:

Operandos:

Resultados:

chlo.broadcast_xor (chlo::BroadcastXorOp)

Operador lógico XOR (com transmissão opcional)

Sintaxe:

operation ::= `chlo.broadcast_xor` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

Retorna logical_xor(lhs, rhs) elemento a elemento.

Consulte https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

Características: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, InferTensorType

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

Efeitos: MemoryEffects::Effect{}

Atributos:

Operandos:

Resultados:

chlo.broadcast_zeta (chlo::BroadcastZetaOp)

Função zeta de Hurwitz

Sintaxe:

operation ::= `chlo.broadcast_zeta` $lhs `,` $rhs attr-dict `:`
              `(` type($lhs) `,` type($rhs) `)` `->` type(results)

Retorna Zeta(operand, operand) elemento a elemento.

\[ \(\zeta(x, q) = \sum_{n=0}^{\infty} (q + n)^{-x}\) \]

Características: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Efeitos: MemoryEffects::Effect{}

Atributos:

Operandos:

Resultados:

chlo.conj (chlo::ConjOp)

Operador Conj

Sintaxe:

operation ::= `chlo.conj` $operand attr-dict `:` type($operand) `->` type($result)

Retorna Conj(operand) elemento a elemento.

\[ \conj(x) = (\real(x), \neg(\imag(x))) \]

Traços: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Efeitos: MemoryEffects::Effect{}

Operandos:

Resultados:

chlo.constant (chlo::ConstantOp)

Operador constante

Sintaxe:

operation ::= `chlo.constant` attr-dict $value

Representa um valor constante.

Características: AlwaysSpeculatableImplTrait, ConstantLike

Interfaces: ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Efeitos: MemoryEffects::Effect{}

Atributos:

Resultados:

chlo.constant_like (chlo::ConstantLikeOp)

Operador constante semelhante

Retorna uma constante de splat da mesma forma que o operando.

Características: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultShape

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

Efeitos: MemoryEffects::Effect{}

Atributos:

Operandos:

Resultados:

chlo.cosh (chlo::CoshOp)

Operador cosh

Sintaxe:

operation ::= `chlo.cosh` $operand attr-dict `:` type($operand) `->` type($result)

Retorna Cosh(operand) elemento a elemento.

\[ \cosh(x) = (e^x + e^-x) / 2 \]

Traços: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Efeitos: MemoryEffects::Effect{}

Operandos:

Resultados:

chlo.digamma (chlo::DigammaOp)

Função digamma

Sintaxe:

operation ::= `chlo.digamma` $operand attr-dict `:` type($operand) `->` type($result)

Retorna Digamma(operand) elemento a elemento.

Traços: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Efeitos: MemoryEffects::Effect{}

Operandos:

Resultados:

chlo.erf (chlo::ErfOp)

Operador Erfc

Sintaxe:

operation ::= `chlo.erf` $operand attr-dict `:` type($operand) `->` type($result)

Calcula a função de erro de Gauss de x elemento a elemento.

erf(x) = erf_impl(x) if |x| < 1 = 1 - erfc_impl(x) otherwise

Traços: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Efeitos: MemoryEffects::Effect{}

Operandos:

Resultados:

chlo.erf_inv (chlo::ErfInvOp)

Erf inversa

Sintaxe:

operation ::= `chlo.erf_inv` $operand attr-dict `:` type($operand) `->` type($result)

Retorna ErfInv(operand) elemento a elemento.

Traços: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Efeitos: MemoryEffects::Effect{}

Operandos:

Resultados:

chlo.erfc (chlo::ErfcOp)

Operador Erfc

Sintaxe:

operation ::= `chlo.erfc` $operand attr-dict `:` type($operand) `->` type($result)

Calcula uma aproximação do complemento da função de erro (1 - erf(x)).

erfc(x) = erfc_impl(x) if |x| > 1 = 1 - erf_impl(x) otherwise

Traços: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Efeitos: MemoryEffects::Effect{}

Operandos:

Resultados:

chlo.is_inf (chlo::IsInfOp)

Predicado IsInf

Sintaxe:

operation ::= `chlo.is_inf` $operand attr-dict `:` type($operand) `->` type($result)

Retorna se um valor é +/-inf elemento a elemento.

Características: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultShape

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

Efeitos: MemoryEffects::Effect{}

Operandos:

Resultados:

chlo.is_neg_inf (chlo::IsNegInfOp)

Predicado IsNegInf

Sintaxe:

operation ::= `chlo.is_neg_inf` $operand attr-dict `:` type($operand) `->` type($result)

Retorna se um valor é um elemento -inf por elemento.

Características: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultShape

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

Efeitos: MemoryEffects::Effect{}

Operandos:

Resultados:

chlo.is_pos_inf (chlo::IsPosInfOp)

Predicado IsPosInf

Sintaxe:

operation ::= `chlo.is_pos_inf` $operand attr-dict `:` type($operand) `->` type($result)

Retorna se um valor é +inf elemento a elemento.

Características: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultShape

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

Efeitos: MemoryEffects::Effect{}

Operandos:

Resultados:

chlo.lgamma (chlo::LgammaOp)

Função Lgamma

Sintaxe:

operation ::= `chlo.lgamma` $operand attr-dict `:` type($operand) `->` type($result)

Retorna Lgamma(operand) elemento a elemento.

Traços: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Efeitos: MemoryEffects::Effect{}

Operandos:

Resultados:

chlo.next_after (chlo::NextAfterOp)

Operador std::nextafter

Sintaxe:

operation ::= `chlo.next_after` $x `,` $y attr-dict `:` type($x) `,` type($y) `->` type(results)

Retorna o próximo valor representável de x na direção de y, elemento por elemento. Ele também pode retornar um número subnormal.

Equivalente à função std::nextafter do C++.

Características: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType

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

Efeitos: MemoryEffects::Effect{}

Operandos:

Resultados:

chlo.polygamma (chlo::PolygammaOp)

Função poligamma

Sintaxe:

operation ::= `chlo.polygamma` $n `,` $x attr-dict `:` type($n) `,` type($x) `->` type(results)

Retorna Polygamma(operand, operand) elemento a elemento.

Características: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType

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

Efeitos: MemoryEffects::Effect{}

Operandos:

Resultados:

chlo.ragged_dot (chlo::RaggedDotOp)

Calcula uma multiplicação de matrizes em uma única dimensão irregular

Essa operação usa três argumentos de tensor (lhs, rhs e group_sizes) e um atributo "ragged_dot_dimension_numbers". Assim como "dot_general", "lhs" e "rhs" permitem dimensões de lote e de contração arbitrárias. Além disso, o lado esquerdo precisa ter uma dimensão irregular, e o lado direito pode ter no máximo uma dimensão de grupo. A operação tem três modos, dependendo do tipo de dimensão irregular do lado esquerdo.

No modo 1, a assinatura de forma é [b,m,k], [g,b,k,n], [b,g] -> [b,m,n]. Aqui, a dimensão irregular é uma dimensão não contraída do lado esquerdo (m). As dimensões b e k representam dimensões de lote e contração, respectivamente. O lado direito precisa ter uma dimensão de grupo (g).

No modo 2, a assinatura de forma é [b,m,k], [b,k,n], [b,g] -> [g,b,m,n]. Aqui, a dimensão irregular é uma dimensão de contração de lhs/rhs (k).

No modo 3, a assinatura de forma é [b,m,k], [b,k,n], [g] -> [b,m,n]. Aqui, a dimensão irregular é uma dimensão de lote do lado esquerdo/direito (b).

Características: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Efeitos: MemoryEffects::Effect{}

Atributos:

Operandos:

Resultados:

chlo.scan (chlo::ScanOp)

Operação de verificação

Aplica uma função de redução body a inputs e inits ao longo de dimension e gera results (que inclui outputs e carries).

Se is_reverse for verdadeiro, a verificação será feita em ordem inversa. is_associative indica se a função de redução é associativa.

Consulte: https://www.tensorflow.org/xla/operation_semantics#scan

No momento, o ScanOp não tem uma decomposição para StableHLO.

Características: AttrSizedOperandSegments, AttrSizedResultSegments, InferTensorType, IsolatedFromAbove, RecursiveMemoryEffects

Interfaces: InferShapedTypeOpInterface, InferTypeOpInterface, OpAsmOpInterface

Atributos:

Operandos:

Resultados:

chlo.sinh (chlo::SinhOp)

Operação sinh

Sintaxe:

operation ::= `chlo.sinh` $operand attr-dict `:` type($operand) `->` type($result)

Retorna Sinh(operand) elemento a elemento.

\[ \sinh(x) = (e^x - e^-x) / 2 if |x| < 1 = e^(x + log(1/2)) - e^(-x + log(1/2)) otherwise. \]

Traços: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Efeitos: MemoryEffects::Effect{}

Operandos:

Resultados:

chlo.square (chlo::SquareOp)

Operação de quadrado

Sintaxe:

operation ::= `chlo.square` $operand attr-dict `:` type($operand) `->` type($result)

Retorna Square(operand) elemento a elemento.

\[ \square(x) = complex((x.real - x.imag) * (x.real + x.imag), x.real * x.imag * 2) if x is a complex number = x * x otherwise \]

Traços: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Efeitos: MemoryEffects::Effect{}

Operandos:

Resultados:

chlo.tan (chlo::TanOp)

Operação de tangente

Sintaxe:

operation ::= `chlo.tan` $operand attr-dict `:` type($operand) `->` type($result)

Retorna Tan(operand) elemento a elemento.

\[ \tan(x) = \sin(x) / \cos(x) \]

Traços: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Efeitos: MemoryEffects::Effect{}

Operandos:

Resultados:

chlo.top_k (chlo::TopKOp)

Encontra valores e índices dos k maiores elementos da última dimensão

Sintaxe:

operation ::= `chlo.top_k` `(`$operand `,` `k` `=` $k`)` attr-dict `:`
              type($operand) `->` `(`type($values)`,` type($indices)`)`

Se a entrada for um vetor (classificação 1), vai encontrar as k maiores entradas no vetor e gerar os valores e índices delas como vetores. Assim, values[j] é a jª maior entrada em input, e o índice dela é indices[j].

Para matrizes (ou entradas de classificação mais alta), calcula as k principais entradas em cada linha (ou vetor ao longo da última dimensão). Sendo assim,

values.shape = indices.shape = input.shape[:-1] + [k]

Se dois elementos forem iguais, o elemento de índice mais baixo vai aparecer primeiro.

Características: AlwaysSpeculatableImplTrait, InferTensorType

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

Efeitos: MemoryEffects::Effect{}

Atributos:

Operandos:

Resultados:

chlo.zeta (chlo::ZetaOp)

Função zeta de Hurwitz

Sintaxe:

operation ::= `chlo.zeta` $x `,` $q attr-dict `:` type($x) `,` type($q) `->` type(results)

Retorna Zeta(operand, operand) elemento a elemento.

\[ \(\zeta(x, q) = \sum_{n=0}^{\infty} (q + n)^{-x}\) \]

Características: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType

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

Efeitos: MemoryEffects::Effect{}

Operandos:

Resultados:

Atributos

ComparisonDirectionAttr

Qual operação de comparação realizar.

Sintaxe:

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

Parâmetros:

ComparisonTypeAttr

Qual tipo de comparação usar.

Sintaxe:

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

Parâmetros:

PrecisionAttr

Precisão do XLA para um operando. Tem um significado específico do back-end.

Sintaxe:

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

Parâmetros:

RaggedDotDimensionNumbersAttr

Atributo que modela as informações de dimensão para ponto irregular.

Parâmetros:

Tipos enumerados

ComparisonDirection

Qual operação de comparação realizar.

Casos:

ComparisonType

Qual tipo de comparação usar.

Casos:

Precisão

Precisão do XLA para um operando. Tem um significado específico do back-end.

Casos: