'chlo' 다이얼렉트

Client HLO Ops

이 다이얼렉트에는 XlaBuilder C++ API의 API 표면 영역과 밀접하게 정렬되는 작업이 포함되어 있습니다. 이러한 작업에는 하위 수준 다이얼렉트 (예: stablehlo)에 있는 것 이상의 의미가 있습니다. 기본적으로 클라이언트 라이브러리가 API 호출에 구문 설탕이나 여러 작업의 구성을 사용하는 경우 이 다이얼렉트는 API 호출을 모델링하고 하위 수준 다이얼렉트로 완전히 구체화되는 변환 패턴을 제공하려고 합니다.

작업

chlo._asin_acos_kernel (chlo::AsinAcosKernelOp)

AsinAcosKernel 연산자

구문:

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

AsinAcosKernel(operand)을 요소별로 반환합니다.

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

이 작업은 분해에서 중간 값으로 사용되며 프레임워크에서 직접 구성하거나 백엔드에서 소비해서는 안 됩니다.

특성: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

인터페이스: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

피연산자:

결과:

chlo.acos (chlo::AcosOp)

Acos 연산자

구문:

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

Acos(operand)을 요소별로 반환합니다.

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

특성: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

인터페이스: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

피연산자:

결과:

chlo.acosh (chlo::AcoshOp)

Acosh 작업

구문:

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

Acosh(operand)을 요소별로 반환합니다.

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

특성: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

인터페이스: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

피연산자:

결과:

chlo.asin (chlo::AsinOp)

Asin 연산자

구문:

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

Asin(operand)을 요소별로 반환합니다.

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

특성: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

인터페이스: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

피연산자:

결과:

chlo.asinh (chlo::AsinhOp)

asinh 작업

구문:

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

Asinh(operand)을 요소별로 반환합니다.

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

특성: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

인터페이스: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

피연산자:

결과:

chlo.atan (chlo::AtanOp)

Atan 연산자

구문:

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

Atan(operand)을 요소별로 반환합니다.

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

특성: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

인터페이스: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

피연산자:

결과:

chlo.atanh (chlo::AtanhOp)

Atanh 연산자

구문:

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

Atanh(operand)을 요소별로 반환합니다.

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

특성: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

인터페이스: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

피연산자:

결과:

chlo.bessel_i1e (chlo::BesselI1eOp)

1차 베셀 함수

구문:

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

bessel_i1e(operand)을 요소별로 반환합니다.

특성: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

인터페이스: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

피연산자:

결과:

chlo.broadcast_add (chlo::BroadcastAddOp)

더하기 연산자 (선택적 브로드캐스팅 포함)

구문:

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

lhs + rhs을 요소별로 반환합니다.

https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations를 참고하세요.

특성: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, HLO_CompatibleOperandsAndResultElementType, InferTensorType

인터페이스: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

속성:

피연산자:

결과:

chlo.broadcast_and (chlo::BroadcastAndOp)

논리적 and 연산자 (선택적 브로드캐스팅 포함)

구문:

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

logical_and(lhs, rhs)을 요소별로 반환합니다.

https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations를 참고하세요.

특성: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, InferTensorType

인터페이스: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

속성:

피연산자:

결과:

chlo.broadcast_atan2 (chlo::BroadcastAtan2Op)

Atan2 연산자 (선택적 브로드캐스팅 포함)

구문:

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

atan2(lhs/rhs)을 요소별로 반환합니다.

https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations를 참고하세요.

특성: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

인터페이스: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

속성:

피연산자:

결과:

chlo.broadcast_compare (chlo::BroadcastCompareOp)

비교 연산자 (선택적 브로드캐스팅 포함)

구문:

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

comparison_direction 및 compare_type에 따라 lhs와 rhs을 요소별로 비교합니다. 지정하지 않으면 compare_type은 부동 소수점 요소 유형의 경우 FLOAT, 부호 있는 요소 유형의 경우 SIGNED, 부호 없는 요소 유형의 경우 UNSIGNED입니다.

https://www.tensorflow.org/xla/operation_semantics#element-wise_comparison_operations를 참고하세요.

특성: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType

인터페이스: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

속성:

피연산자:

결과:

chlo.broadcast_complex (chlo::BroadcastComplexOp)

복잡한 연산자 (선택적 브로드캐스팅 포함)

구문:

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

실수와 허수 값의 쌍을 복소수 값으로 요소별로 변환합니다.

특성: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType

인터페이스: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

속성:

피연산자:

결과:

chlo.broadcast_divide (chlo::BroadcastDivOp)

나누기 연산자 (선택적 브로드캐스팅 포함)

구문:

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

lhs / rhs을 요소별로 반환합니다.

https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations를 참고하세요.

특성: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

인터페이스: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

속성:

피연산자:

결과:

chlo.broadcast_maximum (chlo::BroadcastMaxOp)

최대 연산자 (선택적 브로드캐스팅 포함)

구문:

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

max(lhs, rhs)을 요소별로 반환합니다.

https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations를 참고하세요.

특성: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, HLO_CompatibleOperandsAndResultElementType, InferTensorType

인터페이스: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

속성:

피연산자:

결과:

chlo.broadcast_minimum (chlo::BroadcastMinOp)

최소 연산자 (선택적 브로드캐스팅 포함)

구문:

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

min(lhs, rhs)을 요소별로 반환합니다.

https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations를 참고하세요.

특성: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, HLO_CompatibleOperandsAndResultElementType, InferTensorType

인터페이스: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

속성:

피연산자:

결과:

chlo.broadcast_multiply (chlo::BroadcastMulOp)

곱셈 연산자 (선택적 브로드캐스팅 포함)

구문:

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

lhs * rhs을 요소별로 반환합니다.

https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations를 참고하세요.

특성: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

인터페이스: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

속성:

피연산자:

결과:

chlo.broadcast_next_after (chlo::BroadcastNextAfterOp)

Std::nextafter 연산자 (선택적 브로드캐스팅 포함)

구문:

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

rhs 방향으로 lhs의 다음 표현 가능한 값을 요소별로 반환합니다. 비정상적인 숫자를 반환할 수도 있습니다.

C++ std::nextafter 함수와 동일합니다.

특성: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

인터페이스: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

속성:

피연산자:

결과:

chlo.broadcast_or (chlo::BroadcastOrOp)

논리적 or 연산자 (선택적 브로드캐스팅 포함)

구문:

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

logical_or(lhs, rhs)을 요소별로 반환합니다.

https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations를 참고하세요.

특성: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, InferTensorType

인터페이스: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

속성:

피연산자:

결과:

chlo.broadcast_polygamma (chlo::BroadcastPolygammaOp)

폴리감마 함수 (선택적 브로드캐스팅 포함)

구문:

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

Polygamma(operand, operand)을 요소별로 반환합니다.

특성: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

인터페이스: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

속성:

피연산자:

결과:

chlo.broadcast_power (chlo::BroadcastPowOp)

거듭제곱 연산자 (선택적 브로드캐스팅 포함)

구문:

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

lhs ^ rhs을 요소별로 반환합니다.

https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations를 참고하세요.

특성: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

인터페이스: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

속성:

피연산자:

결과:

chlo.broadcast_remainder (chlo::BroadcastRemOp)

나머지 연산자 (선택적 브로드캐스팅 포함)

구문:

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

lhs % rhs을 요소별로 반환합니다.

https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations를 참고하세요.

특성: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

인터페이스: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

속성:

피연산자:

결과:

chlo.broadcast_select (chlo::BroadcastSelectOp)

연산자 선택 (선택사항인 numpy 스타일 브로드캐스팅 포함)

구문:

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

술어 배열의 값을 기반으로 두 입력 배열의 요소에서 출력 배열을 구성합니다.

https://www.tensorflow.org/xla/operation_semantics#select를 참고하세요.

특성: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType

인터페이스: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

피연산자:

결과:

chlo.broadcast_shift_left (chlo::BroadcastShiftLeftOp)

왼쪽 시프트 연산자 (선택적 브로드캐스팅 포함)

구문:

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

lhs << rhs을 요소별로 반환합니다.

https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations를 참고하세요.

특성: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

인터페이스: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

속성:

피연산자:

결과:

chlo.broadcast_shift_right_arithmetic (chlo::BroadcastShiftRightArithmeticOp)

산술 오른쪽 시프트 연산자 (선택적 브로드캐스팅 포함)

구문:

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

lhs >> rhs을 요소별로 반환합니다.

https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations를 참고하세요.

특성: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

인터페이스: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

속성:

피연산자:

결과:

chlo.broadcast_shift_right_logical (chlo::BroadcastShiftRightLogicalOp)

오른쪽 시프트 논리 연산자 (선택적 브로드캐스팅 포함)

구문:

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

lhs >> rhs을 요소별로 반환합니다.

https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations를 참고하세요.

특성: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

인터페이스: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

속성:

피연산자:

결과:

chlo.broadcast_subtract (chlo::BroadcastSubOp)

빼기 연산자 (선택적 브로드캐스팅 포함)

구문:

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

lhs - rhs을 요소별로 반환합니다.

https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations를 참고하세요.

특성: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

인터페이스: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

속성:

피연산자:

결과:

chlo.broadcast_xor (chlo::BroadcastXorOp)

논리 xor 연산자 (선택적 브로드캐스팅 포함)

구문:

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

logical_xor(lhs, rhs)을 요소별로 반환합니다.

https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations를 참고하세요.

특성: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, InferTensorType

인터페이스: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

속성:

피연산자:

결과:

chlo.broadcast_zeta (chlo::BroadcastZetaOp)

Hurwitz zeta 함수

구문:

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

Zeta(operand, operand)을 요소별로 반환합니다.

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

특성: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

인터페이스: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

속성:

피연산자:

결과:

chlo.conj (chlo::ConjOp)

Conj 연산자

구문:

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

Conj(operand)을 요소별로 반환합니다.

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

특성: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

인터페이스: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

피연산자:

결과:

chlo.constant (chlo::ConstantOp)

상수 연산자

구문:

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

상수 값을 나타냅니다.

특성: AlwaysSpeculatableImplTrait, ConstantLike

인터페이스: ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

속성:

결과:

chlo.constant_like (chlo::ConstantLikeOp)

Constant like operator

피연산자와 모양이 동일한 스플랫 상수를 반환합니다.

특성: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultShape

인터페이스: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

속성:

피연산자:

결과:

chlo.cosh (chlo::CoshOp)

Cosh 연산자

구문:

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

Cosh(operand)을 요소별로 반환합니다.

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

특성: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

인터페이스: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

피연산자:

결과:

chlo.digamma (chlo::DigammaOp)

디감마 함수

구문:

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

Digamma(operand)을 요소별로 반환합니다.

특성: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

인터페이스: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

피연산자:

결과:

chlo.erf (chlo::ErfOp)

Erfc 연산자

구문:

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

x의 가우스 오차 함수를 요소별로 계산합니다.

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

특성: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

인터페이스: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

피연산자:

결과:

chlo.erf_inv (chlo::ErfInvOp)

역 Erf

구문:

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

ErfInv(operand)을 요소별로 반환합니다.

특성: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

인터페이스: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

피연산자:

결과:

chlo.erfc (chlo::ErfcOp)

Erfc 연산자

구문:

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

오차 함수 보수 (1 - erf(x))의 근삿값을 계산합니다.

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

특성: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

인터페이스: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

피연산자:

결과:

chlo.is_inf (chlo::IsInfOp)

IsInf 술어

구문:

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

값이 +/-inf 요소별인지 반환합니다.

특성: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultShape

인터페이스: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

피연산자:

결과:

chlo.is_neg_inf (chlo::IsNegInfOp)

IsNegInf predicate

구문:

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

값이 -inf 요소별인지 반환합니다.

특성: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultShape

인터페이스: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

피연산자:

결과:

chlo.is_pos_inf (chlo::IsPosInfOp)

IsPosInf predicate

구문:

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

값이 +inf 요소별인지 반환합니다.

특성: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultShape

인터페이스: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

피연산자:

결과:

chlo.lgamma (chlo::LgammaOp)

Lgamma 함수

구문:

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

Lgamma(operand)을 요소별로 반환합니다.

특성: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

인터페이스: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

피연산자:

결과:

chlo.next_after (chlo::NextAfterOp)

Std::nextafter 연산자

구문:

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

y 방향으로 x의 다음 표현 가능한 값을 요소별로 반환합니다. 비정상적인 숫자를 반환할 수도 있습니다.

C++ std::nextafter 함수와 동일합니다.

특성: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType

인터페이스: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

피연산자:

결과:

chlo.polygamma (chlo::PolygammaOp)

폴리감마 함수

구문:

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

Polygamma(operand, operand)을 요소별로 반환합니다.

특성: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType

인터페이스: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

피연산자:

결과:

chlo.ragged_dot (chlo::RaggedDotOp)

단일 러그드 차원에 대한 matmul을 계산합니다.

이 작업은 텐서 인수 3개(lhs, rhs, group_sizes)와 'ragged_dot_dimension_numbers' 속성을 사용합니다. dot_general과 마찬가지로 lhs와 rhs는 임의의 배치 및 축소 차원이 허용됩니다. 또한 lhs에는 불규칙한 차원이 하나 있어야 하고 rhs에는 최대 하나의 그룹 차원이 있을 수 있습니다. 이 작업에는 lhs 불규칙 차원의 종류에 따라 세 가지 모드가 있습니다.

모드 1에서 모양 서명은 [b,m,k], [g,b,k,n], [b,g] -> [b,m,n]입니다. 여기서 불규칙한 차원은 lhs 비축약형 차원 (m)입니다. b 및 k 차원은 각각 배치 및 축약형 차원을 나타냅니다. rhs에는 그룹 측정기준 (g)이 있어야 합니다.

모드 2에서 모양 서명은 [b,m,k], [b,k,n], [b,g] -> [g,b,m,n]입니다. 여기서 불규칙한 차원은 lhs/rhs 축소 차원 (k)입니다.

모드 3에서 모양 서명은 [b,m,k], [b,k,n], [g] -> [b,m,n]입니다. 여기서 불규칙한 차원은 lhs/rhs 배치 차원 (b)입니다.

특성: AlwaysSpeculatableImplTrait

인터페이스: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

속성:

피연산자:

결과:

chlo.scan (chlo::ScanOp)

스캔 작업

dimension를 따라 inputs 및 inits에 감소 함수 body를 적용하고 results (outputs 및 carries로 구성됨)를 생성합니다.

is_reverse이 true이면 역순으로 스캔이 실행됩니다. is_associative은 감소 함수가 결합적인지 여부를 나타냅니다.

참고: https://www.tensorflow.org/xla/operation_semantics#scan

ScanOp에는 현재 StableHLO로의 분해가 없습니다.

특성: AttrSizedOperandSegments, AttrSizedResultSegments, InferTensorType, IsolatedFromAbove, RecursiveMemoryEffects

인터페이스: InferShapedTypeOpInterface, InferTypeOpInterface, OpAsmOpInterface

속성:

피연산자:

결과:

chlo.sinh (chlo::SinhOp)

Sinh 작업

구문:

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

Sinh(operand)을 요소별로 반환합니다.

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

특성: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

인터페이스: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

피연산자:

결과:

chlo.square (chlo::SquareOp)

제곱 연산

구문:

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

Square(operand)을 요소별로 반환합니다.

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

특성: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

인터페이스: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

피연산자:

결과:

chlo.tan (chlo::TanOp)

탄젠트 연산

구문:

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

Tan(operand)을 요소별로 반환합니다.

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

특성: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

인터페이스: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

피연산자:

결과:

chlo.top_k (chlo::TopKOp)

마지막 차원에서 k개의 가장 큰 요소의 값과 색인을 찾습니다.

구문:

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

입력이 벡터 (순위 1)인 경우 벡터에서 k개의 가장 큰 항목을 찾아 값과 색인을 벡터로 출력합니다. 따라서 values[j]는 input에서 j번째로 큰 항목이며 색인은 indices[j]입니다.

행렬 (또는 고차원 입력)의 경우 각 행 (또는 마지막 차원을 따라가는 벡터)에서 상위 k개의 항목을 계산합니다. 따라서

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

두 요소가 동일하면 인덱스가 낮은 요소가 먼저 표시됩니다.

특성: AlwaysSpeculatableImplTrait, InferTensorType

인터페이스: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

속성:

피연산자:

결과:

chlo.zeta (chlo::ZetaOp)

Hurwitz zeta 함수

구문:

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

Zeta(operand, operand)을 요소별로 반환합니다.

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

특성: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType

인터페이스: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

효과: MemoryEffects::Effect{}

피연산자:

결과:

속성

ComparisonDirectionAttr

실행할 비교 작업입니다.

구문:

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

매개변수:

ComparisonTypeAttr

사용할 비교 유형입니다.

구문:

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

매개변수:

PrecisionAttr

피연산자의 XLA 정밀도입니다. 백엔드별 의미가 있습니다.

구문:

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

매개변수:

RaggedDotDimensionNumbersAttr

들쭉날쭉한 점의 측정기준 정보를 모델링하는 속성입니다.

매개변수:

열거형

ComparisonDirection

실행할 비교 작업입니다.

케이스:

ComparisonType

사용할 비교 유형입니다.

케이스:

정밀도

피연산자의 XLA 정밀도입니다. 백엔드별 의미가 있습니다.

케이스: