'chlo' Dialect

Client HLO Ops

इस डायलेक्ट में ऐसे ऑपरेशंस शामिल होते हैं जो XlaBuilder C++ API के एपीआई सर्फ़ेस एरिया के साथ काफ़ी हद तक अलाइन होते हैं. ऐसे ऑपरेशंस में ऐसी सिमैंटिक्स होती हैं जो लोअर लेवल के डायलेक्ट (जैसे, stablehlo) में मौजूद सिमैंटिक्स से अलग होती हैं. असल में, जब भी क्लाइंट लाइब्रेरी किसी एपीआई कॉल के लिए सिंटैक्टिक शुगर या कई ऑपरेशंस के कंपोज़िशन का इस्तेमाल करती है, तो यह डायलेक्ट एपीआई कॉल को मॉडल करने की कोशिश करता है. साथ ही, लोअर लेवल के डायलेक्ट में पूरी तरह से बदलने के लिए कन्वर्ज़न पैटर्न उपलब्ध कराता है.

कार्रवाइयां

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)

पहले क्रम का बेसल फ़ंक्शन

सिंटैक्स:

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)

लॉजिकल एंड ऑपरेटर (ब्रॉडकास्ट करने का विकल्प)

सिंटैक्स:

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, फ़्लोट होता है. वहीं, साइंड एलिमेंट टाइप के लिए 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)

हर्विट्ज़ ज़ेटा फ़ंक्शन

सिंटैक्स:

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)

स्थिरता से जुड़े ऑपरेटर

यह फ़ंक्शन, ऑपरेंड के आकार के बराबर स्प्लैट कॉन्स्टेंट दिखाता है.

ट्रेट: 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)

Digamma function

सिंटैक्स:

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)

Inverse 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 predicate

सिंटैक्स:

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 का हिसाब लगाता है

इस ऑपरेशन में तीन टेंसर आर्ग्युमेंट---lhs, rhs, और group_sizes---और "ragged_dot_dimension_numbers" एट्रिब्यूट का इस्तेमाल किया जाता है. dot_general की तरह, lhs और rhs को आर्बिट्ररी बैच और कॉन्ट्रैक्टिंग डाइमेंशन की अनुमति है. इसके अलावा, एलएचएस में एक रैग्ड डाइमेंशन होना ज़रूरी है. साथ ही, आरएचएस में ज़्यादा से ज़्यादा एक ग्रुप डाइमेंशन हो सकता है. एलएचएस रैग्ड डाइमेंशन के आधार पर, इस ऑपरेटर के तीन मोड होते हैं.

मोड 1 में, शेप-सिग्नेचर [b,m,k], [g,b,k,n], [b,g] -> [b,m,n] होता है. यहां, रैग्ड डाइमेंशन, एलएचएस नॉन-कॉन्ट्रैक्टिंग डाइमेंशन (m) है. डाइमेंशन b और k, बैच और कॉन्ट्रैक्टिंग डाइमेंशन को दिखाते हैं. आरएचएस में ग्रुप डाइमेंशन (g) होना ज़रूरी है.

मोड 2 में, शेप-सिग्नेचर [b,m,k], [b,k,n], [b,g] -> [g,b,m,n] होता है. यहां, रैग्ड डाइमेंशन, एलएचएस/आरएचएस कॉन्ट्रैक्टिंग डाइमेंशन (k) है.

मोड 3 में, शेप-सिग्नेचर [b,m,k], [b,k,n], [g] -> [b,m,n] है. यहां रैग्ड डाइमेंशन, एलएचएस/आरएचएस बैच डाइमेंशन (b) है.

विशेषताएं: AlwaysSpeculatableImplTrait

इंटरफ़ेस: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

असर: MemoryEffects::Effect{}

विशेषताएं:

ऑपरेंड:

नतीजे:

chlo.scan (chlo::ScanOp)

स्कैन करने की प्रोसेस

यह फ़ंक्शन, dimension के साथ-साथ inputs और inits पर रिडक्शन फ़ंक्शन body लागू करता है. साथ ही, results (जिसमें outputs और carries शामिल हैं) बनाता है.

अगर is_reverse की वैल्यू 'सही है' पर सेट है, तो स्कैन उल्टे क्रम में किया जाता है. 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)

हर्विट्ज़ ज़ेटा फ़ंक्शन

सिंटैक्स:

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

यह एट्रिब्यूट, रैग्ड डॉट के लिए डाइमेंशन की जानकारी को मॉडल करता है.

पैरामीटर:

Enums

ComparisonDirection

तुलना करने के लिए कौनसी कार्रवाई करनी है.

केस:

ComparisonType

तुलना करने के लिए किस तरह का ऑपरेटर इस्तेमाल करना है.

केस:

स्पष्टता

किसी ऑपरेंड के लिए XLA की सटीक वैल्यू. इसका मतलब बैकएंड के हिसाब से अलग होता है.

केस: