Phương ngữ 'chlo'

Client HLO Ops

Phương ngữ này chứa các thao tác phù hợp chặt chẽ với diện tích API của API XlaBuilder C++, trong đó các thao tác như vậy có ngữ nghĩa vượt xa những gì có trong các phương ngữ cấp thấp (chẳng hạn như stablehlo). Về cơ bản, bất cứ khi nào thư viện ứng dụng sử dụng cú pháp đơn giản hoặc thành phần của nhiều thao tác cho một lệnh gọi API, phương ngữ này sẽ cố gắng mô hình hoá lệnh gọi API và cung cấp các mẫu chuyển đổi để hiện thực hoá hoàn toàn thành các phương ngữ cấp thấp.

Hoạt động tính toán

chlo._asin_acos_kernel (chlo::AsinAcosKernelOp)

Toán tử AsinAcosKernel

Cú pháp:

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

Trả về AsinAcosKernel(operand) theo từng phần tử.

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

Hoạt động này được dùng làm giá trị trung gian trong quá trình phân tách và không bao giờ được các khung hình tạo trực tiếp hoặc được các phần phụ trợ sử dụng.

Đặc điểm: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

Giao diện: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Toán hạng:

Kết quả:

chlo.acos (chlo::AcosOp)

Toán tử Acos

Cú pháp:

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

Trả về Acos(operand) theo từng phần tử.

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

Đặc điểm: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

Giao diện: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Toán hạng:

Kết quả:

chlo.acosh (chlo::AcoshOp)

Thao tác Acosh

Cú pháp:

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

Trả về Acosh(operand) theo từng phần tử.

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

Đặc điểm: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

Giao diện: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Toán hạng:

Kết quả:

chlo.asin (chlo::AsinOp)

Toán tử Asin

Cú pháp:

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

Trả về Asin(operand) theo từng phần tử.

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

Đặc điểm: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

Giao diện: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Toán hạng:

Kết quả:

chlo.asinh (chlo::AsinhOp)

Thao tác Asinh

Cú pháp:

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

Trả về Asinh(operand) theo từng phần tử.

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

Đặc điểm: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

Giao diện: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Toán hạng:

Kết quả:

chlo.atan (chlo::AtanOp)

Toán tử Atan

Cú pháp:

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

Trả về Atan(operand) theo từng phần tử.

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

Đặc điểm: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

Giao diện: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Toán hạng:

Kết quả:

chlo.atanh (chlo::AtanhOp)

Toán tử Atanh

Cú pháp:

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

Trả về Atanh(operand) theo từng phần tử.

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

Đặc điểm: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

Giao diện: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Toán hạng:

Kết quả:

chlo.bessel_i1e (chlo::BesselI1eOp)

Hàm Bessel bậc 1

Cú pháp:

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

Trả về bessel_i1e(operand) theo từng phần tử.

Đặc điểm: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

Giao diện: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Toán hạng:

Kết quả:

chlo.broadcast_add (chlo::BroadcastAddOp)

Toán tử cộng (có thể chọn truyền tin)

Cú pháp:

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

Trả về lhs + rhs theo từng phần tử.

Xem tại https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

Đặc điểm: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, HLO_CompatibleOperandsAndResultElementType, InferTensorType

Giao diện: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Thuộc tính:

Toán hạng:

Kết quả:

chlo.broadcast_and (chlo::BroadcastAndOp)

Toán tử logic và (có thể chọn truyền tin)

Cú pháp:

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

Trả về logical_and(lhs, rhs) theo từng phần tử.

Xem tại https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

Đặc điểm: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, InferTensorType

Giao diện: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Thuộc tính:

Toán hạng:

Kết quả:

chlo.broadcast_atan2 (chlo::BroadcastAtan2Op)

Toán tử Atan2 (có thể chọn truyền tin)

Cú pháp:

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

Trả về atan2(lhs/rhs) theo từng phần tử.

Xem tại https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

Đặc điểm: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

Giao diện: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Thuộc tính:

Toán hạng:

Kết quả:

chlo.broadcast_compare (chlo::BroadcastCompareOp)

Toán tử so sánh (có thể chọn truyền tin)

Cú pháp:

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

So sánh lhs và rhs theo từng phần tử theo comparison_direction và compare_type. Nếu không được chỉ định, compare_type sẽ là FLOAT cho các loại phần tử có độ chính xác đơn, SIGNED cho các loại phần tử có dấu và UNSIGNED cho các loại phần tử không có dấu.

Xem tại https://www.tensorflow.org/xla/operation_semantics#element-wise_comparison_operations

Đặc điểm: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType

Giao diện: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Thuộc tính:

Toán hạng:

Kết quả:

chlo.broadcast_complex (chlo::BroadcastComplexOp)

Toán tử phức tạp (có thể chọn truyền tin)

Cú pháp:

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

Thực hiện quá trình chuyển đổi từng phần tử của một cặp giá trị thực và giá trị ảo thành một giá trị phức.

Đặc điểm: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType

Giao diện: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Thuộc tính:

Toán hạng:

Kết quả:

chlo.broadcast_divide (chlo::BroadcastDivOp)

Toán tử chia (có thể chọn truyền tin)

Cú pháp:

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

Trả về lhs / rhs theo từng phần tử.

Xem tại https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

Đặc điểm: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

Giao diện: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Thuộc tính:

Toán hạng:

Kết quả:

chlo.broadcast_maximum (chlo::BroadcastMaxOp)

Toán tử tối đa (có thể chọn truyền tin)

Cú pháp:

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

Trả về max(lhs, rhs) theo từng phần tử.

Xem tại https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

Đặc điểm: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, HLO_CompatibleOperandsAndResultElementType, InferTensorType

Giao diện: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Thuộc tính:

Toán hạng:

Kết quả:

chlo.broadcast_minimum (chlo::BroadcastMinOp)

Toán tử tối thiểu (có thể phát sóng)

Cú pháp:

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

Trả về min(lhs, rhs) theo từng phần tử.

Xem tại https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

Đặc điểm: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, HLO_CompatibleOperandsAndResultElementType, InferTensorType

Giao diện: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Thuộc tính:

Toán hạng:

Kết quả:

chlo.broadcast_multiply (chlo::BroadcastMulOp)

Toán tử nhân (có thể chọn truyền tin)

Cú pháp:

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

Trả về lhs * rhs theo từng phần tử.

Xem tại https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

Đặc điểm: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

Giao diện: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Thuộc tính:

Toán hạng:

Kết quả:

chlo.broadcast_next_after (chlo::BroadcastNextAfterOp)

Toán tử Std::nextafter (có thể chọn truyền tin)

Cú pháp:

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

Trả về giá trị có thể biểu thị tiếp theo của lhs theo hướng rhs, theo từng phần tử. Hàm này cũng có thể trả về một số dưới mức bình thường.

Tương đương với hàm std::nextafter của C++.

Đặc điểm: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

Giao diện: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Thuộc tính:

Toán hạng:

Kết quả:

chlo.broadcast_or (chlo::BroadcastOrOp)

Toán tử logic or (có thể chọn truyền tin)

Cú pháp:

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

Trả về logical_or(lhs, rhs) theo từng phần tử.

Xem tại https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

Đặc điểm: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, InferTensorType

Giao diện: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Thuộc tính:

Toán hạng:

Kết quả:

chlo.broadcast_polygamma (chlo::BroadcastPolygammaOp)

Hàm Polygamma (có thể chọn phát sóng)

Cú pháp:

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

Trả về Polygamma(operand, operand) theo từng phần tử.

Đặc điểm: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

Giao diện: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Thuộc tính:

Toán hạng:

Kết quả:

chlo.broadcast_power (chlo::BroadcastPowOp)

Toán tử luỹ thừa (có thể chọn phát sóng)

Cú pháp:

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

Trả về lhs ^ rhs theo từng phần tử.

Xem tại https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

Đặc điểm: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

Giao diện: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Thuộc tính:

Toán hạng:

Kết quả:

chlo.broadcast_remainder (chlo::BroadcastRemOp)

Toán tử số dư (có thể chọn truyền tin)

Cú pháp:

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

Trả về lhs % rhs theo từng phần tử.

Xem tại https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

Đặc điểm: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

Giao diện: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Thuộc tính:

Toán hạng:

Kết quả:

chlo.broadcast_select (chlo::BroadcastSelectOp)

Chọn toán tử (với tính năng truyền tin kiểu numpy không bắt buộc)

Cú pháp:

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

Tạo một mảng đầu ra từ các phần tử của hai mảng đầu vào, dựa trên các giá trị của một mảng vị từ.

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

Đặc điểm: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType

Giao diện: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Toán hạng:

Kết quả:

chlo.broadcast_shift_left (chlo::BroadcastShiftLeftOp)

Toán tử dịch trái (có thể truyền tin)

Cú pháp:

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

Trả về lhs << rhs theo từng phần tử.

Xem tại https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

Đặc điểm: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

Giao diện: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Thuộc tính:

Toán hạng:

Kết quả:

chlo.broadcast_shift_right_arithmetic (chlo::BroadcastShiftRightArithmeticOp)

Toán tử số học dịch phải (có thể chọn truyền tin)

Cú pháp:

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

Trả về lhs >> rhs theo từng phần tử.

Xem tại https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

Đặc điểm: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

Giao diện: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Thuộc tính:

Toán hạng:

Kết quả:

chlo.broadcast_shift_right_logical (chlo::BroadcastShiftRightLogicalOp)

Toán tử logic dịch chuyển bit sang phải (có thể chọn truyền tin)

Cú pháp:

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

Trả về lhs >> rhs theo từng phần tử.

Xem tại https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

Đặc điểm: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

Giao diện: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Thuộc tính:

Toán hạng:

Kết quả:

chlo.broadcast_subtract (chlo::BroadcastSubOp)

Toán tử trừ (có thể truyền tin không bắt buộc)

Cú pháp:

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

Trả về lhs - rhs theo từng phần tử.

Xem tại https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

Đặc điểm: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

Giao diện: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Thuộc tính:

Toán hạng:

Kết quả:

chlo.broadcast_xor (chlo::BroadcastXorOp)

Toán tử xor logic (có thể chọn truyền tin)

Cú pháp:

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

Trả về logical_xor(lhs, rhs) theo từng phần tử.

Xem tại https://www.tensorflow.org/xla/operation_semantics#element-wise_binary_arithmetic_operations

Đặc điểm: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, Commutative, HLO_BroadcastingElementwise, InferTensorType

Giao diện: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Thuộc tính:

Toán hạng:

Kết quả:

chlo.broadcast_zeta (chlo::BroadcastZetaOp)

Hàm zeta Hurwitz

Cú pháp:

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

Trả về Zeta(operand, operand) theo từng phần tử.

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

Đặc điểm: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultElementType

Giao diện: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Thuộc tính:

Toán hạng:

Kết quả:

chlo.conj (chlo::ConjOp)

Conj operator

Cú pháp:

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

Trả về Conj(operand) theo từng phần tử.

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

Đặc điểm: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

Giao diện: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Toán hạng:

Kết quả:

chlo.constant (chlo::ConstantOp)

Toán tử hằng số

Cú pháp:

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

Biểu thị một giá trị không đổi.

Đặc điểm: AlwaysSpeculatableImplTrait, ConstantLike

Giao diện: ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Thuộc tính:

Kết quả:

chlo.constant_like (chlo::ConstantLikeOp)

Toán tử tương tự hằng số

Trả về một hằng số splat có cùng hình dạng với toán hạng.

Đặc điểm: AlwaysSpeculatableImplTrait, CHLO_Broadcasting, HLO_BroadcastingElementwise, InferTensorType, SameOperandsAndResultShape

Giao diện: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Thuộc tính:

Toán hạng:

Kết quả:

chlo.cosh (chlo::CoshOp)

Toán tử Cosh

Cú pháp:

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

Trả về Cosh(operand) theo từng phần tử.

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

Đặc điểm: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

Giao diện: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Toán hạng:

Kết quả:

chlo.digamma (chlo::DigammaOp)

Hàm digamma

Cú pháp:

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

Trả về Digamma(operand) theo từng phần tử.

Đặc điểm: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

Giao diện: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Toán hạng:

Kết quả:

chlo.erf (chlo::ErfOp)

Toán tử Erfc

Cú pháp:

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

Tính hàm sai số Gauss của x theo từng phần tử.

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

Đặc điểm: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

Giao diện: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Toán hạng:

Kết quả:

chlo.erf_inv (chlo::ErfInvOp)

Hàm Erf nghịch đảo

Cú pháp:

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

Trả về ErfInv(operand) theo từng phần tử.

Đặc điểm: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

Giao diện: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Toán hạng:

Kết quả:

chlo.erfc (chlo::ErfcOp)

Toán tử Erfc

Cú pháp:

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

Tính toán giá trị gần đúng của hàm sai số bù (1 – erf(x)).

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

Đặc điểm: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

Giao diện: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Toán hạng:

Kết quả:

chlo.is_inf (chlo::IsInfOp)

Vị từ IsInf

Cú pháp:

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

Trả về liệu một giá trị có phải là phần tử +/-inf hay không.

Đặc điểm: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultShape

Giao diện: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Toán hạng:

Kết quả:

chlo.is_neg_inf (chlo::IsNegInfOp)

Vị từ IsNegInf

Cú pháp:

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

Trả về liệu một giá trị có phải là phần tử -inf hay không.

Đặc điểm: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultShape

Giao diện: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Toán hạng:

Kết quả:

chlo.is_pos_inf (chlo::IsPosInfOp)

Vị từ IsPosInf

Cú pháp:

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

Trả về liệu một giá trị có phải là phần tử +inf hay không.

Đặc điểm: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultShape

Giao diện: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Toán hạng:

Kết quả:

chlo.lgamma (chlo::LgammaOp)

Hàm Lgamma

Cú pháp:

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

Trả về Lgamma(operand) theo từng phần tử.

Đặc điểm: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

Giao diện: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Toán hạng:

Kết quả:

chlo.next_after (chlo::NextAfterOp)

Toán tử Std::nextafter

Cú pháp:

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

Trả về giá trị có thể biểu thị tiếp theo của x theo hướng y, theo từng phần tử. Hàm này cũng có thể trả về một số dưới mức bình thường.

Tương đương với hàm std::nextafter của C++.

Đặc điểm: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType

Giao diện: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Toán hạng:

Kết quả:

chlo.polygamma (chlo::PolygammaOp)

Hàm Polygamma

Cú pháp:

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

Trả về Polygamma(operand, operand) theo từng phần tử.

Đặc điểm: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType

Giao diện: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Toán hạng:

Kết quả:

chlo.ragged_dot (chlo::RaggedDotOp)

Tính toán matmul trên một phương diện không đồng đều duy nhất

Thao tác này lấy 3 đối số tensor: lhs, rhs và group_sizes, cùng một thuộc tính "ragged_dot_dimension_numbers". Giống như dot_general, lhs và rhs được phép có kích thước lô và kích thước thu hẹp tuỳ ý. Ngoài ra, lhs phải có một phương diện không đồng đều và rhs có thể có tối đa một phương diện nhóm. Op này có 3 chế độ, tuỳ thuộc vào loại phương diện không đồng đều lhs.

Ở chế độ 1, chữ ký hình dạng là [b,m,k], [g,b,k,n], [b,g] -> [b,m,n]. Ở đây, phương diện không đồng đều là một phương diện không thu hẹp lhs (m). Các phương diện b và k lần lượt biểu thị phương diện theo lô và phương diện thu hẹp. rhs phải có một phương diện nhóm (g).

Ở chế độ 2, chữ ký hình dạng là [b,m,k], [b,k,n], [b,g] -> [g,b,m,n]. Ở đây, phương diện không đồng đều là phương diện thu hẹp lhs/rhs (k).

Ở chế độ 3, chữ ký hình dạng là [b,m,k], [b,k,n], [g] -> [b,m,n]. Ở đây, phương diện không đồng đều là phương diện lô lhs/rhs (b).

Đặc điểm: AlwaysSpeculatableImplTrait

Giao diện: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Thuộc tính:

Toán hạng:

Kết quả:

chlo.scan (chlo::ScanOp)

Thao tác quét

Áp dụng hàm giảm body cho inputs và inits dọc theo dimension và tạo ra results (bao gồm outputs và carries).

Nếu is_reverse là true, thì quá trình quét sẽ được thực hiện theo thứ tự ngược lại. is_associative cho biết liệu hàm giảm có mang tính kết hợp hay không.

Xem tại: https://www.tensorflow.org/xla/operation_semantics#scan

ScanOp hiện không có quá trình phân tách thành StableHLO.

Đặc điểm: AttrSizedOperandSegments, AttrSizedResultSegments, InferTensorType, IsolatedFromAbove, RecursiveMemoryEffects

Giao diện: InferShapedTypeOpInterface, InferTypeOpInterface, OpAsmOpInterface

Thuộc tính:

Toán hạng:

Kết quả:

chlo.sinh (chlo::SinhOp)

Phép toán sinh

Cú pháp:

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

Trả về Sinh(operand) theo từng phần tử.

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

Đặc điểm: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

Giao diện: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Toán hạng:

Kết quả:

chlo.square (chlo::SquareOp)

Phép toán bình phương

Cú pháp:

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

Trả về Square(operand) theo từng phần tử.

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

Đặc điểm: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

Giao diện: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Toán hạng:

Kết quả:

chlo.tan (chlo::TanOp)

Phép toán Tan

Cú pháp:

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

Trả về Tan(operand) theo từng phần tử.

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

Đặc điểm: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType, Elementwise, SameOperandsAndResultShape

Giao diện: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Toán hạng:

Kết quả:

chlo.top_k (chlo::TopKOp)

Tìm giá trị và chỉ mục của k phần tử lớn nhất cho phương diện cuối cùng

Cú pháp:

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

Nếu dữ liệu đầu vào là một vectơ (hạng 1), hàm này sẽ tìm k mục nhập lớn nhất trong vectơ và xuất giá trị cũng như chỉ mục của các mục nhập đó dưới dạng vectơ. Do đó, values[j] là mục nhập lớn thứ j trong input và chỉ mục của mục nhập này là indices[j].

Đối với ma trận (tương ứng với đầu vào có thứ hạng cao hơn), hãy tính toán k mục nhập hàng đầu trong mỗi hàng (tương ứng với vectơ dọc theo phương diện cuối cùng). Do đó,

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

Nếu hai phần tử bằng nhau, phần tử có chỉ mục thấp hơn sẽ xuất hiện trước.

Đặc điểm: AlwaysSpeculatableImplTrait, InferTensorType

Giao diện: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Thuộc tính:

Toán hạng:

Kết quả:

chlo.zeta (chlo::ZetaOp)

Hàm zeta Hurwitz

Cú pháp:

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

Trả về Zeta(operand, operand) theo từng phần tử.

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

Đặc điểm: AlwaysSpeculatableImplTrait, CompatibleOperandsAndResultType

Giao diện: ConditionallySpeculatable, InferShapedTypeOpInterface, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface)

Hiệu ứng: MemoryEffects::Effect{}

Toán hạng:

Kết quả:

Thuộc tính

ComparisonDirectionAttr

Thao tác so sánh cần thực hiện.

Cú pháp:

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

Các thông số:

ComparisonTypeAttr

Loại so sánh cần sử dụng.

Cú pháp:

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

Các thông số:

PrecisionAttr

Độ chính xác XLA cho một toán hạng. Có ý nghĩa cụ thể đối với phần phụ trợ.

Cú pháp:

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

Các thông số:

RaggedDotDimensionNumbersAttr

Thuộc tính mô hình hoá thông tin về phương diện cho dấu chấm không đều.

Các thông số:

Enum

ComparisonDirection

Thao tác so sánh cần thực hiện.

Hộp đựng:

ComparisonType

Loại so sánh cần sử dụng.

Hộp đựng:

Chính xác

Độ chính xác XLA cho một toán hạng. Có ý nghĩa cụ thể đối với phần phụ trợ.

Hộp đựng: