Dialekt „chlo”

Client HLO Ops

Ten dialekt zawiera operacje, które są ściśle powiązane z obszarem interfejsu API XlaBuilder C++, w którym takie operacje mają semantykę wykraczającą poza to, co istnieje w dialektach niższego poziomu (np. stablehlo). Zasadniczo, gdy biblioteka klienta używa lukru syntaktycznego lub kompozycji wielu operacji w przypadku wywołania interfejsu API, ten dialekt próbuje modelować wywołanie interfejsu API i zapewnia wzorce konwersji, aby w pełni zmaterializować się w dialektach niższego poziomu.

Operacje

chlo._asin_acos_kernel (chlo::AsinAcosKernelOp)

Operator AsinAcosKernel

Składnia:

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

Zwraca AsinAcosKernel(operand) dla każdego elementu.

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

Ten operator jest używany jako wartość pośrednia w dekompozycjach i nigdy nie powinien być tworzony bezpośrednio przez platformy ani używany przez backendy.

Cechy: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Skutki: MemoryEffects::Effect{}

Operandy:

Wyniki:

chlo.acos (chlo::AcosOp)

Operator Acos

Składnia:

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

Zwraca Acos(operand) dla każdego elementu.

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

Cechy: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Skutki: MemoryEffects::Effect{}

Operandy:

Wyniki:

chlo.acosh (chlo::AcoshOp)

Operacja acosh

Składnia:

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

Zwraca Acosh(operand) dla każdego elementu.

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

Cechy: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Skutki: MemoryEffects::Effect{}

Operandy:

Wyniki:

chlo.asin (chlo::AsinOp)

Operator ASIN

Składnia:

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

Zwraca Asin(operand) dla każdego elementu.

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

Cechy: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Skutki: MemoryEffects::Effect{}

Operandy:

Wyniki:

chlo.asinh (chlo::AsinhOp)

Operacja asinh

Składnia:

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

Zwraca Asinh(operand) dla każdego elementu.

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

Cechy: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Skutki: MemoryEffects::Effect{}

Operandy:

Wyniki:

chlo.atan (chlo::AtanOp)

Operator atan

Składnia:

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

Zwraca Atan(operand) dla każdego elementu.

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

Cechy: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Skutki: MemoryEffects::Effect{}

Operandy:

Wyniki:

chlo.atanh (chlo::AtanhOp)

Operator atanh

Składnia:

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

Zwraca Atanh(operand) dla każdego elementu.

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

Cechy: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Skutki: MemoryEffects::Effect{}

Operandy:

Wyniki:

chlo.bessel_i1e (chlo::BesselI1eOp)

Funkcja Bessela rzędu 1

Składnia:

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

Zwraca bessel_i1e(operand) dla każdego elementu.

Cechy: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Skutki: MemoryEffects::Effect{}

Operandy:

Wyniki:

chlo.broadcast_add (chlo::BroadcastAddOp)

Operator dodawania (z opcjonalnym rozgłaszaniem)

Składnia:

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

Zwraca lhs + rhs dla każdego elementu.

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

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

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

Skutki: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

chlo.broadcast_and (chlo::BroadcastAndOp)

Operator logiczny i (z opcjonalnym rozgłaszaniem)

Składnia:

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

Zwraca logical_and(lhs, rhs) dla każdego elementu.

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

Cechy: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, InferTensorType

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

Skutki: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

chlo.broadcast_atan2 (chlo::BroadcastAtan2Op)

Operator Atan2 (z opcjonalnym rozgłaszaniem)

Składnia:

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

Zwraca atan2(lhs/rhs) dla każdego elementu.

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

Cechy: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Skutki: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

chlo.broadcast_compare (chlo::BroadcastCompareOp)

Porównanie operatora (z opcjonalnym nadawaniem)

Składnia:

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

Porównuje elementy lhs i rhs element po elemencie zgodnie z warunkami comparison_direction i compare_type. Jeśli nie określono inaczej, w przypadku typów elementów zmiennoprzecinkowych compare_type ma wartość FLOAT, w przypadku typów elementów ze znakiem SIGNED, a w przypadku typów elementów bez znaku UNSIGNED.

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

Cechy: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType

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

Skutki: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

chlo.broadcast_complex (chlo::BroadcastComplexOp)

Złożony operator (z opcjonalnym rozgłaszaniem)

Składnia:

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

Wykonuje konwersję elementów pary wartości rzeczywistych i urojonych na wartość zespoloną.

Cechy: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType

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

Skutki: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

chlo.broadcast_divide (chlo::BroadcastDivOp)

Operator dzielenia (z opcjonalnym rozgłaszaniem)

Składnia:

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

Zwraca lhs / rhs dla każdego elementu.

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

Cechy: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Skutki: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

chlo.broadcast_maximum (chlo::BroadcastMaxOp)

Maksymalny operator (z opcjonalnym nadawaniem)

Składnia:

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

Zwraca max(lhs, rhs) dla każdego elementu.

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

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

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

Skutki: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

chlo.broadcast_minimum (chlo::BroadcastMinOp)

Operator minimalny (z opcjonalnym nadawaniem)

Składnia:

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

Zwraca min(lhs, rhs) dla każdego elementu.

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

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

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

Skutki: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

chlo.broadcast_multiply (chlo::BroadcastMulOp)

Operator mnożenia (z opcjonalnym rozgłaszaniem)

Składnia:

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

Zwraca lhs * rhs dla każdego elementu.

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

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

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

Skutki: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

chlo.broadcast_next_after (chlo::BroadcastNextAfterOp)

Operator Std::nextafter (z opcjonalnym rozgłaszaniem)

Składnia:

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

Zwraca następną reprezentowaną wartość lhs w kierunku rhs, element po elemencie. Może też zwrócić liczbę podnormalną.

Odpowiednik funkcji std::nextafter w C++.

Cechy: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Skutki: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

chlo.broadcast_or (chlo::BroadcastOrOp)

Operator logiczny OR (z opcjonalnym rozgłaszaniem)

Składnia:

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

Zwraca logical_or(lhs, rhs) dla każdego elementu.

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

Cechy: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, InferTensorType

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

Skutki: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

chlo.broadcast_polygamma (chlo::BroadcastPolygammaOp)

Funkcja poligamma (z opcjonalnym rozgłaszaniem)

Składnia:

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

Zwraca Polygamma(operand, operand) dla każdego elementu.

Cechy: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Skutki: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

chlo.broadcast_power (chlo::BroadcastPowOp)

Operator potęgowania (z opcjonalnym rozgłaszaniem)

Składnia:

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

Zwraca lhs ^ rhs dla każdego elementu.

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

Cechy: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Skutki: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

chlo.broadcast_remainder (chlo::BroadcastRemOp)

Operator reszty z opcjonalnym rozgłaszaniem

Składnia:

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

Zwraca lhs % rhs dla każdego elementu.

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

Cechy: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Skutki: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

chlo.broadcast_select (chlo::BroadcastSelectOp)

Wybierz operatora (z opcjonalnym rozgłaszaniem w stylu numpy)

Składnia:

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

Tworzy tablicę wyjściową z elementów 2 tablic wejściowych na podstawie wartości tablicy predykatu.

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

Cechy: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType

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

Skutki: MemoryEffects::Effect{}

Operandy:

Wyniki:

chlo.broadcast_shift_left (chlo::BroadcastShiftLeftOp)

Operator przesunięcia w lewo (z opcjonalnym rozgłaszaniem)

Składnia:

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

Zwraca lhs << rhs dla każdego elementu.

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

Cechy: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Skutki: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

chlo.broadcast_shift_right_arithmetic (chlo::BroadcastShiftRightArithmeticOp)

Operator przesunięcia bitowego w prawo (z opcjonalnym rozgłaszaniem)

Składnia:

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

Zwraca lhs >> rhs dla każdego elementu.

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

Cechy: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Skutki: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

chlo.broadcast_shift_right_logical (chlo::BroadcastShiftRightLogicalOp)

Przesunięcie w prawo operatora logicznego (z opcjonalnym rozgłaszaniem)

Składnia:

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

Zwraca lhs >> rhs dla każdego elementu.

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

Cechy: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Skutki: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

chlo.broadcast_subtract (chlo::BroadcastSubOp)

Operator odejmowania (z opcjonalnym rozgłaszaniem)

Składnia:

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

Zwraca lhs - rhs dla każdego elementu.

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

Cechy: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Skutki: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

chlo.broadcast_xor (chlo::BroadcastXorOp)

Operator logiczny xor (z opcjonalnym rozgłaszaniem)

Składnia:

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

Zwraca logical_xor(lhs, rhs) dla każdego elementu.

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

Cechy: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, InferTensorType

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

Skutki: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

chlo.broadcast_zeta (chlo::BroadcastZetaOp)

Funkcja dzeta Hurwitza

Składnia:

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

Zwraca Zeta(operand, operand) dla każdego elementu.

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

Cechy: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

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

Skutki: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

chlo.conj (chlo::ConjOp)

Operator koniunkcji

Składnia:

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

Zwraca Conj(operand) dla każdego elementu.

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

Cechy: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Skutki: MemoryEffects::Effect{}

Operandy:

Wyniki:

chlo.constant (chlo::ConstantOp)

Operator stałej

Składnia:

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

Reprezentuje stałą wartość.

Cechy: AlwaysSpeculatableImplTrait, ConstantLike

Interfejsy: ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Skutki: MemoryEffects::Effect{}

Atrybuty:

Wyniki:

chlo.constant_like (chlo::ConstantLikeOp)

Operator podobny do stałej

Zwraca stałą splat o takim samym kształcie jak operand.

Cechy: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultShape

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

Skutki: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

chlo.cosh (chlo::CoshOp)

Operator cosh

Składnia:

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

Zwraca Cosh(operand) dla każdego elementu.

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

Cechy: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Skutki: MemoryEffects::Effect{}

Operandy:

Wyniki:

chlo.digamma (chlo::DigammaOp)

Funkcja digamma

Składnia:

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

Zwraca Digamma(operand) dla każdego elementu.

Cechy: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Skutki: MemoryEffects::Effect{}

Operandy:

Wyniki:

chlo.erf (chlo::ErfOp)

Operator erfc

Składnia:

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

Oblicza funkcję błędu Gaussa dla każdego elementu x.

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

Cechy: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Skutki: MemoryEffects::Effect{}

Operandy:

Wyniki:

chlo.erf_inv (chlo::ErfInvOp)

Odwrotna funkcja błędu

Składnia:

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

Zwraca ErfInv(operand) dla każdego elementu.

Cechy: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Skutki: MemoryEffects::Effect{}

Operandy:

Wyniki:

chlo.erfc (chlo::ErfcOp)

Operator erfc

Składnia:

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

Oblicza przybliżenie uzupełniającej funkcji błędu (1 – erf(x)).

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

Cechy: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Skutki: MemoryEffects::Effect{}

Operandy:

Wyniki:

chlo.is_inf (chlo::IsInfOp)

Predykat IsInf

Składnia:

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

Zwraca informację, czy wartość jest elementem +/-inf.

Cechy: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultShape

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

Skutki: MemoryEffects::Effect{}

Operandy:

Wyniki:

chlo.is_neg_inf (chlo::IsNegInfOp)

Predykat IsNegInf

Składnia:

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

Zwraca wartość logiczną, która określa, czy wartość jest elementem -inf.

Cechy: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultShape

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

Skutki: MemoryEffects::Effect{}

Operandy:

Wyniki:

chlo.is_pos_inf (chlo::IsPosInfOp)

IsPosInf predicate

Składnia:

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

Zwraca wartość, która określa, czy wartość jest elementem +inf.

Cechy: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultShape

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

Skutki: MemoryEffects::Effect{}

Operandy:

Wyniki:

chlo.lgamma (chlo::LgammaOp)

Funkcja Lgamma

Składnia:

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

Zwraca Lgamma(operand) dla każdego elementu.

Cechy: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Skutki: MemoryEffects::Effect{}

Operandy:

Wyniki:

chlo.next_after (chlo::NextAfterOp)

Operator std::nextafter

Składnia:

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

Zwraca następną reprezentowaną wartość x w kierunku y, element po elemencie. Może też zwrócić liczbę podnormalną.

Odpowiednik funkcji std::nextafter w C++.

Cechy: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType

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

Skutki: MemoryEffects::Effect{}

Operandy:

Wyniki:

chlo.polygamma (chlo::PolygammaOp)

Funkcja poligamma

Składnia:

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

Zwraca Polygamma(operand, operand) dla każdego elementu.

Cechy: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType

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

Skutki: MemoryEffects::Effect{}

Operandy:

Wyniki:

chlo.ragged_dot (chlo::RaggedDotOp)

Oblicza matmul w jednym nieregularnym wymiarze

Ta operacja przyjmuje 3 argumenty tensorowe: lhs, rhs i group_sizes oraz atrybut „ragged_dot_dimension_numbers”. Podobnie jak w przypadku dot_general, argumenty lhs i rhs mogą mieć dowolne wymiary wsadowe i kontraktowe. Dodatkowo lewa strona musi mieć 1 wymiar nieregularny, a prawa strona może mieć co najwyżej 1 wymiar grupy. Operacja ma 3 tryby w zależności od rodzaju nierównego wymiaru po lewej stronie.

W trybie 1 sygnatura kształtu to [b,m,k], [g,b,k,n], [b,g] -> [b,m,n]. W tym przypadku nierówny wymiar to wymiar niekurczący się po lewej stronie (m). Wymiary b i k reprezentują odpowiednio wymiary wsadowe i kurczące się. Prawa strona musi zawierać wymiar grupy (g).

W trybie 2 sygnatura kształtu to [b,m,k], [b,k,n], [b,g] -> [g,b,m,n]. Wymiar nierówny jest tu wymiarem kurczącym się po lewej lub prawej stronie (k).

W trybie 3 sygnatura kształtu to [b,m,k], [b,k,n], [g] -> [b,m,n]. W tym przypadku nierówny wymiar to wymiar wsadu po lewej lub prawej stronie (b).

Cechy: AlwaysSpeculatableImplTrait

Interfejsy: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Skutki: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

chlo.scan (chlo::ScanOp)

Operacja skanowania

Stosuje funkcję redukcji body do inputs i inits wzdłuż dimension i tworzy results (składającą się z outputs i carries).

Jeśli is_reverse ma wartość Prawda, skanowanie jest przeprowadzane w odwrotnej kolejności. is_associative wskazuje, czy funkcja redukcji jest łączna.

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

Operacja ScanOp nie ma obecnie dekompozycji do StableHLO.

Cechy: AttrSizedOperandSegments, AttrSizedResultSegments, InferTensorType, IsolatedFromAbove, RecursiveMemoryEffects

Interfejsy: InferShapedTypeOpInterface, InferTypeOpInterface, OpAsmOpInterface

Atrybuty:

Operandy:

Wyniki:

chlo.sinh (chlo::SinhOp)

Operacja sinh

Składnia:

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

Zwraca Sinh(operand) dla każdego elementu.

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

Cechy: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Skutki: MemoryEffects::Effect{}

Operandy:

Wyniki:

chlo.square (chlo::SquareOp)

Operacja kwadratowa

Składnia:

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

Zwraca Square(operand) dla każdego elementu.

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

Cechy: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Skutki: MemoryEffects::Effect{}

Operandy:

Wyniki:

chlo.tan (chlo::TanOp)

Operacja tan

Składnia:

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

Zwraca Tan(operand) dla każdego elementu.

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

Cechy: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

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

Skutki: MemoryEffects::Effect{}

Operandy:

Wyniki:

chlo.top_k (chlo::TopKOp)

Znajduje wartości i indeksy k największych elementów w przypadku ostatniego wymiaru

Składnia:

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

Jeśli dane wejściowe są wektorem (ranga 1), funkcja znajduje k największych elementów w wektorze i zwraca ich wartości oraz indeksy w postaci wektorów. Zatem values[j] jest j-tym co do wielkości elementem w zbiorze input, a jego indeks to indices[j].

W przypadku macierzy (lub danych wejściowych wyższego rzędu) oblicza k największych wartości w każdym wierszu (lub wektorze wzdłuż ostatniego wymiaru). Wobec tego

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

Jeśli 2 elementy są równe, pierwszy wyświetla się element o niższym indeksie.

Cechy: AlwaysSpeculatableImplTrait, InferTensorType

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

Skutki: MemoryEffects::Effect{}

Atrybuty:

Operandy:

Wyniki:

chlo.zeta (chlo::ZetaOp)

Funkcja dzeta Hurwitza

Składnia:

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

Zwraca Zeta(operand, operand) dla każdego elementu.

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

Cechy: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType

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

Skutki: MemoryEffects::Effect{}

Operandy:

Wyniki:

Atrybuty

ComparisonDirectionAttr

Operacja porównania do wykonania.

Składnia:

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

Parametry:

ComparisonTypeAttr

Którego typu porównania użyć.

Składnia:

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

Parametry:

PrecisionAttr

Precyzja XLA dla operandu. Ma znaczenie specyficzne dla backendu.

Składnia:

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

Parametry:

RaggedDotDimensionNumbersAttr

Atrybut, który modeluje informacje o wymiarach dla nieregularnej kropki.

Parametry:

Wartości w polu enum

ComparisonDirection

Operacja porównania do wykonania.

Przypadki:

ComparisonType

Którego typu porównania użyć.

Przypadki:

Precyzja

Precyzja XLA dla operandu. Ma znaczenie specyficzne dla backendu.

Przypadki: