Dialecto "chlo"

Operaciones de HLO para clientes

Este dialecto contiene operaciones que se alinean estrechamente con el área de la API de la API de XlaBuilder C++, en la que dichas operaciones tienen una semántica que va más allá de lo que existe en los dialectos de nivel inferior (como stablehlo). Básicamente, cada vez que la biblioteca cliente usa azúcar sintáctico o composición de varias operaciones para una llamada a la API, este dialecto intenta modelar la llamada a la API y proporciona patrones de conversión para materializarse por completo en dialectos de nivel inferior.

Operaciones

chlo._asin_acos_kernel (chlo::AsinAcosKernelOp)

Operador AsinAcosKernel

Sintaxis:

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

Devuelve AsinAcosKernel(operand) según cada 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))

Esta operación se usa como un valor intermedio en las descomposiciones y los frameworks nunca deben construirla directamente ni los backends deben consumirla.

Rasgos: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Efectos: MemoryEffects::Effect{}

Operandos:

Resultados:

chlo.acos (chlo::AcosOp)

Operador de ACOS

Sintaxis:

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

Devuelve Acos(operand) según cada elemento.

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

Rasgos: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Efectos: MemoryEffects::Effect{}

Operandos:

Resultados:

chlo.acosh (chlo::AcoshOp)

Operación Acosh

Sintaxis:

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

Devuelve Acosh(operand) según cada elemento.

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

Rasgos: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Efectos: MemoryEffects::Effect{}

Operandos:

Resultados:

chlo.asin (chlo::AsinOp)

Operador de ASIN

Sintaxis:

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

Devuelve Asin(operand) según cada elemento.

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

Rasgos: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Efectos: MemoryEffects::Effect{}

Operandos:

Resultados:

chlo.asinh (chlo::AsinhOp)

Operación asinh

Sintaxis:

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

Devuelve Asinh(operand) según cada elemento.

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

Rasgos: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Efectos: MemoryEffects::Effect{}

Operandos:

Resultados:

chlo.atan (chlo::AtanOp)

Operador atan

Sintaxis:

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

Devuelve Atan(operand) según cada elemento.

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

Rasgos: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Efectos: MemoryEffects::Effect{}

Operandos:

Resultados:

chlo.atanh (chlo::AtanhOp)

Operador atanh

Sintaxis:

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

Devuelve Atanh(operand) según cada elemento.

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

Rasgos: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Efectos: MemoryEffects::Effect{}

Operandos:

Resultados:

chlo.bessel_i1e (chlo::BesselI1eOp)

Función de Bessel de orden 1

Sintaxis:

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

Devuelve bessel_i1e(operand) según cada elemento.

Rasgos: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Efectos: MemoryEffects::Effect{}

Operandos:

Resultados:

chlo.broadcast_add (chlo::BroadcastAddOp)

Operador de suma (con transmisión opcional)

Sintaxis:

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

Devuelve lhs + rhs según cada elemento.

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

Rasgos: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, HLO_CompatibleOperandsAndResultElementType, InferTensorType

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

Efectos: MemoryEffects::Effect{}

Atributos:

Operandos:

Resultados:

chlo.broadcast_and (chlo::BroadcastAndOp)

Operador lógico AND (con transmisión opcional)

Sintaxis:

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

Devuelve logical_and(lhs, rhs) según cada elemento.

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

Rasgos: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, InferTensorType

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

Efectos: MemoryEffects::Effect{}

Atributos:

Operandos:

Resultados:

chlo.broadcast_atan2 (chlo::BroadcastAtan2Op)

Operador Atan2 (con transmisión opcional)

Sintaxis:

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

Devuelve atan2(lhs/rhs) según cada elemento.

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

Rasgos: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Efectos: MemoryEffects::Effect{}

Atributos:

Operandos:

Resultados:

chlo.broadcast_compare (chlo::BroadcastCompareOp)

Operador de comparación (con transmisión opcional)

Sintaxis:

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

Compara lhs y rhs elemento por elemento según comparison_direction y compare_type. Si no se especifica, compare_type es FLOAT para los tipos de elementos flotantes, SIGNED para los tipos de elementos firmados y UNSIGNED para los tipos de elementos no firmados.

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

Rasgos: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType

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

Efectos: MemoryEffects::Effect{}

Atributos:

Operandos:

Resultados:

chlo.broadcast_complex (chlo::BroadcastComplexOp)

Operador complejo (con transmisión opcional)

Sintaxis:

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

Realiza la conversión de cada elemento de un par de valores reales e imaginarios en un valor complejo.

Rasgos: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType

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

Efectos: MemoryEffects::Effect{}

Atributos:

Operandos:

Resultados:

chlo.broadcast_divide (chlo::BroadcastDivOp)

Operador de división (con transmisión opcional)

Sintaxis:

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

Devuelve lhs / rhs según cada elemento.

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

Rasgos: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Efectos: MemoryEffects::Effect{}

Atributos:

Operandos:

Resultados:

chlo.broadcast_maximum (chlo::BroadcastMaxOp)

Operador máximo (con transmisión opcional)

Sintaxis:

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

Devuelve max(lhs, rhs) según cada elemento.

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

Rasgos: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, HLO_CompatibleOperandsAndResultElementType, InferTensorType

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

Efectos: MemoryEffects::Effect{}

Atributos:

Operandos:

Resultados:

chlo.broadcast_minimum (chlo::BroadcastMinOp)

Operador mínimo (con transmisión opcional)

Sintaxis:

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

Devuelve min(lhs, rhs) según cada elemento.

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

Rasgos: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, HLO_CompatibleOperandsAndResultElementType, InferTensorType

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

Efectos: MemoryEffects::Effect{}

Atributos:

Operandos:

Resultados:

chlo.broadcast_multiply (chlo::BroadcastMulOp)

Operador de multiplicación (con transmisión opcional)

Sintaxis:

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

Devuelve lhs * rhs según cada elemento.

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

Rasgos: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Efectos: MemoryEffects::Effect{}

Atributos:

Operandos:

Resultados:

chlo.broadcast_next_after (chlo::BroadcastNextAfterOp)

Operador Std::nextafter (con transmisión opcional)

Sintaxis:

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

Devuelve el siguiente valor representable de lhs en la dirección de rhs, elemento por elemento. También puede devolver un número subnormal.

Equivale a la función std::nextafter de C++.

Rasgos: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Efectos: MemoryEffects::Effect{}

Atributos:

Operandos:

Resultados:

chlo.broadcast_or (chlo::BroadcastOrOp)

Operador lógico OR (con transmisión opcional)

Sintaxis:

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

Devuelve logical_or(lhs, rhs) según cada elemento.

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

Rasgos: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, InferTensorType

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

Efectos: MemoryEffects::Effect{}

Atributos:

Operandos:

Resultados:

chlo.broadcast_polygamma (chlo::BroadcastPolygammaOp)

Función poligamma (con transmisión opcional)

Sintaxis:

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

Devuelve Polygamma(operand, operand) según cada elemento.

Rasgos: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Efectos: MemoryEffects::Effect{}

Atributos:

Operandos:

Resultados:

chlo.broadcast_power (chlo::BroadcastPowOp)

Operador de potencia (con transmisión opcional)

Sintaxis:

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

Devuelve lhs ^ rhs según cada elemento.

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

Rasgos: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Efectos: MemoryEffects::Effect{}

Atributos:

Operandos:

Resultados:

chlo.broadcast_remainder (chlo::BroadcastRemOp)

Operador de resto (con transmisión opcional)

Sintaxis:

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

Devuelve lhs % rhs según cada elemento.

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

Rasgos: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Efectos: MemoryEffects::Effect{}

Atributos:

Operandos:

Resultados:

chlo.broadcast_select (chlo::BroadcastSelectOp)

Seleccionar operador (con transmisión opcional al estilo de NumPy)

Sintaxis:

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

Construye un array de salida a partir de elementos de dos arrays de entrada, según los valores de un array de predicado.

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

Rasgos: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType

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

Efectos: MemoryEffects::Effect{}

Operandos:

Resultados:

chlo.broadcast_shift_left (chlo::BroadcastShiftLeftOp)

Operador de desplazamiento a la izquierda (con transmisión opcional)

Sintaxis:

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

Devuelve lhs << rhs según cada elemento.

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

Rasgos: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Efectos: MemoryEffects::Effect{}

Atributos:

Operandos:

Resultados:

chlo.broadcast_shift_right_arithmetic (chlo::BroadcastShiftRightArithmeticOp)

Operador aritmético de desplazamiento a la derecha (con transmisión opcional)

Sintaxis:

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

Devuelve lhs >> rhs según cada elemento.

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

Rasgos: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Efectos: MemoryEffects::Effect{}

Atributos:

Operandos:

Resultados:

chlo.broadcast_shift_right_logical (chlo::BroadcastShiftRightLogicalOp)

Operador lógico de desplazamiento a la derecha (con transmisión opcional)

Sintaxis:

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

Devuelve lhs >> rhs según cada elemento.

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

Rasgos: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Efectos: MemoryEffects::Effect{}

Atributos:

Operandos:

Resultados:

chlo.broadcast_subtract (chlo::BroadcastSubOp)

Operador de resta (con transmisión opcional)

Sintaxis:

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

Devuelve lhs - rhs según cada elemento.

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

Rasgos: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Efectos: MemoryEffects::Effect{}

Atributos:

Operandos:

Resultados:

chlo.broadcast_xor (chlo::BroadcastXorOp)

Operador xor lógico (con transmisión opcional)

Sintaxis:

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

Devuelve logical_xor(lhs, rhs) según cada elemento.

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

Rasgos: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, InferTensorType

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

Efectos: MemoryEffects::Effect{}

Atributos:

Operandos:

Resultados:

chlo.broadcast_zeta (chlo::BroadcastZetaOp)

Función zeta de Hurwitz

Sintaxis:

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

Devuelve Zeta(operand, operand) según cada elemento.

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

Rasgos: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Efectos: MemoryEffects::Effect{}

Atributos:

Operandos:

Resultados:

chlo.conj (chlo::ConjOp)

Operador de conjunción

Sintaxis:

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

Devuelve Conj(operand) según cada elemento.

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

Rasgos: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Efectos: MemoryEffects::Effect{}

Operandos:

Resultados:

chlo.constant (chlo::ConstantOp)

Operador constante

Sintaxis:

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

Representa un valor constante.

Rasgos: AlwaysSpeculatableImplTrait y ConstantLike

Interfaces: ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Efectos: MemoryEffects::Effect{}

Atributos:

Resultados:

chlo.constant_like (chlo::ConstantLikeOp)

Operador similar a una constante

Devuelve una constante de splat con la misma forma que el operando.

Rasgos: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultShape

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

Efectos: MemoryEffects::Effect{}

Atributos:

Operandos:

Resultados:

chlo.cosh (chlo::CoshOp)

Operador de cosh

Sintaxis:

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

Devuelve Cosh(operand) según cada elemento.

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

Rasgos: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Efectos: MemoryEffects::Effect{}

Operandos:

Resultados:

chlo.digamma (chlo::DigammaOp)

Función digamma

Sintaxis:

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

Devuelve Digamma(operand) según cada elemento.

Rasgos: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Efectos: MemoryEffects::Effect{}

Operandos:

Resultados:

chlo.erf (chlo::ErfOp)

Operador Erfc

Sintaxis:

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

Calcula la función error de Gauss del elemento x de forma independiente para cada elemento.

erf(x) = erf_impl(x) si |x| < 1 = 1 - erfc_impl(x) en otros casos

Rasgos: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Efectos: MemoryEffects::Effect{}

Operandos:

Resultados:

chlo.erf_inv (chlo::ErfInvOp)

Erf inversa

Sintaxis:

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

Devuelve ErfInv(operand) según cada elemento.

Rasgos: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Efectos: MemoryEffects::Effect{}

Operandos:

Resultados:

chlo.erfc (chlo::ErfcOp)

Operador Erfc

Sintaxis:

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

Calcula una aproximación del complemento de la función error (1 - erf(x)).

erfc(x) = erfc_impl(x) si |x| > 1 = 1 - erf_impl(x) de lo contrario

Rasgos: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Efectos: MemoryEffects::Effect{}

Operandos:

Resultados:

chlo.is_inf (chlo::IsInfOp)

Predicado IsInf

Sintaxis:

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

Devuelve si un valor es +/-inf para cada elemento.

Rasgos: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultShape

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

Efectos: MemoryEffects::Effect{}

Operandos:

Resultados:

chlo.is_neg_inf (chlo::IsNegInfOp)

Predicado IsNegInf

Sintaxis:

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

Devuelve si un valor es -inf de forma independiente para cada elemento.

Rasgos: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultShape

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

Efectos: MemoryEffects::Effect{}

Operandos:

Resultados:

chlo.is_pos_inf (chlo::IsPosInfOp)

Es predicado de PosInf

Sintaxis:

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

Devuelve si un valor es +inf de forma según el elemento.

Rasgos: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultShape

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

Efectos: MemoryEffects::Effect{}

Operandos:

Resultados:

chlo.lgamma (chlo::LgammaOp)

Función Lgamma

Sintaxis:

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

Devuelve Lgamma(operand) según cada elemento.

Rasgos: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Efectos: MemoryEffects::Effect{}

Operandos:

Resultados:

chlo.next_after (chlo::NextAfterOp)

Operador Std::nextafter

Sintaxis:

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

Devuelve el siguiente valor representable de x en la dirección de y, elemento por elemento. También puede devolver un número subnormal.

Equivale a la función std::nextafter de C++.

Rasgos: AlwaysSpeculatableImplTrait y CompatibleOperandsAndResultType

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

Efectos: MemoryEffects::Effect{}

Operandos:

Resultados:

chlo.polygamma (chlo::PolygammaOp)

Función poligamma

Sintaxis:

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

Devuelve Polygamma(operand, operand) según cada elemento.

Rasgos: AlwaysSpeculatableImplTrait y CompatibleOperandsAndResultType

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

Efectos: MemoryEffects::Effect{}

Operandos:

Resultados:

chlo.ragged_dot (chlo::RaggedDotOp)

Calcula una multiplicación de matrices en una sola dimensión irregular

Esta operación toma tres argumentos de tensor (lhs, rhs y group_sizes) y un atributo "ragged_dot_dimension_numbers". Al igual que dot_general, se permiten dimensiones de lote y de contracción arbitrarias para lhs y rhs. Además, el LHD debe tener una dimensión irregular, y el RHD puede tener como máximo una dimensión de grupo. La operación tiene tres modos, según el tipo de dimensión irregular del lado izquierdo.

En el modo 1, la firma de forma es [b,m,k], [g,b,k,n], [b,g] -> [b,m,n]. Aquí, la dimensión irregular es una dimensión no contractiva del lado izquierdo (m). Las dimensiones b y k representan dimensiones de lote y contractivas, respectivamente. El lado derecho debe tener una dimensión de grupo (g).

En el modo 2, la firma de forma es [b,m,k], [b,k,n], [b,g] -> [g,b,m,n]. Aquí, la dimensión irregular es una dimensión de contracción del lado izquierdo o derecho (k).

En el modo 3, la firma de forma es [b,m,k], [b,k,n], [g] -> [b,m,n]. Aquí, la dimensión irregular es una dimensión de lote del lado izquierdo o derecho (b).

Rasgos: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Efectos: MemoryEffects::Effect{}

Atributos:

Operandos:

Resultados:

chlo.scan (chlo::ScanOp)

Operación de análisis

Aplica una función de reducción body a inputs y inits a lo largo de dimension y genera results (que incluye outputs y carries).

Si is_reverse es verdadero, el análisis se realiza en orden inverso. is_associative indica si la función de reducción es asociativa.

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

Actualmente, ScanOp no tiene una descomposición en StableHLO.

Rasgos: AttrSizedOperandSegments, AttrSizedResultSegments, InferTensorType, IsolatedFromAbove, RecursiveMemoryEffects

Interfaces: InferShapedTypeOpInterface, InferTypeOpInterface, OpAsmOpInterface

Atributos:

Operandos:

Resultados:

chlo.sinh (chlo::SinhOp)

Operación sinh

Sintaxis:

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

Devuelve Sinh(operand) según cada elemento.

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

Rasgos: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Efectos: MemoryEffects::Effect{}

Operandos:

Resultados:

chlo.square (chlo::SquareOp)

Operación de cuadrado

Sintaxis:

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

Devuelve Square(operand) según cada 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 \]

Rasgos: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Efectos: MemoryEffects::Effect{}

Operandos:

Resultados:

chlo.tan (chlo::TanOp)

Operación de tangente

Sintaxis:

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

Devuelve Tan(operand) según cada elemento.

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

Rasgos: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Efectos: MemoryEffects::Effect{}

Operandos:

Resultados:

chlo.top_k (chlo::TopKOp)

Encuentra los valores y los índices de los k elementos más grandes para la última dimensión

Sintaxis:

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

Si la entrada es un vector (de rango 1), encuentra las k entradas más grandes en el vector y genera sus valores y sus índices como vectores. Por lo tanto, values[j] es la entrada j-ésima más grande en input, y su índice es indices[j].

Para las matrices (o entradas de mayor rango), calcula las k entradas principales en cada fila (o vector a lo largo de la última dimensión). Entonces,

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

Si dos elementos son iguales, aparece primero el elemento con el índice más bajo.

Rasgos: AlwaysSpeculatableImplTrait y InferTensorType

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

Efectos: MemoryEffects::Effect{}

Atributos:

Operandos:

Resultados:

chlo.zeta (chlo::ZetaOp)

Función zeta de Hurwitz

Sintaxis:

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

Devuelve Zeta(operand, operand) según cada elemento.

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

Rasgos: AlwaysSpeculatableImplTrait y CompatibleOperandsAndResultType

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

Efectos: MemoryEffects::Effect{}

Operandos:

Resultados:

Atributos

ComparisonDirectionAttr

Qué operación de comparación se debe realizar.

Sintaxis:

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

Parámetros:

ComparisonTypeAttr

Tipo de comparación que se usará.

Sintaxis:

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

Parámetros:

PrecisionAttr

Es la precisión de XLA para un operando. Tiene un significado específico para el backend.

Sintaxis:

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

Parámetros:

RaggedDotDimensionNumbersAttr

Atributo que modela la información de la dimensión para el punto irregular.

Parámetros:

Enums

ComparisonDirection

Qué operación de comparación se debe realizar.

Casos:

ComparisonType

Tipo de comparación que se usará.

Casos:

Precisión

Es la precisión de XLA para un operando. Tiene un significado específico para el backend.

Casos: