OpenXLA Project

এই পৃষ্ঠাটি Cloud Translation API অনুবাদ করেছে।

`-chlo-legalize-to-stablehlo`

CHLO ops ফ্লো থেকে StableHLO এবং Shape ops এ বৈধ করে

`-shape-legalize-to-stablehlo`

StableHLO-তে আকৃতি-সম্পর্কিত অপারেশনগুলিকে বৈধ করুন।

একটি পরীক্ষামূলক পাস যা আকৃতি-সম্পর্কিত অপারেশনগুলিকে StableHLO অপ্সকে বৈধ করে।

একটি ঐচ্ছিক পাসের মাধ্যমে আকৃতি এবং ডেটা কম্পিউটেশন একত্রে আনার ফলে StableHLO ইকোসিস্টেমের পক্ষে সম্ভাব্যভাবে কম্পাইলেশন পাইপলাইনগুলিকে লিভারেজ করা সম্ভব হবে যা StableHLO ক্রিয়াকলাপগুলিকে গতিশীলতার মডেল করতে ব্যবহার করে৷

`-stablehlo-canonicalize-dynamism`

গতিশীল StableHLO অপ্সকে স্ট্যাটিক অপস-এ ক্যানোনিকালাইজ করে।

DynamicReshapeOp-এর মতো ডায়নামিক StableHLO ops-কে সংশ্লিষ্ট স্ট্যাটিক কাউন্টারপার্টের সাথে প্রতিস্থাপন করে যেমন DynamicReshapeOp থেকে ReshapeOp অথবা DynamicBroadcastInDim থেকে BroadcastInDim যদি = এই অপ্সের সমস্ত ডায়নামিক উপাদান আসলে ধ্রুবক হয়।

  %c = stablehlo.constant dense<16> : tensor<1xi32>
  %0 = stablehlo.dynamic_broadcast_in_dim %cst, %c, dims = [] : (tensor<f32>, tensor<1xi32>) -> tensor<16xf32>

  ==>

  %0 = stablehlo.broadcast_in_dim %cst, dims = [] : (tensor<f32>) -> tensor<16xf32>

`-stablehlo-compatibility-expander`

StableHLO অপারেশনের জন্য সামঞ্জস্য বিস্তারকারী।

StableHLO ops আপডেট পায় বা সর্বশেষ সংস্করণে নতুন op চালু করা হয়। এই অপ্ট-ইন পাসটি পুরানো StableHLO সংস্করণগুলির সাথে নতুন StableHLO ক্রিয়াকলাপগুলিকে সেই পুরানো সংস্করণগুলির দ্বারা সমর্থিত সমতুল্য ক্রিয়াকলাপে পচিয়ে দিয়ে পিছনের সামঞ্জস্যকে প্রসারিত করে৷

কেন এটি একটি অপ্ট-ইন পাস?

মাঝে মাঝে, StableHLO op বর্ধিতকরণগুলি OpenXLA ইকোসিস্টেমে নির্দিষ্ট সাধারণ প্যাটার্নগুলির পরিচালনাকে ব্যাপকভাবে সহজ করার জন্য ব্যবহৃত হয়। এর মধ্যে রয়েছে TanOp-এর মতো জিনিস, যার উচ্চ ফ্রেমওয়ার্ক এবং কম্পাইলার সমর্থন রয়েছে, সেইসাথে সংগ্রহ/স্ক্যাটার ব্যাচিং ডাইমেনশন, যা স্লাইস ব্যবহার করে উপস্থাপন করা যেতে পারে, কিন্তু শার্ডিংকে আরও কঠিন করে তোলে। এই শ্রেণীর নতুন বৈশিষ্ট্যগুলির জন্য, আমরা স্বয়ংক্রিয়ভাবে ডাউনগ্রেড অফার করি না, কারণ এটি পরবর্তী অপ্টিমাইজেশানগুলিতে ব্যবহৃত গুরুত্বপূর্ণ তথ্য ফেলে দিতে পারে। এই পাসটি সম্ভাব্য কম সর্বোত্তম সংকলনের ব্যয়ে সামঞ্জস্যতা সর্বাধিক করার জন্য লক্ষ্য সংস্করণের উপর ভিত্তি করে এই অপ্সগুলিকে প্রসারিত করতে ব্যবহার করা যেতে পারে।

func.func @tan_op_non_complex(%arg0: tensor<4xf64>) -> tensor<4xf64> {
  %1 = stablehlo.tan %arg0 : tensor<4xf64>
  func.return %1 : tensor<4xf64>
}

==>

func.func @tan_op_non_complex(%arg0: tensor<4xf64>) -> tensor<4xf64> {
  %0 = stablehlo.sine %arg0 : tensor<4xf64>
  %1 = stablehlo.cosine %arg0 : tensor<4xf64>
  %2 = stablehlo.divide %0, %1 : tensor<4xf64>
  return %2 : tensor<4xf64>
}

অপশন

-target : The target version. Must be a version of the form #.#.#.

`-stablehlo-complex-math-expander`

StableHLO জটিল গণিত ক্রিয়াকলাপের জন্য এক্সপান্ডার।

StableHLO জটিল গণিত অপারেশনগুলি StableHLO বাস্তব গণিত অপারেশন ব্যবহার করে পচনশীল।

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

func.func @sqrt_op_complex(%arg0: tensor<4xcomplex<f64>>) -> tensor<4xcomplex<f64>> {
  %1 = stablehlo.sqrt %arg0 : tensor<4xcomplex<f64>>
  func.return %1 : tensor<4xcomplex<f64>>
}

==>

func.func @sqrt_op_complex(%arg0: tensor<4xcomplex<f64>>) -> tensor<4xcomplex<f64>> {
  TBD
  return %2 : tensor<4xcomplex<f64>>
}

`-stablehlo-convert-to-signless`

আইআরকে সাইনলেস পূর্ণসংখ্যাতে রূপান্তরিত করতে পাস করুন।

`-stablehlo-legalize-composite-to-call`

কম্পোজিট অপ্স প্রতিস্থাপন করে তাদের পচন ধরে।

কম্পোজিট অপসকে তাদের পচনশীলতার কল দিয়ে প্রতিস্থাপন করে, যেমন নিচেরটি:

stablehlo.composite "my_namespace.my_op" %arg0, %arg1 {
  decomposition = @bar,
  version = 1,
  composite_attributes = {
    "my_attribute": "my_value"
  }
}

হয়ে যাবে:

func.call @bar(%arg0, %arg1)

"ব্যতীত" পতাকা ব্যবহার করে এই রূপান্তর থেকে কম্পোজিটের একটি উপসেট বাদ দেওয়া যেতে পারে, যেমন:

stablehlo-opt --stablehlo-legalize-composite-to-call=except='foo.baz,foo.qux'

অপশন

-except : Names of composites that should not be replaced with calls.

`-stablehlo-legalize-deprecated-ops`

ভাল-সমর্থিত অপ্স থেকে অবচয়িত অপ্সকে বৈধ করুন।

