-chlo-legalize-to-stablehlo

جریان عملیات CHLO را به عملیات StableHLO و Shape قانونی می‌کند.

-shape-legalize-to-stablehlo

گزینه‌های مربوط به شکل را به StableHLO قانونی کنید.

یک مجوز آزمایشی که عملیات‌های مرتبط با شکل را به عملیات‌های StableHLO قانونی می‌کند.

گرد هم آوردن محاسبات شکل و داده از طریق یک گذرگاه اختیاری، این امکان را برای اکوسیستم StableHLO فراهم می‌کند که به طور بالقوه از خطوط لوله کامپایل که از عملیات StableHLO برای مدل‌سازی پویایی استفاده می‌کنند، بهره ببرد.

-stablehlo-canonicalize-dynamism

عملیات‌های پویای StableHLO را به عملیات‌های ایستا تبدیل می‌کند.

اگر همه عناصر پویای = این عملیات‌ها در واقع ثابت باشند، عملیات‌های پویای StableHLO مانند DynamicReshapeOp را با معادل‌های استاتیک مربوطه مانند 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-check-shape-assertions

گزینه‌های assertion مربوط به ‎stablehlo.custom_call@shape را بررسی کنید.

اعتبارسنجی فراخوانی‌های سفارشی shape_assertion.

ادعاهای شکل، محدودیت‌های ابعاد پویا را در StableHLO اعتبارسنجی می‌کنند. برای مثال، اگر یک چارچوب نیاز به اعمال محدودیت DimA < 2 داشته باشد، می‌توان IR زیر را منتشر کرد:

%dimA = <get_dimension_size or input arg> : tensor<i32>
%c2 = stablehlo.constant dense<2> : tensor<i32>
%is_lt = stablehlo.compare LT %dimA, %c2 : tensor<i1>
stablehlo.custom_call @shape_assertion(%is_lt) { error_message = "DimA must be less than 2" }

پس از گذر، اگر شکل‌ها درست باشند، stablehlo.custom_call حذف خواهد شد.

گزینه‌ها

-enable-shape-assertions : Whether shape assertions may generate errors.

-stablehlo-compatibility-expander

گسترش‌دهنده سازگاری برای عملیات StableHLO.

عملیات StableHLO به‌روزرسانی می‌شود یا عملیات جدیدی در آخرین نسخه‌ها معرفی می‌شود. این مجوز، با تجزیه عملیات جدیدتر StableHLO به عملیات معادل پشتیبانی‌شده توسط آن نسخه‌های قدیمی‌تر، سازگاری با نسخه‌های قدیمی‌تر StableHLO را گسترش می‌دهد.

چرا این یک مجوز ورود به سیستم است؟

گاهی اوقات، از بهبودهای عملیات StableHLO برای ساده‌سازی قابل توجه مدیریت الگوهای رایج خاص در اکوسیستم 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

برای تبدیل IR به اعداد صحیح بدون علامت، مقدار را وارد کنید.

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

زیرمجموعه‌ای از کامپوزیت‌ها را می‌توان با استفاده از پرچم "except" از این تبدیل مستثنی کرد، به عنوان مثال:

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

عملیات منسوخ‌شده را به عملیات‌های با پشتیبانی خوب تبدیل کنید.

RFC مربوط به منسوخ‌سازی‌های StableHLO نسخه ۱.۰ (شماره ۲۲۸۳) پیشنهاد حذف چندین عملیات اضافی را می‌دهد. این مرحله به ارزیابی تأثیر حذف این عملیات‌ها در خطوط لوله کامپایل مختلف با قانونی کردن آنها برای همتایان دارای پشتیبانی بلندمدتشان کمک می‌کند.

گزینه‌ها

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

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

الگوی (کوانتیزه کردن، عملیات ممیز شناور و کوانتیزه کردن) را به عملیات کوانتیزه StableHLO تبدیل کنید.

الگوی (de-quantize، عملیات ممیز شناور و quantize) را به عملیات quantized در 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 به عملیات ریاضی اولیه StableHLO.

برنامه‌های StableHLO را با استفاده از انواع UniformQuantized به عملیات ریاضی عدد صحیح معادل معنایی تبدیل کنید.

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

عملیات 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<!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 را به آخرین نسخه ops در VHLO قانونی کنید. سپس این ops ها می‌توانند با استفاده از VhloToVersionPass به نسخه‌های قدیمی‌تر VHLO برای سازگاری رو به جلو، دانگرید شوند.

stablehlo.exponential %[[ARG0]] <{result_accuracy = DEFAULT}> : tensor<f32>
# ====>
"vhlo.exponential_v2"(%[[ARG0]]) <{result_accuracy = #vhlo.DEFAULT_v1}> : !vhlo.tensor_v1<!vhlo.f32_v1>

برای جزئیات کامل در مورد نحوه استفاده از VHLO برای حفظ سازگاری رو به جلو و عقب، به vhlo.md > گویش VHLO مراجعه کنید.

گزینه‌ها

-allow-other-dialects : Allow serialization to use other (potentially unstable) dialects, inserts unrealized casts between dialects.

-stablehlo-refine-arguments

شکل آرگومان‌های تابع main را اصلاح می‌کند.

آرگومان‌های تابع main را با استفاده از امضای نوع ورودی تغییر می‌دهد. آرگومان‌ها را در custom_call @stablehlo.shape_refinement_operand_wrapper قرار می‌دهد تا IR قبل از اجرای اصلاح شکل، معتبر باقی بماند.

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<...>' مشخص کرد، یا به متد pass create ارسال کرد. لیست انواع اصلاح‌شده باید نوع هر آرگومان را برای متد 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) در ابتدای لیست آرگومان‌ها دریافت کنند و پس از آن برخی آرگومان‌های ثابت سراسری که اعداد صحیح ثابت هستند، مانند مقادیر حل‌شده اعداد صحیح نمادین (مثلاً تانسور) قرار گیرند. : الف = ۵).
• برخی از توابع میانی ممکن است محاسبات مربوط به ثابت‌های سراسری را برگردانند، مثلاً floordiv روی مقادیر symint. این توابع با برگرداندن فقط مقادیر ثابت پس از اصلاح مشخص می‌شوند. این توابع درون‌خطی هستند.
• تمام فراخوانی‌های یک تابع واحد به شکل آرگومان‌های یکسانی ختم می‌شوند و هیچ فراخوانی تابع بازگشتی/هم‌بازگشتی انجام نمی‌شود.

-stablehlo-wrap-in-composite

یک عملیات StableHLO غیرکامپوزیتی را در یک عملیات کامپوزیتی می‌پیچد.

عملیات StableHLO را در عملیات stablehlo.composite قرار می‌دهد.

برای مثال، یک برنامه ساده StableHLO را در نظر بگیرید:

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

اعمال این گذر برای عملیات wrap کردن 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>
}

یادداشت‌ها:

• ویژگی name مربوط به عملیات تولید شده stablehlo.composite همیشه با نام عملیات اصلی که در آن قرار گرفته است، یکسان خواهد بود (به عنوان مثال، اگر یک عملیات stablehlo.add را در آن قرار دهید، نام ترکیب نیز "stablehlo.add" خواهد بود).
• تابع خصوصی که عملیات اصلی را کپسوله‌سازی می‌کند (که توسط ویژگی decomposition عملیات stablehlo.composite به آن ارجاع داده شده است) با استفاده از الگوی <op_name>.impl[.N] نامگذاری خواهد شد، که در آن <op_name> نام عملیات اصلی است و N یک شناسه عدد صحیح منحصر به فرد است که برای جلوگیری از تداخل نامگذاری در ماژول تولید می‌شود.

این گذرگاه می‌تواند به دو روش متمایز مورد استفاده قرار گیرد:

حالت ۱: استفاده از خط فرمان

این حالت برای اشکال‌زدایی یا آزمایش در نظر گرفته شده است، زیرا حداقل کنترل را بر ویژگی‌های عملیات تولید شده stablehlo.composite ارائه می‌دهد. این حالت تمام نمونه‌های عملیات مشخص شده با استفاده از گزینه‌های op-names (لیستی از نام عملیات که با کاما از هم جدا شده‌اند) را در بر می‌گیرد. ویژگی‌های عملیات stablehlo.composite تازه ایجاد شده، همان ویژگی‌های عملیات اصلی خواهد بود.

مثال استفاده:

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

حالت ۲: پوشش‌دهی در سراسر ماژول برنامه‌نویسی‌شده با مدیریت ویژگی‌های سفارشی

این حالت، پوشش‌دهی برنامه‌نویسی‌شده را به کل ماژول گسترش می‌دهد و کنترل دقیقی بر روی عملیات پوشش‌دهی‌شده و ویژگی‌های آنها ارائه می‌دهد. این امر با استفاده از API مربوط createStablehloWrapInCompositePass که یک CompositeAttributeProviderMap را به عنوان آرگومان دریافت می‌کند، محقق می‌شود.

CompositeAttributeProviderMap نقشه‌ای است که مشخص می‌کند کدام عملیات باید برای پوشش‌دهی در نظر گرفته شوند و چگونه ویژگی‌های آنها باید مدیریت شود. معانی آن به شرح زیر است:

• کلیدها (mlir::TypeID): TypeID یک عملیات MLIR. اگر TypeID یک عملیات با یک کلید در نقشه مطابقت داشته باشد، کاندیدی برای بسته‌بندی می‌شود.
• مقادیر (توابع لامبدا): تابع لامبدا از نوع std::function<std::optional<NamedAttrList>(Operation*)> . این تابع برای هر عملیات کاندید اعمال می‌شود.
  • ورودی: یک mlir::Operation* که نمونه‌ای از نوع عملیات مربوط به کلید TypeID است.
  • مقدار برگشتی: یک std::optional<NamedAttrList> .
    • اگر لامبدا یک NamedAttrList (که در std::optional قرار گرفته است) برگرداند، عملیات در یک عملیات stablehlo::composite قرار می‌گیرد و از ویژگی‌های برگشتی برای تنظیم ویژگی‌های کامپوزیت استفاده می‌شود.
    • اگر لامبدا std::nullopt برگرداند، عملیات بسته‌بندی نمی‌شود . این امر امکان بسته‌بندی انتخابی بر اساس معیارهای سفارشی را فراهم می‌کند.

مثال (سی++):

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 (mlir::isa<mlir::Float32Type>(op->getOperand(0).getType())) {
    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 را به هم تبدیل کنید.

برای ارتقاء و کاهش نسخه‌های IR، نسخه‌های VHLO را به یکدیگر تبدیل می‌کند تا سازگاری رو به جلو و عقب حفظ شود.

"vhlo.exponential_v2"(%[[ARG0]]) <{result_accuracy = DEFAULT}>
# ==( -target=1.0.0 )==>
"vhlo.exponential_v1"(%[[ARG0]])
# ==( -target=1.9.0 )==>
"vhlo.exponential_v2"(%[[ARG0]]) <{result_accuracy = DEFAULT}>

برای جزئیات کامل در مورد نحوه استفاده از VHLO برای حفظ سازگاری رو به جلو و عقب، به vhlo.md > گویش VHLO مراجعه کنید.

گزینه‌ها

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