-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

_Check stablehlo.custom_call @shapeassertion ops.

التحقّق من صحة طلبات 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

Pass to transform the IR to be on signless integers.

-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 الإصدار 1.0 نهائيًا (#2283) إزالة عدة عمليات مكررة. تساعد هذه الخطوة في تقييم تأثير عمليات الإزالة هذه في مختلف مسارات التجميع من خلال تحويلها إلى نظيراتها المتوافقة على المدى الطويل.

الخيارات

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

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

دمج نمط Fuse (إزالة التكميم، وعملية الفاصلة العائمة، والتكميم) في عملية 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 إلى عمليات رياضية أولية في 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 في أحدث إصدار من العمليات في VHLO يمكن بعد ذلك خفض مستوى هذه العمليات إلى إصدارات أقدم من VHLO لتحقيق التوافق مع الإصدارات الأحدث باستخدام VhloToVersionPass.

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

يمكنك الاطّلاع على vhlo.md > The VHLO dialect لمعرفة التفاصيل الكاملة حول كيفية استخدام VHLO للحفاظ على التوافق مع الإصدارات السابقة واللاحقة.

الخيارات

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

-stablehlo-refine-arguments

تحسين أشكال وسيطات الدالة الرئيسية:

تعدّل هذه السمة وسيطات الدالة الرئيسية باستخدام توقيع نوع الإدخال. يتم تضمين وسيطات الدوال في 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) أو الثوابت العامة مثل القيم التي تم تحديدها للأعداد الصحيحة الرمزية (أي tensor : A = 5)، على أنّها عمليات dimension. يمكن تحويل جميع قيم السمات إلى ثوابت من خلال عملية طيّ الثوابت بين الإجراءات.
  • قد تتلقّى الدوال الوسيطة عددًا من وسيطات الرموز المميزة (من النوع !stablehlo.token) في بداية قائمة الوسيطات، يليها بعض وسيطات الثوابت العامة التي تكون عبارة عن أعداد صحيحة ثابتة عددية، مثل القيم التي تم تحديدها للأعداد الصحيحة الرمزية (أي tensor : A = 5).
  • قد تعرض بعض الدوال الوسيطة عمليات حسابية على الثوابت العامة، أي 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>
}

سيؤدي تطبيق هذا التصريح لتنفيذ عمليات 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 هو معرّف عدد صحيح فريد تم إنشاؤه لمنع تعارض الأسماء داخل الوحدة.

يمكن استخدام هذه البطاقة بطريقتَين مختلفتَين:

الوضع 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، التي تأخذ CompositeAttributeProviderMap كمعلَمة.

CompositeAttributeProviderMap هي خريطة تحدّد العمليات التي يجب أخذها في الاعتبار عند التغليف وكيفية التعامل مع سماتها. دلالات هذه السمة هي كما يلي:

  • المفاتيح (mlir::TypeID): TypeID لعملية MLIR إذا تطابق TypeID عملية مع مفتاح في الخريطة، يصبح مرشحًا للتغليف.
  • القيم (دوال Lambda): دالة Lambda من النوع std::function<std::optional<NamedAttrList>(Operation*)>. يتم تطبيق هذه الدالة على كل عملية مرشّحة.
    • الإدخال: mlir::Operation*، وهو مثيل لنوع العملية المرتبط بالمفتاح TypeID
    • القيمة المعروضة: std::optional<NamedAttrList>
      • إذا عرضت الدالة lambda قيمة 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 (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 لضمان التوافق

تحويل بين إصدارات VHLO لترقية IR وخفض مستواها بهدف الحفاظ على التوافق مع الإصدارات الأحدث والأقدم

"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.md > The VHLO dialect لمعرفة التفاصيل الكاملة حول كيفية استخدام VHLO للحفاظ على التوافق مع الإصدارات السابقة واللاحقة.

الخيارات

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