StableHLO স্পেসিফিকেশন

StableHLO হল মেশিন লার্নিং (ML) মডেলে উচ্চ-স্তরের অপারেশনের (HLO) জন্য একটি অপারেশন সেট। StableHLO বিভিন্ন ML ফ্রেমওয়ার্ক এবং ML কম্পাইলারগুলির মধ্যে একটি পোর্টেবিলিটি স্তর হিসাবে কাজ করে: ML ফ্রেমওয়ার্কগুলি যেগুলি StableHLO প্রোগ্রামগুলি তৈরি করে সেগুলি ML কম্পাইলারগুলির সাথে সামঞ্জস্যপূর্ণ যেগুলি StableHLO প্রোগ্রামগুলি ব্যবহার করে৷

আমাদের লক্ষ্য হল বিভিন্ন ML ফ্রেমওয়ার্ক (যেমন TensorFlow, JAX এবং PyTorch) এবং ML কম্পাইলার (যেমন XLA এবং IREE) এর মধ্যে আরও আন্তঃকার্যযোগ্যতা তৈরি করে ML বিকাশকে সহজ করা এবং ত্বরান্বিত করা। সেই শেষের দিকে, এই নথিটি StableHLO প্রোগ্রামিং ভাষার জন্য একটি স্পেসিফিকেশন প্রদান করে।

এই স্পেসিফিকেশন তিনটি প্রধান বিভাগ রয়েছে. প্রথমত, প্রোগ্রাম বিভাগটি StableHLO প্রোগ্রামগুলির গঠন বর্ণনা করে যা StableHLO ফাংশন নিয়ে গঠিত যা নিজেরাই StableHLO ops নিয়ে গঠিত। সেই কাঠামোর মধ্যে, Ops বিভাগটি পৃথক অপ্সের শব্দার্থবিদ্যা নির্দিষ্ট করে। এক্সিকিউশন বিভাগটি একটি প্রোগ্রামের মধ্যে একসাথে এই সমস্ত অপারেশন চালানোর জন্য শব্দার্থবিদ্যা প্রদান করে। অবশেষে, স্বরলিপি বিভাগটি স্পেসিফিকেশন জুড়ে ব্যবহৃত স্বরলিপি নিয়ে আলোচনা করে।

প্রোগ্রাম

Program ::= {Func}

StableHLO প্রোগ্রামগুলি একটি নির্বিচারে StableHLO ফাংশন নিয়ে গঠিত। নিচে @main ফাংশন সহ একটি উদাহরণ প্রোগ্রাম রয়েছে যাতে 3টি ইনপুট ( %image , %weights এবং %bias ) এবং 1টি আউটপুট রয়েছে। ফাংশনের শরীরে 6টি অপ্স আছে।

func.func @main(
  %image: tensor<28x28xf32>,
  %weights: tensor<784x10xf32>,
  %bias: tensor<1x10xf32>
) -> tensor<1x10xf32> {
  %0 = "stablehlo.reshape"(%image) : (tensor<28x28xf32>) -> tensor<1x784xf32>
  %1 = "stablehlo.dot"(%0, %weights) : (tensor<1x784xf32>, tensor<784x10xf32>) -> tensor<1x10xf32>
  %2 = "stablehlo.add"(%1, %bias) : (tensor<1x10xf32>, tensor<1x10xf32>) -> tensor<1x10xf32>
  %3 = "stablehlo.constant"() {value = dense<0.0> : tensor<1x10xf32>} : () -> tensor<1x10xf32>
  %4 = "stablehlo.maximum"(%2, %3) : (tensor<1x10xf32>, tensor<1x10xf32>) -> tensor<1x10xf32>
  "func.return"(%4): (tensor<1x10xf32>) -> ()
}

ফাংশন

Func        ::= 'func' '.' 'func' FuncId FuncInputs FuncOutputs '{' FuncBody '}'
FuncInputs  ::= '(' [FuncInput {',' FuncInput}] `)`
FuncInput   ::= ValueId ':' ValueType
FuncOutputs ::= ['->' FuncOutput, {',' FuncOutput}]
FuncOutput  ::= ValueType
FuncBody    ::= {Op}

StableHLO ফাংশন (যাকে ফাংশন নামেও ডাকা হয়) এর একটি শনাক্তকারী, ইনপুট/আউটপুট এবং একটি বডি থাকে। ভবিষ্যতে, আমরা HLO ( #425 , #626 , #740 , #744 ) এর সাথে আরও ভাল সামঞ্জস্য অর্জনের জন্য ফাংশনের জন্য অতিরিক্ত মেটাডেটা চালু করার পরিকল্পনা করছি।

শনাক্তকারী

FuncId  ::= '@' letter {letter | digit}
ValueId ::= '%' digit {digit}
          | '%' letter {letter | digit}
letter  ::= 'a' | ... | 'z' | 'A' | ... | 'Z' | '_'
digit   ::= '0' | ... | '9'

StableHLO শনাক্তকারী অনেক প্রোগ্রামিং ভাষায় শনাক্তকারীর মতো, দুটি বিশেষত্ব সহ: 1) সমস্ত শনাক্তকারীর সিগিল থাকে যা বিভিন্ন ধরণের শনাক্তকারীকে আলাদা করে, 2) স্ট্যাবলএইচএলও প্রোগ্রামের প্রজন্মকে সহজ করার জন্য মান শনাক্তকারী সম্পূর্ণরূপে সংখ্যাসূচক হতে পারে।

প্রকারভেদ

Type         ::= ValueType | NonValueType
ValueType    ::= TensorType | QuantizedTensorType | TokenType | TupleType
NonValueType ::= TensorElementType | QuantizedTensorElementType | FunctionType | StringType

StableHLO প্রকারগুলিকে মান প্রকারে শ্রেণীবদ্ধ করা হয় (যাকে প্রথম-শ্রেণীর প্রকারও বলা হয়) যা StableHLO মান এবং অ-মূল্য প্রকারের প্রতিনিধিত্ব করে যা অন্যান্য প্রোগ্রাম উপাদানগুলিকে বর্ণনা করে। StableHLO প্রকারগুলি অনেক প্রোগ্রামিং ল্যাঙ্গুয়েজের প্রকারের মতই, যার প্রধান বিশেষত্ব হল StableHLO-এর ডোমেন-নির্দিষ্ট প্রকৃতি যার ফলে কিছু অস্বাভাবিক ফলাফল দেখা যায় (যেমন স্কেলার প্রকারগুলি মান প্রকার নয়)।

TensorType ::= 'tensor' '<' Shape TensorElementType '>'
Shape ::= {DimensionSize 'x'}
DimensionSize ::= digit {digit} | '?'

টেনসরের ধরনগুলি টেনসরকে প্রতিনিধিত্ব করে, যেমন বহুমাত্রিক অ্যারে। তাদের একটি আকৃতি এবং একটি উপাদানের ধরন রয়েছে, যেখানে একটি আকৃতি 0 থেকে R-1 পর্যন্ত সংখ্যাযুক্ত সংশ্লিষ্ট মাত্রাগুলির (যাকে অক্ষও বলা হয়) এর আরোহী ক্রমে নন-নেতিবাচক বা অজানা মাত্রার আকারগুলিকে প্রতিনিধিত্ব করে। R মাত্রার সংখ্যাকে র‌্যাঙ্ক বলা হয়। উদাহরণস্বরূপ, tensor<2x3xf32> আকৃতি 2x3 এবং উপাদান প্রকার f32 সহ একটি টেনসর প্রকার। এর দুটি মাত্রা রয়েছে (বা অন্য কথায়, দুটি অক্ষ) - 0 তম মাত্রা এবং 1 ম মাত্রা - যার আকার 2 এবং 3৷ এর র্যাঙ্ক হল 2৷

আকৃতি আংশিক বা সম্পূর্ণ অজানা (গতিশীল) হতে পারে, যেমন tensor<?x2xf64> আংশিকভাবে অজানা এবং tensor<?x?xf64> সম্পূর্ণ অজানা। একটি ? . আকারগুলিকে র‌্যাঙ্ক করা যাবে না।

