Dialekt „chlo“

Client HLO Ops

Dieser Dialekt enthält Vorgänge, die eng an die API-Oberfläche der XlaBuilder C++ API angelehnt sind, wobei solche Vorgänge eine Semantik haben, die über die in den Dialekten auf niedrigerer Ebene (z. B. stablehlo) hinausgeht. Immer wenn die Clientbibliothek syntaktischen Zucker oder die Zusammensetzung mehrerer Vorgänge für einen API-Aufruf verwendet, versucht dieser Dialekt, den API-Aufruf zu modellieren und Konvertierungsmuster bereitzustellen, um ihn vollständig in Dialekte auf niedrigerer Ebene zu materialisieren.

Vorgänge

chlo._asin_acos_kernel (chlo::AsinAcosKernelOp)

AsinAcosKernel-Operator

Syntax:

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

Gibt AsinAcosKernel(operand) elementweise zurück.

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

Dieser Vorgang wird als Zwischenwert in Zerlegungen verwendet und sollte niemals direkt von Frameworks erstellt oder von Back-Ends genutzt werden.

Merkmale: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Auswirkungen: MemoryEffects::Effect{}

Operanden:

Ergebnisse:

chlo.acos (chlo::AcosOp)

Acos-Operator

Syntax:

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

Gibt Acos(operand) elementweise zurück.

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

Merkmale: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Auswirkungen: MemoryEffects::Effect{}

Operanden:

Ergebnisse:

chlo.acosh (chlo::AcoshOp)

Acosh-Vorgang

Syntax:

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

Gibt Acosh(operand) elementweise zurück.

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

Merkmale: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Auswirkungen: MemoryEffects::Effect{}

Operanden:

Ergebnisse:

chlo.asin (chlo::AsinOp)

Asin-Operator

Syntax:

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

Gibt Asin(operand) elementweise zurück.

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

Merkmale: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Auswirkungen: MemoryEffects::Effect{}

Operanden:

Ergebnisse:

chlo.asinh (chlo::AsinhOp)

Asinh-Vorgang

Syntax:

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

Gibt Asinh(operand) elementweise zurück.

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

Merkmale: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Auswirkungen: MemoryEffects::Effect{}

Operanden:

Ergebnisse:

chlo.atan (chlo::AtanOp)

Atan-Operator

Syntax:

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

Gibt Atan(operand) elementweise zurück.

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

Merkmale: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Auswirkungen: MemoryEffects::Effect{}

Operanden:

Ergebnisse:

chlo.atanh (chlo::AtanhOp)

Atanh-Operator

Syntax:

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

Gibt Atanh(operand) elementweise zurück.

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

Merkmale: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Auswirkungen: MemoryEffects::Effect{}

Operanden:

Ergebnisse:

chlo.bessel_i1e (chlo::BesselI1eOp)

Besselfunktion 1. Ordnung

Syntax:

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

Gibt bessel_i1e(operand) elementweise zurück.

Merkmale: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Auswirkungen: MemoryEffects::Effect{}

Operanden:

Ergebnisse:

chlo.broadcast_add (chlo::BroadcastAddOp)

Additionsoperator (mit optionalem Broadcasting)

Syntax:

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

Gibt lhs + rhs elementweise zurück.

Weitere Informationen finden Sie unter https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations.

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

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

Auswirkungen: MemoryEffects::Effect{}

Attribute:

Operanden:

Ergebnisse:

chlo.broadcast_and (chlo::BroadcastAndOp)

Logischer AND-Operator (mit optionaler Übertragung)

Syntax:

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

Gibt logical_and(lhs, rhs) elementweise zurück.

Weitere Informationen finden Sie unter https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations.

Merkmale: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, InferTensorType

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

Auswirkungen: MemoryEffects::Effect{}

Attribute:

Operanden:

Ergebnisse:

chlo.broadcast_atan2 (chlo::BroadcastAtan2Op)

Atan2-Operator (mit optionalem Broadcasting)

Syntax:

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

Gibt atan2(lhs/rhs) elementweise zurück.

Weitere Informationen finden Sie unter https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations.

Merkmale: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Auswirkungen: MemoryEffects::Effect{}

Attribute:

Operanden:

Ergebnisse:

chlo.broadcast_compare (chlo::BroadcastCompareOp)

Vergleichsoperator (mit optionaler Übertragung)

Syntax:

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

Vergleicht lhs und rhs elementweise gemäß comparison_direction und compare_type. Wenn nichts angegeben ist, ist compare_type FLOAT für Gleitkomma-Elementtypen, SIGNED für signierte Elementtypen und UNSIGNED für nicht signierte Elementtypen.

Weitere Informationen finden Sie unter https://www.tensorflow.org/xla/operation_semantics#element-wise_comparison_operations.

Merkmale: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType

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

Auswirkungen: MemoryEffects::Effect{}

Attribute:

Operanden:

Ergebnisse:

chlo.broadcast_complex (chlo::BroadcastComplexOp)

Komplexer Operator (mit optionalem Broadcasting)

Syntax:

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

Führt die elementweise Umwandlung eines Paars aus reellen und imaginären Werten in einen komplexen Wert durch.

Merkmale: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType

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

Auswirkungen: MemoryEffects::Effect{}

Attribute:

Operanden:

Ergebnisse:

chlo.broadcast_divide (chlo::BroadcastDivOp)

Divisionsoperator (mit optionalem Broadcasting)

Syntax:

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

Gibt lhs / rhs elementweise zurück.

Weitere Informationen finden Sie unter https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations.

Merkmale: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Auswirkungen: MemoryEffects::Effect{}

Attribute:

Operanden:

Ergebnisse:

chlo.broadcast_maximum (chlo::BroadcastMaxOp)

Maximaler Bediener (mit optionaler Übertragung)

Syntax:

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

Gibt max(lhs, rhs) elementweise zurück.

Weitere Informationen finden Sie unter https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations.

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

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

Auswirkungen: MemoryEffects::Effect{}

Attribute:

Operanden:

Ergebnisse:

chlo.broadcast_minimum (chlo::BroadcastMinOp)

Mindestoperator (mit optionaler Übertragung)

Syntax:

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

Gibt min(lhs, rhs) elementweise zurück.

Weitere Informationen finden Sie unter https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations.

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

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

Auswirkungen: MemoryEffects::Effect{}

Attribute:

Operanden:

Ergebnisse:

chlo.broadcast_multiply (chlo::BroadcastMulOp)

Multiplikationsoperator (mit optionalem Broadcasting)

Syntax:

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

Gibt lhs * rhs elementweise zurück.

Weitere Informationen finden Sie unter https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations.

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

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

Auswirkungen: MemoryEffects::Effect{}

Attribute:

Operanden:

Ergebnisse:

chlo.broadcast_next_after (chlo::BroadcastNextAfterOp)

Std::nextafter-Operator (mit optionalem Broadcasting)

Syntax:

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

Gibt den nächsten darstellbaren Wert von lhs in Richtung von rhs zurück, elementweise. Es kann auch eine subnormale Zahl zurückgegeben werden.

Entspricht der C++-Funktion „std::nextafter“.

Merkmale: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Auswirkungen: MemoryEffects::Effect{}

Attribute:

Operanden:

Ergebnisse:

chlo.broadcast_or (chlo::BroadcastOrOp)

Logischer OR-Operator (mit optionalem Broadcasting)

Syntax:

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

Gibt logical_or(lhs, rhs) elementweise zurück.

Weitere Informationen finden Sie unter https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations.

Merkmale: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, InferTensorType

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

Auswirkungen: MemoryEffects::Effect{}

Attribute:

Operanden:

Ergebnisse:

chlo.broadcast_polygamma (chlo::BroadcastPolygammaOp)

Polygamma-Funktion (mit optionalem Broadcasting)

Syntax:

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

Gibt Polygamma(operand, operand) elementweise zurück.

Merkmale: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Auswirkungen: MemoryEffects::Effect{}

Attribute:

Operanden:

Ergebnisse:

chlo.broadcast_power (chlo::BroadcastPowOp)

Stromversorgungsoperator (mit optionaler Übertragung)

Syntax:

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

Gibt lhs ^ rhs elementweise zurück.

Weitere Informationen finden Sie unter https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations.

Merkmale: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Auswirkungen: MemoryEffects::Effect{}

Attribute:

Operanden:

Ergebnisse:

chlo.broadcast_remainder (chlo::BroadcastRemOp)

Restoperator (mit optionalem Broadcasting)

Syntax:

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

Gibt lhs % rhs elementweise zurück.

Weitere Informationen finden Sie unter https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations.

Merkmale: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Auswirkungen: MemoryEffects::Effect{}

Attribute:

Operanden:

Ergebnisse:

chlo.broadcast_select (chlo::BroadcastSelectOp)

Operator auswählen (mit optionalem Broadcasting im NumPy-Stil)

Syntax:

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

Erstellt ein Ausgabearray aus Elementen von zwei Eingabearrays basierend auf den Werten eines Prädikatsarrays.

Weitere Informationen finden Sie unter https://www.tensorflow.org/xla/operation_semantics#select.

Merkmale: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType

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

Auswirkungen: MemoryEffects::Effect{}

Operanden:

Ergebnisse:

chlo.broadcast_shift_left (chlo::BroadcastShiftLeftOp)

Operator zum Verschieben nach links (mit optionalem Broadcasting)

Syntax:

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

Gibt lhs << rhs elementweise zurück.

Weitere Informationen finden Sie unter https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations.

Merkmale: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Auswirkungen: MemoryEffects::Effect{}

Attribute:

Operanden:

Ergebnisse:

chlo.broadcast_shift_right_arithmetic (chlo::BroadcastShiftRightArithmeticOp)

Arithmetischer Operator für Rechtsverschiebung (mit optionalem Broadcasting)

Syntax:

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

Gibt lhs >> rhs elementweise zurück.

Weitere Informationen finden Sie unter https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations.

Merkmale: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Auswirkungen: MemoryEffects::Effect{}

Attribute:

Operanden:

Ergebnisse:

chlo.broadcast_shift_right_logical (chlo::BroadcastShiftRightLogicalOp)

Logischer Operator für die Rechtsverschiebung (mit optionalem Broadcasting)

Syntax:

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

Gibt lhs >> rhs elementweise zurück.

Weitere Informationen finden Sie unter https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations.

Merkmale: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Auswirkungen: MemoryEffects::Effect{}

Attribute:

Operanden:

Ergebnisse:

chlo.broadcast_subtract (chlo::BroadcastSubOp)

Subtraktionsoperator (mit optionalem Broadcasting)

Syntax:

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

Gibt lhs - rhs elementweise zurück.

Weitere Informationen finden Sie unter https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations.

Merkmale: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Auswirkungen: MemoryEffects::Effect{}

Attribute:

Operanden:

Ergebnisse:

chlo.broadcast_xor (chlo::BroadcastXorOp)

Logischer XOR-Operator (mit optionalem Broadcasting)

Syntax:

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

Gibt logical_xor(lhs, rhs) elementweise zurück.

Weitere Informationen finden Sie unter https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations.

Merkmale: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, InferTensorType

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

Auswirkungen: MemoryEffects::Effect{}

Attribute:

Operanden:

Ergebnisse:

chlo.broadcast_zeta (chlo::BroadcastZetaOp)

Hurwitz-Zeta-Funktion

Syntax:

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

Gibt Zeta(operand, operand) elementweise zurück.

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

Merkmale: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Auswirkungen: MemoryEffects::Effect{}

Attribute:

Operanden:

Ergebnisse:

chlo.conj (chlo::ConjOp)

Conj-Operator

Syntax:

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

Gibt Conj(operand) elementweise zurück.

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

Merkmale: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Auswirkungen: MemoryEffects::Effect{}

Operanden:

Ergebnisse:

chlo.constant (chlo::ConstantOp)

Konstanter Operator

Syntax:

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

Stellt einen konstanten Wert dar.

Merkmale: AlwaysSpeculatableImplTrait, ConstantLike

Schnittstellen: ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Auswirkungen: MemoryEffects::Effect{}

Attribute:

Ergebnisse:

chlo.constant_like (chlo::ConstantLikeOp)

Constant like operator

Gibt eine Splat-Konstante mit derselben Form wie der Operand zurück.

Merkmale: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultShape

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

Auswirkungen: MemoryEffects::Effect{}

Attribute:

Operanden:

Ergebnisse:

chlo.cosh (chlo::CoshOp)

Cosh-Operator

Syntax:

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

Gibt Cosh(operand) elementweise zurück.

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

Merkmale: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Auswirkungen: MemoryEffects::Effect{}

Operanden:

Ergebnisse:

chlo.digamma (chlo::DigammaOp)

Digamma-Funktion

Syntax:

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

Gibt Digamma(operand) elementweise zurück.

Merkmale: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Auswirkungen: MemoryEffects::Effect{}

Operanden:

Ergebnisse:

chlo.erf (chlo::ErfOp)

Erfc-Operator

Syntax:

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

Berechnet die Gaußsche Fehlerfunktion von x elementweise.

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

Merkmale: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Auswirkungen: MemoryEffects::Effect{}

Operanden:

Ergebnisse:

chlo.erf_inv (chlo::ErfInvOp)

Inverse Erf

Syntax:

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

Gibt ErfInv(operand) elementweise zurück.

Merkmale: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Auswirkungen: MemoryEffects::Effect{}

Operanden:

Ergebnisse:

chlo.erfc (chlo::ErfcOp)

Erfc-Operator

Syntax:

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

Berechnet eine Näherung des Komplements der Fehlerfunktion (1 – erf(x)).

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

Merkmale: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Auswirkungen: MemoryEffects::Effect{}

Operanden:

Ergebnisse:

chlo.is_inf (chlo::IsInfOp)

IsInf-Prädikat

Syntax:

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

Gibt zurück, ob ein Wert elementweise +/-inf ist.

Merkmale: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultShape

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

Auswirkungen: MemoryEffects::Effect{}

Operanden:

Ergebnisse:

chlo.is_neg_inf (chlo::IsNegInfOp)

IsNegInf-Prädikat

Syntax:

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

Gibt zurück, ob ein Wert elementweise „-inf“ ist.

Merkmale: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultShape

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

Auswirkungen: MemoryEffects::Effect{}

Operanden:

Ergebnisse:

chlo.is_pos_inf (chlo::IsPosInfOp)

IsPosInf-Prädikat

Syntax:

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

Gibt zurück, ob ein Wert elementweise +inf ist.

Merkmale: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultShape

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

Auswirkungen: MemoryEffects::Effect{}

Operanden:

Ergebnisse:

chlo.lgamma (chlo::LgammaOp)

Lgamma-Funktion

Syntax:

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

Gibt Lgamma(operand) elementweise zurück.

Merkmale: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Auswirkungen: MemoryEffects::Effect{}

Operanden:

Ergebnisse:

chlo.next_after (chlo::NextAfterOp)

Std::nextafter-Operator

Syntax:

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

Gibt den nächsten darstellbaren Wert von x in Richtung von y zurück, elementweise. Es kann auch eine subnormale Zahl zurückgegeben werden.

Entspricht der C++-Funktion „std::nextafter“.

Merkmale: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType

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

Auswirkungen: MemoryEffects::Effect{}

Operanden:

Ergebnisse:

chlo.polygamma (chlo::PolygammaOp)

Polygamma-Funktion

Syntax:

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

Gibt Polygamma(operand, operand) elementweise zurück.

Merkmale: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType

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

Auswirkungen: MemoryEffects::Effect{}

Operanden:

Ergebnisse:

chlo.ragged_dot (chlo::RaggedDotOp)

Berechnet eine Matmul über eine einzelne unregelmäßige Dimension.

Für diesen Vorgang sind drei Tensor-Argumente erforderlich: „lhs“, „rhs“ und „group_sizes“ sowie das Attribut „ragged_dot_dimension_numbers“. Wie bei dot_general sind für lhs und rhs beliebige Batch- und Kontraktionsdimensionen zulässig. Außerdem muss die linke Seite eine unregelmäßige Dimension haben und die rechte Seite darf höchstens eine Gruppendimension haben. Der Vorgang hat drei Modi, je nach Art der unregelmäßigen Dimension auf der linken Seite.

Im Modus 1 ist die Formsignatur [b,m,k], [g,b,k,n], [b,g] -> [b,m,n]. Hier ist die unregelmäßige Dimension eine nicht kontrahierende Dimension auf der linken Seite (m). Die Dimensionen b und k stellen Batch- und kontrahierende Dimensionen dar. Die rechte Seite muss eine Gruppendimension (g) enthalten.

Im Modus 2 ist die Formsignatur [b,m,k], [b,k,n], [b,g] -> [g,b,m,n]. Hier ist die unregelmäßige Dimension eine kontrahierende Dimension auf der linken/rechten Seite (k).

Im Modus 3 ist die Formsignatur [b,m,k], [b,k,n], [g] -> [b,m,n]. Hier ist die unregelmäßige Dimension eine Batchdimension auf der linken oder rechten Seite (b).

Merkmale: AlwaysSpeculatableImplTrait

Schnittstellen: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Auswirkungen: MemoryEffects::Effect{}

Attribute:

Operanden:

Ergebnisse:

chlo.scan (chlo::ScanOp)

Scanvorgang

Wendet eine Reduktionsfunktion body auf inputs und inits entlang der dimension an und erzeugt results (bestehend aus outputs und carries).

Wenn is_reverse „true“ ist, wird der Scan in umgekehrter Reihenfolge ausgeführt. is_associative gibt an, ob die Reduzierungsfunktion assoziativ ist.

Weitere Informationen finden Sie unter https://www.tensorflow.org/xla/operation_semantics#scan.

ScanOp hat derzeit keine Zerlegung in StableHLO.

Merkmale: AttrSizedOperandSegments, AttrSizedResultSegments, InferTensorType, IsolatedFromAbove, RecursiveMemoryEffects

Schnittstellen: InferShapedTypeOpInterface, InferTypeOpInterface, OpAsmOpInterface

Attribute:

Operanden:

Ergebnisse:

chlo.sinh (chlo::SinhOp)

Sinh-Vorgang

Syntax:

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

Gibt Sinh(operand) elementweise zurück.

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

Merkmale: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Auswirkungen: MemoryEffects::Effect{}

Operanden:

Ergebnisse:

chlo.square (chlo::SquareOp)

Quadratische Operation

Syntax:

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

Gibt Square(operand) elementweise zurück.

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

Merkmale: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Auswirkungen: MemoryEffects::Effect{}

Operanden:

Ergebnisse:

chlo.tan (chlo::TanOp)

Tangens-Operation

Syntax:

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

Gibt Tan(operand) elementweise zurück.

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

Merkmale: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Auswirkungen: MemoryEffects::Effect{}

Operanden:

Ergebnisse:

chlo.top_k (chlo::TopKOp)

Sucht Werte und Indexe der k größten Elemente für die letzte Dimension

Syntax:

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

Wenn die Eingabe ein Vektor (Rang 1) ist, werden die k größten Einträge im Vektor gesucht und ihre Werte und Indexe als Vektoren ausgegeben. values[j] ist also der j-größte Eintrag in input und sein Index ist indices[j].

Für Matrizen (bzw. Eingaben mit höherem Rang) werden die k Einträge mit den höchsten Werten in jeder Zeile (bzw. in jedem Vektor entlang der letzten Dimension) berechnet. Das heißt,

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

Wenn zwei Elemente gleich sind, wird das Element mit dem niedrigeren Index zuerst angezeigt.

Merkmale: AlwaysSpeculatableImplTrait, InferTensorType

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

Auswirkungen: MemoryEffects::Effect{}

Attribute:

Operanden:

Ergebnisse:

chlo.zeta (chlo::ZetaOp)

Hurwitz-Zeta-Funktion

Syntax:

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

Gibt Zeta(operand, operand) elementweise zurück.

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

Merkmale: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType

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

Auswirkungen: MemoryEffects::Effect{}

Operanden:

Ergebnisse:

Attribute

ComparisonDirectionAttr

Welcher Vergleichsvorgang ausgeführt werden soll.

Syntax:

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

Parameter:

ComparisonTypeAttr

Welcher Vergleichstyp verwendet werden soll.

Syntax:

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

Parameter:

PrecisionAttr

XLA-Genauigkeit für einen Operanden. Hat eine Back-End-spezifische Bedeutung.

Syntax:

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

Parameter:

RaggedDotDimensionNumbersAttr

Attribut, das die Dimensionsinformationen für den unregelmäßigen Punkt modelliert.

Parameter:

Enums

ComparisonDirection

Welcher Vergleichsvorgang ausgeführt werden soll.

Schutzhüllen:

ComparisonType

Welcher Vergleichstyp verwendet werden soll.

Schutzhüllen:

Precision

XLA-Genauigkeit für einen Operanden. Hat eine Back-End-spezifische Bedeutung.

Schutzhüllen: