Dialecte 'chlo'

Opérations HLO pour les clients

Ce dialecte contient des opérations qui s'alignent étroitement sur la surface de l'API de l'API C++ XlaBuilder, où ces opérations ont une sémantique qui va au-delà de ce qui existe dans les dialectes de niveau inférieur (comme stablehlo). Essentiellement, chaque fois que la bibliothèque cliente utilise du sucre syntaxique ou la composition de plusieurs opérations pour un appel d'API, ce dialecte tente de modéliser l'appel d'API et de fournir des modèles de conversion pour se matérialiser complètement dans des dialectes de niveau inférieur.

Opérations

chlo._asin_acos_kernel (chlo::AsinAcosKernelOp)

Opérateur AsinAcosKernel

Syntaxe :

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

Renvoie AsinAcosKernel(operand) pour chaque élément.

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

Cette opération est utilisée comme valeur intermédiaire dans les décompositions et ne doit jamais être construite directement par les frameworks ni consommée par les backends.

Traits : AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats :

chlo.acos (chlo::AcosOp)

Opérateur Acos

Syntaxe :

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

Renvoie Acos(operand) pour chaque élément.

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

Traits : AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats :

chlo.acosh (chlo::AcoshOp)

Opération Acosh

Syntaxe :

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

Renvoie Acosh(operand) pour chaque élément.

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

Traits : AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats :

chlo.asin (chlo::AsinOp)

Opérateur ASIN

Syntaxe :

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

Renvoie Asin(operand) pour chaque élément.

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

Traits : AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats :

chlo.asinh (chlo::AsinhOp)

Opération Asinh

Syntaxe :

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

Renvoie Asinh(operand) pour chaque élément.

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

Traits : AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats :

chlo.atan (chlo::AtanOp)

Opérateur Atan

Syntaxe :

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

Renvoie Atan(operand) pour chaque élément.

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

Traits : AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats :

chlo.atanh (chlo::AtanhOp)

Opérateur Atanh

Syntaxe :

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

Renvoie Atanh(operand) pour chaque élément.

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

Traits : AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats :

chlo.bessel_i1e (chlo::BesselI1eOp)

Fonction de Bessel d'ordre 1

Syntaxe :

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

Renvoie bessel_i1e(operand) pour chaque élément.

Traits : AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats :

chlo.broadcast_add (chlo::BroadcastAddOp)

Opérateur d'addition (avec diffusion facultative)

Syntaxe :

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

Renvoie lhs + rhs pour chaque élément.

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

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

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

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats :

chlo.broadcast_and (chlo::BroadcastAndOp)

Opérateur logique "and" (avec diffusion facultative)

Syntaxe :

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

Renvoie logical_and(lhs, rhs) pour chaque élément.

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

Traits : AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, InferTensorType

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

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats :

chlo.broadcast_atan2 (chlo::BroadcastAtan2Op)

Opérateur Atan2 (avec diffusion facultative)

Syntaxe :

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

Renvoie atan2(lhs/rhs) pour chaque élément.

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

Traits : AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats :

chlo.broadcast_compare (chlo::BroadcastCompareOp)

Opérateur de comparaison (avec diffusion facultative)

Syntaxe :

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

Compare lhs et rhs élément par élément selon comparison_direction et compare_type. Si elle n'est pas spécifiée, compare_type est FLOAT pour les types d'éléments float, SIGNED pour les types d'éléments signés et UNSIGNED pour les types d'éléments non signés.

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

Traits : AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType

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

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats :

chlo.broadcast_complex (chlo::BroadcastComplexOp)

Opérateur complexe (avec diffusion facultative)

Syntaxe :

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

Effectue la conversion élément par élément d'une paire de valeurs réelles et imaginaires en une valeur complexe.

Traits : AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType

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

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats :

chlo.broadcast_divide (chlo::BroadcastDivOp)

Opérateur de division (avec diffusion facultative)

Syntaxe :

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

Renvoie lhs / rhs pour chaque élément.

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

Traits : AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats :

chlo.broadcast_maximum (chlo::BroadcastMaxOp)

Opérateur maximum (avec diffusion facultative)

Syntaxe :

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

Renvoie max(lhs, rhs) pour chaque élément.

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

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

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

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats :

chlo.broadcast_minimum (chlo::BroadcastMinOp)

Opérateur minimal (avec diffusion facultative)

Syntaxe :

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

Renvoie min(lhs, rhs) pour chaque élément.

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

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

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

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats :

chlo.broadcast_multiply (chlo::BroadcastMulOp)

Opérateur de multiplication (avec diffusion facultative)

Syntaxe :

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

Renvoie lhs * rhs pour chaque élément.

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

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

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

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats :

chlo.broadcast_next_after (chlo::BroadcastNextAfterOp)

Opérateur Std::nextafter (avec diffusion facultative)

Syntaxe :

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

Renvoie la prochaine valeur représentable de lhs dans la direction de rhs, élément par élément. Elle peut également renvoyer un nombre subnormal.

Équivaut à la fonction C++ std::nextafter.

Traits : AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats :

chlo.broadcast_or (chlo::BroadcastOrOp)

Opérateur logique "or" (avec diffusion facultative)

Syntaxe :

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

Renvoie logical_or(lhs, rhs) pour chaque élément.

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

Traits : AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, InferTensorType

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

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats :

chlo.broadcast_polygamma (chlo::BroadcastPolygammaOp)

Fonction polygamma (avec diffusion facultative)

Syntaxe :

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

Renvoie Polygamma(operand, operand) pour chaque élément.

Traits : AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats :

chlo.broadcast_power (chlo::BroadcastPowOp)

Opérateur de puissance (avec diffusion facultative)

Syntaxe :

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

Renvoie lhs ^ rhs pour chaque élément.

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

Traits : AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats :

chlo.broadcast_remainder (chlo::BroadcastRemOp)

Opérateur de reste (avec diffusion facultative)

Syntaxe :

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

Renvoie lhs % rhs pour chaque élément.

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

Traits : AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats :

chlo.broadcast_select (chlo::BroadcastSelectOp)

Sélectionner l'opérateur (avec diffusion de style NumPy facultative)

Syntaxe :

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

Construit un tableau de sortie à partir des éléments de deux tableaux d'entrée, en fonction des valeurs d'un tableau de prédicats.

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

Traits : AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType

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

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats :

chlo.broadcast_shift_left (chlo::BroadcastShiftLeftOp)

Opérateur de décalage vers la gauche (avec diffusion facultative)

Syntaxe :

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

Renvoie lhs << rhs pour chaque élément.

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

Traits : AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats :

chlo.broadcast_shift_right_arithmetic (chlo::BroadcastShiftRightArithmeticOp)

Opérateur arithmétique de décalage vers la droite (avec diffusion facultative)

Syntaxe :

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

Renvoie lhs >> rhs pour chaque élément.

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

Traits : AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats :

chlo.broadcast_shift_right_logical (chlo::BroadcastShiftRightLogicalOp)

Opérateur logique de décalage à droite (avec diffusion facultative)

Syntaxe :

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

Renvoie lhs >> rhs pour chaque élément.

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

Traits : AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats :

chlo.broadcast_subtract (chlo::BroadcastSubOp)

Opérateur de soustraction (avec diffusion facultative)

Syntaxe :

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

Renvoie lhs - rhs pour chaque élément.

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

Traits : AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats :

chlo.broadcast_xor (chlo::BroadcastXorOp)

Opérateur logique xor (avec diffusion facultative)

Syntaxe :

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

Renvoie logical_xor(lhs, rhs) pour chaque élément.

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

Traits : AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, InferTensorType

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

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats :

chlo.broadcast_zeta (chlo::BroadcastZetaOp)

Fonction zêta de Hurwitz

Syntaxe :

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

Renvoie Zeta(operand, operand) pour chaque élément.

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

Traits : AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats :

chlo.conj (chlo::ConjOp)

Opérateur conj

Syntaxe :

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

Renvoie Conj(operand) pour chaque élément.

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

Traits : AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats :

chlo.constant (chlo::ConstantOp)

Opérateur Constant

Syntaxe :

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

Représente une valeur constante.

Traits : AlwaysSpeculatableImplTrait, ConstantLike

Interfaces : ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Effets : MemoryEffects::Effect{}

Attributs :

Résultats :

chlo.constant_like (chlo::ConstantLikeOp)

Opérateur "constant like"

Renvoie une constante splat de la même forme que l'opérande.

Traits : AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultShape

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

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats :

chlo.cosh (chlo::CoshOp)

Opérateur Cosh

Syntaxe :

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

Renvoie Cosh(operand) pour chaque élément.

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

Traits : AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats :

chlo.digamma (chlo::DigammaOp)

Fonction digamma

Syntaxe :

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

Renvoie Digamma(operand) pour chaque élément.

Traits : AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats :

chlo.erf (chlo::ErfOp)

Opérateur Erfc

Syntaxe :

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

Calcule la fonction d'erreur de Gauss de x élément par élément.

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

Traits : AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats :

chlo.erf_inv (chlo::ErfInvOp)

Inverse Erf

Syntaxe :

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

Renvoie ErfInv(operand) pour chaque élément.

Traits : AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats :

chlo.erfc (chlo::ErfcOp)

Opérateur Erfc

Syntaxe :

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

Calcule une approximation du complément de la fonction d'erreur (1 - erf(x)).

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

Traits : AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats :

chlo.is_inf (chlo::IsInfOp)

Prédicat IsInf

Syntaxe :

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

Renvoie si une valeur est +/-inf élément par élément.

Traits : AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultShape

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

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats :

chlo.is_neg_inf (chlo::IsNegInfOp)

Prédicat IsNegInf

Syntaxe :

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

Indique si une valeur est un élément -inf.

Traits : AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultShape

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

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats :

chlo.is_pos_inf (chlo::IsPosInfOp)

Prédicat IsPosInf

Syntaxe :

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

Renvoie si une valeur est +inf élément par élément.

Traits : AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultShape

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

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats :

chlo.lgamma (chlo::LgammaOp)

Fonction Lgamma

Syntaxe :

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

Renvoie Lgamma(operand) pour chaque élément.

Traits : AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats :

chlo.next_after (chlo::NextAfterOp)

Opérateur Std::nextafter

Syntaxe :

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

Renvoie la prochaine valeur représentable de x dans la direction de y, élément par élément. Elle peut également renvoyer un nombre subnormal.

Équivaut à la fonction C++ std::nextafter.

Traits : AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType

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

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats :

chlo.polygamma (chlo::PolygammaOp)

Fonction polygamma

Syntaxe :

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

Renvoie Polygamma(operand, operand) pour chaque élément.

Traits : AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType

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

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats :

chlo.ragged_dot (chlo::RaggedDotOp)

Calcule un matmul sur une seule dimension irrégulière.

Cette opération prend trois arguments Tensor (lhs, rhs et group_sizes) et un attribut "ragged_dot_dimension_numbers". Comme dot_general, lhs et rhs sont autorisés à avoir des dimensions de lot et de contraction arbitraires. De plus, le membre de gauche doit comporter une dimension irrégulière, et le membre de droite peut comporter au maximum une dimension de groupe. L'opération comporte trois modes, en fonction du type de dimension irrégulière lhs.

En mode 1, la signature de forme est [b,m,k], [g,b,k,n], [b,g] -> [b,m,n]. Ici, la dimension irrégulière est une dimension non contractante lhs (m). Les dimensions b et k représentent respectivement les dimensions de lot et de contraction. Le membre de droite doit comporter une dimension de groupe (g).

En mode 2, la signature de forme est [b,m,k], [b,k,n], [b,g] -> [g,b,m,n]. Ici, la dimension irrégulière est une dimension de contraction lhs/rhs (k).

En mode 3, la signature de forme est [b,m,k], [b,k,n], [g] -> [b,m,n]. Ici, la dimension irrégulière est une dimension de lot lhs/rhs (b).

Caractéristiques : AlwaysSpeculatableImplTrait

Interfaces : ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats :

chlo.scan (chlo::ScanOp)

Opération d'analyse

Applique une fonction de réduction body à inputs et inits le long de dimension et produit results (comprenant outputs et carries).

Si is_reverse est "true", l'analyse est effectuée dans l'ordre inverse. is_associative indique si la fonction de réduction est associative.

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

ScanOp ne dispose actuellement pas de décomposition en StableHLO.

Traits : AttrSizedOperandSegments, AttrSizedResultSegments, InferTensorType, IsolatedFromAbove, RecursiveMemoryEffects

Interfaces : InferShapedTypeOpInterface, InferTypeOpInterface, OpAsmOpInterface

Attributs :

Opérandes :

Résultats :

chlo.sinh (chlo::SinhOp)

Opération Sinh

Syntaxe :

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

Renvoie Sinh(operand) pour chaque élément.

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

Traits : AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats :

chlo.square (chlo::SquareOp)

Opération de mise au carré

Syntaxe :

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

Renvoie Square(operand) pour chaque élément.

\[ \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 \]

Traits : AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats :

chlo.tan (chlo::TanOp)

Opération Tan

Syntaxe :

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

Renvoie Tan(operand) pour chaque élément.

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

Traits : AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats :

chlo.top_k (chlo::TopKOp)

Recherche les valeurs et les index des k plus grands éléments pour la dernière dimension

Syntaxe :

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

Si l'entrée est un vecteur (rang 1), trouve les k entrées les plus grandes du vecteur et génère leurs valeurs et leurs indices sous forme de vecteurs. Ainsi, values[j] est la je entrée la plus grande de input, et son index est indices[j].

Pour les matrices (ou les entrées de rang supérieur), calcule les k premières entrées de chaque ligne (ou vecteur le long de la dernière dimension). Ainsi :

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

Si deux éléments sont égaux, celui dont l'index est le plus faible apparaît en premier.

Traits : AlwaysSpeculatableImplTrait, InferTensorType

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

Effets : MemoryEffects::Effect{}

Attributs :

Opérandes :

Résultats :

chlo.zeta (chlo::ZetaOp)

Fonction zêta de Hurwitz

Syntaxe :

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

Renvoie Zeta(operand, operand) pour chaque élément.

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

Traits : AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType

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

Effets : MemoryEffects::Effect{}

Opérandes :

Résultats :

Attributs

ComparisonDirectionAttr

Opération de comparaison à effectuer.

Syntaxe :

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

Paramètres :

ComparisonTypeAttr

Type de comparaison à utiliser.

Syntaxe :

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

Paramètres :

PrecisionAttr

Précision XLA pour un opérande. A une signification spécifique au backend.

Syntaxe :

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

Paramètres :

RaggedDotDimensionNumbersAttr

Attribut qui modélise les informations de dimension pour le point irrégulier.

Paramètres :

Enums

ComparisonDirection

Opération de comparaison à effectuer.

Étuis :

ComparisonType

Type de comparaison à utiliser.

Étuis :

Précision

Précision XLA pour un opérande. A une signification spécifique au backend.

Étuis :