ভবিষ্যতে, আমরা ডাইমেনশন সাইজ এবং এলিমেন্টের প্রকারের বাইরে টেনসরের প্রকারগুলিকে অন্বেষণ করার পরিকল্পনা করছি, উদাহরণস্বরূপ, লেআউট ( #629 ) এবং স্পারসিটি ( #1078 ) অন্তর্ভুক্ত করা।

QuantizedTensorType ::= 'tensor' '<' Shape QuantizedTensorElementType '>'
QuantizedTensorElementType ::= '!quant.uniform' '<'
                  QuantizationStorageType
                  ['<' QuantizationStorageMin ':' QuantizationStorageMax '>']
                  ':' QuantizationExpressedType
                  [':' QuantizationDimension]
                  ',' QuantizationParameters '>'
QuantizationStorageType ::= IntegerType
QuantizationStorageMin ::= IntegerConstant
QuantizationStorageMax ::= IntegerConstant
QuantizationExpressedType ::= FloatType
QuantizationDimension ::= IntegerConstant
QuantizationParameters ::= QuantizationParameter
                         | '{' QuantizationParameter {',' QuantizationParameter} '}'
QuantizationParameter ::= QuantizationScale ':' QuantizationZeroPoint
QuantizationScale ::= FloatConstant
QuantizationZeroPoint ::= IntegerConstant

কোয়ান্টাইজড এলিমেন্টের ধরন storage_min থেকে storage_max (অন্তর্ভুক্ত) পরিসরে একটি স্টোরেজ প্রকারের পূর্ণসংখ্যার মানগুলিকে উপস্থাপন করে যা একটি প্রকাশিত ধরণের ফ্লোটিং-পয়েন্ট মানগুলির সাথে মিলে যায়। একটি প্রদত্ত পূর্ণসংখ্যার মান i এর জন্য, সংশ্লিষ্ট ফ্লোটিং-পয়েন্ট মান f কে f = (i - zero_point) * scale হিসাবে গণনা করা যেতে পারে, যেখানে scale এবং zero_point কে কোয়ান্টাইজেশন প্যারামিটার বলা হয়। storage_min এবং storage_max ব্যাকরণে ঐচ্ছিক, কিন্তু যথাক্রমে min_value(storage_type) এবং max_value(storage_type) এর ডিফল্ট মান রয়েছে। কোয়ান্টাইজড উপাদানের প্রকারের নিম্নলিখিত সীমাবদ্ধতা রয়েছে:

• (C1) type(storage_min) = storage_type ।
• (C2) type(storage_max) = storage_type ।
• (C3) min_value(storage_type) <= storage_min < storage_max <= max_value(storage_type) ।
• (C4) type(scales...) = expressed_type ।
• (C5) 0 < scales ।
• (C6) is_finite(scales...) ।
• (C7) storage_min <= zero_points <= storage_max
• (C8) type(zero_points...) = storage_type ।
• (C9) size(scales) = size(zero_points) ।
• (C10) যদি_ is_empty(quantization_dimension) , তাহলে size(scales) = 1 ।
• (C11) 0 <= quantization_dimension ।

এই মুহুর্তে, QuantizationScale একটি ফ্লোটিং-পয়েন্ট ধ্রুবক, কিন্তু পূর্ণসংখ্যা-ভিত্তিক স্কেলগুলিতে প্রবল আগ্রহ রয়েছে, যা গুণক এবং স্থানান্তর দ্বারা উপস্থাপিত হয়। আমরা নিকট ভবিষ্যতে এটি অন্বেষণ করার পরিকল্পনা করছি ( #1404 )।

QuantizationZeroPoint শব্দার্থবিদ্যার উপর একটি চলমান আলোচনা রয়েছে, যার মধ্যে রয়েছে ধরন, মান এবং একটি কোয়ান্টাইজড টেনসরের ধরনে শুধুমাত্র একটি বা সম্ভাব্য একাধিক শূন্য পয়েন্ট থাকতে পারে কিনা। এই আলোচনার ফলাফলের উপর ভিত্তি করে, শূন্য পয়েন্টের কাছাকাছি স্পেসিফিকেশন ভবিষ্যতে পরিবর্তিত হতে পারে ( #1405 )।

আর একটি চলমান আলোচনায় QuantizationStorageMin এবং QuantizationStorageMax শব্দার্থবিদ্যা জড়িত যে এই মানগুলিতে এবং কোয়ান্টাইজড টেনসরগুলির মানগুলির উপর কোন সীমাবদ্ধতা আরোপ করা উচিত কিনা তা নির্ধারণ করতে ( #1406 )।

অবশেষে, আমরা অজানা স্কেল এবং শূন্য বিন্দুর প্রতিনিধিত্বকারী অন্বেষণ করার পরিকল্পনা করছি, একইভাবে আমরা অজানা মাত্রার আকার ( #1407 ) প্রতিনিধিত্ব করে অন্বেষণ করার পরিকল্পনা করছি।

কোয়ান্টাইজড টেনসর প্রকারগুলি কোয়ান্টাইজড উপাদান সহ টেনসরগুলিকে উপস্থাপন করে। এই টেনসরগুলি রেগুলার টেনসরের মতো হুবহু একই, তাদের উপাদানগুলির রেগুলার এলিমেন্ট টাইপের পরিবর্তে কোয়ান্টাইজড এলিমেন্ট টাইপ আছে।

কোয়ান্টাইজেশন টেনসরে, কোয়ান্টাইজেশন প্রতি-টেনসর হতে পারে, যার অর্থ, সমগ্র টেনসরের জন্য একটি scale এবং zero_point থাকতে পারে বা প্রতি-অক্ষ হতে পারে, যার অর্থ, একাধিক scales এবং zero_points থাকতে পারে, একটি নির্দিষ্ট মাত্রা quantization_dimension প্রতি স্লাইসে এক জোড়া। আরও আনুষ্ঠানিকভাবে, প্রতি-অক্ষ পরিমাপ সহ একটি টেনসর t এ, quantization_dimension dim(t, quantization_dimension) স্লাইস রয়েছে : t[:, ..., 0, ..., :], t[:, ..., 1, ..., :] , ইত্যাদি। i তম স্লাইসের সমস্ত উপাদান তাদের পরিমাপকরণ পরামিতি হিসাবে scales[i] এবং zero_points[i] ব্যবহার করে। কোয়ান্টাইজড টেনসর প্রকারের নিম্নলিখিত সীমাবদ্ধতা রয়েছে:

• প্রতি-টেনসর পরিমাপের জন্য:
  • কোন অতিরিক্ত সীমাবদ্ধতা.
• প্রতি-অক্ষ পরিমাপের জন্য:
  • (C13) quantization_dimension < rank(self) .
  • (C14) dim(self, quantization_dimension) = size(scales) ।

TokenType ::= 'token'

টোকেন প্রকারগুলি টোকেনগুলিকে প্রতিনিধিত্ব করে, যেমন অস্বচ্ছ মানগুলি কিছু ক্রিয়াকলাপের দ্বারা উত্পাদিত এবং সেবন করে৷ এক্সিকিউশন বিভাগে বর্ণিত ক্রিয়াকলাপের উপর কার্যকর আদেশ আরোপ করার জন্য টোকেন ব্যবহার করা হয়।

TupleType ::= 'tuple' '<' TupleElementTypes '>'
TupleElementTypes ::= [ValueType {',' ValueType}]

Tuple প্রকারগুলি tuples, অর্থাৎ ভিন্নধর্মী তালিকাগুলিকে প্রতিনিধিত্ব করে। Tuples হল একটি উত্তরাধিকার বৈশিষ্ট্য যা শুধুমাত্র HLO এর সাথে সামঞ্জস্যের জন্য বিদ্যমান। HLO-তে, টিপলগুলি বৈচিত্র্যময় ইনপুট এবং আউটপুটগুলিকে উপস্থাপন করতে ব্যবহৃত হয়। StableHLO-তে, বৈচিত্র্যময় ইনপুট এবং আউটপুটগুলি স্থানীয়ভাবে সমর্থিত, এবং StableHLO-তে টিপলের একমাত্র ব্যবহার হল HLO ABI-কে ব্যাপকভাবে উপস্থাপন করা যেখানে যেমন T , tuple<T> এবং tuple<tuple<T>> একটি নির্দিষ্ট বাস্তবায়নের উপর নির্ভর করে বস্তুগতভাবে ভিন্ন হতে পারে। . ভবিষ্যতে, আমরা HLO ABI-তে পরিবর্তন করার পরিকল্পনা করছি যা আমাদের StableHLO ( #598 ) থেকে টিপল ধরনের অপসারণ করতে পারে।

TensorElementType ::= BooleanType | IntegerType | FloatType | ComplexType
BooleanType ::= 'i1'
IntegerType ::= SignedIntegerType | UnsignedIntegerType
SignedIntegerType ::= 'si4' | 'si8' | 'si16' | 'si32' | 'si64'
UnsignedIntegerType ::= 'ui4' | 'ui8' | 'ui16' | 'ui32' | 'ui64'
FloatType ::= 'f8E4M3FN' | 'f8E5M2' | 'f8E4M3FNUZ' | 'f8E5M2FNUZ'
            | 'f8E4M3B11FNUZ' | 'bf16' | 'f16' | 'f32' | 'f64'
ComplexType ::= 'complex' '<' ComplexElementType '>'
ComplexElementType ::= 'f32' | 'f64'

উপাদান প্রকারগুলি টেনসর ধরণের উপাদানগুলির প্রতিনিধিত্ব করে। অনেক প্রোগ্রামিং ভাষার বিপরীতে, এই প্রকারগুলি StableHLO-তে প্রথম শ্রেণীর নয়। এর মানে হল যে StableHLO প্রোগ্রামগুলি এই ধরণের মানগুলিকে সরাসরি উপস্থাপন করতে পারে না (ফলে, টাইপ tensor<T> এর 0-মাত্রিক টেনসর মানগুলির সাথে T টাইপের স্কেলার মানগুলিকে উপস্থাপন করা বাহাদুরিপূর্ণ)।

• বুলিয়ান টাইপ বুলিয়ান মান true এবং false উপস্থাপন করে।
• পূর্ণসংখ্যার প্রকারগুলি হয় স্বাক্ষরিত ( si ) বা স্বাক্ষরবিহীন ( ui ) হতে পারে এবং সমর্থিত বিট প্রস্থগুলির মধ্যে একটি থাকতে পারে ( 4 , 8 , 16 , 32 বা 64 )৷ স্বাক্ষরিত siN প্রকারগুলি -2^(N-1) থেকে 2^(N-1)-1 সহ পূর্ণসংখ্যার মানগুলিকে উপস্থাপন করে, এবং স্বাক্ষরবিহীন uiN প্রকারগুলি 0 থেকে 2^N-1 সহ পূর্ণসংখ্যার মানগুলিকে উপস্থাপন করে।
• ফ্লোটিং-পয়েন্ট প্রকারগুলি নিম্নলিখিতগুলির মধ্যে একটি হতে পারে:
  • f8E4M3FN এবং f8E5M2 প্রকারগুলি যথাক্রমে ডিপ লার্নিংয়ের জন্য FP8 ফর্ম্যাটে বর্ণিত FP8 ফর্ম্যাটের E4M3 এবং E5M2 এনকোডিংগুলির সাথে সম্পর্কিত৷
  • f8E4M3FNUZ এবং f8E5M2FNUZ প্রকারগুলি ডিপ নিউরাল নেটওয়ার্কগুলির জন্য 8-বিট সংখ্যাসূচক ফর্ম্যাটে বর্ণিত FP8 ফর্ম্যাটের E4M3 এবং E5M2 এনকোডিংয়ের সাথে সম্পর্কিত৷
  • ডিপ নিউরাল নেটওয়ার্কের জন্য হাইব্রিড 8-বিট ফ্লোটিং পয়েন্ট (HFP8) প্রশিক্ষণ এবং অনুমানে বর্ণিত FP8 ফর্ম্যাটের E4M3 এনকোডিংয়ের সাথে সম্পর্কিত f8E4M3B11FNUZ প্রকার।
  • BFloat16-এ বর্ণিত bfloat16 বিন্যাসের সাথে সম্পর্কিত bf16 প্রকার : ক্লাউড TPU-তে উচ্চ কার্যক্ষমতার গোপনীয়তা ।
  • f16 , f32 এবং f64 প্রকার যথাক্রমে binary16 ("অর্ধ স্পষ্টতা"), binary32 ("একক নির্ভুলতা") এবং binary64 ("ডাবল স্পষ্টতা") বিন্যাসের সাথে IEEE 754 স্ট্যান্ডার্ডে বর্ণিত।
• জটিল প্রকারগুলি জটিল মানগুলিকে উপস্থাপন করে যেগুলির একটি বাস্তব অংশ এবং একই উপাদান প্রকারের একটি কাল্পনিক অংশ রয়েছে৷ সমর্থিত জটিল প্রকারগুলি হল complex<f32> (উভয় অংশই f32 প্রকারের) এবং complex<f64> (উভয় অংশই f64 প্রকার)।

FunctionType ::= '(' InputTypes ')' '->' '(' OutputTypes ')'
InputTypes ::= [ValueType {',' ValueType}]
OutputTypes ::= [ValueType {',' ValueType}]

ফাংশন প্রকারগুলি নামযুক্ত এবং বেনামী উভয় ফাংশন উপস্থাপন করে। তাদের ইনপুট প্রকার রয়েছে ( -> এর বাম দিকের প্রকারের তালিকা) এবং আউটপুট প্রকারগুলি ( -> এর ডানদিকের প্রকারের তালিকা)। অনেক প্রোগ্রামিং ভাষায়, ফাংশনের ধরন প্রথম শ্রেণীর, কিন্তু StableHLO তে নয়।

StringType ::= 'string'

স্ট্রিং টাইপ বাইটের ক্রম উপস্থাপন করে। অনেক প্রোগ্রামিং ভাষার বিপরীতে, স্ট্রিং টাইপ StableHLO-তে প্রথম শ্রেণীর নয় এবং শুধুমাত্র প্রোগ্রাম উপাদানগুলির জন্য স্ট্যাটিক মেটাডেটা নির্দিষ্ট করতে ব্যবহৃত হয়।

অপারেশন

StableHLO অপারেশনগুলি (যাকে ops ও বলা হয়) মেশিন লার্নিং মডেলগুলিতে উচ্চ-স্তরের অপারেশনগুলির একটি বন্ধ সেট উপস্থাপন করে। উপরে যেমন আলোচনা করা হয়েছে, StableHLO সিনট্যাক্স MLIR দ্বারা প্রচণ্ডভাবে অনুপ্রাণিত, যা অগত্যা সবচেয়ে ergonomic বিকল্প নয়, কিন্তু ML ফ্রেমওয়ার্ক এবং ML কম্পাইলারগুলির মধ্যে আরও আন্তঃকার্যযোগ্যতা তৈরি করার জন্য StableHLO-এর লক্ষ্যের জন্য যুক্তিযুক্তভাবে উপযুক্ত।

Op            ::= [OpOutputs] OpName OpInputs ':' OpSignature
OpName        ::= '"' 'stablehlo' '.' OpMnemonic '"'
OpMnemonic    ::= 'abs' | 'add' | ...

StableHLO অপারেশনগুলির (যাকে অপসও বলা হয়) একটি নাম, ইনপুট/আউটপুট এবং একটি স্বাক্ষর থাকে। নাম stablehlo. উপসর্গ এবং একটি স্মারক যা স্বতন্ত্রভাবে সমর্থিত অপ্সগুলির একটিকে চিহ্নিত করে। সমস্ত সমর্থিত অপারেশনগুলির একটি বিস্তৃত তালিকার জন্য নীচে দেখুন৷

এই মুহুর্তে, বন্যের StableHLO প্রোগ্রামে মাঝে মাঝে এমন ক্রিয়াকলাপ থাকে যা এই নথিতে বর্ণনা করা হয় না। ভবিষ্যতে, আমরা হয় এই ক্রিয়াকলাপগুলিকে StableHLO অপসেটে শোষণ করার বা StableHLO প্রোগ্রামগুলিতে উপস্থিত হওয়া থেকে নিষিদ্ধ করার পরিকল্পনা করছি৷ ইতিমধ্যে, এখানে এই অপারেশনগুলির তালিকা রয়েছে:

• builtin.module , func.func , func.call এবং func.return ( #425 )।
• chlo অপারেশন ( #602 )।
• StableHLO ক্রিয়াকলাপগুলির "HLO-এর মধ্যে নয়" বিভাগে - এগুলি প্রথমে StableHLO অপসেটের অংশ ছিল কিন্তু পরে এটি ভালভাবে ফিট নয় বলে মনে করা হয়েছে: broadcast , create_token , cross-replica-sum , dot , einsum , torch_index_select , unary_einsum ( #3 ) , এবং trace ( #604 )।
• StableHLO ক্রিয়াকলাপগুলির "ডায়নামিজম" বিভাগ - সেগুলি MHLO থেকে বুটস্ট্র্যাপ করা হয়েছিল, এবং আমরা সেগুলি নির্দিষ্ট করার প্রক্রিয়ায় আছি: dynamic_broadcast_in_dim , dynamic_conv , dynamic_gather , dynamic_pad , real_dynamic_slice , set_dimension_size . ( #8 )।
• শেপ কম্পিউটেশন, arith , shape এবং tensor অপারেশন সহ ( #8 )।

OpInputs        ::= OpInputValues OpInputFuncs OpInputAttrs
OpInputValues   ::= '(' [OpInputValue {',' OpInputValue}] ')'
OpInputValue    ::= ValueId
OpInputFuncs    ::= ['(' OpInputFunc {',' OpInputFunc} ')']
OpInputAttrs    ::= ['{' OpInputAttr {',' OpInputAttr} '}']
OpOutputs       ::= [OpOutput {',' OpOutput} '=']
OpOutput        ::= ValueId

অপস ইনপুট গ্রহণ করে এবং আউটপুট উত্পাদন করে। ইনপুটগুলি ইনপুট মানগুলিতে শ্রেণীবদ্ধ করা হয় (নির্বাহের সময় গণনা করা হয়), ইনপুট ফাংশন (স্ট্যাবলিকভাবে প্রদান করা হয়, কারণ স্টেবলএইচএলও ফাংশনগুলি প্রথম শ্রেণীর মান নয়) এবং ইনপুট বৈশিষ্ট্যগুলি (এছাড়াও স্থিরভাবে প্রদান করা হয়)। একটি অপ দ্বারা খাওয়া এবং উত্পাদিত ইনপুট এবং আউটপুট তার স্মৃতির উপর নির্ভর করে। উদাহরণস্বরূপ, add অপটি 2টি ইনপুট মান গ্রহণ করে এবং 1টি আউটপুট মান তৈরি করে। তুলনায়, select_and_scatter op 3টি ইনপুট মান, 2টি ইনপুট ফাংশন এবং 3টি ইনপুট বৈশিষ্ট্য ব্যবহার করে৷

OpInputFunc ::= '{' Unused FuncInputs ':' FuncBody '}'
Unused      ::= '^' digit {digit}
              | '^' letter {letter | digit}

ইনপুট ফাংশনগুলি (যাকে বেনামী ফাংশনও বলা হয়) নামযুক্ত ফাংশনগুলির সাথে খুব মিল: 1) তাদের কোনও শনাক্তকারী নেই (তাই নাম "বেনামী"), 2) তারা আউটপুট প্রকারগুলি ঘোষণা করে না (আউটপুট প্রকারগুলি হল ফাংশনের মধ্যে return অপ থেকে অনুমান করা হয়েছে)।

ইনপুট ফাংশনের জন্য সিনট্যাক্সে বর্তমানে একটি অব্যবহৃত অংশ রয়েছে (উপরে Unused উত্পাদন দেখুন) যা MLIR-এর সাথে সামঞ্জস্যের জন্য রয়েছে। এমএলআইআর-এ, "অঞ্চল" এর আরও সাধারণ ধারণা রয়েছে যেখানে জাম্প অপ্সের মাধ্যমে একসাথে সংযুক্ত একাধিক "ব্লক" থাকতে পারে। এই ব্লকগুলিতে Unused প্রোডাকশনের সাথে সঙ্গতিপূর্ণ আইডি রয়েছে, যাতে তাদের একে অপরের থেকে আলাদা করা যায়। StableHLO এর জাম্প অপ্স নেই, তাই MLIR সিনট্যাক্সের সংশ্লিষ্ট অংশটি অব্যবহৃত (কিন্তু এখনও আছে)।

OpInputAttr      ::= OpInputAttrName '=' OpInputAttrValue
OpInputAttrName  ::= letter {letter | digit}
OpInputAttrValue ::= Constant

ইনপুট বৈশিষ্ট্যগুলির একটি নাম এবং একটি মান রয়েছে যা সমর্থিত ধ্রুবকগুলির মধ্যে একটি৷ তারা প্রোগ্রাম উপাদানগুলির জন্য স্ট্যাটিক মেটাডেটা নির্দিষ্ট করার প্রাথমিক উপায়। উদাহরণ স্বরূপ, concatenate op বৈশিষ্ট্যের dimension ব্যবহার করে তার ইনপুট মানগুলি যে মাত্রার সাথে সংযুক্ত করা হয়েছে তা নির্দিষ্ট করতে। একইভাবে, slice অপটি ইনপুট মান স্লাইস করতে ব্যবহৃত সীমানা নির্দিষ্ট করতে start_indices এবং limit_indices এর মতো একাধিক বৈশিষ্ট্য ব্যবহার করে।

এই মুহুর্তে, বন্যের StableHLO প্রোগ্রামে মাঝে মাঝে এমন বৈশিষ্ট্য থাকে যা এই নথিতে বর্ণনা করা হয়নি। ভবিষ্যতে, আমরা হয় StableHLO অপসেটে এই বৈশিষ্ট্যগুলি শোষণ করার বা StableHLO প্রোগ্রামগুলিতে উপস্থিত হওয়া থেকে নিষিদ্ধ করার পরিকল্পনা করছি৷ ইতিমধ্যে, এখানে এই বৈশিষ্ট্যগুলির তালিকা রয়েছে:

• layout ( #629 )।
• mhlo.frontend_attributes ( #628 )।
• mhlo.sharding ( #619 )।
• output_operand_aliases ( #740 )।
• অবস্থান মেটাডেটা ( #594 )।

OpSignature ::= '(' [ValueType {',' ValueType}] ')' '->' '(' [ValueType {',' ValueType}] ')'

অপ স্বাক্ষরে সমস্ত ইনপুট মান ( -> এর বাম দিকের প্রকারের তালিকা) এবং সমস্ত আউটপুট মানগুলির প্রকার ( -> এর ডানদিকের প্রকারের তালিকা) থাকে। কঠোরভাবে বলতে গেলে, ইনপুট প্রকারগুলি অপ্রয়োজনীয়, এবং আউটপুট প্রকারগুলি প্রায় সবসময়ই অপ্রয়োজনীয় (কারণ বেশিরভাগ StableHLO অপ্সের জন্য, আউটপুট প্রকারগুলি ইনপুট থেকে অনুমান করা যেতে পারে)। তবুও, MLIR এর সাথে সামঞ্জস্যের জন্য op স্বাক্ষর ইচ্ছাকৃতভাবে StableHLO সিনট্যাক্সের অংশ।

নীচে একটি উদাহরণ op যার স্মৃতিচিহ্ন হল select_and_scatter । এটি 3টি ইনপুট মান ( %operand , %source এবং %init_value ), 2টি ইনপুট ফাংশন এবং 3টি ইনপুট অ্যাট্রিবিউট ( window_dimensions , window_strides এবং padding ) ব্যবহার করে। নোট করুন কিভাবে op-এর স্বাক্ষর শুধুমাত্র এর ইনপুট মানগুলির প্রকারগুলি অন্তর্ভুক্ত করে (কিন্তু ইনপুট ফাংশন এবং বৈশিষ্ট্যগুলির প্রকারগুলি নয় যা ইনলাইনে দেওয়া হয়)৷

%result = "stablehlo.select_and_scatter"(%operand, %source, %init_value) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = "stablehlo.compare"(%arg0, %arg1) {
      comparison_direction = #stablehlo<comparison_direction GE>
    } : (tensor<i32>, tensor<i32>) -> tensor<i1>
    "stablehlo.return"(%0) : (tensor<i1>) -> ()
}, {
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = "stablehlo.add"(%arg0, %arg1) : (tensor<i32>, tensor<i32>) -> tensor<i32>
    "stablehlo.return"(%0) : (tensor<i32>) -> ()
}) {
  window_dimensions = dense<[3, 1]> : tensor<2xi64>,
  window_strides = dense<[2, 1]> : tensor<2xi64>,
  padding = dense<[[0, 1], [0, 0]]> : tensor<2x2xi64>
} : (tensor<4x2xi32>, tensor<2x2xi32>, tensor<i32>) -> tensor<4x2xi32>

ধ্রুবক

Constant ::= BooleanConstant
           | IntegerConstant
           | FloatConstant
           | ComplexConstant
           | TensorConstant
           | QuantizedTensorConstant
           | StringConstant
           | EnumConstant

StableHLO ধ্রুবকগুলির একটি আক্ষরিক এবং একটি প্রকার রয়েছে যা একসাথে একটি StableHLO মান উপস্থাপন করে। সাধারণত, টাইপটি ধ্রুবক সিনট্যাক্সের অংশ, এটি দ্ব্যর্থহীন হলে (যেমন একটি বুলিয়ান ধ্রুবকের দ্ব্যর্থহীনভাবে i1 টাইপ থাকে, যেখানে একটি পূর্ণসংখ্যা ধ্রুবকের একাধিক সম্ভাব্য প্রকার থাকতে পারে)।

BooleanConstant ::= BooleanLiteral
BooleanLiteral  ::= 'true' | 'false'

বুলিয়ান ধ্রুবক বুলিয়ান মান true এবং false উপস্থাপন করে। বুলিয়ান ধ্রুবকের টাইপ i1 আছে।

IntegerConstant   ::= IntegerLiteral ':' IntegerType
IntegerLiteral    ::= ['-' | '+'] DecimalDigits
                    | ['-' | '+'] '0x' HexadecimalDigits
DecimalDigits     ::= decimalDigit {decimalDigit}
HexadecimalDigits ::= hexadecimalDigit {hexadecimalDigit}
decimalDigit      ::= '0' | ... | '9'
hexadecimalDigit  ::= decimalDigit | 'a' | ... | 'f' | 'A' | ... | 'F'

পূর্ণসংখ্যার ধ্রুবকগুলি দশমিক বা হেক্সাডেসিমেল স্বরলিপি ব্যবহার করে এমন স্ট্রিংগুলির মাধ্যমে পূর্ণসংখ্যার মানগুলিকে উপস্থাপন করে। অন্যান্য বেস, যেমন বাইনারি বা অক্টাল, সমর্থিত নয়। পূর্ণসংখ্যার ধ্রুবকগুলির নিম্নলিখিত সীমাবদ্ধতা রয়েছে:

• (C1) is_wellformed(integer_literal, integer_type) ।

FloatConstant  ::= FloatLiteral ':' FloatType
FloatLiteral   ::= SignPart IntegerPart FractionalPart ScientificPart
                 | '0x' [HexadecimalDigits]
SignPart       ::= ['-' | '+']
IntegerPart    ::= DecimalDigits
FractionalPart ::= ['.' [DecimalDigits]]
ScientificPart ::= [('e' | 'E') ['-' | '+'] DecimalDigits]

ফ্লোটিং-পয়েন্ট ধ্রুবকগুলি স্ট্রিংগুলির মাধ্যমে ফ্লোটিং-পয়েন্ট মানগুলি উপস্থাপন করে যা দশমিক বা বৈজ্ঞানিক নোটেশন ব্যবহার করে। অতিরিক্তভাবে, হেক্সাডেসিমেল নোটেশনটি সংশ্লিষ্ট প্রকারের ফ্লোটিং-পয়েন্ট বিন্যাসে অন্তর্নিহিত বিটগুলিকে সরাসরি নির্দিষ্ট করতে ব্যবহার করা যেতে পারে। ফ্লোটিং-পয়েন্ট ধ্রুবকগুলির নিম্নলিখিত সীমাবদ্ধতা রয়েছে:

• (C1) নন-হেক্সাডেসিমেল নোটেশন ব্যবহার করা হলে, is_wellformed(float_literal, float_type)
• (C2) যদি হেক্সাডেসিমাল নোটেশন ব্যবহার করা হয়, size(hexadecimal_digits) = num_bits(float_type) / 4 ।

ComplexConstant ::= ComplexLiteral ':' ComplexType
ComplexLiteral  ::= '(' RealPart ',' ImaginaryPart ')'
RealPart        ::= FloatLiteral
ImaginaryPart   ::= FloatLiteral

জটিল ধ্রুবকগুলি একটি বাস্তব অংশ (প্রথমে আসে) এবং একটি কাল্পনিক অংশ (দ্বিতীয় আসে) তালিকা ব্যবহার করে জটিল মানগুলি উপস্থাপন করে। উদাহরণস্বরূপ, (1.0, 0.0) : complex<f32> 1.0 + 0.0i , এবং (0.0, 1.0) : complex<f32> 0.0 + 1.0i প্রতিনিধিত্ব করে। যে ক্রমে এই অংশগুলি মেমরিতে সংরক্ষণ করা হয় তা বাস্তবায়ন-সংজ্ঞায়িত। জটিল ধ্রুবকগুলির নিম্নলিখিত সীমাবদ্ধতা রয়েছে:

• (C1) is_wellformed(real_part, complex_element_type(complex_type)) ।
• (C2) is_wellformed(imaginary_part, complex_element_type(complex_type)) ।

TensorConstant ::= TensorLiteral ':' TensorType
TensorLiteral  ::= 'dense' '<' (DenseLiteral | ElementLiteral) '>'
DenseLiteral   ::= DenseDimension | DenseElements
DenseDimension ::= '[' [DenseLiteral {',' DenseLiteral}] ']'
DenseElements  ::= [ElementLiteral {',' ElementLiteral}]
ElementLiteral ::= BooleanLiteral | IntegerLiteral | FloatLiteral | ComplexLiteral

টেনসর ধ্রুবকগুলি NumPy স্বরলিপির মাধ্যমে নির্দিষ্ট নেস্টেড তালিকা ব্যবহার করে টেনসর মানগুলি উপস্থাপন করে। উদাহরণস্বরূপ, dense<[[1, 2, 3], [4, 5, 6]]> : tensor<2x3xi32> সূচকগুলি থেকে উপাদানগুলিতে নিম্নলিখিত ম্যাপিং সহ একটি টেনসর মান উপস্থাপন করে: {0, 0} => 1 , {0, 1} => 2 , {0, 2} => 3 , {1, 0} => 4 , {1, 1} => 5 , {1, 2} => 6 । যে ক্রমে এই উপাদানগুলি মেমরিতে সংরক্ষণ করা হয় তা বাস্তবায়ন-সংজ্ঞায়িত। টেনসর ধ্রুবকগুলির নিম্নলিখিত সীমাবদ্ধতা রয়েছে:

• (C1) has_syntax(tensor_literal, element_type(tensor_type)) , যেখানে:
  • has_syntax(element_literal: Syntax, element_type: Type) = is_wellformed(element_literal, type) ।
  • has_syntax(tensor_literal: List, element_type: Type) = has_syntax(tensor_literal..., element_type)
• (C2) has_shape(tensor_literal, shape(tensor_type)) , যেখানে:
  • has_shape(element_literal: Syntax, []) = true ।
  • has_shape(tensor_literal: List, shape: List) = size(tensor_literal) = shape[0] and has_shape(tensor_literal..., shape[1:])
  • অন্যথায়, false ।

QuantizedTensorConstant ::= QuantizedTensorLiteral ':' QuantizedTensorType
QuantizedTensorLiteral  ::= 'dense' '<' (DenseLiteral | ElementLiteral) '>'

কোয়ান্টাইজড টেনসর ধ্রুবকগুলি তাদের স্টোরেজ প্রকারের ধ্রুবক হিসাবে নির্দিষ্ট উপাদানগুলির সাথে টেনসর ধ্রুবকের মতো একই স্বরলিপি ব্যবহার করে কোয়ান্টাইজড টেনসর মানগুলি উপস্থাপন করে। কোয়ান্টাইজড টেনসর ধ্রুবকগুলির নিম্নলিখিত সীমাবদ্ধতা রয়েছে:

• (C1) has_syntax(quantized_tensor_literal, storage_type(quantized_tensor_type)) ।
• (C2) has_shape(quantized_tensor_literal, shape(quantized_tensor_type)) ।

StringConstant  ::= StringLiteral
StringLiteral   ::= '"' {stringCharacter | escapeSequence} '"'
stringCharacter ::= all ASCII characters except '\00', '\01', ... '\1f' and '"'
escapeSequence  ::= '\' ('"' | '\' | 'n' | 't' | (hexadecimalDigit hexadecimalDigit))

স্ট্রিং লিটারেলে ASCII অক্ষর এবং এস্কেপ সিকোয়েন্স ব্যবহার করে নির্দিষ্ট করা বাইট থাকে। তারা এনকোডিং-অজ্ঞেয়বাদী, তাই এই বাইটের ব্যাখ্যা বাস্তবায়ন-সংজ্ঞায়িত। স্ট্রিং লিটারেলে টাইপ string থাকে।

অপ্স

abs

শব্দার্থবিদ্যা

operand টেনসরে উপাদান-ভিত্তিক abs অপারেশন করে এবং result টেনসর তৈরি করে। উপাদান প্রকারের উপর নির্ভর করে, নিম্নলিখিতগুলি করে:

• স্বাক্ষরিত পূর্ণসংখ্যার জন্য: পূর্ণসংখ্যা মডুলাস।
• ফ্লোটের জন্য: IEEE-754 থেকে abs ।
• জটিল সংখ্যার জন্য: জটিল মডুলাস।
• কোয়ান্টাইজড প্রকারের জন্য: dequantize_op_quantize(abs, operand, type(result)) ।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) shape(result) = shape(operand) ।
• (C2) baseline_element_type(result) এইভাবে সংজ্ঞায়িত করা হয়েছে:
  • complex_element_type(element_type(operand)) is_complex(operand) হলে।
  • baseline_element_type(operand) অন্যথায়।

উদাহরণ

// %operand: [-2, 0, 2]
%result = "stablehlo.abs"(%operand) : (tensor<3xi32>) -> tensor<3xi32>
// %result: [2, 0, 2]

আরো উদাহরণ

যোগ করুন

শব্দার্থবিদ্যা

দুটি টেনসর lhs এবং rhs এর উপাদান-ভিত্তিক সংযোজন সম্পাদন করে এবং একটি result টেনসর তৈরি করে। উপাদান প্রকারের উপর নির্ভর করে, নিম্নলিখিতগুলি করে:

• বুলিয়ানদের জন্য: লজিক্যাল OR।
• পূর্ণসংখ্যার জন্য: পূর্ণসংখ্যা সংযোজন।
• ফ্লোটের জন্য: IEEE-754 থেকে addition ।
• জটিল সংখ্যার জন্য: জটিল যোগ।
• quantized প্রকারের জন্য: dequantize_op_quantize(add, lhs, rhs, type(result)) ।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• যদি অপারেশনটি নন-কোয়ান্টাইজড টেনসর ব্যবহার করে:
  • (C1) type(lhs) = type(rhs) = type(result) ।
• যদি অপারেশন কোয়ান্টাইজড টেনসর ব্যবহার করে:
  • (C2) is_quantized(lhs) and is_quantized(rhs) and is_quantized(result) ।
  • (C3) storage_type(lhs) = storage_type(rhs) = storage_type(result) ।
  • (C4) expressed_type(lhs) = expressed_type(rhs) = expressed_type(result) ।
  • (C5) (is_per_axis_quantized(lhs) or is_per_axis_quantized(rhs)) = is_per_axis_quantized(result)
  • (C6) যদি_ is_per_axis_quantized(lhs) , তাহলে quantization_dimension(lhs) = quantization_dimension(result) ।
  • (C7) যদি_ is_per_axis_quantized(rhs) , তাহলে quantization_dimension(rhs) = quantization_dimension(result) ।

উদাহরণ

// %lhs: [[1, 2], [3, 4]]
// %rhs: [[5, 6], [7, 8]]
%result = "stablehlo.add"(%lhs, %rhs) : (tensor<2x2xi32>, tensor<2x2xi32>) -> tensor<2x2xi32>
// %result: [[6, 8], [10, 12]]

আরো উদাহরণ

সর্বোপরি

শব্দার্থবিদ্যা

নিশ্চিত করে যে inputs উৎপাদনকারী ক্রিয়াকলাপগুলি result উপর নির্ভর করে এমন কোনও অপারেশনের আগে সম্পাদিত হয়। এই ক্রিয়াকলাপটি কার্যকর করা কিছুই করে না, এটি শুধুমাত্র result থেকে inputs ডেটা নির্ভরতা স্থাপনের জন্য বিদ্যমান।

ইনপুট

আউটপুট

উদাহরণ

// %input0: !stablehlo.token
// %input1: !stablehlo.token
%result = "stablehlo.after_all"(%input0, %input1) : (!stablehlo.token, !stablehlo.token) -> !stablehlo.token

আরো উদাহরণ

সব_জড়ো করা

শব্দার্থবিদ্যা

StableHLO প্রসেস গ্রিডের প্রতিটি প্রসেস গ্রুপের মধ্যে, all_gather_dim বরাবর প্রতিটি প্রক্রিয়া থেকে operand টেনসরের মানগুলিকে একত্রিত করে এবং একটি result টেনসর তৈরি করে।

অপারেশনটি StableHLO প্রসেস গ্রিডকে process_groups এ বিভক্ত করে যা নিম্নরূপ সংজ্ঞায়িত করা হয়েছে:

• cross_replica(replica_groups) যদি channel_id <= 0 and use_global_device_ids = false ।
• cross_replica_and_partition(replica_groups) যদি channel_id > 0 and use_global_device_ids = false ।
• flattened_ids(replica_groups) যদি channel_id > 0 and use_global_device_ids = true ।

পরে, প্রতিটি process_group মধ্যে:

• operands@receiver = [operand@sender for sender in process_group] process_group সকল receiver জন্য।
• result@process = concatenate(operands@process, all_gather_dim) process_group এ সমস্ত process জন্য।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) 0 <= all_gather_dim < rank(operand) ।
• (C2) is_unique(replica_groups) ।
• (C3) size(replica_groups) সংজ্ঞায়িত করা হয়েছে এভাবে:
  • num_replicas যদি cross_replica ব্যবহার করা হয়।
  • num_replicas যদি cross_replica_and_partition ব্যবহার করা হয়।
  • num_processes যদি flattened_ids ব্যবহার করা হয়।
• (C4) 0 <= replica_groups < size(replica_groups) ।
• (C5) যদি use_global_device_ids = true , তাহলে channel_id > 0 ।
• (C6) type(result) = type(operand) ছাড়া:
  • dim(result, all_gather_dim) = dim(operand, all_gather_dim) * dim(process_groups, 1) ।

উদাহরণ

// num_replicas: 2
// num_partitions: 1
// %operand@(0, 0): [[1, 2], [3, 4]]
// %operand@(1, 0): [[5, 6], [7, 8]]
%result = "stablehlo.all_gather"(%operand) {
  all_gather_dim = 1 : i64,
  replica_groups = dense<[[0, 1]]> : tensor<1x2xi64>,
  // channel_id = 0
  channel_handle = #stablehlo.channel_handle<handle = 0, type = 0>
  // use_global_device_ids = false
} : (tensor<2x2xi64>) -> tensor<2x4xi64>
// %result@(0, 0): [[1, 2, 5, 6], [3, 4, 7, 8]]
// %result@(1, 0): [[1, 2, 5, 6], [3, 4, 7, 8]]

আরো উদাহরণ

all_reduce

শব্দার্থবিদ্যা

StableHLO প্রসেস গ্রিডের প্রতিটি প্রক্রিয়া গোষ্ঠীর মধ্যে, প্রতিটি প্রক্রিয়া থেকে operand টেনসরের মানগুলিতে একটি হ্রাস ফাংশন computation প্রয়োগ করে এবং একটি result টেনসর তৈরি করে।

অপারেশনটি StableHLO প্রসেস গ্রিডকে process_groups এ বিভক্ত করে যা নিম্নরূপ সংজ্ঞায়িত করা হয়েছে:

• cross_replica(replica_groups) যদি channel_id <= 0 and use_global_device_ids = false ।
• cross_replica_and_partition(replica_groups) যদি channel_id > 0 and use_global_device_ids = false ।
• flattened_ids(replica_groups) যদি channel_id > 0 and use_global_device_ids = true ।

পরে, প্রতিটি process_group মধ্যে:

• result@process[result_index] = exec(schedule) কিছু বাইনারি ট্রি schedule জন্য exec(সূচি) যেখানে:
  • exec(node) = computation(exec(node.left), exec(node.right)) ।
  • exec(leaf) = leaf.value .
• schedule হল একটি বাস্তবায়ন-সংজ্ঞায়িত বাইনারি ট্রি যার ইন-অর্ডার ট্রাভার্সাল হল to_destination_type(operands@process_group...[result_index], type(func_inputs(computation)[0]))

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) is_unique(replica_groups) ।
• (C2) size(replica_groups) এইভাবে সংজ্ঞায়িত করা হয়েছে:
  • num_replicas যদি cross_replica ব্যবহার করা হয়।
  • num_replicas যদি cross_replica_and_partition ব্যবহার করা হয়।
  • num_processes যদি flattened_ids ব্যবহার করা হয়।
• (C3) 0 <= replica_groups < size(replica_groups) ।
• (C4) যদি use_global_device_ids = true , তাহলে channel_id > 0 ।
• (C5) computation টাইপ আছে (tensor<E>, tensor<E>) -> (tensor<E>) যেখানে is_promotable(element_type(operand), E) ।
• (C6) shape(result) = shape(operand) ।
• (C7) element_type(result) = E

উদাহরণ

// num_replicas: 2
// num_partitions: 1
// %operand@(0, 0): [1, 2, 3, 4]
// %operand@(1, 0): [5, 6, 7, 8]
%result = "stablehlo.all_reduce"(%operand) ({
  ^bb0(%arg0: tensor<i64>, %arg1: tensor<i64>):
    %0 = "stablehlo.add"(%arg0, %arg1) : (tensor<i64>, tensor<i64>) -> tensor<i64>
    "stablehlo.return"(%0) : (tensor<i64>) -> ()
}) {
  replica_groups = dense<[[0, 1]]> : tensor<1x2xi64>,
  channel_handle = #stablehlo.channel_handle<handle = 0, type = 0>
} : (tensor<4xi64>) -> tensor<4xi64>
// %result@(0, 0): [6, 8, 10, 12]
// %result@(1, 0): [6, 8, 10, 12]

আরো উদাহরণ

সব_থেকে_সমস্ত

শব্দার্থবিদ্যা

StableHLO প্রসেস গ্রিডের প্রতিটি প্রসেস গ্রুপের মধ্যে, operand টেনসরের মানগুলিকে split_dimension বরাবর অংশে বিভক্ত করে, প্রসেসের মধ্যে বিভক্ত অংশগুলিকে ছড়িয়ে দেয়, concat_dimension বরাবর বিক্ষিপ্ত অংশগুলিকে সংযুক্ত করে এবং result টেনসর তৈরি করে।

অপারেশনটি StableHLO প্রসেস গ্রিডকে process_groups এ বিভক্ত করে যা নিম্নরূপ সংজ্ঞায়িত করা হয়েছে:

• cross_replica(replica_groups) যদি channel_id <= 0 হয়।
• cross_partition(replica_groups) যদি channel_id > 0 ।

পরে, প্রতিটি process_group মধ্যে:

• split_parts@sender = split(operand@sender, split_count, split_dimension) process_group এ সমস্ত sender জন্য।
• scattered_parts@receiver = [split_parts@sender[receiver_index] for sender in process_group] যেখানে receiver_index = process_group.index(receiver) ।
• result@process = concatenate(scattered_parts@process, concat_dimension) ।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) 0 <= split_dimension < rank(operand) ।
• (C2) dim(operand, split_dimension) % split_count = 0 ।
• (C3) 0 <= concat_dimension < rank(operand) ।
• (C4) 0 < split_count ।
• (C5) is_unique(replica_groups) ।
• (C6) size(replica_groups) এইভাবে সংজ্ঞায়িত করা হয়েছে:
  • num_replicas যদি cross_replica ব্যবহার করা হয়।
  • num_partitions যদি cross_partition ব্যবহার করা হয়।
• (C7) 0 <= replica_groups < size(replica_groups) ।
• (C8) dim(replica_groups, 1) = split_count ।
• (C9) type(result) = type(operand) ছাড়া:
  • dim(result, split_dimension) = dim(operand, split_dimension) / split_count ।
  • dim(result, concat_dimension) = dim(operand, concat_dimension) * split_count

উদাহরণ

// num_replicas: 2
// num_partitions: 1
// %operand@(0, 0): [[1, 2, 3, 4],
//                   [5, 6, 7, 8]]
// %operand@(1, 0): [[9, 10, 11, 12],
//                   [13, 14, 15, 16]]
%result = "stablehlo.all_to_all"(%operand) {
  split_dimension = 1 : i64,
  concat_dimension = 0 : i64,
  split_count = 2 : i64,
  replica_groups = dense<[[0, 1]]> : tensor<1x2xi64>
} : (tensor<2x4xi64>) -> tensor<4x2xi64>
// %result@(0, 0): [[1, 2],
//                  [5, 6],
//                  [9, 10],
//                  [13, 14]]
// %result@(1, 0): [[3, 4],
//                  [7, 8],
//                  [11, 12],
//                  [15, 16]]

আরো উদাহরণ

এবং

শব্দার্থবিদ্যা

দুটি টেনসর lhs এবং rhs এর উপাদান-ভিত্তিক AND সম্পাদন করে এবং একটি result টেনসর তৈরি করে। উপাদান প্রকারের উপর নির্ভর করে, নিম্নলিখিতগুলি করে:

• বুলিয়ানদের জন্য: যৌক্তিক এবং।
• পূর্ণসংখ্যার জন্য: bitwise AND.

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) type(lhs) = type(rhs) = type(result) ।

উদাহরণ

// %lhs: [[1, 2], [3, 4]]
// %rhs: [[5, 6], [7, 8]]
%result = "stablehlo.and"(%lhs, %rhs) : (tensor<2x2xi32>, tensor<2x2xi32>) -> tensor<2x2xi32>
// %result: [[1, 2], [3, 0]]

আরো উদাহরণ

atan2

শব্দার্থবিদ্যা

lhs এবং rhs টেনসরে উপাদান-ভিত্তিক atan2 অপারেশন করে এবং result টেনসর তৈরি করে। উপাদান প্রকারের উপর নির্ভর করে, নিম্নলিখিতগুলি করে:

• ফ্লোটের জন্য: IEEE-754 থেকে atan2 ।
• জটিল সংখ্যার জন্য: জটিল atan2।
• কোয়ান্টাইজড ধরনের জন্য: dequantize_op_quantize(atan2, lhs, rhs, type(result)) ।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) baseline_type(lhs) = baseline_type(rhs) = baseline_type(result) ।

উদাহরণ

// %lhs: [0.0, 1.0, -1.0]
// %rhs: [0.0, 0.0, 0.0]
%result = "stablehlo.atan2"(%lhs, %rhs) : (tensor<3xf64>, tensor<3xf64>) -> tensor<3xf64>
// %result: [0.0, 1.57079637, -1.57079637] // [0.0, pi/2, -pi/2]

আরো উদাহরণ

ব্যাচ_নর্ম_গ্র্যাড

শব্দার্থবিদ্যা

grad_output থেকে batch_norm_training ব্যাকপ্রোপাগেটিং এর বিভিন্ন ইনপুটের গ্রেডিয়েন্ট গণনা করে এবং grad_operand , grad_scale এবং grad_offset টেনসর তৈরি করে। আরও আনুষ্ঠানিকভাবে, এই ক্রিয়াকলাপটি নিম্নরূপ পাইথন সিনট্যাক্স ব্যবহার করে বিদ্যমান StableHLO ক্রিয়াকলাপগুলির একটি পচন হিসাবে প্রকাশ করা যেতে পারে:

def compute_sum(operand, feature_index):
  (sum,) = reduce(
      inputs=[operand],
      init_values=[constant(0, element_type(operand))],
      dimensions=[i for i in range(rank(operand)) if i != feature_index],
      body=lambda x, y: add(x, y))
  return sum

def compute_mean(operand, feature_index):
  sum = compute_sum(operand, feature_index)
  divisor = constant(size(operand) / dim(operand, feature_index),
                     element_type(operand))
  divisor_bcast = broadcast_in_dim(divisor, [], type(sum))
  return divide(sum, divisor_bcast)

def batch_norm_grad(operand, scale, mean, variance, grad_output, epsilon, feature_index):
  # Broadcast inputs to type(operand)
  scale_bcast = broadcast_in_dim(scale, [feature_index], type(operand))
  mean_bcast = broadcast_in_dim(mean, [feature_index], type(operand))
  variance_bcast = broadcast_in_dim(variance, [feature_index], type(operand))
  epsilon_bcast = broadcast_in_dim(constant(epsilon, element_type(operand)), [],
                                   type(operand))

  # Perform normalization using the provided `mean` and `variance`
  # Intermediate values will be useful for computing gradients
  centered_operand = subtract(operand, mean_bcast)
  stddev = sqrt(add(variance_bcast, epsilon_bcast))
  normalized_operand = divide(centered_operand, stddev)

  # Use the implementation from batchnorm_expander.cc in XLA
  # Temporary variables have exactly the same names as in the C++ code
  elements_per_feature = broadcast_in_dim(
      constant(divide(size(operand), dim(operand, feature_index)),
               element_type(grad_output)),
      [], type(operand))
  i1 = multiply(grad_output, elements_per_feature)
  i2 = broadcast_in_dim(
      compute_sum(grad_output, feature_index), [feature_index], type(operand))
  i3 = broadcast_in_dim(
      compute_sum(multiply(grad_output, centered_operand), feature_index),
      [feature_index], type(operand))
  i4 = multiply(i3, centered_operand)
  i5 = divide(i4, add(variance_bcast, epsilon_bcast))
  i6 = subtract(subtract(i1, i2), i5)

  grad_operand =
      multiply(divide(divide(scale_bcast, stddev), elements_per_feature), i6)
  grad_scale =
      compute_sum(multiply(grad_output, normalized_operand), feature_index)
  grad_offset = compute_sum(grad_output, feature_index)

  return grad_operand, grad_scale, grad_offset

quantized প্রকারের জন্য, dequantize_batch_norm_grad_or_training_quantize(lambda operand, scale, mean, variance, grad_output: batch_norm_grad(operand, scale, mean, variance, grad_output, epsilon, feature_index), operand, scale, mean, variance, grad_output, type(grad_operand), type(grad_scale), type(feature_index)) ।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) 0 <= feature_index < rank(operand) ।
• (C2) operand , scale , mean , variance , grad_output , grad_operand , grad_scale এবং grad_offset একই baseline_element_type আছে।
• (C3) operand , grad_output এবং grad_operand আকৃতি একই।
• (C4) scale , mean , variance , grad_scale এবং grad_offset আকৃতি একই।
• (C5) size(scale) = dim(operand, feature_index)

উদাহরণ

// %operand: [
//            [[1.0, 2.0], [3.0, 4.0]],
//            [[3.0, 4.0], [1.0, 2.0]]
//           ]
// %scale: [1.0, 1.0]
// %mean: [2.0, 3.0]
// %variance: [1.0, 1.0]
// %grad_output: [
//                [[0.1, 0.1], [0.1, 0.1]],
//                [[0.1, 0.1], [0.1, 0.1]]
//               ]
%grad_operand, %grad_scale, %grad_offset =
"stablehlo.batch_norm_grad"(%operand, %scale, %mean, %variance, %grad_output) {
  epsilon = 0.0 : f32,
  feature_index = 2 : i64
} : (tensor<2x2x2xf64>, tensor<2xf64>, tensor<2xf64>, tensor<2xf64>,
     tensor<2x2x2xf64>) -> (tensor<2x2x2xf64>, tensor<2xf64>, tensor<2xf64>)
// %grad_operand: [
//                 [[0.0, 0.0], [0.0, 0.0]],
//                 [[0.0, 0.0], [0.0, 0.0]]
//                ]
// %grad_scale:  [0.0, 0.0]
// %grad_offset: [0.4, 0.4]

ব্যাচ_নর্ম_ইনফারেন্স

শব্দার্থবিদ্যা

feature_index মাত্রা ব্যতীত সমস্ত মাত্রা জুড়ে operand টেনসরকে স্বাভাবিক করে এবং একটি result টেনসর তৈরি করে। আরও আনুষ্ঠানিকভাবে, এই ক্রিয়াকলাপটি নিম্নরূপ পাইথন সিনট্যাক্স ব্যবহার করে বিদ্যমান StableHLO ক্রিয়াকলাপগুলির একটি পচন হিসাবে প্রকাশ করা যেতে পারে:

def batch_norm_inference(operand, scale, offset, mean, variance, epsilon, feature_index):
  # Broadcast inputs to shape(operand)
  scale_bcast = broadcast_in_dim(scale, [feature_index], type(operand))
  offset_bcast = broadcast_in_dim(offset, [feature_index], type(operand))
  mean_bcast = broadcast_in_dim(mean, [feature_index], type(operand))
  variance_bcast = broadcast_in_dim(variance, [feature_index], type(operand))
  epsilon_bcast = broadcast_in_dim(constant(epsilon, element_type(operand)), [],
                                   type(operand))

  # Perform normalization using the provided `mean` and `variance` instead of
  # computing them like `batch_norm_training` does.
  centered_operand = subtract(operand, mean_bcast)
  stddev = sqrt(add(variance_bcast, epsilon_bcast))
  normalized_operand = divide(centered_operand, stddev)
  return add(multiply(scale_bcast, normalized_operand), offset_bcast)

quantized প্রকারের জন্য, dequantize_op_quantize(lambda operand, scale, offset, mean, variance: batch_norm_inference(operand, scale, offset, mean, variance, epsilon, feature_index), operand, scale, offset, mean, variance, type(result)) .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) 0 <= feature_index < rank(operand) ।
• (C2) operand , scale , offset , mean , variance এবং result একই baseline_element_type আছে।
• (C3) size(scale) = dim(operand, feature_index)
• (C4) size(offset) = dim(operand, feature_index) ।
• (C5) size(mean) = dim(operand, feature_index)
• (C6) size(variance) = dim(operand, feature_index)
• (C7) baseline_type(operand) = baseline_type(result) ।

উদাহরণ

// %operand: [
//            [[1.0, 2.0], [3.0, 4.0]],
//            [[3.0, 4.0], [1.0, 2.0]]
//           ]
// %scale: [1.0, 1.0]
// %offset: [1.0, 1.0]
// %mean: [2.0, 3.0]
// %variance: [1.0, 1.0]
%result = "stablehlo.batch_norm_inference"(%operand, %scale, %offset, %mean, %variance) {
  epsilon = 0.0 : f32,
  feature_index = 2 : i64
} : (tensor<2x2x2xf64>, tensor<2xf64>, tensor<2xf64>, tensor<2xf64>, tensor<2xf64>) -> tensor<2x2x2xf64>
// %result: [
//           [[0.0, 0.0], [2.0, 2.0]],
//           [[2.0, 2.0], [0.0, 0.0]]
//          ]

ব্যাচ_নর্ম_প্রশিক্ষণ

শব্দার্থবিদ্যা

feature_index ডাইমেনশন ব্যতীত সমস্ত মাত্রা জুড়ে কম্পিউট মানে এবং ভ্যারিয়েন্স এবং output , batch_mean এবং batch_var টেনসর উত্পাদনকারী operand টেনসরকে স্বাভাবিক করে। আরও আনুষ্ঠানিকভাবে, এই ক্রিয়াকলাপটি নিম্নরূপ পাইথন সিনট্যাক্স ব্যবহার করে বিদ্যমান StableHLO ক্রিয়াকলাপগুলির একটি পচন হিসাবে প্রকাশ করা যেতে পারে:

def compute_mean(operand, feature_index):
  (sum,) = reduce(
      inputs=[operand],
      init_values=[constant(0, element_type(operand))],
      dimensions=[i for i in range(rank(operand)) if i != feature_index],
      body=lambda x, y: add(x, y))
  divisor = constant(size(operand) / dim(operand, feature_index),
                     element_type(operand))
  divisor_bcast = broadcast_in_dim(divisor, [], type(sum))
  return divide(sum, divisor_bcast)

def compute_variance(operand, feature_index):
  mean = compute_mean(operand, feature_index)
  mean_bcast = broadcast_in_dim(mean, [feature_index], type(operand))
  centered_operand = subtract(operand, mean_bcast)
  return compute_mean(mul(centered_operand, centered_operand), feature_index)

def batch_norm_training(operand, scale, offset, epsilon, feature_index):
  mean = compute_mean(operand, feature_index)
  variance = compute_variance(operand, feature_index)
  return batch_norm_inference(operand, scale, offset, mean, variance, epsilon,
                              feature_index),
         mean, variance

quantized ধরনের জন্য, dequantize_batch_norm_grad_or_training_quantize(lambda operand, scale, offset: batch_norm_training(operand, scale, offset, epsilon, feature_index), operand, scale, offset, type(output), type(batch_mean), type(batch_var))

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) 0 <= feature_index < rank(operand) ।
• (C2) operand , scale , offset , batch_mean , batch_var এবং output একই baseline_element_type আছে।
• (C3) size(scale) = dim(operand, feature_index)
• (C4) size(offset) = dim(operand, feature_index) ।
• (C5) size(batch_mean) = dim(operand, feature_index) ।
• (C6) size(batch_var) = dim(operand, feature_index) ।
• (C7) baseline_type(output) = baseline_type(operand) ।

উদাহরণ

// %operand: [
//            [[1.0, 2.0], [3.0, 4.0]],
//            [[3.0, 4.0], [1.0, 2.0]]
//           ]
// %scale: [1.0, 1.0]
// %offset: [1.0, 1.0]
%output, %batch_mean, %batch_var = "stablehlo.batch_norm_training"(%operand, %scale, %offset) {
  epsilon = 0.0 : f32,
  feature_index = 2 : i64
} : (tensor<2x2x2xf64>, tensor<2xf64>, tensor<2xf64>) ->
    (tensor<2x2x2xf64>, tensor<2xf64>, tensor<2xf64>)
// %output: [
//           [[0.0, 0.0], [2.0, 2.0]],
//           [[2.0, 2.0], [0.0, 0.0]]
//          ]
// %batch_mean: [2.0, 3.0]
// %batch_var: [1.0, 1.0]

bitcast_convert

শব্দার্থবিদ্যা

operand টেনসরে একটি বিটকাস্ট অপারেশন সম্পাদন করে এবং একটি result টেনসর তৈরি করে যেখানে result টেনসরের ধরন ব্যবহার করে সম্পূর্ণ operand টেনসরের বিটগুলি পুনরায় ব্যাখ্যা করা হয়।

আরো আনুষ্ঠানিকভাবে, দেওয়া হল E = element_type(operand) , E' = element_type(result) , এবং R = rank(operand) :

• যদি num_bits(E') < num_bits(E) , bits(result[i0, ..., iR-1, :]) = bits(operand[i0, ..., iR-1])
• যদি num_bits(E') > num_bits(E) , bits(result[i0, ..., iR-2]) = bits(operand[i0, ..., iR-2, :])
• যদি num_bits(E') = num_bits(E) , bits(result[i0, ..., iR-1]) = bits(operand[i0, ..., iR-1])

bits একটি প্রদত্ত মানের ইন-মেমরি উপস্থাপনা প্রদান করে, এবং এর আচরণটি বাস্তবায়ন-সংজ্ঞায়িত কারণ টেনসরগুলির সঠিক উপস্থাপনাটি বাস্তবায়ন-সংজ্ঞায়িত, এবং উপাদান প্রকারের সঠিক উপস্থাপনাটি বাস্তবায়ন-সংজ্ঞায়িত।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) দেওয়া E = is_quantized(operand) ? storage_type(operand) : element_type(operand) , E' = is_quantized(result) ? storage_type(result) : element_type(result) , এবং R = rank(operand) :
  • যদি num_bits(E') = num_bits(E) , shape(result) = shape(operand) ।
  • যদি num_bits(E') < num_bits(E) :
  • rank(result) = R + 1 ।
  • dim(result, i) = dim(operand, i) সব 0 <= i < R এর জন্য।
  • dim(result, R) * num_bits(E') = num_bits(E) ।
  • যদি num_bits(E') > num_bits(E) :
  • rank(result) = R - 1 ।
  • dim(result, i) = dim(operand, i) সব 0 <= i < R এর জন্য।
  • dim(operand, R - 1) * num_bits(E) = num_bits(E')
• (C2) যদি is_complex(operand) or is_complex(result) , তাহলে is_complex(operand) and is_complex(result) ।

উদাহরণ

// %operand: 0x0123456789ABCDEF
%result = "stablehlo.bitcast_convert"(%operand) : (tensor<f64>) -> tensor<4xf16>
// %result: [0xCDEF, 0x89AB, 0x4567, 0x0123] // little-endian representation

আরো উদাহরণ

broadcast_in_dim

শব্দার্থবিদ্যা

operand টেনসরে ডেটা নকল করে একটি ইনপুট টেনসরের মাত্রা এবং/অথবা র‌্যাঙ্ক প্রসারিত করে এবং result টেনসর তৈরি করে। আরও আনুষ্ঠানিকভাবে, result[result_index] = operand[operand_index] যেখানে সমস্ত d axes(operand) :

• operand_index[d] = 0 যদি dim(operand, d) = 1 ।
• operand_index[d] = result_index[broadcast_dimensions[d]] অন্যথায়।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (সি 1) element_type(result) দ্বারা দেওয়া হয়েছে:
  • element_type(operand) , যদি !is_per_axis_quantized(operand) ।
  • element_type(operand) ব্যতীত quantization_dimension(operand) , scales(operand) , এবং zero_points(operand) quantization_dimension(result) , scales(result) , এবং zero_points(result) রেস। থেকে আলাদা হতে পারে, অন্যথায়।
• (সি 2) size(broadcast_dimensions) = rank(operand) ।
• (সি 3) 0 <= broadcast_dimensions < rank(result) ।
• (সি 4) is_unique(broadcast_dimensions) ।
• (সি 5) সমস্ত d axes(operand) :
  • dim(operand, d) = 1 বা
  • dim(operand, d) = dim(result, broadcast_dimensions[d]) ।
• (সি 6) যদি is_per_axis_quantized(result) :
  • quantization_dimension(result) = broadcast_dimensions[quantization_dimension(operand)] ।
  • যদি dim(operand, quantization_dimension(operand)) = 1 , তবে scales(result)[i] = scales(operand)[0] and zero_points(result)[i] = zero_points(operand)[0] for i in range(dim(result, quantization_dimension(result)))

উদাহরণ

// %operand: [
//            [1, 2, 3]
//           ]
%result = "stablehlo.broadcast_in_dim"(%operand) {
  broadcast_dimensions = array<i64: 2, 1>
} : (tensor<1x3xi32>) -> tensor<2x3x2xi32>
// %result: [
//            [
//             [1, 1],
//             [2, 2],
//             [3, 3]
//            ],
//            [
//             [1, 1],
//             [2, 2],
//             [3, 3]
//            ]
//          ]

আরো উদাহরণ

মামলা

শব্দার্থবিদ্যা

index মানের উপর নির্ভর করে branches থেকে ঠিক একটি ফাংশন সম্পাদন করে আউটপুট উত্পাদন করে। আরও আনুষ্ঠানিকভাবে, result = selected_branch() যেখানে:

• selected_branch = branches[index] যদি 0 <= index < size(branches) ।
• selected_branch = branches[-1] অন্যথায়।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (সি 1) 0 < size(branches) ।
• (সি 2) input_types(branches...) = [] ।
• (সি 3) same(output_types(branches...))
• (সি 4) type(results...) = output_types(branches[0])

উদাহরণ

// %index: -1
// %result_branch0: [0, 0]
// %result_branch1: [1, 1]
%result0, %result1 = "stablehlo.case"(%index) ({
  "stablehlo.return"(%result_branch0, %result_branch0) : (tensor<2xi64>, tensor<2xi64>) -> ()
}, {
  "stablehlo.return"(%result_branch1, %result_branch1) : (tensor<2xi64>, tensor<2xi64>) -> ()
}) : (tensor<i32>) -> (tensor<2xi64>, tensor<2xi64>)
// %result0: [1, 1]
// %result1: [1, 1]

আরো উদাহরণ

সিবিআরটি

শব্দার্থবিদ্যা

operand টেনসরে উপাদান-ভিত্তিক কিউবিক রুট অপারেশন সম্পাদন করে এবং result টেনসর তৈরি করে। উপাদান ধরণের উপর নির্ভর করে নিম্নলিখিতগুলি করে:

• ভাসমানগুলির জন্য: আইইইই -754 থেকে rootn(x, 3) ।
• জটিল সংখ্যার জন্য: জটিল কিউবিক রুট।
• কোয়ান্টাইজড প্রকারের জন্য: dequantize_op_quantize(cbrt, operand, type(result))

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (সি 1) baseline_type(operand) = baseline_type(result) ।

উদাহরণ

// %operand: [0.0, 1.0, 8.0, 27.0]
%result = "stablehlo.cbrt"(%operand) : (tensor<4xf64>) -> tensor<4xf64>
// %result: [0.0, 1.0, 2.0, 3.0]

আরো উদাহরণ

ছাদ

শব্দার্থবিদ্যা

operand টেনসারের উপাদান-ভিত্তিক সিল সম্পাদন করে এবং একটি result টেনসর তৈরি করে। আইইইইই -754 স্পেসিফিকেশন থেকে roundToIntegralTowardPositive অপারেশন প্রয়োগ করে। কোয়ান্টাইজড প্রকারের জন্য, dequantize_op_quantize(ceil, operand, type(result)) সম্পাদন করে।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (সি 1) baseline_type(operand) = baseline_type(result) ।

উদাহরণ

// %operand: [-0.8166, -0.2530, 0.2530, 0.8166, 2.0]
%result = "stablehlo.ceil"(%operand) : (tensor<5xf32>) -> tensor<5xf32>
// %result: [-0.0, -0.0, 1.0, 1.0, 2.0]

আরো উদাহরণ

চোলেস্কি

শব্দার্থবিদ্যা

ম্যাট্রিক্সের একটি ব্যাচের কোলেস্কি পচন গণনা করে।

আরও আনুষ্ঠানিকভাবে, i index_space(result) এর জন্য, result[i0, ..., iR-3, :, :] a[i0, ..., iR-3, :, :] , এর একটি কোলেস্কি পচন নিম্ন-ত্রিভুজাকার উভয় আকারে (যদি lower true হয়) বা উপরের-ত্রিভুজাকার (যদি lower false হয়) ম্যাট্রিক্স। বিপরীত ত্রিভুজের আউটপুট মানগুলি, অর্থাত্ উচ্চতর ত্রিভুজ বা কঠোর নিম্ন ত্রিভুজ অনুসারে, বাস্তবায়ন-সংজ্ঞায়িত।

যদি i উপস্থিত থাকে যেখানে ইনপুট ম্যাট্রিক্স কোনও হার্মিটিয়ান পজিটিভ-ডিফিনেট ম্যাট্রিক্স নয়, তবে আচরণটি অপরিজ্ঞাত।

কোয়ান্টাইজড প্রকারের জন্য, dequantize_op_quantize(lambda operand: cholesky(operand, lower), a, type(result)) সম্পাদন করে।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (সি 1) baseline_type(a) = baseline_type(result) ।
• (সি 2) 2 <= rank(a) ।
• (সি 3) dim(a, -2) = dim(a, -1) ।

উদাহরণ

// %a: [
//      [1.0, 2.0, 3.0],
//      [2.0, 20.0, 26.0],
//      [3.0, 26.0, 70.0]
//     ]
%result = "stablehlo.cholesky"(%a) {
  lower = true
} : (tensor<3x3xf32>) -> tensor<3x3xf64>
// %result: [
//           [1.0, 0.0, 0.0],
//           [2.0, 4.0, 0.0],
//           [3.0, 5.0, 6.0]
//          ]

বাতা

শব্দার্থবিদ্যা

ন্যূনতম এবং সর্বোচ্চ মানের মধ্যে operand টেনসারের প্রতিটি উপাদানকে ক্ল্যাম্প করে এবং result টেনসর তৈরি করে। আরও আনুষ্ঠানিকভাবে, result[result_index] = minimum(maximum(operand[result_index], min_element), max_element) , যেখানে min_element = rank(min) = 0 ? min[] : min[result_index] , max_element = rank(max) = 0 ? max[] : max[result_index] । কোয়ান্টাইজড প্রকারের জন্য, dequantize_op_quantize(clamp, min, operand, max, type(result)) সম্পাদন করে।

জটিল সংখ্যার উপর অর্ডার দেওয়ার ক্ষেত্রে অবাক করা শব্দার্থবিজ্ঞানের সাথে জড়িত, তাই ভবিষ্যতে আমরা এই অপারেশনের জন্য জটিল সংখ্যার জন্য সমর্থন অপসারণের পরিকল্পনা করছি ( #560 )।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (সি 1) rank(min) = 0 or shape(min) = shape(operand)
• (সি 2) rank(max) = 0 or shape(max) = shape(operand) ।
• baseline_element_type(min) = baseline_element_type(operand) = baseline_element_type(max)
• (সি 4) baseline_type(operand) = baseline_type(result) ।

উদাহরণ

// %min: [5, 10, 15]
// %operand: [3, 13, 23]
// %max: [10, 15, 20]
%result = "stablehlo.clamp"(%min, %operand, %max) : (tensor<3xi32>, tensor<3xi32>, tensor<3xi32>) -> tensor<3xi32>
// %result: [5, 13, 20]

আরো উদাহরণ

যৌথ_সম্প্রচার

শব্দার্থবিদ্যা

স্থিতিশীলতা প্রক্রিয়া গ্রিডে প্রতিটি প্রক্রিয়া গোষ্ঠীর মধ্যে, উত্স প্রক্রিয়া থেকে operand টেনসারের মান লক্ষ্য প্রক্রিয়াগুলিতে প্রেরণ করুন এবং result টেনসর উত্পাদন করুন।

অপারেশনটি স্টেবলহ্লো প্রক্রিয়া গ্রিডকে process_groups বিভক্ত করে যা নিম্নলিখিত হিসাবে সংজ্ঞায়িত করা হয়েছে:

• cross_replica(replica_groups) যদি channel_id <= 0 ।
• cross_partition(replica_groups) যদি channel_id > 0 ।

এরপরে, result@process দেওয়া হয়:

• operand@process_groups[i, 0] যদি সেখানে উপস্থিত থাকে i প্রক্রিয়াটি process_groups[i] ।
• broadcast_in_dim(constant(is_quantized(result) ? quantize(0, element_type(result)) : 0, element_type(result)), [], type(result)) অন্যথায়।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (সি 1) is_unique(replica_groups) ।
• (সি 2) 0 <= replica_groups < N যেখানে N হিসাবে সংজ্ঞায়িত করা হয়েছে:
  • num_replicas যদি cross_replica ব্যবহার করা হয়।
  • num_partitions যদি cross_partition ব্যবহার করা হয়।
• (সি 3) type(result) = type(operand) ।

উদাহরণ

// num_replicas: 4
// num_partitions: 1
// %operand@(0, 0): [[1, 2]]
// %operand@(1, 0): [[3, 4]]
// %operand@(2, 0): [[5, 6]]
// %operand@(3, 0): [[7, 8]]
%result = "stablehlo.collective_broadcast"(%operand) {
  replica_groups = dense<[[2, 1]]> : tensor<1x2xi64>,
  channel_handle = #stablehlo.channel_handle<handle = 0, type = 0>
} : (tensor1x2xi64>) -> tensor<1x2xi64>
// %result@(0, 0): [[0, 0]]
// %result@(1, 0): [[5, 6]]
// %result@(2, 0): [[5, 6]]
// %result@(3, 0): [[0, 0]]

সমষ্টিগত_পারমিউট

শব্দার্থবিদ্যা

স্থিতিশীলতা প্রক্রিয়া গ্রিডে প্রতিটি প্রক্রিয়া গোষ্ঠীর মধ্যে, উত্স প্রক্রিয়া থেকে operand টেনসারের মানটি লক্ষ্য প্রক্রিয়াতে প্রেরণ করে এবং result টেনসর তৈরি করে।

অপারেশনটি স্টেবলহ্লো প্রক্রিয়া গ্রিডকে process_groups বিভক্ত করে যা নিম্নলিখিত হিসাবে সংজ্ঞায়িত করা হয়েছে:

• cross_replica(source_target_pairs) যদি channel_id <= 0 ।
• cross_partition(source_target_pairs) যদি channel_id > 0 ।

এরপরে, result@process দেওয়া হয়:

• operand@process_groups[i, 0] , যদি সেখানে উপস্থিত থাকে যে i যেমন process_groups[i, 1] = process ।
• broadcast_in_dim(constant(is_quantized(result) ? quantize(0, element_type(result)) : 0, element_type(result)), [], type(result)) অন্যথায়।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (সি 1) dim(source_target_pairs, 1) = 2 ।
• (সি 2) is_unique(source_target_pairs[:, 0]) ।
• (সি 3) is_unique(source_target_pairs[:, 1]) ।
• (সি 4) 0 <= source_target_pairs < N , যেখানে N হিসাবে সংজ্ঞায়িত করা হয়েছে:
  • num_replicas যদি cross_replica ব্যবহার করা হয়।
  • num_partitions যদি cross_partition ব্যবহার করা হয়।
• (সি 5) type(result) = type(operand) ।

উদাহরণ

// num_replicas: 3
// num_partitions: 1
// %operand@(0, 0): [[1, 2], [3, 4]]
// %operand@(1, 0): [[5, 6], [7, 8]]
// %operand@(2, 0): [[9, 10], [11, 12]]
%result = "stablehlo.collective_permute"(%operand) {
  source_target_pairs = dense<[[0, 1], [1, 2]]> : tensor<2x2xi64>,
  channel_handle = #stablehlo.channel_handle<handle = 0, type = 0>
} : (tensor<2x2xi64>) -> tensor<2x2xi64>
//
// %result@(0, 0): [[0, 0], [0, 0]]
// %result@(1, 0): [[1, 2], [3, 4]]
// %result@(2, 0): [[5, 6], [7, 8]]

আরো উদাহরণ

তুলনা করা

শব্দার্থবিদ্যা

comparison_direction এবং compare_type অনুসারে lhs এবং rhs টেনারগুলির উপাদান-ভিত্তিক তুলনা সম্পাদন করে এবং result টেনসর তৈরি করে।

comparison_direction এবং compare_type মানগুলি নিম্নলিখিত শব্দার্থবিজ্ঞান রয়েছে:

বুলিয়ান এবং পূর্ণসংখ্যার উপাদানগুলির জন্য:

• EQ : lhs = rhs ।
• NE : lhs != rhs ।
• GE : lhs >= rhs ।
• GT : lhs > rhs ।
• LE : lhs <= rhs ।
• LT : lhs < rhs ।

compare_type = FLOAT সহ ভাসমান-পয়েন্ট উপাদান প্রকারের জন্য, ওপি নিম্নলিখিত আইইইই -754 অপারেশনগুলি প্রয়োগ করে:

• EQ : compareQuietEqual ।
• NE : compareQuietNotEqual ।
• GE : compareQuietGreaterEqual
• GT : compareQuietGreater ।
• LE : compareQuietLessEqual ।
• LT : compareQuietLess ।

compare_type = TOTALORDER সহ ভাসমান-পয়েন্ট উপাদান প্রকারের জন্য, ওপি আইইইই -754 থেকে totalOrder এবং compareQuietEqual ক্রিয়াকলাপের সংমিশ্রণ ব্যবহার করে। এই বৈশিষ্ট্যটি অব্যবহৃত বলে মনে হচ্ছে, সুতরাং ভবিষ্যতে আমরা এটি অপসারণের পরিকল্পনা করছি ( #584 )।

জটিল উপাদানগুলির জন্য, (real, imag) জোড়গুলির লিক্সোগ্রাফিক তুলনা প্রদত্ত comparison_direction এবং compare_type ব্যবহার করে সঞ্চালিত হয়। জটিল সংখ্যার উপর একটি ক্রম চাপানোতে আশ্চর্যজনক শব্দার্থবিজ্ঞানের সাথে জড়িত, সুতরাং ভবিষ্যতে আমরা comparison_direction GE , GT , LE বা LT ( #560 ) হয় যখন জটিল সংখ্যার জন্য সমর্থন অপসারণের পরিকল্পনা করছি।

কোয়ান্টাইজড ধরণের জন্য। dequantize_compare(lhs, rhs, comparison_direction) ।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (সি 1) baseline_element_type(lhs) = baseline_element_type(rhs) ।
• (সি 2) shape(lhs) = shape(rhs) = shape(result) ।
• (সি 3) compare_type হিসাবে সংজ্ঞায়িত করা হয়েছে:
  • SIGNED যদি is_signed_integer(element_type(lhs)) ।
  • UNSIGNED যদি is_unsigned_integer(element_type(lhs)) or is_boolean(element_type(lhs))
  • FLOAT বা TOTALORDER যদি is_float(element_type(lhs)) ।
  • FLOAT যদি is_complex(element_type(lhs)) ।

উদাহরণ

// %lhs: [1.0, 3.0]
// %rhs: [1.1, 2.9]
%result = "stablehlo.compare"(%lhs, %rhs) {
  comparison_direction = #stablehlo<comparison_direction LT>,
  compare_type = #stablehlo<comparison_type FLOAT>
} : (tensor<2xf32>, tensor<2xf32>) -> tensor<2xi1>
// %result: [true, false]

আরো উদাহরণ

জটিল

শব্দার্থবিদ্যা

বাস্তব এবং কাল্পনিক মান, lhs এবং rhs একজোড়া থেকে একটি জটিল মানতে উপাদান-ভিত্তিক রূপান্তর সম্পাদন করে এবং result টেনসর তৈরি করে।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (সি 1) type(lhs) = type(rhs) ।
• (সি 2) shape(result) = shape(lhs) ।
• (সি 3) element_type(result) টাইপ complex<E> যেখানে E = element_type(lhs) রয়েছে।

উদাহরণ

// %lhs: [1.0, 3.0]
// %rhs: [2.0, 4.0]
%result = "stablehlo.complex"(%lhs, %rhs) : (tensor<2xf64>, tensor<2xf64>) -> tensor<2xcomplex<f64>>
// %result: [(1.0, 2.0), (3.0, 4.0)]

আরো উদাহরণ

যৌগিক

শব্দার্থবিদ্যা

inputs এবং composite_attributes গ্রহণ এবং results উত্পাদন করে এমন অন্যান্য স্থিতিশীল অপারেশনগুলির তৈরি (রচিত) একটি অপারেশনকে এনক্যাপসুলেট করে। ওপি -র শব্দার্থবিজ্ঞানগুলি decomposition বৈশিষ্ট্য দ্বারা প্রয়োগ করা হয়। composite ওপি প্রোগ্রামের শব্দার্থবিজ্ঞান পরিবর্তন না করে তার পচন দিয়ে প্রতিস্থাপন করা যেতে পারে। যেসব ক্ষেত্রে পচনকে অন্তর্ভুক্ত করা একই ওপি শব্দার্থবিজ্ঞান সরবরাহ করে না, custom_call ব্যবহার করা পছন্দ করে।

version ক্ষেত্রটি ( 0 এ ডিফল্ট) যখন কোনও সংমিশ্রণের শব্দার্থবিজ্ঞানের পরিবর্তন হয় তখন বোঝাতে ব্যবহৃত হয়।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (সি 1) is_namespaced_op_name(name)
• (সি 2) is_defined_in_parent_scope(decomposition)
• (সি 3) types(inputs...) == input_types(decomposition)
• (সি 4) types(results...) == output_types(decomposition)

উদাহরণ

%results = "stablehlo.composite"(%input0, %input1) {
  name = "my_namespace.my_op",
  composite_attributes = {
    my_attribute = "my_value"
  },
  decomposition = @my_op,
  version = 1 : i32
} : (tensor<f32>, tensor<f32>) -> tensor<f32>

আরো উদাহরণ

শ্রেণীবদ্ধভাবে সংযুক্ত করা

শব্দার্থবিদ্যা

প্রদত্ত আর্গুমেন্ট হিসাবে একই ক্রমে dimension মাত্রা বরাবর inputs কনটেনটেটস এবং result টেনসর তৈরি করে। আরও আনুষ্ঠানিকভাবে, result[i0, ..., id, ..., iR-1] = inputs[k][i0, ..., kd, ..., iR-1] , যেখানে:

1. id = d0 + ... + dk-1 + kd ।
2. d dimension সমান, এবং d0 , ... d inputs মাত্রা মাপ।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (সি 1) same(element_type(inputs...))
• (সি 2) same(shape(inputs...)) dim(inputs..., dimension) ব্যতীত।
• (সি 3) 0 < size(inputs) ।
• (সি 4) 0 <= dimension < rank(inputs[0]) ।
• (সি 5) element_type(result) = element_type(inputs[0]) ।
• (সি 6) shape(result) = shape(inputs[0]) ব্যতীত:
  • dim(result, dimension) = dim(inputs[0], dimension) + ...

উদাহরণ

// %input0: [[1, 2], [3, 4], [5, 6]]
// %input1: [[7, 8]]
%result = "stablehlo.concatenate"(%input0, %input1) {
  dimension = 0 : i64
} : (tensor<3x2xi64>, tensor<1x2xi64>) -> tensor<4x2xi64>
// %result: [[1, 2], [3, 4], [5, 6], [7, 8]]

আরো উদাহরণ

ধ্রুবক

শব্দার্থবিদ্যা

একটি ধ্রুবক value থেকে একটি output টেনসর উত্পাদন করে।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (সি 1) type(value) = type(output) ।

উদাহরণ

%output = "stablehlo.constant"() {
  value = dense<[[0.0, 1.0], [2.0, 3.0]]> : tensor<2x2xf32>
} : () -> tensor<2x2xf32>
// %output: [[0.0, 1.0], [2.0, 3.0]]

আরো উদাহরণ

রূপান্তর

শব্দার্থবিদ্যা

operand টেনসারে একটি উপাদান থেকে অন্য উপাদান থেকে অন্যটিতে একটি উপাদান-ভিত্তিক রূপান্তর সম্পাদন করে এবং result টেনসর তৈরি করে।

বুলিয়ান থেকে যে-কোনও-সমর্থিত-টাইপ রূপান্তরগুলির জন্য, মান false শূন্যে রূপান্তরিত হয় এবং true মানটি একটিতে রূপান্তরিত হয়। যে কোনও সমর্থিত-টাইপ-টু-বুলিয়ান রূপান্তরগুলির জন্য, একটি শূন্য মানকে false রূপান্তরিত করা হয়, এবং অ-শূন্য মানগুলি true রূপান্তরিত হয়। জটিল ধরণের জন্য এটি কীভাবে কাজ করে তার জন্য নীচে দেখুন।

পূর্ণসংখ্যা-থেকে-বুদ্ধিমান , পূর্ণসংখ্যা-থেকে-ভাসমান-পয়েন্ট বা ভাসমান-পয়েন্ট-থেকে-ভাসমান-পয়েন্ট জড়িত রূপান্তরগুলির জন্য, যদি উত্সের মানটি গন্তব্য প্রকারের মধ্যে হুবহু উপস্থাপিত হতে পারে তবে ফলাফলের মানটি সঠিক উপস্থাপনা। অন্যথায়, আচরণটি টিবিডি ( #180 )।

ভাসমান-পয়েন্ট-টু-ইনজিগারে জড়িত রূপান্তরগুলির জন্য, ভগ্নাংশের অংশটি কাটা হয়। যদি কাটা মানটি গন্তব্য প্রকারে প্রতিনিধিত্ব করা যায় না তবে আচরণটি টিবিডি ( #180 )।

জটিল থেকে জটিল জড়িত রূপান্তর বাস্তব এবং কল্পিত অংশগুলিকে রূপান্তর করার জন্য ভাসমান-পয়েন্ট-থেকে-ভাসমান-পয়েন্ট রূপান্তরগুলির একই আচরণ অনুসরণ করে।

জটিল-থেকে-অন্য-অন্য ধরণের এবং যে কোনও ধরণের থেকে জটিল রূপান্তরগুলির জন্য, উত্স কাল্পনিক মানটিকে উপেক্ষা করা হয় বা গন্তব্য কাল্পনিক মান যথাক্রমে শূন্য হয়। আসল অংশটির রূপান্তর ভাসমান-পয়েন্ট রূপান্তর অনুসরণ করে।

নীতিগতভাবে, এই অপারেশনটি ডেকুয়ান্টিজেশন (কোয়ান্টাইজড টেনারগুলি থেকে নিয়মিত টেনারগুলিতে রূপান্তর), কোয়ান্টাইজেশন (নিয়মিত টেনারস থেকে কোয়ান্টাইজড টেনসরগুলিতে রূপান্তর) এবং প্রয়োজনীয়করণ (কোয়ান্টাইজড টেনসারের মধ্যে রূপান্তর) প্রকাশ করতে পারে, তবে এই মুহুর্তে আমরা সেই জন্য উত্সর্গীকৃত অপারেশনগুলি - ইউনিফর্ম_ডেকান্টাইজ করেছি - uniform_dequantize প্রথম ব্যবহারের কেস এবং দ্বিতীয় এবং তৃতীয় ব্যবহারের ক্ষেত্রে uniform_quantize । ভবিষ্যতে, এই দুটি ওপি convert ( #1576 ) এ একীভূত হতে পারে।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (সি 1) shape(operand) = shape(result) ।

উদাহরণ

// %operand: [-1, 0, 1]
%result = "stablehlo.convert"(%operand) : (tensor<3xi64>) -> tensor<3xcomplex<f64>>
// %result: [(-1.0, 0.0), (0.0, 0.0), (1.0, 0.0)]

আরো উদাহরণ

আবর্তন

শব্দার্থবিদ্যা

lhs উইন্ডো এবং rhs স্লাইসগুলির মধ্যে ডট পণ্য গণনা করে এবং result উত্পাদন করে। নিম্নলিখিত চিত্রটি দেখায় যে কীভাবে result উপাদানগুলি lhs এবং rhs থেকে একটি কংক্রিট উদাহরণ ব্যবহার করে গণনা করা হয়।

আরও আনুষ্ঠানিকভাবে, lhs উইন্ডোজ প্রকাশ করতে সক্ষম হওয়ার জন্য lhs ক্ষেত্রে ইনপুটগুলির নিম্নলিখিত পুনর্নির্মাণের বিষয়টি বিবেচনা করুন:

• lhs_window_dimensions = lhs_shape(dim(lhs, input_batch_dimension), dim(rhs, kernel_spatial_dimensions), dim(lhs, input_feature_dimension))
• lhs_window_strides = lhs_shape(1, window_strides, 1) ।
• lhs_padding = lhs_shape([0, 0], padding, [0, 0])
• lhs_base_dilations = lhs_shape(1, lhs_dilation, 1) ।
• lhs_window_dilations = lhs_shape(1, rhs_dilation, 1) ।

এই রিফ্রেমিংটি নিম্নলিখিত সহায়ক ফাংশনগুলি ব্যবহার করে:

• lhs_shape(n, hw, c) = permute([n] + hw + [c], [input_batch_dimension] + input_spatial_dimensions + [input_feature_dimension])
• result_shape(n1, hw, c1) = permute([n1] + hw + [c1], [output_batch_dimension] + output_spatial_dimensions + [output_feature_dimension])
• permute([j0, j1, ..., jR-1], permutation) = [i0, i1, ..., iR-1] যেখানে j[d] = i[permutation[d]] ।

যদি feature_group_count = 1 এবং batch_group_count = 1 , তবে সূচক_স্পেসে সমস্ত output_spatial_index জন্য index_space(dim(result, output_spatial_dimensions...)) , result[result_shape(:, output_spatial_index, :)] = dot_product যেখানে:

• padding_value = constant(0, element_type(lhs))
• padded_lhs = pad(lhs, padding_value, lhs_padding[:, 0], lhs_padding[:, 1], lhs_base_dilations - 1)
• lhs_window_start = lhs_shape(0, output_spatial_index, 0) * lhs_window_strides ।
• lhs_window = slice(padded_lhs, lhs_window_start, lhs_window_start + lhs_window_dimensions, lhs_window_dilations) ।
• reversed_lhs_window = reverse(lhs_window, [input_spatial_dimensions[dim] for dim in range(size(window_reversal)) if window_reversal[dim] = true]) এই বৈশিষ্ট্যটি অব্যবহৃত বলে মনে হচ্ছে, সুতরাং ভবিষ্যতে আমরা এটি অপসারণের পরিকল্পনা করছি ( #1181 )।
• dot_product = dot_general(reversed_lhs_window, rhs, lhs_batching_dimensions=[], lhs_contracting_dimensions=input_spatial_dimensions + [input_feature_dimension], rhs_batching_dimensions=[], rhs_contracting_dimensions=kernel_spatial_dimensions + [kernel_input_feature_dimension]) .

যদি feature_group_count > 1 :

• lhses = split(lhs, feature_group_count, input_feature_dimension) ।
• rhses = split(rhs, feature_group_count, kernel_output_feature_dimension) ।
• results... = convolution(lhses..., rhses..., ..., feature_group_count=1, ...)
• result = concatenate(results, output_feature_dimension) ।

যদি batch_group_count > 1 :

• lhses = split(lhs, batch_group_count, input_batch_dimension) ।
• rhses = split(rhs, batch_group_count, kernel_output_feature_dimension) ।
• results... = convolution(lhses..., rhses..., ..., batch_group_count=1, ...)
• result = concatenate(results, output_feature_dimension) ।

কোয়ান্টাইজড প্রকারের জন্য, dequantize_op_quantize( lambda lhs, rhs: convolution(lhs, rhs, window_strides, padding, lhs_dilation, rhs_dilation, window_reversal, input_batch_dimension, input_feature_dimension, input_spatial_dimensions, kernel_input_feature_dimension, kernel_output_feature_dimension, kernel_spatial_dimensions, output_batch_dimension, output_feature_dimension, output_spatial_dimensions, feature_group_count, batch_group_count, precision_config), lhs, rhs, type(result)) ।

হাইব্রিড কোয়ান্টাইজড প্রকারের জন্য, hybrid_dequantize_then_op( lambda lhs, rhs: convolution(lhs, rhs, window_strides, padding, lhs_dilation, rhs_dilation, window_reversal, input_batch_dimension, input_feature_dimension, input_spatial_dimensions, kernel_input_feature_dimension, kernel_output_feature_dimension, kernel_spatial_dimensions, output_batch_dimension, output_feature_dimension, output_spatial_dimensions, feature_group_count, batch_group_count, precision_config), lhs, rhs) ।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (সি 1) N = rank(lhs) = rank(rhs) ।
• (সি 2) size(window_strides) = N - 2 ।
• (সি 3) 0 < window_strides ।
• (সি 4) shape(padding) = [N - 2, 2] ।
• (সি 5) size(lhs_dilation) = N - 2 ।
• (সি 6) 0 < lhs_dilation ।
• (সি 7) size(rhs_dilation) = N - 2 ।
• (সি 8) 0 < rhs_dilation ।
• (সি 9) size(window_reversal) = N - 2 ।
• (সি 10) dim(lhs, input_batch_dimension) % batch_group_count = 0 ।
• (সি 11) dim(lhs, input_feature_dimension) % feature_group_count = 0 ।
• (সি 12) size(input_spatial_dimensions) = N - 2 ।
• input_dimensions = [input_batch_dimension] + input_spatial_dimensions + [input_feature_dimension]
  • is_unique(input_dimensions) ।
  • 0 <= input_dimensions < N ।
• (C14) dim(rhs, kernel_input_feature_dimension) = dim(lhs, input_feature_dimension) / feature_group_count ।
• (সি 15) dim(rhs, kernel_output_feature_dimension) % batch_group_count = 0 ।
• (সি 16) dim(rhs, kernel_output_feature_dimension) % feature_group_count = 0 ।
• (সি 17) size(kernel_spatial_dimensions) = N - 2 ।
• (C18) প্রদত্ত kernel_dimensions = kernel_spatial_dimensions + [kernel_input_feature_dimension] + [kernel_output_feature_dimension] :
  • is_unique(kernel_dimensions) ।
  • 0 <= kernel_dimensions < N ।
• (সি 19) size(output_spatial_dimensions) = N - 2 ।
• (সি 20) প্রদত্ত output_dimensions = [output_batch_dimension] + output_spatial_dimensions + [output_feature_dimension] :
  • is_unique(output_dimensions) ।
  • 0 <= output_dimensions < N ।
• (সি 21) 0 < feature_group_count ।
• (সি 22) 0 < batch_group_count ।
• (সি 23) feature_group_count = 1 or batch_group_count = 1 ।
• (সি 24) size(precision_config) = 2 ।
• (সি 25) dim(result, result_dim) হিসাবে সংজ্ঞায়িত করা হয়েছে:
  • dim(lhs, input_batch_dimension) / batch_group_count যদি result_dim = output_batch_dimension ।
  • dim(rhs, kernel_output_feature_dimension) যদি result_dim = output_feature_dimension ।
  • num_windows অন্যথায়, যেখানে:
  • output_spatial_dimensions[spatial_dim] = result_dim ।
  • lhs_dim = input_spatial_dimensions[spatial_dim] ।
  • rhs_dim = kernel_spatial_dimensions[spatial_dim] ।
  • dilated_input_shape[lhs_dim] = dim(lhs, lhs_dim) = 0 ? 0 : (dim(lhs, lhs_dim) - 1) * lhs_dilation[spatial_dim] + 1 ।
  • padded_input_shape[lhs_dim] = padding[spatial_dim, 0] + dilated_input_shape[lhs_dim] + padding[spatial_dim, 1] ।
  • dilated_window_shape[lhs_dim] = dim(rhs, rhs_dim) = 0 ? 0 : (dim(rhs, rhs_dim) - 1) * rhs_dilation[spatial_dim] + 1 ।
  • is_empty_window[lhs_dim] = padded_input_shape[lhs_dim] = 0 || dilated_window_shape[lhs_dim] > padded_input_shape[lhs_dim] ।
  • num_windows = is_empty_window[lhs_dim] ? 0 : floor((padded_input_shape[lhs_dim] - dilated_window_shape[lhs_dim]) / window_strides[spatial_dim]) + 1 ।
• (সি 26) rank(result) = N ।
• যদি অপারেশনটি অ-কোয়ান্টাইজড টেনার ব্যবহার করে:
  • (সি 27) element_type(lhs) = element_type(rhs) = element_type(result) ।
• যদি অপারেশনটি কোয়ান্টাইজড টেনার ব্যবহার করে:
  • (সি 28) is_quantized(lhs) = is_quantized(result) and is_quantized(rhs) ।
  • (C29) যদি is_per_axis_quantized(rhs) , তবে quantization_dimension(rhs) = kernel_output_feature_dimension ।
  • (সি 30) যদি is_per_axis_quantized(result) , তবে quantization_dimension(result) = output_feature_dimension ।
  • যদি is_quantized(lhs) :
  • (সি 31) storage_type(lhs) = storage_type(rhs) ।
  • (সি 32) expressed_type(lhs) = expressed_type(rhs) = expressed_type(result) ।
  • (C33) যদি is_per_tensor_quantized(rhs) , তবে is_per_tensor_quantized(result) ।
  • যদি !is_quantized(lhs) :
  • (সি 34) element_type(lhs) = expressed_type(rhs) = element_type(result) ।

উদাহরণ

// %lhs: [[
//        [
//          [1], [2], [5], [6]
//        ],
//        [
//          [3], [4], [7], [8]
//        ],
//        [
//          [10], [11], [14], [15]
//        ],
//        [
//          [12], [13], [16], [17]
//        ]
//      ]]
//
// %rhs : [
//         [[[1]], [[1]], [[1]]],
//         [[[1]], [[1]], [[1]]],
//         [[[1]], [[1]], [[1]]]
//        ]
%result = "stablehlo.convolution"(%lhs, %rhs) {
  window_strides = array<i64: 4, 4>,
  padding = dense<0> : tensor<2x2xi64>,
  lhs_dilation = array<i64: 2, 2>,
  rhs_dilation = array<i64: 1, 1>,
  window_reversal = array<i1: false, false>,
  // In the StableHLO dialect, dimension numbers are encoded via:
  // `[<input dimensions>]x[<kernel dimensions>]->[output dimensions]`.
  // "b" is batch dimension, "f" is feature dimension,
  // "i" is input feature dimension, "o" is output feature dimension,
  // "0/1/etc" are spatial dimensions.
  dimension_numbers = #stablehlo.conv<[b, 0, 1, f]x[0, 1, i, o]->[b, 0, 1, f]>,
  batch_group_count = 1 : i64,
  feature_group_count = 1 : i64,
  precision_config = [#stablehlo<precision DEFAULT>, #stablehlo<precision DEFAULT>]
} : (tensor<1x4x4x1xi64>, tensor<3x3x1x1xi64>) -> tensor<1x2x2x1xi64>
// %result: [[
//            [[10], [26]],
//            [[46], [62]]
//          ]]

আরো উদাহরণ

কোসাইন

শব্দার্থবিদ্যা

operand টেনসারে উপাদান-ভিত্তিক কোসাইন অপারেশন সম্পাদন করে এবং result টেনসর তৈরি করে। উপাদান ধরণের উপর নির্ভর করে নিম্নলিখিতগুলি করে:

• ভাসমানের জন্য: আইইইই -754 থেকে cos ।
• জটিল সংখ্যার জন্য: জটিল কোসাইন।
• কোয়ান্টাইজড প্রকারের জন্য: dequantize_op_quantize(cosine, operand, type(result)) ।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (সি 1) baseline_type(operand) = baseline_type(result) ।

উদাহরণ

// %operand: [
//            [0.0, 1.57079632],       // [0, pi/2]
//            [3.14159265, 4.71238898] // [pi, 3pi/2]
//           ]
%result = "stablehlo.cosine"(%operand) : (tensor<2x2xf32>) -> tensor<2x2xf32>
// %result: [[1.0, 0.0], [-1.0, 0.0]]

আরো উদাহরণ

গণনা_প্রধান_শূন্য

শব্দার্থবিদ্যা

operand টেনসারে শীর্ষস্থানীয় শূন্য বিটগুলির সংখ্যার উপাদান-ভিত্তিক গণনা সম্পাদন করে এবং result টেনসর তৈরি করে।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (সি 1) type(operand) = type(result) ।

উদাহরণ

// %operand: [[0, 1], [128, -1]]
%result = "stablehlo.count_leading_zeros"(%operand) : (tensor<2x2xi64>) -> tensor<2x2xi64>
// %result: [[64, 63], [56, 0]]

আরো উদাহরণ

কাস্টম_কল

শব্দার্থবিদ্যা

একটি বাস্তবায়ন-সংজ্ঞায়িত অপারেশন call_target_name এনক্যাপসুলেট করে যা inputs নেয় এবং called_computations গ্রহণ করে এবং results দেয়। has_side_effect , backend_config এবং api_version অতিরিক্ত বাস্তবায়ন-সংজ্ঞায়িত মেটাডেটা সরবরাহ করতে ব্যবহৃত হতে পারে।

এই মুহুর্তে, এই অপারেশনে মেটাডেটার মোটামুটি বিশৃঙ্খলাযুক্ত সংগ্রহ রয়েছে যা এক্সএলএ সংকলকটিতে এর সমকক্ষ অপারেশনের জৈব বিবর্তনকে প্রতিফলিত করে। ভবিষ্যতে, আমরা এই মেটাডেটা ( #741 ) একত্রিত করার পরিকল্পনা করছি।

ইনপুট

আউটপুট

উদাহরণ

%results = "stablehlo.custom_call"(%input0) {
  call_target_name = "foo",
  has_side_effect = false,
  backend_config = "bar",
  api_version = 1 : i32,
  called_computations = [@foo]
} : (tensor<f64>) -> tensor<f64>

বিভক্ত করা

শব্দার্থবিদ্যা

লভ্যাংশ lhs এবং বিভাজক rhs টেনারগুলির উপাদান-ভিত্তিক বিভাগ সম্পাদন করে এবং result টেনসর তৈরি করে। উপাদান ধরণের উপর নির্ভর করে নিম্নলিখিতগুলি করে:

• পূর্ণসংখ্যার জন্য: পূর্ণসংখ্যা বিভাগ যা কোনও ভগ্নাংশের অংশটি ফেলে দেওয়া বীজগণিতের ভাগফল উত্পাদন করে।
• ভাসমানের জন্য: আইইইই -754 থেকে division ।
• জটিল সংখ্যার জন্য: জটিল বিভাগ।
• কোয়ান্টাইজড ধরণের জন্য:
  • dequantize_op_quantize(divide, lhs, rhs, type(result)) ।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (সি 1) baseline_type(lhs) = baseline_type(rhs) = baseline_type(result) ।

উদাহরণ

// %lhs: [17.1, -17.1, 17.1, -17.1]
// %rhs: [3.0, 3.0, -3.0, -3.0]
%result = "stablehlo.divide"(%lhs, %rhs) : (tensor<4xf32>, tensor<4xf32>) -> tensor<4xf32>
// %result: [5.66666651, -5.66666651, -5.66666651, 5.66666651]

আরো উদাহরণ

ডট_জেনারেল

শব্দার্থবিদ্যা

lhs স্লাইস এবং rhs টুকরোগুলির মধ্যে ডট পণ্যগুলি গণনা করে এবং result টেনসর তৈরি করে।

আরও আনুষ্ঠানিকভাবে, result[result_index] = dot_product , যেখানে:

• lhs_result_dimensions = [d for d in axes(lhs) and d not in lhs_batching_dimensions and d not in lhs_contracting_dimensions] ।
• rhs_result_dimensions = [d for d in axes(rhs) and d not in rhs_batching_dimensions and d not in rhs_contracting_dimensions] ।
• result_batching_index + result_lhs_index + result_rhs_index = result_index যেখানে size(result_batching_index) = size(lhs_batching_dimensions) , size(result_lhs_index) = size(lhs_result_dimensions) size(result_rhs_index) = size(rhs_result_dimensions)
• transposed_lhs = transpose(lhs, lhs_batching_dimensions + lhs_result_dimensions + lhs_contracting_dimensions) ।
• transposed_lhs_slice = slice(transposed_lhs, result_batching_index + result_lhs_index + [:, ..., :]) ।
• reshaped_lhs_slice = reshape(transposed_lhs_slice, dims(lhs, lhs_contracting_dimensions)) ।
• transposed_rhs = transpose(rhs, rhs_batching_dimensions + rhs_result_dimensions + rhs_contracting_dimensions) ।
• transposed_rhs_slice = slice(transposed_rhs, result_batching_index + result_rhs_index + [:, ..., :]) ।
• reshaped_rhs_slice = reshape(transposed_rhs_slice, dims(rhs, rhs_contracting_dimensions)) ।
• dot_product = reduce( inputs=[multiply(reshaped_lhs_slice, reshaped_rhs_slice)], init_values=[constant(0, element_type(result))], dimensions=range(size(lhs_contracting_dimensions)), body=lambda x, y: add(x, y)) ।

কোয়ান্টাইজড প্রকারের জন্য, dequantize_op_quantize( lambda lhs, rhs: dot_general(lhs, rhs, lhs_batching_dimensions, rhs_batching_dimensions, lhs_contracting_dimensions, rhs_contracting_dimensions, precision_config), lhs, rhs, type(result))

হাইব্রিড কোয়ান্টাইজড প্রকারের জন্য, hybrid_dequantize_then_op( lambda lhs, rhs: dot_general(lhs, rhs, lhs_batching_dimensions, rhs_batching_dimensions, lhs_contracting_dimensions, rhs_contracting_dimensions, precision_config), lhs, rhs) সম্পাদন করে।

precision_config এক্সিলারেটর ব্যাকেন্ডগুলিতে গণনার জন্য গতি এবং নির্ভুলতার মধ্যে ট্রেড অফকে নিয়ন্ত্রণ করে। এটি নিম্নলিখিতগুলির মধ্যে একটি হতে পারে (এই মুহুর্তে, এই এনাম মানগুলির শব্দার্থবিজ্ঞানগুলি আন্ডারস্পাইফাইড করা হয়েছে, তবে আমরা #755 এ এটিকে সম্বোধন করার পরিকল্পনা করছি):

• DEFAULT : দ্রুততম গণনা, তবে মূল সংখ্যায় কমপক্ষে সঠিক অনুমান।
• HIGH : ধীর গণনা, তবে মূল সংখ্যার আরও সঠিক অনুমান।
• HIGHEST : ধীরতম গণনা, তবে মূল সংখ্যার সর্বাধিক সঠিক অনুমান।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (সি 1) size(lhs_batching_dimensions) = size(rhs_batching_dimensions) ।
• (সি 2) size(lhs_contracting_dimensions) = size(rhs_contracting_dimensions) ।
• (সি 3) is_unique(lhs_batching_dimensions + lhs_contracting_dimensions) ।
• (সি 4) is_unique(rhs_batching_dimensions + rhs_contracting_dimensions) ।
• (সি 5) 0 <= lhs_batching_dimensions < rank(lhs) ।
• (সি 6) 0 <= lhs_contracting_dimensions < rank(lhs) ।
• (সি 7) 0 <= rhs_batching_dimensions < rank(rhs) ।
• (সি 8) 0 <= rhs_contracting_dimensions < rank(rhs) ।
• (সি 9) dim(lhs, lhs_batching_dimensions...) = dim(rhs, rhs_batching_dimensions...) ।
• (সি 10) dim(lhs, lhs_contracting_dimensions...) = dim(rhs, rhs_contracting_dimensions...)
• (সি 11) size(precision_config) = 2 ।
• (সি 12) shape(result) = dim(lhs, lhs_batching_dimensions) + dim(lhs, lhs_result_dimensions) + dim(rhs, rhs_result_dimensions)
• যদি অপারেশনটি অ-কোয়ান্টাইজড টেনার ব্যবহার করে:
  • (সি 13) element_type(lhs) = element_type(rhs) ।
• যদি অপারেশনটি কোয়ান্টাইজড টেনার ব্যবহার করে:
  • (সি 14) is_quantized(lhs) = is_quantized(result) and is_quantized(rhs) ।
  • (সি 15) zero_points(rhs) = 0 ।
  • (সি 16) যদি is_per_axis_quantized(rhs) , তবে quantization_dimension(rhs) rhs_contracting_dimensions নয়।
  • যদি is_quantized(lhs) :
  • (সি 17) storage_type(lhs) = storage_type(rhs) ।
  • (সি 18) expressed_type(lhs) = expressed_type(rhs) = expressed_type(result) ।
  • (C19) যদি is_per_tensor_quantized(rhs) , তবে is_per_tensor_quantized(result) ।
  • যদি !is_quantized(lhs) :
  • (সি 20) element_type(lhs) = expressed_type(rhs) = element_type(result) ।

উদাহরণ

// %lhs: [
//        [[1, 2],
//         [3, 4]],
//        [[5, 6],
//         [7, 8]]
//       ]
// %rhs: [
//        [[1, 0],
//         [0, 1]],
//        [[1, 0],
//         [0, 1]]
//       ]
%result = "stablehlo.dot_general"(%lhs, %rhs) {
  dot_dimension_numbers = #stablehlo.dot<
    lhs_batching_dimensions = [0],
    rhs_batching_dimensions = [0],
    lhs_contracting_dimensions = [2],
    rhs_contracting_dimensions = [1]
  >,
  precision_config = [#stablehlo<precision DEFAULT>, #stablehlo<precision DEFAULT>]
} : (tensor<2x2x2xi64>, tensor<2x2x2xi64>) -> tensor<2x2x2xi64>
// %result: [
//           [[1, 2],
//            [3, 4]],
//           [[5, 6],
//            [7, 8]]
//          ]

আরো উদাহরণ

dynamic_iota

শব্দার্থবিদ্যা

এই অপারেশনটি আইওটিএ অপের সাথে কার্যত অভিন্ন, তবে ফলাফলের আকারটি output_shape মাধ্যমে গতিশীলভাবে নির্দিষ্ট করা হয়।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (সি 1) 0 <= iota_dimension < size(output_shape) ।
• (সি 2) rank(result) = size(output_shape) ।

উদাহরণ

%output_shape = stablehlo.constant dense<[4, 5]> : tensor<2xi64>
%result = "stablehlo.dynamic_iota"(%output_shape) {
  iota_dimension = 0 : i64
} : (tensor<2xi64>) -> tensor<4x5xi64>
// %result: [
//           [0, 0, 0, 0, 0],
//           [1, 1, 1, 1, 1],
//           [2, 2, 2, 2, 2],
//           [3, 3, 3, 3, 3]
//          ]

আরো উদাহরণ

ডাইনামিক_রিশেপ

শব্দার্থবিদ্যা

এই অপারেশনটি পুনরায় আকার দেওয়ার জন্য কার্যত অভিন্ন, তবে ফলাফলের আকারটি output_shape মাধ্যমে গতিশীলভাবে নির্দিষ্ট করা হয়।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (সি 1) element_type(result) দ্বারা দেওয়া হয়েছে:
  • element_type(operand) , যদি !is_per_axis_quantized(operand) ।
  • element_type(operand) ব্যতীত quantization_dimension(operand) এবং quantization_dimension(result) বাদে অন্যথায় পৃথক হতে পারে।
• (সি 2) size(operand) = size(result) ।
• (সি 3) যদি is_per_axis_quantized(operand) :
  • reduce(dims(operand, [0, 1, ..., quantization_dimension(operand) - 1]), init_values=1, dimensions=[0], body=lambda x, y: x * y) = reduce(dims(result, [0, 1, ..., quantization_dimension(result) - 1]), init_values=1, dimensions=[0], body=lambda x, y: x * y)
  • dim(operand, quantization_dimension(operand)) = dim(result, quantization_dimension(result)) ।
  • reduce(dims(operand, [quantization_dimension(operand) + 1, ..., rank(operand) - 1]), init_values=1, dimensions=[0], body=lambda x, y: x * y) = reduce(dims(result, [quantization_dimension(result) + 1, ..., rank(result) - 1]), init_values=1, dimensions=[0], body=lambda x, y: x * y)
• (সি 4) size(output_shape) = rank(result) ।

উদাহরণ

// %operand: [[1, 2, 3], [4, 5, 6]]
%output_shape = stablehlo.constant dense<[3, 2]> : tensor<2xi64>
%result = "stablehlo.dynamic_reshape"(%operand, %output_shape) : (tensor<2x3xi64>, tensor<2xi64>) -> tensor<3x2xi64>
// %result: [[1, 2], [3, 4], [5, 6]]

আরো উদাহরণ

dynamic_slice

শব্দার্থবিদ্যা

গতিশীলভাবে অভিযুক্ত প্রারম্ভিক সূচকগুলি ব্যবহার করে operand থেকে একটি টুকরো বের করে এবং result টেনসর তৈরি করে। start_indices প্রতিটি মাত্রার জন্য স্লাইসের প্রারম্ভিক সূচকগুলি সম্ভাব্য সামঞ্জস্যের সাপেক্ষে থাকে এবং slice_sizes প্রতিটি মাত্রার জন্য স্লাইসের আকার ধারণ করে। আরও আনুষ্ঠানিকভাবে, result[result_index] = operand[operand_index] যেখানে:

• adjusted_start_indices = clamp(0, start_indices, shape(operand) - slice_sizes)
• operand_index = adjusted_start_indices + result_index ।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (সি 1) element_type(operand) = element_type(result) ।
• (সি 2) size(start_indices) = size(slice_sizes) = rank(operand)
• (সি 3) same(type(start_indices...)) ।
• (সি 4) 0 <= slice_sizes <= shape(operand) ।
• (সি 5) shape(result) = slice_sizes ।

উদাহরণ

// %operand: [
//            [0, 0, 1, 1],
//            [0, 0, 1, 1],
//            [0, 0, 0, 0],
//            [0, 0, 0, 0]
//           ]
// %start_indices0: -1
// %start_indices1: 3
%result = "stablehlo.dynamic_slice"(%operand, %start_indices0, %start_indices1) {
  slice_sizes = array<i64: 2, 2>
} : (tensor<4x4xi32>, tensor<i64>, tensor<i64>) -> tensor<2x2xi32>
// %result: [
//           [1, 1],
//           [1, 1]
//          ]

আরো উদাহরণ

ডাইনামিক_আপডেট_স্লাইস

শব্দার্থবিদ্যা

একটি result টেনসর উত্পাদন করে যা operand টেনসরের সমান, ব্যতীত start_indices শুরু হওয়া স্লাইসটি update মানগুলির সাথে আপডেট করা হয়। আরও আনুষ্ঠানিকভাবে, result[result_index] হিসাবে সংজ্ঞায়িত করা হয়েছে:

• update[update_index] যদি 0 <= update_index < shape(update) যেখানে:
  • adjusted_start_indices = clamp(0, start_indices, shape(operand) - shape(update))
  • update_index = result_index - adjusted_start_indices ।
• operand[result_index] অন্যথায়।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (সি 1) type(operand) = type(result) ।
• (সি 2) element_type(update) = element_type(operand) ।
• (সি 3) rank(update) = rank(operand) ।
• (সি 4) size(start_indices) = rank(operand) ।
• (সি 5) same(type(start_indices...)) ।
• (সি 6) 0 <= shape(update) <= shape(operand) ।

উদাহরণ

// %operand: [
//            [1, 1, 0, 0],
//            [1, 1, 0, 0],
//            [1, 1, 1, 1],
//            [1, 1, 1, 1]
//           ]
// %update: [
//           [1, 1],
//           [1, 1]
//          ]
// %start_indices0: -1
// %start_indices1: 3
%result = "stablehlo.dynamic_update_slice"(%operand, %update, %start_indices0, %start_indices1)
  : (tensor<4x4xi32>, tensor<2x2xi32>, tensor<i64>, tensor<i64>) -> tensor<4x4xi32>
// %result: [
//           [1, 1, 1, 1],
//           [1, 1, 1, 1],
//           [1, 1, 1, 1],
//           [1, 1, 1, 1]
//          ]

আরো উদাহরণ

সূচকীয়

শব্দার্থবিদ্যা

operand টেনসরে উপাদান-ভিত্তিক এক্সফোনেনশিয়াল অপারেশন সম্পাদন করে এবং result টেনসর তৈরি করে। উপাদান ধরণের উপর নির্ভর করে নিম্নলিখিতগুলি করে:

• For floats: exp from IEEE-754.
• For complex numbers: complex exponential.
• For quantized types: dequantize_op_quantize(exponential, operand, type(result)) .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) baseline_type(operand) = baseline_type(result) .

উদাহরণ

// %operand: [[0.0, 1.0], [2.0, 3.0]]
%result = "stablehlo.exponential"(%operand) : (tensor<2x2xf64>) -> tensor<2x2xf64>
// %result: [[1.0, 2.7182818284590451], [7.3890560989306504, 20.085536923187668]]

আরো উদাহরণ

সূচকীয়_মাইনাস_এক

শব্দার্থবিদ্যা

Performs element-wise exponential minus one operation on operand tensor and produces a result tensor. Depending on the element type, does the following:

• For floats: expm1 from IEEE-754.
• For complex numbers: complex exponential minus one.
• For quantized types: dequantize_op_quantize(exponential_minus_one, operand, type(result)) .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) baseline_type(operand) = baseline_type(result) .

উদাহরণ

// %operand: [0.0, 1.0]
%result = "stablehlo.exponential_minus_one"(%operand) : (tensor<2xf64>) -> tensor<2xf64>
// %result: [0.0, 1.71828187]

আরো উদাহরণ

fft

শব্দার্থবিদ্যা

Performs the forward and inverse Fourier transforms for real and complex inputs/outputs.

fft_type is one of the following:

• FFT : Forward complex-to-complex FFT.
• IFFT : Inverse complex-to-complex FFT.
• RFFT : Forward real-to-complex FFT.
• IRFFT : Inverse real-to-complex FFT (ie takes complex, returns real).

More formally, given the function fft which takes 1-dimensional tensors of complex types as input, produces 1-dimensional tensors of same types as output and computes the discrete Fourier transform:

For fft_type = FFT , result is defined as the final result of a series of L computations where L = size(fft_length) . For example, for L = 3 :

• result1[i0, ..., :] = fft(operand[i0, ..., :]) .
• result2[i0, ..., :, iR-1] = fft(result1[i0, ..., :, iR-1]) .
• result[i0, ..., :, iR-2, iR-1] = fft(result2[i0, ..., :, iR-2, iR-1]) .

Furthermore, given the function ifft which has the same type signature and computes the inverse of fft :

For fft_type = IFFT , result is defined as the inverse of the computations for fft_type = FFT . For example, for L = 3 :

• result1[i0, ..., :, iR-2, iR-1] = ifft(operand[i0, ..., :, iR-2, iR-1]) .
• result2[i0, ..., :, iR-1] = ifft(result1[i0, ..., :, iR-1]) .
• result[i0, ..., :] = ifft(result2[i0, ..., :]) .

Furthermore, given the function rfft which takes 1-dimensional tensors of floating-point types, produces 1-dimensional tensors of complex types of the same floating-point semantics and works as follows:

• rfft(real_operand) = truncated_result where
• complex_operand... = (real_operand..., 0.0) .
• complex_result = fft(complex_operand) .
• truncated_result = complex_result[:(rank(complex_result) / 2 + 1)] .

(When the discrete Fourier transform is computed for real operands, the first N/2 + 1 elements of the result unambiguously define the rest of the result, so the result of rfft is truncated to avoid computing redundant elements).

For fft_type = RFFT , result is defined as the final result of a series of L computations where L = size(fft_length) . For example, for L = 3 :

• result1[i0, ..., :] = rfft(operand[i0, ..., :]) .
• result2[i0, ..., :, iR-1] = fft(result1[i0, ..., :, iR-1]) .
• result[i0, ..., :, iR-2, iR-1] = fft(result2[i0, ..., :, iR-2, iR-1]) .

Finally, given the function irfft which has the same type signature and computes the inverse of rfft :

For fft_type = IRFFT , result is defined as the inverse of the computations for fft_type = RFFT . For example, for L = 3 :

• result1[i0, ..., :, iR-2, iR-1] = ifft(operand[i0, ..., :, iR-2, iR-1]) .
• result2[i0, ..., :, iR-1] = ifft(result1[i0, ..., :, iR-1]) .
• result[i0, ..., :] = irfft(result2[i0, ..., :]) .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) size(fft_length) <= rank(operand) .
• (C2) The relationship between operand and result element types varies:
  • If fft_type = FFT , element_type(operand) and element_type(result) have the same complex type.
  • If fft_type = IFFT , element_type(operand) and element_type(result) have the same complex type.
  • If fft_type = RFFT , element_type(operand) is a floating-point type and element_type(result) is a complex type of the same floating-point semantics.
  • If fft_type = IRFFT , element_type(operand) is a complex type and element_type(result) is a floating-point type of the same floating-point semantics.
• (C3) 1 <= size(fft_length) <= 3 .
• (C4) If among operand and result , there is a tensor real of a floating-point type, then shape(real)[-size(fft_length):] = fft_length .
• (C5) shape(result) = shape(operand) except for:
  • If fft_type = RFFT , dim(result, -1) = dim(operand, -1) = 0 ? 0 : dim(operand, -1) / 2 + 1 .
  • If fft_type = IRFFT , dim(operand, -1) = dim(result, -1) = 0 ? 0 : dim(result, -1) / 2 + 1 .

উদাহরণ

// %operand: [(1.0, 0.0), (0.0, 0.0), (0.0, 0.0), (0.0, 0.0)]
%result = "stablehlo.fft"(%operand) {
  fft_type = #stablehlo<fft_type FFT>,
  fft_length = array<i64: 4>
} : (tensor<4xcomplex<f32>>) -> tensor<4xcomplex<f32>>
// %result: [(1.0, 0.0), (1.0, 0.0), (1.0, 0.0), (1.0, 0.0)]

মেঝে

শব্দার্থবিদ্যা

Performs element-wise floor of operand tensor and produces a result tensor. Implements the roundToIntegralTowardNegative operation from the IEEE-754 specification. For quantized types, performs dequantize_op_quantize(floor, operand, type(result)) .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) baseline_type(operand) = baseline_type(result) .

উদাহরণ

// %operand: [-0.8166, -0.2530, 0.2530, 0.8166, 2.0]
%result = "stablehlo.floor"(%operand) : (tensor<5xf32>) -> tensor<5xf32>
// %result: [-1.0, -1.0, 0.0, 0.0, 2.0]

আরো উদাহরণ

জড়ো করা

শব্দার্থবিদ্যা

Gathers slices from operand tensor from offsets specified in start_indices and produces a result tensor.

The following diagram shows how elements in result map on elements in operand using a concrete example. The diagram picks a few example result indices and explains in detail which operand indices they correspond to.

More formally, result[result_index] = operand[operand_index] where:

• batch_dims = [d for d in axes(result) and d not in offset_dims] .
• batch_index = result_index[batch_dims...] .
• start_index is defined as:
  • start_indices[bi0, ..., :, ..., biN] where bi are individual elements in batch_index and : is inserted at the index_vector_dim index, if index_vector_dim < rank(start_indices) .
  • [start_indices[batch_index]] otherwise.
• For d_operand in axes(operand) ,
  • full_start_index[d_operand] = clamp(start_index[d_start], 0, dim(operand, d_operand) - slice_sizes[d_operand]) if d_operand = start_index_map[d_start] .
  • full_start_index[d_operand] = 0 otherwise.
• offset_index = result_index[offset_dims...] .
• full_offset_index = [oi0, ..., 0, ..., oiN] where oi are individual elements in offset_index , and 0 is inserted at indices from collapsed_slice_dims .
• operand_index = full_start_index + full_offset_index .

If indices_are_sorted is true then the implementation can assume that start_indices are sorted with respect to start_index_map , otherwise the behavior is undefined. More formally, for all i1 < i2 from indices(result) , full_start_index(i1) <= full_start_index(i2) .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) rank(operand) = size(offset_dims) + size(collapsed_slice_dims) .
• (C2) 0 <= index_vector_dim <= rank(start_indices) .
• (C3) size(start_index_map) = index_vector_dim < rank(start_indices) ? dim(start_indices, index_vector_dim) : 1 .
• (C4) is_unique(offset_dims) and is_sorted(offset_dims) .
• (C5) 0 <= offset_dims < rank(result) .
• (C6) is_unique(collapsed_slice_dims) and is_sorted(collapsed_slice_dims) .
• (C7) 0 <= collapsed_slice_dims < rank(operand) .
• (C8) slice_sizes[collapsed_slice_dims...] <= 1 .
• (C9) is_unique(start_index_map) .
• (C10) 0 <= start_index_map < rank(operand) .
• (C11) size(slice_sizes) = rank(operand) .
• (C12) 0 <= slice_sizes <= shape(operand) .
• (C13) shape(result) = combine(batch_dim_sizes, offset_dim_sizes) where:
  • batch_dim_sizes = shape(start_indices) except that the dimension size of start_indices corresponding to index_vector_dim is not included.
  • offset_dim_sizes = shape(slice_sizes) except that the dimension sizes in slice_sizes corresponding to collapsed_slice_dims are not included.
  • combine puts batch_dim_sizes at axes corresponding to batch_dims and offset_dim_sizes at axes corresponding to offset_dims .
• (C14) element_type(operand) = element_type(result) .

উদাহরণ

// %operand: [
//            [[1, 2], [3, 4], [5, 6], [7, 8]],
//            [[9, 10],[11, 12], [13, 14], [15, 16]],
//            [[17, 18], [19, 20], [21, 22], [23, 24]]
//           ]
// %start_indices: [
//                  [[0, 0], [1, 0], [2, 1]],
//                  [[0, 1], [1, 1], [0, 2]]
//                 ]
%result = "stablehlo.gather"(%operand, %start_indices) {
  dimension_numbers = #stablehlo.gather<
    offset_dims = [2, 3],
    collapsed_slice_dims = [0],
    start_index_map = [1, 0],
    index_vector_dim = 2>,
  slice_sizes = array<i64: 1, 2, 2>,
  indices_are_sorted = false
} : (tensor<3x4x2xi32>, tensor<2x3x2xi64>) -> tensor<2x3x2x2xi32>
// %result: [
//            [
//              [[1, 2], [3, 4]],
//              [[3, 4], [5, 6]],
//              [[13, 14], [15, 16]]
//            ],
//            [
//              [[9, 10], [11, 12]],
//              [[11, 12], [13, 14]],
//              [[17, 18], [19, 20]]
//            ]
//          ]

আরো উদাহরণ

প্রাপ্ত_মাত্রা_সাইজ

শব্দার্থবিদ্যা

Produces the size of the given dimension of the operand . More formally, result = dim(operand, dimension) . The Semantics concerns only with the shape component of the type. The element-type could be anything.

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) 0 <= dimension < rank(operand) .

উদাহরণ

// %operand: [[1, 2, 3], [4, 5, 6]]
%result = "stablehlo.get_dimension_size"(%operand) {
  dimension = 1 : i64
} : (tensor<2x3xi64>) -> tensor<i32>
// %result: 3

আরো উদাহরণ

get_tuple_element

শব্দার্থবিদ্যা

Extracts element at index position of the operand tuple and produces a result . More formally, result = operand[index] .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) 0 <= index < size(operand) .
• (C2) type(result) = tuple_element_types(operand)[index] .

উদাহরণ

// %operand: ([1.0, 2.0], (3))
%result = "stablehlo.get_tuple_element"(%operand) {
  index = 0 : i32
} : (tuple<tensor<2xf32>, tuple<tensor<i32>>>) -> tensor<2xf32>
// %result: [1.0, 2.0]

আরো উদাহরণ

যদি

শব্দার্থবিদ্যা

Produces the output from executing exactly one function from true_branch or false_branch depending on the value of pred . More formally, result = pred ? true_branch() : false_branch() .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) input_types(true_branch) = input_types(false_branch) = [] .
• (C2) output_types(true_branch) = output_types(false_branch) .
• (C3) type(results...) = output_types(true_branch) .

উদাহরণ

// %result_true_branch: 10
// %result_false_branch: 11
// %pred: true
%result = "stablehlo.if"(%pred) ({
  "stablehlo.return"(%result_true_branch) : (tensor<i32>) -> ()
}, {
  "stablehlo.return"(%result_false_branch) : (tensor<i32>) -> ()
}) : (tensor<i1>) -> tensor<i32>
// %result: 10

আরো উদাহরণ

ইমেজ

শব্দার্থবিদ্যা

Extracts the imaginary part, element-wise, from the operand and produces a result tensor. More formally, for each element x : imag(x) = is_complex(x) ? imaginary_part(x) : constant(0, element_type(result)) .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) shape(result) = shape(operand) .
• (C2) element_type(result) is defined as:
  • complex_element_type(element_type(operand)) if is_complex(operand) .
  • element_type(operand) otherwise.

উদাহরণ

// %operand: [(1.0, 2.0), (3.0, 4.0)]
%result = "stablehlo.imag"(%operand) : (tensor<2xcomplex<f32>>) -> tensor<2xf32>
// %result: [2.0, 4.0]

আরো উদাহরণ

ইনফিড

শব্দার্থবিদ্যা

Reads data from the infeed and produces results .

Semantics of infeed_config is implementation-defined.

results consist of payload values which come first and a token which comes last. In the future, we are planning to split the payload and the token into two separate outputs to improve clarity ( #670 ).

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) 0 < size(results) .
• (C2) is_empty(result[:-1]) or is_tensor(type(results[:-1])) .
• (C3) is_token(type(results[-1])) .

উদাহরণ

// %token: !stablehlo.token
// infeed_queue[0]: [[1, 2], [3, 4]]
// infeed_queue[1]: [[5, 6], [7, 8]]
%results0:2 = "stablehlo.infeed"(%token) {
  infeed_config = ""
} : (!stablehlo.token) -> (tensor<2x2xi64>, !stablehlo.token)
// results0#0: [[1, 2], [3, 4]]
%results1:2 = "stablehlo.infeed"(%token) {
  infeed_config = ""
} : (!stablehlo.token) -> (tensor<2x2xi64>, !stablehlo.token)
// results1#0: [[5, 6], [7, 8]]

আরো উদাহরণ

iota

শব্দার্থবিদ্যা

Fills an output tensor with values in increasing order starting from zero along the iota_dimension dimension. আরো আনুষ্ঠানিকভাবে,

output[output_index] = constant(is_quantized(output) ? quantize(output_index[iota_dimension], element_type(output)) : output_index[iota_dimension], element_type(output)) .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) 0 <= iota_dimension < rank(output) .

উদাহরণ

%output = "stablehlo.iota"() {
  iota_dimension = 0 : i64
} : () -> tensor<4x5xi32>
// %output: [
//           [0, 0, 0, 0, 0],
//           [1, 1, 1, 1, 1],
//           [2, 2, 2, 2, 2],
//           [3, 3, 3, 3, 3]
//          ]

%output = "stablehlo.iota"() {
  iota_dimension = 1 : i64
} : () -> tensor<4x5xi32>
// %output: [
//           [0, 1, 2, 3, 4],
//           [0, 1, 2, 3, 4],
//           [0, 1, 2, 3, 4],
//           [0, 1, 2, 3, 4]
//          ]

আরো উদাহরণ

is_finite

শব্দার্থবিদ্যা

Performs element-wise check whether the value in x is finite (ie is neither +Inf, -Inf, nor NaN) and produces a y tensor. Implements the isFinite operation from the IEEE-754 specification. For quantized types, the result is always true .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) shape(x) = shape(y) .

উদাহরণ

// Logical values: -Inf, +Inf, NaN, ...
// %x: [0xFFF0000000000000, 0x7FF0000000000000, 0x7FF8000000000000, -10.0, -0.0, 0.0, 10.0]
%y = "stablehlo.is_finite"(%x) : (tensor<7xf64) -> tensor<7xi1>
// %y: [false, false, false, true, true, true, true]

আরো উদাহরণ

লগ

শব্দার্থবিদ্যা

Performs element-wise logarithm operation on operand tensor and produces a result tensor. Depending on the element type, does the following:

• For floats: log from IEEE-754.
• For complex numbers: complex logarithm.
• For quantized types: dequantize_op_quantize(log, operand, type(result)) .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) baseline_type(operand) = baseline_type(result) .

উদাহরণ

// %operand: [[1.0, 2.0], [3.0, 4.0]]
%result = "stablehlo.log"(%operand) : (tensor<2x2xf64>) -> tensor<2x2xf64>
// %result: [[0.0, 0.69314718055994529], [1.0986122886681098, 1.3862943611198906]]

আরো উদাহরণ

log_plus_one

শব্দার্থবিদ্যা

Performs element-wise logarithm plus one operation on operand tensor and produces a result tensor. Depending on the element type, does the following:

• For floats: logp1 from IEEE-754.
• For complex numbers: complex logarithm plus one.
• For quantized types: dequantize_op_quantize(log_plus_one, operand, type(result)) .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) baseline_type(operand) = baseline_type(result) .

উদাহরণ

// %operand: [0.0, -0.999, 7.0, 6.38905621, 15.0]
%result = "stablehlo.log_plus_one"(%operand) : (tensor<5xf64>) -> tensor<5xf64>
// %result: [0.0, -6.90776825, 2.07944155, 2.0, 2.77258873]

আরো উদাহরণ

লজিস্টিক

শব্দার্থবিদ্যা

Performs element-wise logistic operation on operand tensor and produces a result tensor. Depending on the element type, does the following:

• For floats: division(1, addition(1, exp(-x))) from IEEE-754.
• For complex numbers: complex logistic.
• For quantized types: dequantize_op_quantize(logistic, operand, type(result)) .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) baseline_type(operand) = baseline_type(result) .

উদাহরণ

// %operand: [[0.0, 1.0], [2.0, 3.0]]
%result = "stablehlo.logistic"(%operand) : (tensor<2x2xf64>) -> tensor<2x2xf64>
// %result: [[0.5, 0.73105858], [0.88079708, 0.95257413]]

আরো উদাহরণ

মানচিত্র

শব্দার্থবিদ্যা

Applies a map function computation to inputs along the dimensions and produces a result tensor.

More formally, result[result_index] = computation(inputs...[result_index]) . Note that dimensions are currently unused and will likely be removed in the future ( #487 ).

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) shape(inputs...) = shape(result) .
• (C2) 0 < size(inputs) = N .
• (C3) dimensions = range(rank(inputs[0])) .
• (C4) computation has type (tensor<E0>, ..., tensor<EN-1>) -> tensor<E'> where Ei = element_type(inputs[i]) and E' = element_type(result) .

উদাহরণ

// %input0: [[0, 1], [2, 3]]
// %input1: [[4, 5], [6, 7]]
%result = "stablehlo.map"(%input0, %input1) ({
  ^bb0(%arg0: tensor<i64>, %arg1: tensor<i64>):
    %0 = stablehlo.multiply %arg0, %arg1 : tensor<i64>
    stablehlo.return %0 : tensor<i64>
}) {
  dimensions = array<i64: 0, 1>
} : (tensor<2x2xi64>, tensor<2x2xi64>) -> tensor<2x2xi64>
// %result: [[0, 5], [12, 21]]

আরো উদাহরণ

সর্বোচ্চ

শব্দার্থবিদ্যা

Performs element-wise max operation on tensors lhs and rhs and produces a result tensor. Depending on the element type, does the following:

• For booleans: logical OR.
• For integers: integer maximum.
• For floats: maximum from IEEE-754.
• For complex numbers: lexicographic maximum for the (real, imaginary) pair. Imposing an ordering on complex numbers involves surprising semantics, so in the future we are planning to remove support for complex numbers for this operation ( #560 ).
• For quantized types:
  • dequantize_op_quantize(maximum, lhs, rhs, type(result)) .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) baseline_type(lhs) = baseline_type(rhs) = baseline_type(result) .

উদাহরণ

// %lhs: [[1, 2], [7, 8]]
// %rhs: [[5, 6], [3, 4]]
%result = "stablehlo.maximum"(%lhs, %rhs) : (tensor<2x2xi32>, tensor<2x2xi32>) -> tensor<2x2xi32>
// %result: [[5, 6], [7, 8]]

আরো উদাহরণ

সর্বনিম্ন

শব্দার্থবিদ্যা

Performs element-wise min operation on tensors lhs and rhs and produces a result tensor. Depending on the element type, does the following:

• For booleans: logical AND.
• For integers: integer minimum.
• For floats: minimum from IEEE-754.
• For complex numbers: lexicographic minimum for the (real, imaginary) pair. Imposing an ordering on complex numbers involves surprising semantics, so in the future we are planning to remove support for complex numbers for this operation ( #560 ).
• For quantized types:
  • dequantize_op_quantize(minimum, lhs, rhs, type(result)) .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) baseline_type(lhs) = baseline_type(rhs) = baseline_type(result) .

উদাহরণ

// %lhs: [[1, 2], [7, 8]]
// %rhs: [[5, 6], [3, 4]]
%result = "stablehlo.minimum"(%lhs, %rhs) : (tensor<2x2xi32>, tensor<2x2xi32>) -> tensor<2x2xi32>
// %result: [[1, 2], [3, 4]]

আরো উদাহরণ

গুণ

শব্দার্থবিদ্যা

Performs element-wise product of two tensors lhs and rhs and produces a result tensor. Depending on the element type, does the following:

• For booleans: logical AND.
• For integers: integer multiplication.
• For floats: multiplication from IEEE-754.
• For complex numbers: complex multiplication.
• For quantized types:
  • dequantize_op_quantize(multiply, lhs, rhs, type(result)) .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) baseline_type(operand) = baseline_type(result) .

উদাহরণ

// %lhs: [[1, 2], [3, 4]]
// %rhs: [[5, 6], [7, 8]]
%result = "stablehlo.multiply"(%lhs, %rhs) : (tensor<2x2xi32>, tensor<2x2xi32>) -> tensor<2x2xi32>
// %result: [[5, 12], [21, 32]]

আরো উদাহরণ

অস্বীকার

শব্দার্থবিদ্যা

Performs element-wise negation of operand tensor and produces a result tensor. Depending on the element type, does the following:

• For signed integers: integer negation.
• For unsigned integers: bitcast to signed integer, integer negation, bitcast back to unsigned integer.
• For floats: negate from IEEE-754.
• For complex numbers: complex negation.
• For quantized types: dequantize_op_quantize(negate, operand, type(result)) .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) baseline_type(operand) = baseline_type(result) .

উদাহরণ

// Negation operation with integer Tensors
// %operand: [0, -2]
%result = "stablehlo.negate"(%operand) : (tensor<2xi32>) -> tensor<2xi32>
// %result: [0, 2]

// Negation operation with with complex tensors
// %operand: (2.5, 0.0)
%result = "stablehlo.negate"(%operand) : (tensor<1xcomplex<f32>>) -> tensor<1xcomplex<f32>>
// %result: [-2.5, -0.0]

আরো উদাহরণ

না

শব্দার্থবিদ্যা

Performs element-wise NOT of tensor operand and produces a result tensor. Depending on the element type, does the following:

• For booleans: logical NOT.
• For integers: bitwise NOT.

যুক্তি

আউটপুট

সীমাবদ্ধতা

• (C1) type(operand) = type(result) .

উদাহরণ

// Bitwise operation with with integer tensors
// %operand: [[1, 2], [3, 4]]
%result = "stablehlo.not"(%operand) : (tensor<2x2xi32>) -> tensor<2x2xi32>
// %result: [[-2, -3], [-4, -5]]

// Bitwise operation with with boolean tensors
// %operand: [true, false]
%result = "stablehlo.not"(%operand) : (tensor<2xi1>) -> tensor<2xi1>
// %result: [false, true]

আরো উদাহরণ

অপ্টিমাইজেশান_বাধা

শব্দার্থবিদ্যা

Ensures that the operations that produce the operand are executed before any operations that depend on the result and prevents compiler transformations from moving operations across the barrier. Other than that, the operation is an identity, ie result = operand .

যুক্তি

আউটপুট

সীমাবদ্ধতা

• (C1) type(operand...) = type(result...) .

উদাহরণ

// %operand0: 0.0
// %operand1: 1.0
%result0, %result1 = "stablehlo.optimization_barrier"(%operand0, %operand1) : (tensor<f32>, tensor<f32>) -> (tensor<f32>, tensor<f32>)
// %result0: 0.0
// %result1: 1.0

আরো উদাহরণ

বা

শব্দার্থবিদ্যা

Performs element-wise OR of two tensors lhs and rhs and produces a result tensor. Depending on the element type, does the following:

• For booleans: logical OR.
• For integers: bitwise OR.

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) type(lhs) = type(rhs) = type(result) .

উদাহরণ

// Bitwise operation with with integer tensors
// %lhs: [[1, 2], [3, 4]]
// %rhs: [[5, 6], [7, 8]]
%result = "stablehlo.or"(%lhs, %rhs) : (tensor<2x2xi32>, tensor<2x2xi32>) -> tensor<2x2xi32>
// %result: [[5, 6], [7, 12]]

// Logical operation with with boolean tensors
// %lhs: [[false, false], [true, true]]
// %rhs: [[false, true], [false, true]]
%result = "stablehlo.or"(%lhs, %rhs) : (tensor<2x2xi1>, tensor<2x2xi1>) -> tensor<2x2xi1>
// %result: [[false, true], [true, true]]

আরো উদাহরণ

আউটফিড

শব্দার্থবিদ্যা

Writes inputs to the outfeed and produces a result token.

Semantics of outfeed_config is implementation-defined.

ইনপুট

আউটপুট

উদাহরণ

%result = "stablehlo.outfeed"(%input0, %token) {
  outfeed_config = ""
} : (tensor<2x2x2xi64>, !stablehlo.token) -> !stablehlo.token

আরো উদাহরণ

প্যাড

শব্দার্থবিদ্যা

Expands operand by padding around the tensor as well as between the elements of the tensor with the given padding_value .

edge_padding_low and edge_padding_high specify the amount of padding added at the low-end (next to index 0) and the high-end (next to the highest index) of each dimension respectively. The amount of padding can be negative, where the absolute value of negative padding indicates the number of elements to remove from the specified dimension.

interior_padding specifies the amount of padding added between any two elements in each dimension which may not be negative. Interior padding occurs before edge padding such that negative edge padding will remove elements from the interior-padded operand.

More formally, result[result_index] is defined as:

• operand[operand_index] if result_index = edge_padding_low + operand_index * (interior_padding + 1) .
• padding_value otherwise.

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) element_type(operand) = element_type(padding_value) = element_type(result) .
• (C2) size(edge_padding_low) = size(edge_padding_high) = size(interior_padding) = rank(operand) .
• (C3) 0 <= interior_padding .
• (C4) shape(result) = shape(operand) + edge_padding_low + max(shape(operand) - 1, 0) * interior_padding + edge_padding_high .

উদাহরণ

// %operand: [
//            [1, 2, 3],
//            [4, 5, 6]
//           ]
// %padding_value: 0
%result = "stablehlo.pad"(%operand, %padding_value) {
  edge_padding_low = array<i64: 0, 1>,
  edge_padding_high = array<i64: 2, 1>,
  interior_padding = array<i64: 1, 2>
} : (tensor<2x3xi32>, tensor<i32>) -> tensor<5x9xi32>
// %result: [
//           [0, 1, 0, 0, 2, 0, 0, 3, 0],
//           [0, 0, 0, 0, 0, 0, 0, 0, 0],
//           [0, 4, 0, 0, 5, 0, 0, 6, 0],
//           [0, 0, 0, 0, 0, 0, 0, 0, 0],
//           [0, 0, 0, 0, 0, 0, 0, 0, 0]
//          ]

আরো উদাহরণ

partition_id

শব্দার্থবিদ্যা

Produces partition_id of the current process.

আউটপুট

উদাহরণ

%result = "stablehlo.partition_id"() : () -> tensor<ui32>

আরো উদাহরণ

popcnt

শব্দার্থবিদ্যা

Performs element-wise count of the number of bits set in the operand tensor and produces a result tensor.

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) type(operand) = type(result) .

উদাহরণ

// %operand: [0, 1, 2, 127]
%result = "stablehlo.popcnt"(%operand) : (tensor<4xi64>) -> tensor<4xi64>
// %result: [0, 1, 1, 7]

আরো উদাহরণ

ক্ষমতা

শব্দার্থবিদ্যা

Performs element-wise exponentiation of lhs tensor by rhs tensor and produces a result tensor. Depending on the element type, does the following:

• For integers: integer exponentiation.
• For floats: pow from IEEE-754.
• For complex numbers: complex exponentiation.
• For quantized types: dequantize_op_quantize(power, lhs, rhs, type(result)) .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) baseline_type(operand) = baseline_type(result) .

উদাহরণ

// %lhs: [-2.0, -0.0, -36.0, 5.0, 3.0, 10000.0]
// %rhs: [2.0, 2.0, 1.1, 2.0, -1.0, 10.0]
%result = "stablehlo.power"(%lhs, %rhs) : (tensor<6xf64>, tensor<6xf64>) -> tensor<6xf64>
// %result: [4.0, 0.0, -nan, 25.0, 0.333333343, inf]

আরো উদাহরণ

বাস্তব

শব্দার্থবিদ্যা

Extracts the real part, element-wise, from the operand and produces a result tensor. More formally, for each element x : real(x) = is_complex(x) ? real_part(x) : x .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) shape(result) = shape(operand) .
• (C2) element_type(result) is defined as:
  • complex_element_type(element_type(operand)) if is_complex(operand) .
  • element_type(operand) otherwise.

উদাহরণ

// %operand: [(1.0, 2.0), (3.0, 4.0)]
%result = "stablehlo.real"(%operand) : (tensor<2xcomplex<f32>>) -> tensor<2xf32>
// %result: [1.0, 3.0]

আরো উদাহরণ

recv

শব্দার্থবিদ্যা

Receives data from a channel with channel_id and produces results .

If is_host_transfer is true , then the operation transfers data from the host. Otherwise, it transfers data from another device. What this means is implementation-defined. This flag duplicates the information provided in channel_type , so in the future we are planning to only keep one of them ( #666 ).

results consist of payload values which come first and a token which comes last. In the future, we are planning to split the payload and the token into two separate outputs to improve clarity ( #670 ).

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) channel_type is defined as:
  • HOST_TO_DEVICE if is_host_transfer = true ,
  • DEVICE_TO_DEVICE otherwise.
• (C2) 0 < size(results) .
• (C3) is_empty(result[:-1]) or is_tensor(type(results[:-1])) .
• (C4) is_token(type(results[-1])) .

উদাহরণ

%results0, %results1 = "stablehlo.recv"(%token) {
  channel_handle = #stablehlo.channel_handle<handle = 1, type = 3>,
  is_host_transfer = true
} : (!stablehlo.token) -> (tensor<2x2xi64>, !stablehlo.token)

আরো উদাহরণ

হ্রাস করা

শব্দার্থবিদ্যা

Applies a reduction function body to inputs and init_values along the dimensions and produces results tensors.

The order of reductions is implementation-defined, which means that body and init_values must form a monoid to guarantee that the operation produces the same results for all inputs on all implementations. However, this condition doesn't hold for many popular reductions. Eg floating-point addition for body and zero for init_values don't actually form a monoid because floating-point addition is not associative.

More formally, results...[j0, ..., jR-1] = reduce(input_slices_converted) where:

• input_slices = inputs...[j0, ..., :, ..., jR-1] , where : are inserted at dimensions .
• input_slices_converted = to_destination_type(input_slices..., type(func_inputs(body)[:len(func_inputs(body))//2])...) .
• init_values_converted = to_destination_type(init_values..., type(func_inputs(body)[len(func_inputs(body))//2:])...) .
• reduce(input_slices_converted) = exec(schedule) for some binary tree schedule where:
  • exec(node) = body(exec(node.left), exec(node.right)) .
  • exec(leaf) = leaf.value .
• schedule is an implementation-defined full binary tree whose in-order traversal consists of:
  • input_slices_converted...[index] values, for all index in index_space(input_slices_converted) in the ascending lexicographic order of index .
  • Interspersed with an implementation-defined amount of init_values_converted at implementation-defined positions.

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) same(shape(inputs...)) .
• (C2) element_type(inputs...) = element_type(init_values...) .
• (C3) 0 < size(inputs) = size(init_values) = size(results) = N .
• (C4) 0 <= dimensions < rank(inputs[0]) .
• (C5) is_unique(dimensions) .
• (C6) body has type (tensor<E0>, ..., tensor<EN-1>, tensor<E0>, ..., tensor<EN-1>) -> (tensor<E0>, ..., tensor<EN-1>) where is_promotable(element_type(inputs[i]), Ei) .
• (C7) shape(results...) = shape(inputs...) except that the dimension sizes of inputs... corresponding to dimensions are not included.
• (C8) element_type(results[i]) = Ei for all i in [0,N) .

উদাহরণ

// %input = [[0, 1, 2, 3, 4, 5]]
// %init_value = 0
%result = "stablehlo.reduce"(%input, %init_value) ({
  ^bb0(%arg0: tensor<i64>, %arg1: tensor<i64>):
    %0 = "stablehlo.add"(%arg0, %arg1) : (tensor<i64>, tensor<i64>) -> tensor<i64>
    "stablehlo.return"(%0) : (tensor<i64>) -> ()
}) {
  dimensions = array<i64: 1>
} : (tensor<1x6xi64>, tensor<i64>) -> tensor<1xi64>
// %result = [15]

আরো উদাহরণ

হ্রাস_নির্ভুলতা

শব্দার্থবিদ্যা

Performs element-wise conversion of operand to another floating-point type that uses exponent_bits and mantissa_bits and back to the original floating-point type and produces an output tensor.

আরো আনুষ্ঠানিকভাবে:

• The mantissa bits of the original value are updated to round the original value to the nearest value representable with mantissa_bits using roundToIntegralTiesToEven semantics.
• Then, if mantissa_bits are smaller than the number of mantissa bits of the original value, the mantissa bits are truncated to mantissa_bits .
• Then, if the exponent bits of the intermediate result don't fit into the range provided by exponent_bits , the intermediate result overflows to infinity using the original sign or underflows to zero using the original sign.
• For quantized types, performs dequantize_op_quantize( lambda operand: reduce_precision(operand, exponent_bits, mantissa_bits), operand, type(result)) .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) baseline_type(operand) = baseline_type(output) .
• (C2) 1 <= exponent_bits .
• (C3) 0 <= mantissa_bits .

উদাহরণ

// Logical values: +Inf, NaN, +Denormal, 0.0, 65519.0, 65520.0
// %operand: [0x7FF0000000000000, 0x7FFFFFFFFFFFFFFF, 0x0000000000000001, 0.0, 65519.0, 65520.0]
%output = "stablehlo.reduce_precision"(%operand) {
  exponent_bits = 5 : i32,
  mantissa_bits = 10 : i32
} : (tensor<6xf64>) -> tensor<6xf64>
// Logical values: +Inf, NaN, 0.0, 0.0, 65504.0, +Inf
// %output: [0x7FF0000000000000, 0x7FFFFFFFFFFFFFFF, 0.0, 0.0, 65504.0, 0x7FF0000000000000]

আরো উদাহরণ

হ্রাস_বিক্ষেপ

শব্দার্থবিদ্যা

Within each process group in the StableHLO process grid, performs reduction, using computations , over the values of the operand tensor from each process, splits the reduction result along scatter_dimension into parts, and scatters the split parts between the processes to produce the result .

The operation splits the StableHLO process grid into process_groups which is defined as follows:

• cross_replica(replica_groups) if channel_id <= 0 and use_global_device_ids = false .
• cross_replica_and_partition(replica_groups) if channel_id > 0 and use_global_device_ids = false .
• flattened_ids(replica_groups) if channel_id > 0 and use_global_device_ids = true .

Afterwards, within each process_group :

• reduced_value = all_reduce(operand, replica_groups, channel_id, use_global_device_ids, computation) .
• parts@sender = split(reduced_value@sender, dim(process_groups, 1), scatter_dimension) .
• result@receiver = parts@sender[receiver_index] for all sender in process_group , where receiver_index = process_group.index(receiver) .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) dim(operand, scatter_dimension) % dim(process_groups, 1) = 0 .
• (C2) 0 <= scatter_dimension < rank(operand) .
• (C3) is_unique(replica_groups) .
• (C4) size(replica_groups) is defined as:
  • num_replicas if cross_replica is used.
  • num_replicas if cross_replica_and_partition is used.
  • num_processes if flattened_ids is used.
• (C5) 0 <= replica_groups < size(replica_groups) .
• (C6) If use_global_device_ids = true , then channel_id > 0 .
• (C7) computation has type (tensor<E>, tensor<E>) -> (tensor<E>) where is_promotable(element_type(operand), E) .
• (C8) shape(result) = shape(operand) except:
  • dim(result, scatter_dimension) = dim(operand, scatter_dimension) / dim(process_groups, 1) .
• (C9) element_type(result) = E .

উদাহরণ

// num_replicas: 2
// num_partitions: 1
// %operand@(0, 0): [[1, 2, 3, 4],
//                   [5, 6, 7, 8]]
// %operand@(1, 0): [[9, 10, 11, 12],
//                   [13, 14, 15, 16]]
%result = "stablehlo.reduce_scatter"(%operand) ({
  ^bb0(%arg0: tensor<i64>, %arg1: tensor<i64>):
  %0 = "stablehlo.add"(%arg0, %arg1) : (tensor<i64>, tensor<i64>) -> tensor<i64>
  "stablehlo.return"(%0) : (tensor<i64>) -> ()
}) {
  scatter_dimension = 1 : i64,
  replica_groups = dense<[[0, 1]]> : tensor<1x2xi64>,
  channel_handle = #stablehlo.channel_handle<handle = 0, type = 0>
} : (tensor<2x4xi64>) -> tensor<2x2xi64>
//
// %result@(0, 0): [[10, 12],
//                  [18, 20]]
// %result@(1, 0): [[14, 16],
//                  [22, 24]]

আরো উদাহরণ

হ্রাস_উইন্ডো

শব্দার্থবিদ্যা

Applies a reduction function body to windows of inputs and init_values and produces results .

The following diagram shows how elements in results... are computed from inputs... using a concrete example.

More formally, results...[result_index] = reduce(windows, init_values, axes(inputs...), body) (see reduce ) where:

• padded_inputs = pad(inputs..., init_values..., padding[:, 0], padding[:, 1], base_dilations - 1) .
• window_start = result_index * window_strides .
• window_end = window_start + (window_dimensions - 1) * window_dilations + 1 .
• windows = slice(padded_inputs..., window_start, window_end, window_dilations) .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) 0 < size(inputs) = size(init_values) = size(results) = N .
• (C2) same(shape(inputs...)) .
• (C3) element_type(inputs...) = element_type(init_values...) .
• (C4) size(window_dimensions) = rank(inputs[0]) .
• (C5) 0 < window_dimensions .
• (C6) size(window_strides) = rank(inputs[0]) .
• (C7) 0 < window_strides .
• (C8) size(base_dilations) = rank(inputs[0]) .
• (C9) 0 < base_dilations .
• (C10) size(window_dilations) = rank(inputs[0]) .
• (C11) 0 < window_dilations .
• (C12) shape(padding) = [rank(inputs[0]), 2] .
• (C13) body has type (tensor<E0>, ..., tensor<EN-1>, tensor<E0>, ..., tensor<EN-1>) -> (tensor<E0>, ..., tensor<EN-1>) where is_promotable(element_type(inputs[i]), Ei) .
• (C14) same(shape(results...)) .
• (C15) shape(results[0]) = num_windows where:
  • dilated_input_shape = shape(inputs[0]) = 0 ? 0 : (shape(inputs[0]) - 1) * base_dilations + 1 .
  • padded_input_shape = padding[:, 0] + dilated_input_shape + padding[:, 1] .
  • dilated_window_shape = (window_dimensions - 1) * window_dilations + 1 .
  • is_empty_window = padded_input_shape = 0 || dilated_window_shape > padded_input_shape .
  • num_windows = is_empty_window ? 0 : floor((padded_input_shape - dilated_window_shape) / window_strides) + 1 .
• (C16) element_type(results[i]) = Ei for all i in [0,N) .

উদাহরণ

// %input = [[1, 2], [3, 4], [5, 6]]
// %init_value = 0
%result = "stablehlo.reduce_window"(%input, %init_value) ({
  ^bb0(%arg0: tensor<i64>, %arg1: tensor<i64>):
    %0 = "stablehlo.add"(%arg0, %arg1) : (tensor<i64>, tensor<i64>) -> tensor<i64>
    "stablehlo.return"(%0) : (tensor<i64>) -> ()
}) {
  window_dimensions = array<i64: 2, 1>,
  window_strides = array<i64: 4, 1>,
  base_dilations = array<i64: 2, 1>,
  window_dilations = array<i64: 3, 1>,
  padding = dense<[[2, 1], [0, 0]]> : tensor<2x2xi64>
} : (tensor<3x2xi64>, tensor<i64>) -> tensor<2x2xi64>
// %result = [[0, 0], [3, 4]]

আরো উদাহরণ

অবশিষ্ট

শব্দার্থবিদ্যা

Performs element-wise remainder of dividend lhs and divisor rhs tensors and produces a result tensor.

More formally, the sign of the result is taken from the dividend, and the absolute value of the result is always less than the divisor's absolute value. The remainder is calculated as lhs - d * rhs , where d is given by:

• For integers: stablehlo.divide(lhs, rhs) .
• For floats: division(lhs, rhs) from IEEE-754 with rounding attribute roundTowardZero .
• For complex numbers: TBD ( #997 ).
• For quantized types:
  • dequantize_op_quantize(remainder, lhs, rhs, type(result)) .

For floating-point element types, this operation is in contrast with the remainder operation from IEEE-754 specification where d is an integral value nearest to the exact value of lhs/rhs with ties to even.

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) baseline_type(operand) = baseline_type(result) .

উদাহরণ

// %lhs: [17, -17, 17, -17]
// %rhs: [3, 3, -3, -3]
%result = "stablehlo.remainder"(%lhs, %rhs) : (tensor<4xi64>, tensor<4xi64>) -> tensor<4xi64>
// %result: [2, -2, 2, -2]

আরো উদাহরণ

প্রতিরূপ_আইডি

শব্দার্থবিদ্যা

Produces replica_id of the current process.

আউটপুট

উদাহরণ

%result = "stablehlo.replica_id"() : () -> tensor<ui32>

আরো উদাহরণ

নতুন আকার দেওয়া

শব্দার্থবিদ্যা

Performs reshape of operand tensor to a result tensor. Conceptually, it amounts to keeping the same canonical representation but potentially changing the shape, eg from tensor<2x3xf32> to tensor<3x2xf32> or tensor<6xf32> .

More formally, result[result_index] = operand[operand_index] where result_index and operand_index have the same position in the lexicographic ordering of index_space(result) and index_space(operand) .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) element_type(result) is given by:
  • element_type(operand) , if !is_per_axis_quantized(operand) .
  • element_type(operand) except that quantization_dimension(operand) and quantization_dimension(result) may differ, otherwise.
• (C2) size(operand) = size(result) .
• (C3) If is_per_axis_quantized(operand) :
  • reduce(dims(operand, [0, 1, ..., quantization_dimension(operand) - 1]), init_values=1, dimensions=[0], body=lambda x, y: x * y) = reduce(dims(result, [0, 1, ..., quantization_dimension(result) - 1]), init_values=1, dimensions=[0], body=lambda x, y: x * y) .
  • dim(operand, quantization_dimension(operand)) = dim(result, quantization_dimension(result)) .
  • reduce(dims(operand, [quantization_dimension(operand) + 1, ..., rank(operand) - 1]), init_values=1, dimensions=[0], body=lambda x, y: x * y) = reduce(dims(result, [quantization_dimension(result) + 1, ..., rank(result) - 1]), init_values=1, dimensions=[0], body=lambda x, y: x * y) .

উদাহরণ

// %operand: [[1, 2, 3], [4, 5, 6]]
%result = "stablehlo.reshape"(%operand) : (tensor<2x3xi32>) -> tensor<3x2xi32>
// %result: [[1, 2], [3, 4], [5, 6]]

আরো উদাহরণ

বিপরীত

শব্দার্থবিদ্যা

Reverses the order of elements in the operand along the specified dimensions and produces a result tensor. More formally, result[result_index] = operand[operand_index] where:

• operand_index[d] = dim(result, d) - result_index[d] - 1 if d in dimensions .
• operand_index[d] = result_index[d] otherwise.

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) type(operand) = type(result) .
• (C2) is_unique(dimensions) .
• (C3) 0 <= dimensions < rank(result) .

উদাহরণ

// %operand = [[1, 2], [3, 4], [5, 6]]
%result = "stablehlo.reverse"(%operand) {
  dimensions = array<i64: 1>
} : (tensor<3x2xi32>) -> tensor<3x2xi32>
// %result: [[2, 1], [4, 3], [6, 5]]

আরো উদাহরণ

আরএনজি

শব্দার্থবিদ্যা

Generates random numbers using the rng_distribution algorithm and produces a result tensor of a given shape shape .

If rng_distribution = UNIFORM , then the random numbers are generated following the uniform distribution over the interval [a, b) . If a >= b , the behavior is undefined.

If rng_distribution = NORMAL , then the random numbers are generated following the normal distribution with mean = a and standard deviation = b . If b < 0 , the behavior is undefined.

The exact way how random numbers are generated is implementation-defined. For example, they may or may not be deterministic, and they may or may not use hidden state.

In conversations with many stakeholders, this op has come up as effectively deprecated, so in the future we are planning to explore removing it ( #597 ).

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) element_type(a) = element_type(b) = element_type(result) .
• (C2) If rng_distribution = NORMAL , then is_float(a) .
• (C3) shape(result) = shape .

উদাহরণ

// %a = 0
// %b = 2
// %shape = [3, 3]
%result = "stablehlo.rng"(%a, %b, %shape) {
  rng_distribution = #stablehlo<rng_distribution UNIFORM>
} : (tensor<i32>, tensor<i32>, tensor<2xi64>) -> tensor<3x3xi32>
// %result: [
//           [1, 0, 1],
//           [1, 1, 1],
//           [0, 0, 0]
//          ]

rng_bit_generator

শব্দার্থবিদ্যা

Returns an output filled with uniform random bits and an updated output state output_state using the pseudorandom number generator algorithm rng_algorithm given an initial state initial_state . The output is guaranteed to be deterministic function of initial_state , but it is not guaranteed to be deterministic between implementations.

rng_algorithm is one of the following:

• DEFAULT : Implementation-defined algorithm.
• THREE_FRY : Implementation-defined variant of the Threefry algorithm.*
• PHILOX : Implementation-defined variant of the Philox algorithm.*

* See: Salmon et al. SC 2011. Parallel random numbers: as easy as 1, 2, 3.

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) type(initial_state) = type(output_state) .
• (C2) size(initial_state) is defined as:
  • implementation-defined if rng_algorithm = DEFAULT .
  • 2 if rng_algorithm = THREE_FRY .
  • 2 or 3 if rng_algorithm = PHILOX .

উদাহরণ

// %initial_state: [1, 2]
%output_state, %output = "stablehlo.rng_bit_generator"(%initial_state) {
  rng_algorithm = #stablehlo<rng_algorithm THREE_FRY>
} : (tensor<2xui64>) -> (tensor<2xui64>, tensor<2x2xui64>)
// %output_state: [1, 6]
// %output: [
//           [9236835810183407956, 16087790271692313299],
//           [18212823393184779219, 2658481902456610144]
//          ]

round_nearest_afz

শব্দার্থবিদ্যা

Performs element-wise rounding towards the nearest integer, breaking ties away from zero, on the operand tensor and produces a result tensor. Implements the roundToIntegralTiesToAway operation from the IEEE-754 specification. For quantized types, performs dequantize_op_quantize(round_nearest_afz, operand, type(result)) .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) baseline_type(operand) = baseline_type(result) .

উদাহরণ

// %operand = [-2.5, 0.4, 0.5, 0.6, 2.5]
%result = "stablehlo.round_nearest_afz"(%operand) : (tensor<5xf64>) -> tensor<5xf64>
// %result: [-3.0, 0.0, 1.0, 1.0, 3.0]

আরো উদাহরণ

বৃত্তাকার_নিকটতম_সম

শব্দার্থবিদ্যা

Performs element-wise rounding towards the nearest integer, breaking ties towards the even integer, on the operand tensor and produces a result tensor. Implements the roundToIntegralTiesToEven operation from the IEEE-754 specification. For quantized types, performs dequantize_op_quantize(round_nearest_even, operand, type(result)) .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) baseline_type(operand) = baseline_type(result) .

উদাহরণ

// %operand = [-2.5, 0.4, 0.5, 0.6, 2.5]
%result = "stablehlo.round_nearest_even"(%operand) : (tensor<5xf64>) -> tensor<5xf64>
// %result: [-2.0, 0.0, 0.0, 1.0, 2.0]

আরো উদাহরণ

rsqrt

শব্দার্থবিদ্যা

Performs element-wise reciprocal square root operation on operand tensor and produces a result tensor. Depending on the element type, does the following:

• For floats: rSqrt from IEEE-754.
• For complex numbers: complex reciprocal square root.
• For quantized types: dequantize_op_quantize(rsqrt, operand, type(result)) .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) baseline_type(operand) = baseline_type(result) .

উদাহরণ

// %operand: [[1.0, 4.0], [9.0, 25.0]]
%result = "stablehlo.rsqrt"(%operand) : (tensor<2x2xf32>) -> tensor<2x2xf32>
// %result: [[1.0, 0.5], [0.33333343, 0.2]]

আরো উদাহরণ

ছিটান

শব্দার্থবিদ্যা

Produces results tensors which are equal to inputs tensors except that several slices specified by scatter_indices are updated with the values updates using update_computation .

The following diagram shows how elements in updates... map on elements in results... using a concrete example. The diagram picks a few example updates... indices and explains in detail which results... indices they correspond to.

More formally, for all update_index in index_space(updates[0]) :

• update_scatter_dims = [d for d in axes(updates[0]) and d not in update_window_dims] .
• update_scatter_index = update_index[update_scatter_dims...] .
• start_index is defined as:
  • scatter_indices[si0, ..., :, ..., siN] where si are individual elements in update_scatter_index and : is inserted at the index_vector_dim index, if index_vector_dim < rank(scatter_indices) .
  • [scatter_indices[update_scatter_index]] otherwise.
• For d_input in axes(inputs[0]) ,
  • full_start_index[d_input] = start_index[d_start] if d_input = scatter_dims_to_operand_dims[d_start] .
  • full_start_index[d_input] = 0 otherwise.
• update_window_index = update_index[update_window_dims...] .
• full_window_index = [wi0, ..., 0, ..., wiN] where wi are individual elements in update_window_index , and 0 is inserted at indices from inserted_window_dims .
• result_index = full_start_index + full_window_index .

Given that, results = exec(schedule, inputs) , where:

• schedule is an implementation-defined permutation of index_space(updates[0]) .
• exec([update_index, ...], results) = exec([...], updated_results) where:
  • If result_index is in bounds for shape(results...)
  • updates_converted = to_destination_type( updates...[update_index], type(func_inputs(update_computation) [len(func_inputs(update_computation))//2:])... )
  • updated_values = update_computation(results...[result_index], updates_converted)
  • updated_results is a copy of results with results...[result_index] set to updated_values... .
  • অন্যথায়
  • updated_results = results .
• exec([], results) = results .

If indices_are_sorted is true then the implementation can assume that scatter_indices are sorted with respect to scatter_dims_to_operand_dims , otherwise the behavior is undefined. More formally, for all i1 < i2 from indices(result) , full_start_index(i1) <= full_start_index(i2) .

If unique_indices is true then the implementation can assume that all result_index indices being scattered to are unique. If unique_indices is true but the indices being scattered to are not unique then the behavior is undefined.

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) same(shape(inputs...)) .
• (C2) rank(inputs[0]) = size(update_window_dims) + size(inserted_window_dims) .
• (C3) same(shape(updates...)) .
• (C4) shape(updates[0]) = combine(update_scatter_dim_sizes, update_window_dim_sizes) where:
  • update_scatter_dim_sizes = shape(scatter_indices) except that the dimension size of scatter_indices corresponding to index_vector_dim is not included.
  • update_window_dim_sizes <= shape(inputs[0]) except that the dimension sizes in inputs[0] corresponding to inserted_window_dims are not included.
  • combine puts update_scatter_dim_sizes at axes corresponding to update_scatter_dims and update_window_dim_sizes at axes corresponding to update_window_dims .
• (C5) 0 < size(inputs) = size(updates) = N .
• (C6) element_type(updates...) = element_type(inputs...) .
• (C7) is_unique(update_window_dims) and is_sorted(update_window_dims) .
• (C8) 0 <= update_window_dims < rank(updates[0]) .
• (C9) is_unique(inserted_window_dims) and is_sorted(update_window_dims) .
• (C10) 0 <= inserted_window_dims < rank(inputs[0]) .
• (C11) size(scatter_dims_to_operand_dims) = index_vector_dim < rank(scatter_indices) ? dim(scatter_indices, index_vector_dim) : 1 .
• (C12) is_unique(scatter_dims_to_operand_dims) .
• (C13) 0 <= scatter_dims_to_operand_dims < rank(inputs[0]) .
• (C14) 0 <= index_vector_dim <= rank(scatter_indices) .
• (C15) update_computation has type (tensor<E0>, ..., tensor<EN-1>, tensor<E0>, ..., tensor<EN-1>) -> (tensor<E0>, ..., tensor<EN-1>) , where is_promotable(element_type(inputs[i]), Ei) .
• (C16) shape(inputs...) = shape(results...) .
• (C17) element_type(results[i]) = Ei for all i in [0,N) .

উদাহরণ

// %input: [
//          [[1, 2], [3, 4], [5, 6], [7, 8]],
//          [[9, 10], [11, 12], [13, 14], [15, 16]],
//          [[17, 18], [19, 20], [21, 22], [23, 24]]
//         ]
// %scatter_indices: [[[0, 2], [1, 0], [2, 1]], [[0, 1], [1, 0], [0, 9]]]
// %update: [
//           [[[1, 1], [1, 1]], [[1, 1], [1, 1]], [[1, 1], [1, 1]]],
//           [[[1, 1], [1, 1]], [[1, 1], [1, 1]], [[1, 1], [1, 1]]]
//          ]
%result = "stablehlo.scatter"(%input, %scatter_indices, %update) ({
  ^bb0(%arg0: tensor<i64>, %arg1: tensor<i64>):
    %0 = "stablehlo.add"(%arg0, %arg1) : (tensor<i64>, tensor<i64>) -> tensor<i64>
    "stablehlo.return"(%0) : (tensor<i64>) -> ()
}) {
  scatter_dimension_numbers = #stablehlo.scatter<
    update_window_dims = [2, 3],
    inserted_window_dims = [0],
    scatter_dims_to_operand_dims = [1, 0],
    index_vector_dim = 2>,
  indices_are_sorted = false,
  unique_indices = false
} : (tensor<3x4x2xi64>, tensor<2x3x2xi64>, tensor<2x3x2x2xi64>) -> tensor<3x4x2xi64>
// %result: [
//           [[1, 2], [5, 6], [7, 8], [7, 8]],
//           [[10, 11], [12, 13], [14, 15], [16, 17]],
//           [[18, 19], [20, 21], [21, 22], [23, 24]]
//          ]

আরো উদাহরণ

নির্বাচন করুন

শব্দার্থবিদ্যা

Produces a result tensor where each element is selected from on_true or on_false tensor based on the value of the corresponding element of pred . More formally, result[result_index] = pred_element ? on_true[result_index] : on_false[result_index] , where pred_element = rank(pred) = 0 ? pred[] : pred[result_index] . For quantized types, performs dequantize_select_quantize(pred, on_true, on_false, type(result)) .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) rank(pred) = 0 or shape(pred) = shape(on_true) .
• (C2) baseline_type(on_true) = baseline_type(on_false) = baseline_type(result) .

উদাহরণ

// %pred: [[false, true], [true, false]]
// %on_true: [[1, 2], [3, 4]]
// %on_false: [[5, 6], [7, 8]]
%result = "stablehlo.select"(%pred, %on_true, %on_false) : (tensor<2x2xi1>, tensor<2x2xi32>, tensor<2x2xi32>) -> tensor<2x2xi32>
// %result: [[5, 2], [3, 8]]

আরো উদাহরণ

সিলেক্ট_এন্ড_স্ক্যাটার

শব্দার্থবিদ্যা

Scatters the values from the source tensor using scatter based on the outcome of reduce_window of the input tensor using select and produces a result tensor.

The following diagram shows how elements in result are computed from operand and source using a concrete example.

আরো আনুষ্ঠানিকভাবে:

• selected_values = reduce_window_without_init(...) with the following inputs:

  • inputs = [operand].
  • window_dimensions , window_strides , and padding which are used as is.
  • base_dilations = windows_dilations = 1 .
  • body is defined as:

  def body(arg0: tensor<E>, arg1: tensor<E>) -> tensor<E>:
    return select(arg0, arg1) ? arg0 : arg1;
  

  where E = element_type(operand) , and reduce_window_without_init works exactly like reduce_window , except that the schedule of the underlying reduce (see reduce ) doesn't include init values. It is currently unspecified what happens if the corresponding window doesn't have values ( #731 ).

• result[result_index] = reduce([source_values], [init_value], [0], scatter) where:

  • source_values = [source[source_index] for source_index in source_indices] .
  • selected_index(source_index) = operand_index if selected_values[source_index] has the operand element from operand_index .
  • source_indices = [source_index for source_index in indices(source) if selected_index(source_index) = result_index] .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) element_type(operand) = element_type(source) .
• (C2) shape(source) = num_windows where:
  • padded_operand_shape = padding[:, 0] + shape(operand) + padding[:, 1] .
  • is_empty_window = padded_operand_shape = 0 || window_dimensions > padded_operand_shape .
  • num_windows = is_empty_window ? 0 : floor((padded_operand_shape - window_dimensions) / window_strides) + 1 .
• (C3) element_type(init_value) = element_type(operand) .
• (C4) size(window_dimensions) = rank(operand) .
• (C5) 0 < window_dimensions .
• (C6) size(window_strides) = rank(operand) .
• (C7) 0 < window_strides .
• (C8) shape(padding) = [rank(operand), 2] .
• (C9) select has type (tensor<E>, tensor<E>) -> tensor<i1> where E = element_type(operand) .
• (C10) scatter has type (tensor<E>, tensor<E>) -> tensor<E> where is_promotable(element_type(operand), E) .
• (C11) shape(operand) = shape(result) .
• (C12) element_type(result) = E .

উদাহরণ

// %operand: [[1, 5], [2, 5], [3, 6], [4, 4]]
// %source: [[5, 6], [7, 8]]
// %init_value: 0
%result = "stablehlo.select_and_scatter"(%operand, %source, %init_value) ({
  ^bb0(%arg0: tensor<i64>, %arg1: tensor<i64>):
    %0 = "stablehlo.compare"(%arg0, %arg1) {
      comparison_direction = #stablehlo<comparison_direction GE>
    } : (tensor<i64>, tensor<i64>) -> tensor<i1>
    "stablehlo.return"(%0) : (tensor<i1>) -> ()
}, {
  ^bb0(%arg0: tensor<i64>, %arg1: tensor<i64>):
    %0 = "stablehlo.add"(%arg0, %arg1) : (tensor<i64>, tensor<i64>) -> tensor<i64>
    "stablehlo.return"(%0) : (tensor<i64>) -> ()
}) {
  window_dimensions = array<i64: 3, 1>,
  window_strides = array<i64: 2, 1>,
  padding = dense<[[0, 1], [0, 0]]> : tensor<2x2xi64>
} : (tensor<4x2xi64>, tensor<2x2xi64>, tensor<i64>) -> tensor<4x2xi64>
// %result: [[0, 0], [0, 0], [5, 14], [7, 0]]

আরো উদাহরণ

পাঠান

শব্দার্থবিদ্যা

Sends inputs to a channel channel_id and produces a result token.

If is_host_transfer is true , then the operation transfers data to the host. Otherwise, it transfers data to another device. What this means is implementation-defined. This flag duplicates the information provided in channel_type , so in the future we are planning to only keep one of them ( #666 ).

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) channel_type is defined as:
  • DEVICE_TO_HOST if is_host_transfer = true ,
  • DEVICE_TO_DEVICE otherwise.

উদাহরণ

%result = "stablehlo.send"(%operand, %token) {
  channel_handle = #stablehlo.channel_handle<handle = 1, type = 2>,
  is_host_transfer = true
} : (tensor<2x2xi64>, !stablehlo.token) -> !stablehlo.token

আরো উদাহরণ

শিফট_বাম

শব্দার্থবিদ্যা

Performs element-wise left-shift operation on the lhs tensor by rhs number of bits and produces a result tensor.

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) type(lhs) = type(rhs) = type(result) .

উদাহরণ

// %lhs: [-1, 0, 1]
// %rhs: [1, 2, 3]
%result = "stablehlo.shift_left"(%lhs, %rhs): (tensor<3xi64>, tensor<3xi64>) -> tensor<3xi64>
// %result: [-2, 0, 8]

আরো উদাহরণ

shift_right_rithmetic

শব্দার্থবিদ্যা

Performs element-wise arithmetic right-shift operation on the lhs tensor by rhs number of bits and produces a result tensor.

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) type(lhs) = type(rhs) = type(result) .

উদাহরণ

// %lhs: [-1, 0, 8]
// %rhs: [1, 2, 3]
%result = "stablehlo.shift_right_arithmetic"(%lhs, %rhs): (tensor<3xi64>, tensor<3xi64>) -> tensor<3xi64>
// %result: [-1, 0, 1]

আরো উদাহরণ

shift_right_logical

শব্দার্থবিদ্যা

Performs element-wise logical right-shift operation on the lhs tensor by rhs number of bits and produces a result tensor.

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) type(lhs) = type(rhs) = type(result) .

উদাহরণ

// %lhs: [-1, 0, 8]
// %rhs: [1, 2, 3]
%result = "stablehlo.shift_right_logical"(%lhs, %rhs): (tensor<3xi64>, tensor<3xi64>) -> tensor<3xi64>
// %result: [9223372036854775807, 0, 1]

আরো উদাহরণ

চিহ্ন

শব্দার্থবিদ্যা

Returns the sign of the operand element-wise and produces a result tensor. More formally, for each element x , the semantics can be expressed using Python syntax as follows:

def sign(x):
  if is_integer(x):
    if compare(x, 0, LT, SIGNED): return -1
    if compare(x, 0, EQ, SIGNED): return 0
    return 1
  elif is_float(x):
    if is_nan(x): return NaN
    if compare(x, -0.0, EQ, FLOAT): return -0.0
    if compare(x, +0.0, EQ, FLOAT): return +0.0
    if compare(x, 0.0, LT, FLOAT): return -1.0
    return 1.0
  elif is_complex(x):
    if is_nan(real(x)) or is_nan(imag(x)): return (NaN, NaN)
    if compare(x, (0.0, 0.0), EQ, FLOAT): return (0.0, 0.0)
    return divide(x, convert(abs(x), type(x)))

For quantized types, performs dequantize_op_quantize(sign, operand, type(result)) .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) baseline_type(operand) = baseline_type(result) .

উদাহরণ

// Logical values: +NaN, -1.0, -0.0, +0.0, 1.0
// operand: [0x7FFFFFFFFFFFFFFF, -1.0, -0.0, 0.0, 1.0]
%result = "stablehlo.sign"(%operand) : (tensor<5xf64>) -> tensor<5xf64>
// Logical values: +NaN, -1.0, -0.0, +0.0, 1.0
// %result: [0x7FFFFFFFFFFFFFFF, -1.0, -0.0, 0.0, 1.0]

আরো উদাহরণ

সাইন

শব্দার্থবিদ্যা

Performs element-wise sine operation on operand tensor and produces a result tensor. Depending on the element type, does the following:

• For floats: sin from IEEE-754.
• For complex numbers: complex sine.
• For quantized types: dequantize_op_quantize(sine, operand, type(result)) .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) baseline_type(operand) = baseline_type(result) .

উদাহরণ

// %operand: [
//            [0.0, 1.57079632],       // [0, pi/2]
//            [3.14159265, 4.71238898] // [pi, 3pi/2]
//           ]
%result = "stablehlo.sine"(%operand) : (tensor<2x2xf32>) -> tensor<2x2xf32>
// %result: [[0.0, 1.0], [0.0, -1.0]]

আরো উদাহরণ

টুকরা

শব্দার্থবিদ্যা

Extracts a slice from the operand using statically-computed starting indices and produces a result tensor. start_indices contain the starting indices of the slice for each dimension, limit_indices contain the ending indices (exclusive) for the slice for each dimension, and strides contain the strides for each dimension.

More formally, result[result_index] = operand[operand_index] where operand_index = start_indices + result_index * strides .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) element_type(operand) = element_type(result) .
• (C2) size(start_indices) = size(limit_indices) = size(strides) = rank(operand) .
• (C3) 0 <= start_indices <= limit_indices <= shape(operand) .
• (C4) 0 < strides .
• (C5) shape(result) = ceil((limit_indices - start_indices) / strides) .

উদাহরণ

// %operand: [
//            [0, 0, 0, 0],
//            [0, 0, 1, 1],
//            [0, 0, 1, 1]
//           ]
%result = "stablehlo.slice"(%operand) {
  start_indices = array<i64: 1, 2>,
  limit_indices = array<i64: 3, 4>,
  strides = array<i64: 1, 1>
} : (tensor<3x4xi64>) -> tensor<2x2xi64>
// % result: [
//            [1, 1],
//            [1, 1]
//           ]

আরো উদাহরণ

সাজান

শব্দার্থবিদ্যা

Sorts 1-dimensional slices of inputs along the dimension dimension together, according to a comparator and produces results .

Unlike similar inputs in other operations, dimension allows negative values, with the semantics described below. In the future, this may be disallowed for consistency reasons ( #1377 ).

If is_stable is true, then the sorting is stable, that is, relative order of elements considered to be equal by the comparator is preserved. For the case where there is a single input, two elements e1 and e2 are considered to be equal by the comparator if and only if comparator(e1, e2) = comparator(e2, e1) = false . See the formalization below for how this generalizes to multiple inputs.

More formally, for all result_index in index_space(results[0]) :

• adjusted_dimension = dimension >= 0 ? dimension : rank(inputs[0]) + dimension .
• result_slice = [ri0, ..., :, ..., riR-1] where riN are individual elements in result_index , and : is inserted at adjusted_dimension .
• inputs_together = (inputs[0]..., ..., inputs[N-1]...) .
• results_together[result_slice] = sort(inputs_together[result_slice], comparator_together) .
• where sort sorts a 1-dimensional slice in non-descending order expecting that comparator_together returns true if the left-hand side argument is less than the right-hand second argument.

• def comparator_together(lhs_together, rhs_together):
    args = []
    for (lhs_el, rhs_el) in zip(lhs_together, rhs_together):
      args.append(lhs_el)
      args.append(rhs_el)
    return comparator(*args)
  

• (results[0]..., ..., results[N-1]...) = results_together .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) 0 < size(inputs) .
• (C2) type(inputs...) = type(results...) .
• (C3) same(shape(inputs...) + shape(results...)) .
• (C4) -R <= dimension < R , where R = rank(inputs[0]) .
• (C5) comparator has type (tensor<E1>, tensor<E1>, ..., tensor<EN-1>, tensor<EN-1>) -> tensor<i1> , where Ei = element_type(inputs[i]) .

উদাহরণ

// %input0 = [[1, 2, 3], [3, 2, 1]]
// %input1 = [[3, 2, 1], [1, 2, 3]]
%result0, %result1 = "stablehlo.sort"(%input0, %input1) ({
  ^bb0(%arg0: tensor<i64>, %arg1: tensor<i64>, %arg2: tensor<i64>, %arg3: tensor<i64>):
    %predicate = "stablehlo.compare"(%arg0, %arg1) {
      comparison_direction = #stablehlo<comparison_direction GT>
    } : (tensor<i64>, tensor<i64>) -> tensor<i1>
    "stablehlo.return"(%predicate) : (tensor<i1>) -> ()
}) {
  dimension = 0 : i64,
  is_stable = true
} : (tensor<2x3xi64>, tensor<2x3xi64>) -> (tensor<2x3xi64>, tensor<2x3xi64>)
// %result0 = [[3, 2, 3], [1, 2, 1]]
// %result1 = [[1, 2, 1], [3, 2, 3]]

আরো উদাহরণ

sqrt

শব্দার্থবিদ্যা

Performs element-wise square root operation on operand tensor and produces a result tensor. Depending on the element type, does the following:

• For floats: squareRoot from IEEE-754.
• For complex numbers: complex square root.
• For quantized types: dequantize_op_quantize(sqrt, operand, type(result)) .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) baseline_type(operand) = baseline_type(result) .

উদাহরণ

// %operand: [[0.0, 1.0], [4.0, 9.0]]
%result = "stablehlo.sqrt"(%operand) : (tensor<2x2xf32>) -> tensor<2x2xf32>
// %result: [[0.0, 1.0], [2.0, 3.0]]

আরো উদাহরণ

বিয়োগ

শব্দার্থবিদ্যা

Performs element-wise subtraction of two tensors lhs and rhs and produces a result tensor. Depending on the element type, does the following:

• For integers: integer subtraction.
• For floats: subtraction from IEEE-754.
• For complex numbers: complex subtraction.
• For quantized types:
  • dequantize_op_quantize(subtract, lhs, rhs, type(result)) .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) baseline_type(lhs) = baseline_type(rhs) = baseline_type(result) .

উদাহরণ

// %lhs: [[6, 8], [10, 12]]
// %rhs: [[5, 6], [7, 8]]
%result = "stablehlo.subtract"(%lhs, %rhs) : (tensor<2x2xf32>, tensor<2x2xf32>) -> (tensor<2x2xf32>)
// %result: [[1, 2], [3, 4]]

আরো উদাহরণ

তানহ

শব্দার্থবিদ্যা

Performs element-wise hyperbolic tangent operation on operand tensor and produces a result tensor. Depending on the element type, does the following:

• For floats: tanh from IEEE-754.
• For complex numbers: complex hyperbolic tangent.
• For quantized types:
  • dequantize_op_quantize(tanh, operand, type(result)) .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) baseline_type(operand) = baseline_type(result) .

উদাহরণ

// %operand: [-1.0, 0.0, 1.0]
%result = "stablehlo.tanh"(%operand) : (tensor<3xf32>) -> tensor<3xf32>
// %result: [-0.76159416, 0.0, 0.76159416]

আরো উদাহরণ

স্থানান্তর

শব্দার্থবিদ্যা

Permutes the dimensions of operand tensor using permutation and produces a result tensor. More formally, result[result_index] = operand[operand_index] where result_index[d] = operand_index[permutation[d]] .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) element_type(result) is given by:
  • element_type(operand) , if !is_per_axis_quantized(operand) .
  • element_type(operand) except that quantization_dimension(operand) and quantization_dimension(result) may differ, otherwise.
• (C2) permutation is a permutation of range(rank(operand)) .
• (C3) shape(result) = dim(operand, permutation...) .
• (C4) If is_per_axis_quantized(result) , then quantization_dimension(operand) = permutation(quantization_dimension(result)) .

উদাহরণ

// %operand: [
//            [[1,2], [3,4], [5,6]],
//            [[7,8], [9,10], [11,12]]
//           ]
%result = "stablehlo.transpose"(%operand) {
  permutation = array<i64: 2, 1, 0>
} : (tensor<2x3x2xi32>) -> tensor<2x3x2xi32>
// %result: [
//           [[1,7], [3,9], [5,11]],
//           [[2,8], [4,10], [6,12]]
//          ]

আরো উদাহরণ

triangular_solve

শব্দার্থবিদ্যা

Solves batches of systems of linear equations with lower or upper triangular coefficient matrices.

More formally, given a and b , result[i0, ..., iR-3, :, :] is the solution to op(a[i0, ..., iR-3, :, :]) * x = b[i0, ..., iR-3, :, :] when left_side is true or x * op(a[i0, ..., iR-3, :, :]) = b[i0, ..., iR-3, :, :] when left_side is false , solving for the variable x where op(a) is determined by transpose_a , which can be one of the following:

• NO_TRANSPOSE : Perform operation using a as-is.
• TRANSPOSE : Perform operation on transpose of a .
• ADJOINT : Perform operation on conjugate transpose of a .

Input data is read only from the lower triangle of a , if lower is true or upper triangle of a , otherwise. Output data is returned in the same triangle; the values in the other triangle are implementation-defined.

If unit_diagonal is true, then the implementation can assume that the diagonal elements of a are equal to 1, otherwise the behavior is undefined.

For quantized types, performs dequantize_op_quantize(lambda x, y: triangular_solve(x, y, left_side, lower, unit_diagonal, transpose_a), a, b, type(result)) .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) baseline_element_type(a) = baseline_element_type(b) .
• (C2) 2 <= rank(a) = rank(b) = R .
• (C3) The relationship between shape(a) and shape(b) is defined as follows:
  • shape(a)[:-3] = shape(b)[:-3] .
  • dim(a, -2) = dim(a, -1) = dim(b, left_side ? -2 : -1) .
• (C4) baseline_type(b) = baseline_type(result) .

উদাহরণ

// %a = [
//       [1.0, 0.0, 0.0],
//       [2.0, 4.0, 0.0],
//       [3.0, 5.0, 6.0]
//      ]
// %b = [
//       [2.0, 0.0, 0.0],
//       [4.0, 8.0, 0.0],
//       [6.0, 10.0, 12.0]
//      ]
%result = "stablehlo.triangular_solve"(%a, %b) {
  left_side = true,
  lower = true,
  unit_diagonal = false,
  transpose_a = #stablehlo<transpose NO_TRANSPOSE>
} : (tensor<3x3xf32>, tensor<3x3xf32>) -> tensor<3x3xf32>
// %result: [
//           [2.0, 0.0, 0.0],
//           [0.0, 2.0, 0.0],
//           [0.0, 0.0, 2.0]
//          ]

টিপল

শব্দার্থবিদ্যা

Produces a result tuple from values val .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) result has type tuple<E0, ..., EN-1> where Ei = type(val[i]) .

উদাহরণ

// %val0: [1.0, 2.0]
// %val1: (3)
%result = "stablehlo.tuple"(%val0, %val1) : (tensor<2xf32>, tuple<tensor<i32>>) -> tuple<tensor<2xf32>, tuple<tensor<i32>>>
// %result: ([1.0, 2.0], (3))

আরো উদাহরণ

uniform_dequantize

শব্দার্থবিদ্যা

Performs element-wise conversion of quantized tensor operand to a floating-point tensor result according to the quantization parameters defined by the operand type.

More formally, result = dequantize(operand) .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) shape(operand) = shape(result) .
• (C2) element_type(result) = expressed_type(operand) .

উদাহরণ

// %operand: [10, 10]
%result = "stablehlo.uniform_dequantize"(%operand) : (tensor<2x!quant.uniform<i8:f32:0, {0.1:-30,0.5:-20}>>) -> tensor<2xf32>
// %result: [4.0, 15.0]

uniform_quantize

শব্দার্থবিদ্যা

Performs element-wise conversion of floating-point tensor or quantized tensor operand to a quantized tensor result according to the quantization parameters defined by the result type.

আরো আনুষ্ঠানিকভাবে,

• If is_float(operand) :
  • result = quantize(operand, type(result)) .
• If is_quantized(operand) :
  • float_result = dequantize(operand) .
  • result = quantize(float_result, type(result)) .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) shape(operand) = shape(result) .
• (C2) expressed_type(result) = is_float(operand) ? element_type(operand) : expressed_type(operand) .

উদাহরণ

// %operand: [4.0, 15.0]
%result = "stablehlo.uniform_quantize"(%operand) : (tensor<2xf32>) -> tensor<2x!quant.uniform<i8:f32:0, {0.1:-30,0.5:-20}>>
// %result: [10, 10]

// %operand: [10, 10]
%result = "stablehlo.uniform_quantize"(%operand) : (tensor<2x!quant.uniform<i8:f32:0, {0.1:-30,0.5:-20}>>) -> tensor<2x!quant.uniform<i8:f32:0, {0.1:-20,0.2:-30}>>
// %result: [20, 45]

যখন

শব্দার্থবিদ্যা

Produces the output from executing body function 0 or more times while the cond function outputs true . More formally, the semantics can be expressed using Python syntax as follows:

internal_state = operand
while cond(*internal_state):
  internal_state = body(*internal_state)
results = internal_state

The behavior of an infinite loop is TBD ( #383 ).

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) cond has type (T0, ..., TN-1) -> tensor<i1> , where Ti = type(operand[i]) .
• (C2) body has type (T0, ..., TN-1) -> (T0, ..., TN-1) , where Ti = type(operand[i]) .
• (C3) type(results...) = type(operand...) .

উদাহরণ

// %init_i: 1
// %init_sum: 0
// %one: 1
// %ten: 10
%results0, %results1 = "stablehlo.while"(%init_i, %init_sum) ({
  ^bb0(%arg0: tensor<i64>, %arg1: tensor<i64>):
    %cond = "stablehlo.compare"(%arg0, %ten) {
      comparison_direction = #stablehlo<comparison_direction LT>
    } : (tensor<i64>, tensor<i64>) -> tensor<i1>
    stablehlo.return %cond : tensor<i1>
  }, {
  ^bb0(%arg0: tensor<i64>, %arg1: tensor<i64>):
    %new_sum = stablehlo.add %arg1, %one : tensor<i64>
    %new_i = stablehlo.add %arg0, %one : tensor<i64>
    stablehlo.return %new_i, %new_sum : tensor<i64>, tensor<i64>
}) : (tensor<i64>, tensor<i64>) -> (tensor<i64>, tensor<i64>)
// %results0: 10
// %results1: 10

আরো উদাহরণ

xor

শব্দার্থবিদ্যা

Performs element-wise XOR of two tensors lhs and rhs and produces a result tensor. Depending on the element type, does the following:

• For booleans: logical XOR.
• For integers: bitwise XOR.

ইনপুট

আউটপুট