StableHLO v1.0 Opset Deprecations RFC (#2283) বেশ কিছু অপ্রয়োজনীয় অপস অপসারণের প্রস্তাব করেছে। এই পাস বিভিন্ন সংকলন পাইপলাইনে এই অপ অপসারণের প্রভাবকে তাদের দীর্ঘমেয়াদী সমর্থিত প্রতিপক্ষের কাছে বৈধ করে মূল্যায়ন করতে সাহায্য করে।

অপশন

-fail-on-unused : Fail on (mostly) unused ops that are deprecated without any fallback.

`-stablehlo-legalize-qdq-to-quantized-op`

StableHLO কোয়ান্টাইজড অপারেশনে ফিউজ (ডি-কোয়ান্টাইজ, ফ্লোটিং-পয়েন্ট অপারেশন এবং কোয়ান্টাইজ) প্যাটার্ন

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

func.func @add(%arg0: tensor<16x16x!quant.uniform<ui8:f32, 34.0:16>>) -> tensor<16x16x!quant.uniform<ui8:f32, 34.0:16>> {
  %0 = stablehlo.uniform_dequantize %arg0 : (tensor<16x16x!quant.uniform<ui8:f32, 34.0:16>>) -> tensor<16x16xf32>
  %1 = stablehlo.abs %0 : tensor<16x16xf32>
  %2 = stablehlo.uniform_quantize %1 : (tensor<16x16xf32>) -> tensor<16x16x!quant.uniform<ui8:f32, 34.0:16>>
  func.return %2 : tensor<16x16x!quant.uniform<ui8:f32, 34.0:16>>
}

হয়ে যাবে:

func.func @add(%arg0: tensor<16x16x!quant.uniform<u8:f32, 3.400000e+01:16>>) -> tensor<16x16x!quant.uniform<u8:f32, 3.400000e+01:16>> {
  %0 = stablehlo.uniform_dequantize %arg0 : (tensor<16x16x!quant.uniform<u8:f32, 3.400000e+01:16>>) -> tensor<16x16xf32>
  %1 = stablehlo.abs %0 : tensor<16x16xf32>
  %2 = stablehlo.abs %arg0 : tensor<16x16x!quant.uniform<u8:f32, 3.400000e+01:16>>
  %3 = stablehlo.uniform_quantize %1 : (tensor<16x16xf32>) -> tensor<16x16x!quant.uniform<u8:f32, 3.400000e+01:16>>
  return %2 : tensor<16x16x!quant.uniform<u8:f32, 3.400000e+01:16>>
}

`-stablehlo-legalize-quant-to-math`

StableHLO quantized ops থেকে StableHLO আদিম গণিত অপ্সে রূপান্তর করুন।

ইউনিফর্ম কোয়ান্টাইজড টাইপ ব্যবহার করে StableHLO প্রোগ্রামগুলিকে শব্দার্থগতভাবে সমতুল্য পূর্ণসংখ্যা গণিত অপারেশনে রূপান্তর করুন।

func.func @add(%arg0: tensor<!quant.uniform<i8:f32,1.0:0>>, %arg1: tensor<!quant.uniform<i8:f32,2.0:1>>) ->  tensor<!quant.uniform<i8:f32,3.0:2>> {
  %0 = "stablehlo.add"(%arg0, %arg1) : (tensor<!quant.uniform<i8:f32,1.0:0>>, tensor<!quant.uniform<i8:f32,2.0:1>>) -> tensor<!quant.uniform<i8:f32,3.0:2>>
  func.return %0 : tensor<!quant.uniform<i8:f32,3.0:2>>
}

হয়ে যাবে:

func.func @add(%arg0: tensor<i8>, %arg1: tensor<i8>) -> tensor<i8> {
  %0 = stablehlo.convert %arg0 : (tensor<i8>) -> tensor<f32>
  %cst = stablehlo.constant dense<0.333333343> : tensor<f32>
  %1 = chlo.broadcast_multiply %0, %cst : (tensor<f32>, tensor<f32>) -> tensor<f32>
  %cst_0 = stablehlo.constant dense<2.000000e+00> : tensor<f32>
  %2 = chlo.broadcast_add %1, %cst_0 : (tensor<f32>, tensor<f32>) -> tensor<f32>
  %3 = stablehlo.round_nearest_even %2 : tensor<f32>
  %4 = stablehlo.convert %3 : (tensor<f32>) -> tensor<i32>
  %5 = stablehlo.convert %arg1 : (tensor<i8>) -> tensor<f32>
  %cst_1 = stablehlo.constant dense<0.666666686> : tensor<f32>
  %6 = chlo.broadcast_multiply %5, %cst_1 : (tensor<f32>, tensor<f32>) -> tensor<f32>
  %cst_2 = stablehlo.constant dense<1.33333337> : tensor<f32>
  %7 = chlo.broadcast_add %6, %cst_2 : (tensor<f32>, tensor<f32>) -> tensor<f32>
  %8 = stablehlo.round_nearest_even %7 : tensor<f32>
  %9 = stablehlo.convert %8 : (tensor<f32>) -> tensor<i32>
  %c = stablehlo.constant dense<2> : tensor<i32>
  %10 = chlo.broadcast_add %4, %9 : (tensor<i32>, tensor<i32>) -> tensor<i32>
  %11 = chlo.broadcast_subtract %10, %c : (tensor<i32>, tensor<i32>) -> tensor<i32>
  %c_3 = stablehlo.constant dense<-128> : tensor<i32>
  %c_4 = stablehlo.constant dense<127> : tensor<i32>
  %12 = stablehlo.clamp %c_3, %11, %c_4 : tensor<i32>
  %13 = stablehlo.convert %12 : (tensor<i32>) -> tensor<i8>
  return %13 : tensor<i8>
}

`-stablehlo-legalize-quantized-op-to-qdq`

কোয়ান্টাইজড স্টেবলএইচএলও অপারেশনকে (ডি-কোয়ান্টাইজ, ফ্লোটিং-পয়েন্ট অপারেশন এবং কোয়ান্টাইজ) প্যাটার্নে পচন।

ইউনিফর্ম কোয়ান্টাইজ/ডিকুয়ান্টাইজ অপারেশন ব্যবহার করে স্টেবলএইচএলও কোয়ান্টাইজড প্রোগ্রামগুলি পচন করা। উদাহরণস্বরূপ, নিম্নলিখিত প্রোগ্রাম

func.func @add(%arg0: tensor<!quant.uniform<i8:f32,1.0:0>>, %arg1: tensor<!quant.uniform<i8:f32,2.0:1>>) ->  tensor<!quant.uniform<i8:f32,3.0:2>> {
  %0 = "stablehlo.add"(%arg0, %arg1) : (tensor<!quant.uniform<i8:f32,1.0:0>>, tensor<!quant.uniform<i8:f32,2.0:1>>) -> tensor<!quant.uniform<i8:f32,3.0:2>>
  func.return %0 : tensor<!quant.uniform<i8:f32,3.0:2>>
}

হয়ে যাবে:

func.func @add(%arg0: tensor<!quant.uniform<i8:f32, 1.000000e+00>>, %arg1: tensor<!quant.uniform<i8:f32, 2.000000e+00:1>>) -> tensor<!quant.uniform<i8:f32, 3.000000e+00:2>> {
  %0 = stablehlo.uniform_dequantize %arg0 : (tensor<!quant.uniform<i8:f32, 1.000000e+00>>) -> tensor<f32>
  %1 = stablehlo.uniform_dequantize %arg1 : (tensor<!quant.uniform<i8:f32, 2.000000e+00:1>>) -> tensor<f32>
  %2 = stablehlo.add %0, %1 : tensor<f32>
  %3 = stablehlo.uniform_quantize %2 : (tensor<f32>) -> tensor<!quant.uniform<i8:f32, 3.000000e+00:2>>
  return %3 : tensor<!quant.uniform<i8:f32, 3.000000e+00:2>>
}

`-stablehlo-legalize-to-vhlo`

StableHLO থেকে VHLO কে বৈধ করুন।

`-stablehlo-refine-arguments`

প্রধান ফাংশনের আর্গুমেন্ট আকারগুলিকে পরিমার্জিত করে।

ইনপুট টাইপ স্বাক্ষর ব্যবহার করে প্রধান ফাংশনের আর্গুমেন্ট পরিবর্তন করে। শেপ রিফাইনমেন্ট চালানোর আগে IR বৈধ রাখতে custom_call @stablehlo.shape_refinement_operand_wrapper এ আর্গুমেন্টগুলি মোড়ানো হয়।

func.func public @main(%arg0: tensor<?xf32>) -> tensor<?xf32> {
  ...
}

==>

func.func public @main(%arg0: tensor<16xf32>) -> tensor<?xf32> {
  %c = stablehlo.constant dense<16> : tensor<1xi64>
  %0 = stablehlo.custom_call @stablehlo.shape_refinement_operand_wrapper(%arg0, %c) {...}
    : (tensor<16xf32>, tensor<1xi64>) -> tensor<?xf32>
  ...

পরিশোধিত প্রকারের একটি তালিকা নির্দিষ্ট করতে refinedTypesOption ব্যবহার করা যেতে পারে। এটিকে MLIR-এ --types='tensor<...>,tensor<...>' দিয়ে নির্দিষ্ট করা যেতে পারে, অথবা পাস তৈরি পদ্ধতিতে পাস করা যেতে পারে। পরিমার্জন প্রকারের তালিকাকে অবশ্যই পরিমার্জিত main পদ্ধতিতে প্রতিটি আর্গুমেন্টের ধরন উল্লেখ করতে হবে।

অপশন

-types : The new types to be used for the main function's arguments, specified as an MLIR TypeRange 'tensor<1x2xf32>, ...'

`-stablehlo-refine-shapes`

একটি StableHLO প্রোগ্রাম জুড়ে আকার পরিমার্জন করে।

একটি StableHLO প্রোগ্রামের মধ্য দিয়ে হেঁটে যায় অপ্সের মধ্যে আকার পরিমার্জন করে।

এই পাসের জন্য ফ্ল্যাগশিপ ব্যবহারের ক্ষেত্রে গতিশীল-আকৃতির প্রোগ্রামগুলিকে স্ট্যাটিক আকারে বিশেষায়িত করা হচ্ছে। যদি একটি গতিশীল-আকৃতির StableHLO প্রোগ্রামের সঠিক কাঠামো থাকে, তাহলে এর আর্গুমেন্ট প্রকারগুলিকে গতিশীল আকার থেকে স্থির আকারে আপডেট করা এবং এই পাসটি চালানোর ফলে পুরো প্রোগ্রাম জুড়ে স্ট্যাটিক আকারগুলি প্রচারিত হবে।

এই পাসটি সরাসরি অপারেন্ডের সাথে ফলাফলের ব্যবহার প্রতিস্থাপন করে custom_call @shape_refinement_operand_wrapper সরিয়ে দেয় এবং পুরো প্রোগ্রাম জুড়ে স্ট্যাটিক আকার প্রচার করে।

  %c = stablehlo.constant dense<16> : tensor<1xi64>
  %0 = stablehlo.custom_call @stablehlo.shape_refinement_operand_wrapper(%arg0, %c) {...}
      : (tensor<16xf32>, tensor<1xi64>) -> tensor<?xf32>
  %1 = stablehlo.add %0, %0 : tensor<?xf32>

  ==>

  %1 = stablehlo.add %arg0, %arg0 : tensor<16xf32>

আকৃতি পরিমার্জনের জন্য বৈধ মডিউলগুলির নিম্নলিখিত বৈশিষ্ট্য থাকতে হবে:

সমস্ত গতিশীল আকার শুধুমাত্র ইনপুট আকারের উপর নির্ভর করে (ইনপুট অ্যারের বিষয়বস্তুর উপর কোন আকৃতি নির্ভরতা নেই)। আমরা সেই ক্রিয়াকলাপগুলিকে উল্লেখ করি যেগুলি কেবলমাত্র ইনপুট আকারের উপর নির্ভরশীলভাবে নির্ভর করে (যেমন, stablehlo.get_dimension_size দ্বারা প্রদত্ত) বা বৈশ্বিক ধ্রুবকগুলি যেমন প্রতীকী পূর্ণসংখ্যাগুলির সমাধান করা মানগুলি (যেমন টেনসর) : A = 5), dimension অপারেশন হিসাবে। আন্তঃপ্রক্রিয়াগত ধ্রুবক ভাঁজ করার মাধ্যমে সমস্ত মাত্রার মানগুলিকে ধ্রুবকগুলিতে সমাধান করা যেতে পারে।
ইন্টারমিডিয়েট ফাংশনগুলি আর্গুমেন্ট তালিকার শুরুতে অনেকগুলি টোকেন আর্গুমেন্ট (!stablehlo.token প্রকারের) নিতে পারে, তারপরে কিছু বিশ্বব্যাপী ধ্রুবক আর্গুমেন্ট যা ধ্রুবক পূর্ণসংখ্যা স্কেলার, যেমন প্রতীকী পূর্ণসংখ্যার সমাধানকৃত মান (যেমন টেনসর) : A = 5)।
কিছু মধ্যবর্তী ফাংশন বৈশ্বিক ধ্রুবকগুলিতে গণনা প্রদান করতে পারে, যেমন সিমিন্ট মানগুলির উপর floordiv । এই ফাংশনগুলি শুধুমাত্র পরিমার্জন করার পরে ধ্রুবক মান ফিরিয়ে দিয়ে নির্দেশিত হয়। এই ফাংশন ইনলাইন করা হয়.
একটি একক ফাংশনের সমস্ত কল একই আর্গুমেন্ট আকারে সমাধান করে এবং কোনো পুনরাবৃত্ত/কো-রিকারসিভ ফাংশন কল করা হয় না।

`-stablehlo-wrap-in-composite`

একটি অ-যৌগিক StableHLO অপকে একটি যৌগিক অপে মোড়ানো হয়।

stablehlo.composite অপারেশনে StableHLO অপারেশন মোড়ানো হয়।

উদাহরণস্বরূপ, একটি সাধারণ StableHLO প্রোগ্রাম বিবেচনা করুন:

func.func @main(%arg0 : tensor<2xf32>, %arg1 : tensor<2xf32>) -> tensor<2xf32> {
  %0 = stablehlo.add %arg0, %arg1 : tensor<2xf32>
  return %0 : tensor<2xf32>
}

stablehlo.add ক্রিয়াকলাপ মোড়ানোর জন্য এই পাসটি প্রয়োগ করার ফলে নিম্নলিখিত প্রোগ্রাম হবে:

func.func @main(%arg0: tensor<2xf32>, %arg1: tensor<2xf32>) -> tensor<2xf32> {
  %0 = stablehlo.composite "stablehlo.add" %arg0, %arg1 {decomposition = @stablehlo.add.impl} : (tensor<2xf32>, tensor<2xf32>) -> tensor<2xf32>
  return %0 : tensor<2xf32>
}
func.func private @stablehlo.add.impl(%arg0: tensor<2xf32>, %arg1: tensor<2xf32>) -> tensor<2xf32> {
  %0 = stablehlo.add %arg0, %arg1 : tensor<2xf32>
  return %0 : tensor<2xf32>
}

নোট:

জেনারেট করা stablehlo.composite অপারেশনের name অ্যাট্রিবিউট সর্বদা মূল অপারেশনের নামের মতোই হবে যা মোড়ানো হয়েছিল (যেমন, আপনি যদি একটি stablehlo.add অপারেশন মোড়ানো হয়, তাহলে কম্পোজিটটির নামও "stablehlo.add" হবে)।
প্রাইভেট ফাংশন যা মূল ক্রিয়াকলাপকে এনক্যাপসুলেট করে ( stablehlo.composite অপারেশনের decomposition বৈশিষ্ট্য দ্বারা উল্লেখ করা হয়েছে) প্যাটার্ন ব্যবহার করে নামকরণ করা হবে <op_name>.impl[.N] , যেখানে <op_name> হল আসল অপারেশনের নাম, এবং N হল একটি অনন্য পূর্ণসংখ্যা শনাক্তকারী যা মোডের মধ্যে নামকরণের দ্বন্দ্ব প্রতিরোধ করার জন্য তৈরি করা হয়েছে।

এই পাস দুটি স্বতন্ত্র উপায়ে ব্যবহার করা যেতে পারে:

মোড 1: কমান্ড-লাইন ব্যবহার

এই মোডটি ডিবাগিং বা পরীক্ষার জন্য উদ্দিষ্ট, কারণ এটি জেনারেট করা stablehlo.composite অপারেশনগুলির বৈশিষ্ট্যগুলির উপর ন্যূনতম নিয়ন্ত্রণ অফার করে৷ এটি op-names (অপারেশন নামের একটি কমা দ্বারা পৃথক করা তালিকা) বিকল্পগুলি ব্যবহার করে নির্দিষ্ট করা ক্রিয়াকলাপের সমস্ত দৃষ্টান্ত মোড়ানো হয়। নতুন তৈরি stablehlo.composite অপারেশনের বৈশিষ্ট্যগুলি মূল অপারেশনের বৈশিষ্ট্যগুলির মতোই হবে৷

ব্যবহারের উদাহরণ:

stablehlo-opt input.mlir --stablehlo-wrap-in-composite=op-names='stablehlo.add,stablehlo.mul' -o output.mlir

মোড 2: কাস্টমাইজড অ্যাট্রিবিউট হ্যান্ডলিং সহ প্রোগ্রাম্যাটিক মডিউল-ওয়াইড র‌্যাপিং

এই মোডটি সমগ্র মডিউলে প্রোগ্রামেটিক মোড়ক প্রসারিত করে, কোন অপারেশনগুলি মোড়ানো এবং তাদের বৈশিষ্ট্যগুলির উপর সূক্ষ্ম-দানাযুক্ত নিয়ন্ত্রণ প্রদান করে। এটি createStablehloWrapInCompositePass API ব্যবহার করে অর্জন করা হয়, যা একটি CompositeAttributeProviderMap একটি যুক্তি হিসাবে নেয়।

CompositeAttributeProviderMap হল একটি মানচিত্র যা নির্দেশ করে যে কোন ক্রিয়াকলাপগুলিকে মোড়ানোর জন্য বিবেচনা করা উচিত এবং কীভাবে তাদের বৈশিষ্ট্যগুলি পরিচালনা করা উচিত৷ এর শব্দার্থবিদ্যা নিম্নরূপ:

কী (mlir::TypeID): একটি MLIR অপারেশনের TypeID । যদি একটি অপারেশনের TypeID মানচিত্রের একটি চাবির সাথে মিলে যায়, তাহলে এটি মোড়ানোর জন্য প্রার্থী হয়ে যায়।
মান (ল্যাম্বডা ফাংশন): std::function<std::optional<NamedAttrList>(Operation*)> টাইপের ল্যাম্বডা ফাংশন। এই ফাংশন প্রতিটি প্রার্থী অপারেশন প্রয়োগ করা হয়.
- ইনপুট: একটি mlir::Operation* , যা TypeID কী-এর সাথে সম্পর্কিত অপারেশন প্রকারের একটি উদাহরণ।
- রিটার্ন মান: একটি std::optional<NamedAttrList> ।
  - যদি ল্যাম্বডা একটি NamedAttrList প্রদান করে ( std::optional তে মোড়ানো), অপারেশনটি একটি stablehlo::composite অপারেশনে মোড়ানো হয়, এবং প্রত্যাবর্তিত বৈশিষ্ট্যগুলি কম্পোজিটের বৈশিষ্ট্যগুলি সেট করতে ব্যবহৃত হয়।
  - lambda std::nullopt ফেরত দিলে, অপারেশনটি মোড়ানো হয় না । এটি কাস্টম মানদণ্ডের উপর ভিত্তি করে নির্বাচনী মোড়ানোর অনুমতি দেয়।

উদাহরণ (C++):


stablehlo::CompositeAttributeProviderMap compositeAttributeProviderMap;

compositeAttributeProviderMap[mlir::TypeID::get<mlir::stablehlo::AddOp>()] =
  [](mlir::Operation* op) -> std::optional<mlir::NamedAttrList> {
  // Custom logic to determine if and how to wrap the operation.
  // Example: Only wrap if it's on a specific type.
  if (op->getOperand(0).getType().isa<mlir::Float32Type>()) {
    return mlir::NamedAttrList(op->getAttrs());
  }
  return std::nullopt; // Do not wrap.
};

pm.addPass(createStablehloWrapInCompositePass(compositeAttributeProviderMap, compositeVersion));
if (mlir::failed(pm.run(module))) {
  return;
}

অপশন

-op-names : The names of the ops to wrap.
-version  : The version number of the composite op.

`-vhlo-legalize-to-stablehlo`

VHLO-কে StableHLO-তে বৈধ করুন।

`-vhlo-to-version`

VHLO এর সংস্করণগুলির মধ্যে রূপান্তর করুন।

অপশন

-target : The target version. Must be a version of the form #.#.# .