دلالات العمليات

يوضّح ما يلي دلالات العمليات المحدّدة في واجهة XlaBuilder. عادةً، يتم ربط هذه العمليات بشكل مباشر بالعمليات المحدّدة في واجهة RPC في xla_data.proto.

ملاحظة حول التسمية: يتعامل نوع البيانات العام XLA مع مصفوفة N-dimensional تحتوي على عناصر من نوع موحّد (مثل عدد عشري 32 بت). في جميع أنحاء المستندات، يتم استخدام المصفوفة للإشارة إلى مصفوفة ذات أبعاد عشوائية. وللتسهيل، تحمل الحالات الخاصة أسماء أكثر تحديدًا ومألوفة، فعلى سبيل المثال، المتّجه هو مصفوفة أحادية البُعد، والمصفوفة هي مصفوفة ثنائية البُعد.

يمكنك الاطّلاع على مزيد من المعلومات حول بنية عملية في الأشكال والتصميم والتصميم المتجانب.

Abs

يمكنك الاطّلاع أيضًا على XlaBuilder::Abs.

القيمة المطلقة لكل عنصر x -> |x|

Abs(operand)

لمزيد من المعلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - abs.

إضافة

يمكنك الاطّلاع أيضًا على XlaBuilder::Add.

تُجري عملية جمع العناصر المتطابقة في lhs وrhs.

Add(lhs, rhs)

يجب أن تكون أشكال الوسيطات متشابهة أو متوافقة. راجِع مستندات البث لمعرفة معنى توافق الأشكال. تكون نتيجة العملية بشكل ناتج عن البث بين مصفوفتَي الإدخال. في هذا النوع، لا يتم تنفيذ العمليات بين مصفوفات ذات ترتيبات مختلفة، إلا إذا كان أحد المعامِلَين عددًا قياسيًا.

يتوفّر خيار بديل يتوافق مع البث بأبعاد مختلفة لعملية الإضافة:

Add(lhs,rhs, broadcast_dimensions)

يجب استخدام هذا النوع من العملية لإجراء عمليات حسابية بين مصفوفات ذات ترتيبات مختلفة (مثل إضافة مصفوفة إلى متّجه).

المعامل broadcast_dimensions الإضافي هو شريحة من الأعداد الصحيحة تحدّد الأبعاد التي سيتم استخدامها لبث المعاملات. يمكنك الاطّلاع على وصف تفصيلي للدلالات في صفحة البث.

لمزيد من المعلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - add.

AddDependency

يمكنك الاطّلاع أيضًا على HloInstruction::AddDependency.

قد يظهر AddDependency في عمليات تفريغ HLO، ولكن ليس من المفترض أن ينشئها المستخدمون النهائيون يدويًا.

AfterAll

يمكنك الاطّلاع أيضًا على XlaBuilder::AfterAll.

تأخذ الدالة AfterAll عددًا متغيرًا من الرموز المميزة وتنتج رمزًا مميزًا واحدًا. الرموز المميزة هي أنواع أساسية يمكن ربطها بين العمليات التي لها آثار جانبية لفرض الترتيب. يمكن استخدام AfterAll كعنصر ربط بين الرموز المميزة لترتيب عملية بعد مجموعة من العمليات.

AfterAll(tokens)

لمزيد من المعلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - after_all.

AllGather

يمكنك الاطّلاع أيضًا على XlaBuilder::AllGather.

تنفّذ عملية التسلسل على مستوى النسخ المتماثلة.

AllGather(operand, all_gather_dimension, shard_count, replica_groups, channel_id, layout, use_global_device_ids)

• replica_groups هي قائمة بمجموعات النسخ المتماثلة التي يتم إجراء التسلسل بينها (يمكن استرداد معرّف النسخة المتماثلة الحالية باستخدام ReplicaId). يحدّد ترتيب النسخ المتماثلة في كل مجموعة ترتيب المواضع التي تظهر بها المدخلات في النتيجة. يجب أن يكون الحقل replica_groups فارغًا (في هذه الحالة، تنتمي جميع النسخ المتماثلة إلى مجموعة واحدة، ويتم ترتيبها من 0 إلى N - 1)، أو أن يحتوي على عدد العناصر نفسه الذي يحتوي عليه عدد النسخ المتماثلة. على سبيل المثال، تنفّذ replica_groups = {0, 2}, {1, 3} عملية تسلسل بين النسختَين المتطابقتَين 0 و2، و1 و3.
• shard_count هو حجم كل مجموعة من النسخ المتماثلة. نحتاج إلى ذلك في الحالات التي تكون فيها replica_groups فارغة.
• يتم استخدام channel_id للتواصل بين الوحدات: يمكن فقط لعمليات all-gather التي لها channel_id نفسها أن تتواصل مع بعضها البعض.
• use_global_device_ids تعرض القيمة "صحيح" إذا كانت المعرّفات في إعداد ReplicaGroup تمثّل معرّفًا عامًا (replica_id * partition_count + partition_id) بدلاً من معرّف نسخة طبق الأصل. يتيح ذلك تجميع الأجهزة بشكل أكثر مرونة إذا كان هذا التخفيض الشامل على مستوى الأقسام والنسخ المتماثلة.

شكل الناتج هو شكل الإدخال الذي تم تكبيره بمقدار all_gather_dimension مرة.shard_count على سبيل المثال، إذا كان هناك نسختان متطابقتان وكانت قيمة المعامِل [1.0, 2.5] و[3.0, 5.25] على التوالي في النسختين المتطابقتين، ستكون قيمة الناتج من هذه العملية حيث all_gather_dim هي 0، هي [1.0, 2.5, 3.0,5.25] في كلتا النسختين المتطابقتين.

يتم تقسيم واجهة برمجة التطبيقات الخاصة بـ AllGather داخليًا إلى تعليمتَين من تعليمات HLO (AllGatherStart وAllGatherDone).

يمكنك الاطّلاع أيضًا على HloInstruction::CreateAllGatherStart.

تعمل AllGatherStart وAllGatherDone كعناصر أساسية في HLO. قد تظهر هذه العمليات في عمليات تفريغ HLO، ولكن ليس من المفترض أن ينشئها المستخدمون النهائيون يدويًا.

لمزيد من المعلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - all_gather.

AllReduce

يمكنك الاطّلاع أيضًا على XlaBuilder::AllReduce.

تُجري عملية حسابية مخصّصة على مستوى النسخ المتماثلة.

AllReduce(operand, computation, replica_groups, channel_id, shape_with_layout, use_global_device_ids)

• عندما يكون operand مجموعة من المصفوفات، يتم تنفيذ عملية تقليل الكل على كل عنصر من عناصر المجموعة.
• replica_groups هي قائمة بمجموعات النسخ المتماثلة التي يتم إجراء عملية التصغير بينها (يمكن استرداد معرّف النسخة المتماثلة الحالية باستخدام ReplicaId). يجب أن تكون replica_groups فارغة (في هذه الحالة، تنتمي جميع النسخ المتماثلة إلى مجموعة واحدة)، أو أن تحتوي على العدد نفسه من العناصر مثل عدد النسخ المتماثلة. على سبيل المثال، تنفّذ replica_groups = {0, 2}, {1, 3} عملية تقليل بين النسختَين المتطابقتَين 0 و2، و1 و3.
• يتم استخدام channel_id للتواصل بين الوحدات: يمكن فقط لعمليات all-reduce التي لها channel_id نفسها أن تتواصل مع بعضها البعض.
• ‫shape_with_layout: يفرض تخطيط AllReduce على التخطيط المحدّد. يُستخدَم هذا لضمان التنسيق نفسه لمجموعة من عمليات AllReduce التي تم تجميعها بشكل منفصل.
• use_global_device_ids تعرض القيمة "صحيح" إذا كانت المعرّفات في إعداد ReplicaGroup تمثّل معرّفًا عامًا (replica_id * partition_count + partition_id) بدلاً من معرّف نسخة طبق الأصل. يتيح ذلك تجميع الأجهزة بشكل أكثر مرونة إذا كان هذا التخفيض الشامل على مستوى الأقسام والنسخ المتماثلة.

يكون شكل الإخراج هو الشكل نفسه للإدخال. على سبيل المثال، إذا كان هناك نسختان متطابقتان وكانت قيمة المعامِل [1.0, 2.5] و[3.0, 5.25] على التوالي في النسختين المتطابقتين، ستكون قيمة الناتج من عملية الجمع هذه [4.0, 7.75] في كلتا النسختين المتطابقتين. إذا كان الإدخال عبارة عن مجموعة صفوف، يكون الإخراج عبارة عن مجموعة صفوف أيضًا.

يتطلّب احتساب نتيجة AllReduce الحصول على إدخال واحد من كل نسخة طبق الأصل، لذا إذا نفّذت إحدى النسخ عقدة AllReduce مرات أكثر من الأخرى، ستنتظر النسخة الأولى إلى الأبد. بما أنّ جميع النسخ المتماثلة تشغّل البرنامج نفسه، لا تتوفّر طرق كثيرة لحدوث ذلك، ولكن يمكن أن يحدث عندما يعتمد شرط حلقة while على بيانات من infeed وتتسبّب البيانات التي infeed في تكرار حلقة while لعدد مرات أكبر على نسخة متماثلة واحدة مقارنةً بنسخة أخرى.

يتم تقسيم واجهة برمجة التطبيقات الخاصة بـ AllReduce داخليًا إلى تعليمتَين من تعليمات HLO (AllReduceStart وAllReduceDone).

يمكنك الاطّلاع أيضًا على HloInstruction::CreateAllReduceStart.

تعمل AllReduceStart وAllReduceDone كعناصر أساسية في HLO. قد تظهر هذه العمليات في عمليات تفريغ HLO، ولكن ليس من المفترض أن ينشئها المستخدمون النهائيون يدويًا.

CrossReplicaSum

يمكنك الاطّلاع أيضًا على XlaBuilder::CrossReplicaSum.

تُجري عملية AllReduce مع احتساب المجموع.

CrossReplicaSum(operand, replica_groups)

تعرض مجموع قيمة المعامِل ضمن كل مجموعة فرعية من النسخ المتماثلة. تقدّم جميع النسخ المتماثلة قيمة إدخال واحدة إلى المجموع، وتتلقّى جميع النسخ المتماثلة المجموع الناتج لكل مجموعة فرعية.

AllToAll

يمكنك الاطّلاع أيضًا على XlaBuilder::AllToAll.

‫AllToAll هي عملية جماعية ترسل البيانات من جميع النوى إلى جميع النوى. تتضمّن هذه العملية مرحلتَين:

1. مرحلة التشتّت في كل نواة، يتم تقسيم المعامِل إلى split_count عدد من الحِزم على طول split_dimensions، ويتم توزيع الحِزم على جميع النوى، على سبيل المثال، يتم إرسال الحزمة رقم i إلى النواة رقم i.
2. مرحلة الجمع تدمج كل نواة الحِزم المستلَمة على طول concat_dimension.

يمكن ضبط النوى المشارِكة من خلال:

• ‫replica_groups: تحتوي كل ReplicaGroup على قائمة بمعرّفات النسخ المتماثلة المشارِكة في عملية الحساب (يمكن استرداد معرّف النسخة المتماثلة الحالية باستخدام ReplicaId). سيتم تطبيق AllToAll ضمن المجموعات الفرعية بالترتيب المحدّد. على سبيل المثال، يعني replica_groups = { {1,2,3}, {4,5,0} } أنّه سيتم تطبيق AllToAll ضمن النسخ المتماثلة {1, 2, 3}، وفي مرحلة التجميع، وسيتم ربط الكتل المستلَمة بالترتيب نفسه 1 و2 و3. بعد ذلك، سيتم تطبيق عملية AllToAll أخرى على النسخ المتماثلة 4 و5 و0، وسيكون ترتيب التسلسل أيضًا 4 و5 و0. إذا كانت replica_groups فارغة، تنتمي جميع النسخ المتماثلة إلى مجموعة واحدة، بترتيب تسلسلي حسب ظهورها.

المتطلَّبات الأساسية:

• يجب أن يكون حجم السمة الخاصة بالمعامل في split_dimension قابلاً للقسمة على split_count.
• شكل المعامِل ليس مجموعة صفوف.

AllToAll(operand, split_dimension, concat_dimension, split_count, replica_groups, layout, channel_id)

يمكنك الاطّلاع على xla::shapes للحصول على مزيد من المعلومات حول الأشكال والتنسيقات..

لمزيد من المعلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - all_to_all.

‫AllToAll - المثال 1

XlaBuilder b("alltoall");
auto x = Parameter(&b, 0, ShapeUtil::MakeShape(F32, {4, 16}), "x");
AllToAll(
    x,
    /*split_dimension=*/ 1,
    /*concat_dimension=*/ 0,
    /*split_count=*/ 4);

في المثال أعلاه، هناك 4 نوى تشارك في عملية Alltoall. في كل نواة، يتم تقسيم المعامِل إلى 4 أجزاء على طول البُعد 1، وبالتالي يكون لكل جزء شكل f32[4,4]. يتم توزيع الأجزاء الأربعة على جميع النوى. بعد ذلك، يربط كل نواة الأجزاء المستلَمة على طول السمة 0، بترتيب النواة 0-4. وبالتالي، يكون شكل الناتج على كل نواة f32[16,4].

AllToAll - Example 2 - StableHLO

في المثال أعلاه، هناك نسختان طبق الأصل تشاركان في AllToAll. في كل نسخة طبق الأصل، يكون شكل المعامِل f32[2,4]. يتم تقسيم المعامِل إلى جزأين على طول البُعد 1، وبالتالي يكون لكل جزء شكل f32[2,2]. بعد ذلك، يتم تبادل الجزأين بين النسخ المتماثلة وفقًا لموضعها في مجموعة النسخ المتماثلة. تجمع كل نسخة طبق الأصل الجزء المقابل لها من كلا المعاملَين وتدمجهما على طول البُعد 0. نتيجةً لذلك، يكون شكل الناتج على كل نسخة هو f32[4,2].

RaggedAllToAll

يمكنك الاطّلاع أيضًا على XlaBuilder::RaggedAllToAll.

تُجري عملية RaggedAllToAll عملية جماعية من الكل إلى الكل، حيث يكون الإدخال والإخراج عبارة عن موترات غير منتظمة.

RaggedAllToAll(input, input_offsets, send_sizes, output, output_offsets, recv_sizes, replica_groups, channel_id)

يتم تحديد الموترات غير المنتظمة من خلال مجموعة من ثلاثة موترات:

• ‫data: يكون موتر data "غير منتظم" على طول البُعد الخارجي، حيث يكون لكل عنصر مفهرس حجم متغير.
• offsets: يفهرس موتر offsets البُعد الخارجي لموتر data، ويمثّل الإزاحة الأولية لكل عنصر غير منتظم في موتر data.
• sizes: يمثّل موتر sizes حجم كل عنصر غير منتظم في موتر data، حيث يتم تحديد الحجم بوحدات من العناصر الفرعية. يتم تعريف العنصر الفرعي على أنّه لاحقة شكل موتر "البيانات" التي يتم الحصول عليها من خلال إزالة البُعد "غير المنتظم" الخارجي.
• يجب أن يكون حجم موترَي offsets وsizes متطابقًا.

مثال على موتر غير منتظم:

data: [8,3] =
{ {a,b,c},{d,e,f},{g,h,i},{j,k,l},{m,n,o},{p,q,r},{s,t,u},{v,w,x} }

offsets: [3] = {0, 1, 4}

sizes: [3] = {1, 3, 4}

// Index 'data' at 'offsets'[0], 'sizes'[0]' // {a,b,c}

// Index 'data' at 'offsets'[1], 'sizes'[1]' // {d,e,f},{g,h,i},{j,k,l}

// Index 'data' at 'offsets'[2], 'sizes'[2]' // {m,n,o},{p,q,r},{s,t,u},{v,w,x}

يجب تقسيم output_offsets بطريقة تتيح لكل نسخة طبق الأصل الحصول على إزاحات من منظور مخرجات النسخة المستهدَفة.

بالنسبة إلى إزاحة الإخراج رقم i، سترسل النسخة المتماثلة الحالية تحديث input[input_offsets[i]:input_offsets[i]+input_sizes[i]] إلى النسخة المتماثلة رقم i التي ستتم كتابتها إلى output_i[output_offsets[i]:output_offsets[i]+send_sizes[i]] في النسخة المتماثلة رقم i output.

على سبيل المثال، إذا كان لدينا نسختان طبق الأصل:

replica 0:
input: [1, 2, 2]
output:[0, 0, 0, 0]
input_offsets: [0, 1]
send_sizes: [1, 2]
output_offsets: [0, 0]
recv_sizes: [1, 1]

replica 1:
input: [3, 4, 0]
output: [0, 0, 0, 0]
input_offsets: [0, 1]
send_sizes: [1, 1]
output_offsets: [1, 2]
recv_sizes: [2, 1]

// replica 0's result will be: [1, 3, 0, 0]
// replica 1's result will be: [2, 2, 4, 0]

تتضمّن عملية ragged all-to-all في HLO الوسيطات التالية:

• input: موتر بيانات إدخال غير منتظم
• ‫output: موتر بيانات الإخراج غير المنتظم
• ‫input_offsets: موتر إزاحات الإدخال غير المنتظم.
• ‫send_sizes: موتر أحجام الإرسال غير المنتظمة
• ‫output_offsets: مصفوفة من الإزاحات غير المنتظمة في ناتج النسخة المتماثلة المستهدَفة.
• recv_sizes: موتر أحجام الاستلام غير المنتظمة

يجب أن يكون لجميع موترات *_offsets و*_sizes الشكل نفسه.

يتوفّر شكلان لموترَي *_offsets و*_sizes:

• [num_devices] حيث يمكن أن يرسل التحديث غير المنتظم من الكل إلى الكل تحديثًا واحدًا على الأكثر إلى كل جهاز بعيد في مجموعة النسخ المتماثلة. على سبيل المثال:

for (remote_device_id : replica_group) {
     SEND input[input_offsets[remote_device_id]],
     output[output_offsets[remote_device_id]],
     send_sizes[remote_device_id] }

• [num_devices, num_updates] حيث يمكن أن يرسل التحديث غير المنتظم من الكل إلى الكل ما يصل إلى num_updates إلى الجهاز البعيد نفسه (كل تحديث بإزاحة مختلفة)، لكل جهاز بعيد في مجموعة النسخ المتماثلة.

على سبيل المثال:

for (remote_device_id : replica_group) {
    for (update_idx : num_updates) {
        SEND input[input_offsets[remote_device_id][update_idx]],
        output[output_offsets[remote_device_id][update_idx]]],
        send_sizes[remote_device_id][update_idx] } }

و

يمكنك الاطّلاع أيضًا على XlaBuilder::And.

تُجري عملية AND على مستوى العناصر في موترَين lhs وrhs.

And(lhs, rhs)

يجب أن تكون أشكال الوسيطات متشابهة أو متوافقة. راجِع مستندات البث لمعرفة معنى توافق الأشكال. تكون نتيجة العملية بشكل ناتج عن البث بين مصفوفتَي الإدخال. في هذا النوع، لا يتم تنفيذ العمليات بين مصفوفات ذات ترتيبات مختلفة، إلا إذا كان أحد المعامِلَين عددًا قياسيًا.

يتوفّر نوع بديل من "And" يتيح البث بأبعاد مختلفة:

And(lhs,rhs, broadcast_dimensions)

يجب استخدام هذا النوع من العملية لإجراء عمليات حسابية بين مصفوفات ذات ترتيبات مختلفة (مثل إضافة مصفوفة إلى متّجه).

المعامل broadcast_dimensions الإضافي هو شريحة من الأعداد الصحيحة تحدّد الأبعاد التي سيتم استخدامها لبث المعاملات. يمكنك الاطّلاع على وصف تفصيلي للدلالات في صفحة البث.

لمزيد من المعلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - and.

غير متزامنة

راجِع أيضًا HloInstruction::CreateAsyncStart وHloInstruction::CreateAsyncUpdate وHloInstruction::CreateAsyncDone.

‫AsyncDone وAsyncStart وAsyncUpdate هي تعليمات HLO داخلية تُستخدم في العمليات غير المتزامنة وتعمل كعناصر أساسية في HLO. قد تظهر هذه العمليات في عمليات تفريغ HLO، ولكن ليس من المفترض أن ينشئها المستخدمون النهائيون يدويًا.

Atan2

يمكنك الاطّلاع أيضًا على XlaBuilder::Atan2.

تُجري هذه الدالة عملية atan2 على مستوى كل عنصر في lhs وrhs.

Atan2(lhs, rhs)

يجب أن تكون أشكال الوسيطات متشابهة أو متوافقة. راجِع مستندات البث لمعرفة معنى توافق الأشكال. تكون نتيجة العملية بشكل ناتج عن البث بين مصفوفتَي الإدخال. في هذا النوع، لا يتم تنفيذ العمليات بين مصفوفات ذات ترتيبات مختلفة، إلا إذا كان أحد المعامِلَين عددًا قياسيًا.

تتوفّر صيغة بديلة مع إمكانية البث بأبعاد مختلفة للدالة Atan2:

Atan2(lhs,rhs, broadcast_dimensions)

يجب استخدام هذا النوع من العملية لإجراء عمليات حسابية بين مصفوفات ذات ترتيبات مختلفة (مثل إضافة مصفوفة إلى متّجه).

المعامل broadcast_dimensions الإضافي هو شريحة من الأعداد الصحيحة تحدّد الأبعاد التي سيتم استخدامها لبث المعاملات. يمكنك الاطّلاع على وصف تفصيلي للدلالات في صفحة البث.

لمزيد من المعلومات عن StableHLO، يُرجى الاطّلاع على StableHLO - atan2.

BatchNormGrad

يمكنك أيضًا الاطّلاع على XlaBuilder::BatchNormGrad وورقة البحث الأصلية حول التسوية الدفعية للحصول على وصف تفصيلي للخوارزمية.

تحسب هذه الدالة تدرّجات التسوية الدفعية.

BatchNormGrad(operand, scale, batch_mean, batch_var, grad_output, epsilon, feature_index)

بالنسبة إلى كل ميزة في سمة الميزة (feature_index هو فهرس سمة الميزة في operand)، تحسب العملية التدرجات بالنسبة إلى operand وoffset وscale على مستوى جميع السمات الأخرى. يجب أن يكون feature_index فهرسًا صالحًا لسمة الميزة في operand.

يتم تحديد التدرّجات الثلاثة من خلال الصيغ التالية (بافتراض مصفوفة رباعية الأبعاد operand وفهرس سمة البُعد l وحجم الدفعة m والأحجام المكانية w وh):

\[ \begin{split} c_l&= \frac{1}{mwh}\sum_{i=1}^m\sum_{j=1}^w\sum_{k=1}^h \left( \nabla y_{ijkl} \frac{x_{ijkl} - \mu_l}{\sigma^2_l+\epsilon} \right) \\\\ d_l&= \frac{1}{mwh}\sum_{i=1}^m\sum_{j=1}^w\sum_{k=1}^h \nabla y_{ijkl} \\\\ \nabla x_{ijkl} &= \frac{\gamma_{l} }{\sqrt{\sigma^2_{l}+\epsilon} } \left( \nabla y_{ijkl} - d_l - c_l (x_{ijkl} - \mu_{l}) \right) \\\\ \nabla \gamma_l &= \sum_{i=1}^m\sum_{j=1}^w\sum_{k=1}^h \left( \nabla y_{ijkl} \frac{x_{ijkl} - \mu_l}{\sqrt{\sigma^2_{l}+\epsilon} } \right) \\\\\ \nabla \beta_l &= \sum_{i=1}^m\sum_{j=1}^w\sum_{k=1}^h \nabla y_{ijkl} \end{split} \]

تمثّل المدخلات batch_mean وbatch_var قيم اللحظات على مستوى الدُفعات والأبعاد المكانية.

نوع الناتج هو مجموعة من ثلاثة معرّفات:

للحصول على معلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - batch_norm_grad.

BatchNormInference

يمكنك أيضًا الاطّلاع على XlaBuilder::BatchNormInference وورقة البحث الأصلية حول التسوية الدفعية للحصول على وصف تفصيلي للخوارزمية.

تعمل هذه الدالة على تسوية مصفوفة على مستوى الدُفعات والسمات المكانية.

BatchNormInference(operand, scale, offset, mean, variance, epsilon, feature_index)

بالنسبة إلى كل ميزة في سمة الميزة (feature_index هو فهرس سمة الميزة في operand)، تحسب العملية المتوسط والتباين في جميع السمات الأخرى، وتستخدم المتوسط والتباين لتسوية كل عنصر في operand. يجب أن يكون feature_index فهرسًا صالحًا لسمة الميزة في operand.

BatchNormInference مكافئة لاستدعاء BatchNormTraining بدون احتساب mean وvariance لكل مجموعة. ويستخدم الإدخالين mean وvariance كقيم مقدَّرة. والغرض من هذه العملية هو تقليل وقت الاستجابة في الاستدلال، ومن هنا جاءت التسمية BatchNormInference.

الناتج هو مصفوفة عادية ذات n أبعاد لها الشكل نفسه كشكل الإدخال operand.

للحصول على معلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - batch_norm_inference.

BatchNormTraining

يمكنك أيضًا الاطّلاع على XlaBuilder::BatchNormTraining وthe original batch normalization paper للحصول على وصف تفصيلي للخوارزمية.

تعمل هذه الدالة على تسوية مصفوفة على مستوى الدُفعات والسمات المكانية.

BatchNormTraining(operand, scale, offset, epsilon, feature_index)

بالنسبة إلى كل ميزة في سمة الميزة (feature_index هو فهرس سمة الميزة في operand)، تحسب العملية المتوسط والتباين في جميع السمات الأخرى، وتستخدم المتوسط والتباين لتسوية كل عنصر في operand. يجب أن يكون feature_index فهرسًا صالحًا لسمة الميزة في operand.

تكون الخوارزمية على النحو التالي لكل مجموعة في operand \(x\) تحتوي على m عناصر بحجم الأبعاد المكانية w وh (بافتراض أنّ operand هي مصفوفة رباعية الأبعاد):

• تحسب هذه الدالة متوسط الدُفعات \(\mu_l\) لكل ميزة l في سمة الميزة: \(\mu_l=\frac{1}{mwh}\sum_{i=1}^m\sum_{j=1}^w\sum_{k=1}^h x_{ijkl}\)

• تحسب هذه الدالة تباين الدُفعات \(\sigma^2_l\): $\sigma^2l=\frac{1}{mwh}\sum{i=1}^m\sum{j=1}^w\sum{k=1}^h (x_{ijkl} - \mu_l)^2$

• التسوية والقياس والتغيير: \(y_{ijkl}=\frac{\gamma_l(x_{ijkl}-\mu_l)}{\sqrt[2]{\sigma^2_l+\epsilon} }+\beta_l\)

تتم إضافة قيمة إبسيلون، وهي عادةً رقم صغير، لتجنُّب أخطاء القسمة على صفر.

نوع الناتج هو مجموعة من ثلاثة XlaOp:

batch_mean وbatch_var هما لحظات يتم احتسابها على مستوى الدُفعة والسمات المكانية باستخدام الصيغ أعلاه.

للحصول على معلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - batch_norm_training.

Bitcast

يمكنك الاطّلاع أيضًا على HloInstruction::CreateBitcast.

قد يظهر Bitcast في عمليات تفريغ HLO، ولكن ليس الهدف أن ينشئ المستخدمون النهائيون هذه العمليات يدويًا.

BitcastConvertType

يمكنك الاطّلاع أيضًا على XlaBuilder::BitcastConvertType.

على غرار tf.bitcast في TensorFlow، تنفّذ هذه الدالة عملية bitcast على مستوى العناصر من شكل بيانات إلى شكل مستهدَف. يجب أن يتطابق حجم الإدخال والإخراج: على سبيل المثال، تتحوّل عناصر s32 إلى عناصر f32 من خلال روتين bitcast، وسيتحوّل عنصر s32 واحد إلى أربعة عناصر s8. يتم تنفيذ Bitcast كعملية إرسال منخفضة المستوى، لذا ستعرض الأجهزة التي تستخدم تمثيلات مختلفة للأرقام العشرية نتائج مختلفة.

BitcastConvertType(operand, new_element_type)

يجب أن تتطابق أبعاد المعامِل والشكل المستهدف، باستثناء البُعد الأخير الذي سيتغير حسب نسبة حجم العنصر الأساسي قبل التحويل وبعده.

يجب ألا تكون أنواع عناصر المصدر والوجهة عبارة عن مجموعات.

للحصول على معلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - bitcast_convert.

Bitcast-converting to primitive type of different width

تتيح تعليمات BitcastConvert HLO الحالة التي لا يساوي فيها حجم نوع عنصر الإخراج T' حجم عنصر الإدخال T. بما أنّ العملية بأكملها هي عبارة عن بث جزئي من الناحية المفاهيمية ولا تغيّر البايتات الأساسية، يجب تغيير شكل العنصر الناتج. بالنسبة إلى B = sizeof(T), B' = sizeof(T')، هناك حالتان محتملتان.

أولاً، عندما B > B'، يحصل شكل الناتج على بُعد جديد أصغر حجمًا يبلغ B/B'. على سبيل المثال:

  f16[10,2]{1,0} %output = f16[10,2]{1,0} bitcast-convert(f32[10]{0} %input)

تبقى القاعدة كما هي بالنسبة إلى الكميات العددية الفعّالة:

  f16[2]{0} %output = f16[2]{0} bitcast-convert(f32[] %input)

بدلاً من ذلك، بالنسبة إلى B' > B، تتطلّب التعليمات أن يكون آخر بُعد منطقي لشكل الإدخال مساويًا B'/B، ويتم حذف هذا البُعد أثناء عملية التحويل:

  f32[10]{0} %output = f32[10]{0} bitcast-convert(f16[10,2]{1,0} %input)

يُرجى العِلم أنّ عمليات التحويل بين عروض بتات مختلفة ليست على مستوى العناصر.

البث

يمكنك الاطّلاع أيضًا على XlaBuilder::Broadcast.

تضيف هذه الدالة سمات إلى مصفوفة من خلال تكرار البيانات في المصفوفة.

Broadcast(operand, broadcast_sizes)

يتم إدراج السمات الجديدة على اليسار، أي إذا كان broadcast_sizes يتضمّن القيم {a0, ..., aN} وكان شكل المعامِل يتضمّن السمات {b0, ..., bM}، فإنّ شكل الناتج يتضمّن السمات {a0, ..., aN, b0, ..., bM}.

يتم فهرسة السمات الجديدة في نُسخ من المعامِل، أي

output[i0, ..., iN, j0, ..., jM] = operand[j0, ..., jM]

على سبيل المثال، إذا كان operand عددًا قياسيًا f32 بقيمة 2.0f، وكان broadcast_sizes هو {2, 3}، ستكون النتيجة مصفوفة بالشكل f32[2, 3] وستكون جميع القيم في النتيجة هي 2.0f.

لمزيد من المعلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - البث.

BroadcastInDim

يمكنك الاطّلاع أيضًا على XlaBuilder::BroadcastInDim.

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

BroadcastInDim(operand, out_dim_size, broadcast_dimensions)

يشبه هذا النوع Broadcast، ولكنّه يتيح إضافة سمات في أي مكان وتوسيع السمات الحالية بحجم 1.

يتم بث operand إلى الشكل الموصوف بـ out_dim_size. تربط broadcast_dimensions أبعاد operand بأبعاد الشكل المستهدف، أي أنّ البُعد رقم i في المعامِل يتم ربطه بالبُعد رقم broadcast_dimension[i] في شكل الناتج. يجب أن تكون أبعاد operand بحجم 1 أو بنفس حجم البُعد في شكل الإخراج الذي يتم الربط به. يتم ملء السمات المتبقية بسمات بحجم 1. بعد ذلك، يتم البث على طول هذه الأبعاد المتدهورة للوصول إلى شكل الناتج. يمكنك الاطّلاع على وصف تفصيلي للدلالات في صفحة البث.

الاتصال

يمكنك الاطّلاع أيضًا على XlaBuilder::Call.

يستدعي عملية حسابية باستخدام الوسيطات المحدّدة.

Call(computation, operands...)

يجب أن تتطابق عدد المعلمات وأنواعها في operands مع معلمات computation. يُسمح بعدم تضمين operands.

CompositeCall

يمكنك الاطّلاع أيضًا على XlaBuilder::CompositeCall.

تتضمّن عملية مؤلَّفة من عمليات StableHLO أخرى، تتلقّى مدخلات وcomposite_attributes وتنتج نتائج. يتم تنفيذ دلالات العملية من خلال سمة التجزئة. يمكن استبدال العملية المركّبة بعملية التحلّل بدون تغيير دلالات البرنامج. في الحالات التي لا يؤدي فيها تضمين عملية التحليل إلى توفير دلالات العملية نفسها، يُفضّل استخدام custom_call.

يُستخدَم حقل الإصدار (القيمة التلقائية هي 0) للإشارة إلى وقت تغيير دلالات العنصر المركّب.

يتم تنفيذ هذه العملية كـ kCall مع السمة is_composite=true. يتم تحديد الحقل decomposition من خلال السمة computation. تخزّن سمات الواجهة الأمامية السمات المتبقية التي تبدأ بالبادئة composite..

مثال على عملية CompositeCall:

f32[] call(f32[] %cst), to_apply=%computation, is_composite=true,
frontend_attributes = {
  composite.name="foo.bar",
  composite.attributes={n = 1 : i32, tensor = dense<1> : tensor<i32>},
  composite.version="1"
}

CompositeCall(computation, operands..., name, attributes, version)

إنّ decomposition الخاص بعملية ليس حقلاً يُطلق عليه اسم، بل يظهر كسمة to_apply تشير إلى الدالة التي تحتوي على التنفيذ الأدنى مستوى، أي to_apply=%funcname.

يمكنك الاطّلاع على مزيد من المعلومات حول التركيب والتحليل على مواصفات StableHLO.

Cbrt

يمكنك الاطّلاع أيضًا على XlaBuilder::Cbrt.

عملية الجذر التكعيبي لكل عنصر x -> cbrt(x).

Cbrt(operand)

تتيح الدالة cbrt أيضًا الوسيط الاختياري result_accuracy:

Cbrt(operand, result_accuracy)

لمزيد من المعلومات عن result_accuracy، يمكنك الاطّلاع على مقالة دقة النتائج.

للحصول على معلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - cbrt.

تقريب للأعلى

يمكنك الاطّلاع أيضًا على XlaBuilder::Ceil.

دالة السقف لكل عنصر x -> ⌈x⌉

Ceil(operand)

لمزيد من المعلومات حول StableHLO، يُرجى الاطّلاع على ‫StableHLO - ceil.

Cholesky

يمكنك الاطّلاع أيضًا على XlaBuilder::Cholesky.

تحسب هذه الدالة تحليل شوليسكي لمجموعة من المصفوفات المحددة الموجبة المتماثلة (الهرميتية).

Cholesky(a, lower)

إذا كانت lower هي true، يتم احتساب المصفوفات المثلثية السفلية l بحيث يكون $a = l . ‫l^T$. إذا كانت lower هي false، يتم احتساب المصفوفات المثلثية العلوية u بحيث تكون \(a = u^T . u\).

تتم قراءة بيانات الإدخال من المثلث السفلي/العلوي من a فقط، وذلك استنادًا إلى قيمة lower. ويتم تجاهل القيم من المثلث الآخر. يتم عرض بيانات الإخراج في المثلث نفسه، أما القيم في المثلث الآخر، فيتم تحديدها حسب التنفيذ ويمكن أن تكون أي شيء.

إذا كان a يحتوي على أكثر من سمتَين، يتم التعامل مع a على أنّه مجموعة من المصفوفات، حيث تكون جميع السمات باستثناء السمتَين الثانويتَين سمات مجمّعة.

إذا لم تكن a متماثلة (هيرميتية) ومحددة موجبة، ستكون النتيجة محددة حسب التنفيذ.

لمزيد من المعلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - cholesky.

عقدة تقييد القيم

يمكنك الاطّلاع أيضًا على XlaBuilder::Clamp.

تثبّت هذه العقدة قيمة عامل ضمن النطاق بين الحدّ الأدنى والحدّ الأقصى.

Clamp(min, operand, max)

بالنظر إلى معامل وقيمتَي الحد الأدنى والأقصى، تعرض هذه الدالة المعامل إذا كان ضمن النطاق بين الحد الأدنى والأقصى، وإلا تعرض قيمة الحد الأدنى إذا كان المعامل أقل من هذا النطاق أو قيمة الحد الأقصى إذا كان المعامل أعلى من هذا النطاق. أي clamp(a, x, b) = min(max(a, x), b).

يجب أن تكون جميع المصفوفات الثلاثة بالشكل نفسه. بدلاً من ذلك، يمكن أن يكون min و/أو max عددًا قياسيًا من النوع T، وذلك كشكل محدود من البث.

مثال مع القيم العددية min وmax:

let operand: s32[3] = {-1, 5, 9};
let min: s32 = 0;
let max: s32 = 6;
==>
Clamp(min, operand, max) = s32[3]{0, 5, 6};

لمزيد من المعلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - clamp.

تصغير

يمكنك الاطّلاع أيضًا على XlaBuilder::Collapse. وعملية tf.reshape

تدمج هذه الدالة أبعاد الصفيف في بُعد واحد.

Collapse(operand, dimensions)

يستبدل Collapse المجموعة الفرعية المحدّدة من سمات المعامِل بسمة واحدة. وسيطات الإدخال هي مصفوفة عشوائية من النوع T ومتّجه ثابت في وقت الترجمة لفهارس الأبعاد. يجب أن تكون فهارس السمات مجموعة فرعية متسلسلة ومرتبة (من أرقام السمات المنخفضة إلى المرتفعة) من سمات T. وبالتالي، فإنّ {0, 1, 2} أو {0, 1} أو {1, 2} هي مجموعات سمات صالحة، ولكنّ {1, 0} أو {0, 2} غير صالحة. ويتم استبدالها بسمة جديدة واحدة في الموضع نفسه في تسلسل السمات الذي تم استبدالها فيه، ويكون حجم السمة الجديدة مساويًا لناتج أحجام السمات الأصلية. أصغر رقم سمة في dimensions هو السمة الأبطأ تغيُّرًا (الأكثر أهمية) في مجموعة الحلقات التي تدمج هذه السمات، وأكبر رقم سمة هو الأسرع تغيُّرًا (الأقل أهمية). اطّلِع على عامل التشغيل tf.reshape إذا كنت بحاجة إلى ترتيب أكثر عمومية للطي.

على سبيل المثال، لنفترض أنّ v هي مصفوفة من 24 عنصرًا:

let v = f32[4x2x3] { { {10, 11, 12}, {15, 16, 17} },
{ {20, 21, 22}, {25, 26, 27} },
{ {30, 31, 32}, {35, 36, 37} },
{ {40, 41, 42}, {45, 46, 47} } };

// Collapse to a single dimension, leaving one dimension.
let v012 = Collapse(v, {0,1,2});
then v012 == f32[24] {10, 11, 12, 15, 16, 17,
20, 21, 22, 25, 26, 27,
30, 31, 32, 35, 36, 37,
40, 41, 42, 45, 46, 47};

// Collapse the two lower dimensions, leaving two dimensions.
let v01 = Collapse(v, {0,1});
then v01 == f32[4x6] { {10, 11, 12, 15, 16, 17},
{20, 21, 22, 25, 26, 27},
{30, 31, 32, 35, 36, 37},
{40, 41, 42, 45, 46, 47} };

// Collapse the two higher dimensions, leaving two dimensions.
let v12 = Collapse(v, {1,2});
then v12 == f32[8x3] { {10, 11, 12},
{15, 16, 17},
{20, 21, 22},
{25, 26, 27},
{30, 31, 32},
{35, 36, 37},
{40, 41, 42},
{45, 46, 47} };

Clz

يمكنك الاطّلاع أيضًا على XlaBuilder::Clz.

تحسب هذه الدالة عدد الأصفار البادئة لكل عنصر.

Clz(operand)

CollectiveBroadcast

يمكنك الاطّلاع أيضًا على XlaBuilder::CollectiveBroadcast.

يبث البيانات على مستوى النسخ المتماثلة. يتم إرسال البيانات من المعرّف الأول للنسخة المتطابقة في كل مجموعة إلى المعرّفات الأخرى في المجموعة نفسها. إذا لم يكن معرّف النسخة المتطابقة في أي مجموعة نسخ متطابقة، سيكون الناتج على تلك النسخة المتطابقة عبارة عن موتر يتألف من أصفار في shape.

CollectiveBroadcast(operand, replica_groups, channel_id)

لمزيد من المعلومات حول StableHLO، يُرجى الاطّلاع على ‫StableHLO - collective_broadcast.

CollectivePermute

يمكنك الاطّلاع أيضًا على XlaBuilder::CollectivePermute.

‫CollectivePermute هي عملية جماعية ترسل البيانات وتتلقّاها على مستوى النسخ المتماثلة.

CollectivePermute(operand, source_target_pairs, channel_id, inplace)

يُرجى العِلم أنّ هناك القيود التالية على source_target_pairs:

• يجب ألا يتضمّن أي زوجَين معرّف نسخة طبق الأصل مستهدَفة نفسه، ويجب ألا يتضمّنا معرّف نسخة طبق الأصل مصدر نفسه.
• إذا لم يكن معرّف النسخة المتماثلة هدفًا في أي زوج، يكون الناتج على تلك النسخة المتماثلة موترًا يتألف من أصفار بالشكل نفسه الذي يتخذه الإدخال.

يتم تقسيم واجهة برمجة التطبيقات الخاصة بعملية CollectivePermute داخليًا إلى تعليمتَين من لغة HLO (CollectivePermuteStart وCollectivePermuteDone).

يمكنك الاطّلاع أيضًا على HloInstruction::CreateCollectivePermuteStart.

تعمل CollectivePermuteStart وCollectivePermuteDone كعناصر أساسية في HLO. قد تظهر هذه العمليات في عمليات تفريغ HLO، ولكن ليس من المفترض أن ينشئها المستخدمون النهائيون يدويًا.

لمزيد من المعلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - collective_permute.

مقارنة

يمكنك الاطّلاع أيضًا على XlaBuilder::Compare.

تُجري مقارنة بين عناصر lhs وrhs في ما يلي:

Eq

يمكنك الاطّلاع أيضًا على XlaBuilder::Eq.

تُجري هذه الدالة مقارنة يساوي بين عناصر lhs وrhs.

\(lhs = rhs\)

Eq(lhs, rhs)

يجب أن تكون أشكال الوسيطات متشابهة أو متوافقة. راجِع مستندات البث لمعرفة معنى توافق الأشكال. تكون نتيجة العملية بشكل ناتج عن البث بين مصفوفتَي الإدخال. في هذا النوع، لا يتم تنفيذ العمليات بين مصفوفات ذات ترتيبات مختلفة، إلا إذا كان أحد المعامِلَين عددًا قياسيًا.

تتوفّر صيغة بديلة تتوافق مع البث بأبعاد مختلفة للمعادلة:

Eq(lhs,rhs, broadcast_dimensions)

يجب استخدام هذا النوع من العملية لإجراء عمليات حسابية بين مصفوفات ذات ترتيبات مختلفة (مثل إضافة مصفوفة إلى متّجه).

المعامل broadcast_dimensions الإضافي هو شريحة من الأعداد الصحيحة تحدّد الأبعاد التي سيتم استخدامها لبث المعاملات. يمكنك الاطّلاع على وصف تفصيلي للدلالات في صفحة البث.

يتوفّر ترتيب إجمالي للأعداد العشرية في Eq، وذلك من خلال فرض ما يلي:

\[-NaN < -Inf < -Finite < -0 < +0 < +Finite < +Inf < +NaN.\]

EqTotalOrder(lhs,rhs, broadcast_dimensions)

لمزيد من المعلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - compare.

Ne

يمكنك الاطّلاع أيضًا على XlaBuilder::Ne.

تُجري هذه الدالة مقارنة لا يساوي بين عناصر lhs وrhs.

\(lhs != rhs\)

Ne(lhs, rhs)

يجب أن تكون أشكال الوسيطات متشابهة أو متوافقة. راجِع مستندات البث لمعرفة معنى توافق الأشكال. تكون نتيجة العملية بشكل ناتج عن البث بين مصفوفتَي الإدخال. في هذا النوع، لا يتم تنفيذ العمليات بين مصفوفات ذات ترتيبات مختلفة، إلا إذا كان أحد المعامِلَين عددًا قياسيًا.

يتوفّر نوع بديل من Ne يتيح البث بأبعاد مختلفة:

Ne(lhs,rhs, broadcast_dimensions)

يجب استخدام هذا النوع من العملية لإجراء عمليات حسابية بين مصفوفات ذات ترتيبات مختلفة (مثل إضافة مصفوفة إلى متّجه).

المعامل broadcast_dimensions الإضافي هو شريحة من الأعداد الصحيحة تحدّد الأبعاد التي سيتم استخدامها لبث المعاملات. يمكنك الاطّلاع على وصف تفصيلي للدلالات في صفحة البث.

يجب أن يكون إجمالي الطلب أكبر من الأعداد العشرية العائمة بالنسبة إلى Ne، وذلك من خلال فرض ما يلي:

\[-NaN < -Inf < -Finite < -0 < +0 < +Finite < +Inf < +NaN.\]

NeTotalOrder(lhs,rhs, broadcast_dimensions)

لمزيد من المعلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - compare.

Ge

يمكنك الاطّلاع أيضًا على XlaBuilder::Ge.

تُجري هذه الدالة مقارنة greater-or-equal-than بين عناصر lhs وrhs.

\(lhs >= rhs\)

Ge(lhs, rhs)

يجب أن تكون أشكال الوسيطات متشابهة أو متوافقة. راجِع مستندات البث لمعرفة معنى توافق الأشكال. تكون نتيجة العملية بشكل ناتج عن البث بين مصفوفتَي الإدخال. في هذا النوع، لا يتم تنفيذ العمليات بين مصفوفات ذات ترتيبات مختلفة، إلا إذا كان أحد المعامِلَين عددًا قياسيًا.

يتوفّر إصدار بديل من Ge يتيح البث بأبعاد مختلفة:

Ge(lhs,rhs, broadcast_dimensions)

يجب استخدام هذا النوع من العملية لإجراء عمليات حسابية بين مصفوفات ذات ترتيبات مختلفة (مثل إضافة مصفوفة إلى متّجه).

المعامل broadcast_dimensions الإضافي هو شريحة من الأعداد الصحيحة تحدّد الأبعاد التي سيتم استخدامها لبث المعاملات. يمكنك الاطّلاع على وصف تفصيلي للدلالات في صفحة البث.

يجب أن يكون إجمالي الطلب أكبر من أرقام النقطة العائمة، وذلك من خلال فرض ما يلي:

\[-NaN < -Inf < -Finite < -0 < +0 < +Finite < +Inf < +NaN.\]

GtTotalOrder(lhs,rhs, broadcast_dimensions)

لمزيد من المعلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - compare.

Gt

يمكنك الاطّلاع أيضًا على XlaBuilder::Gt.

تُجري مقارنة أكبر من على مستوى العناصر بين lhs وrhs.

\(lhs > rhs\)

Gt(lhs, rhs)

يجب أن تكون أشكال الوسيطات متشابهة أو متوافقة. راجِع مستندات البث لمعرفة معنى توافق الأشكال. تكون نتيجة العملية بشكل ناتج عن البث بين مصفوفتَي الإدخال. في هذا النوع، لا يتم تنفيذ العمليات بين مصفوفات ذات ترتيبات مختلفة، إلا إذا كان أحد المعامِلَين عددًا قياسيًا.

يتوفّر نوع بديل مع إمكانية البث بأبعاد مختلفة لـ Gt:

Gt(lhs,rhs, broadcast_dimensions)

يجب استخدام هذا النوع من العملية لإجراء عمليات حسابية بين مصفوفات ذات ترتيبات مختلفة (مثل إضافة مصفوفة إلى متّجه).

المعامل broadcast_dimensions الإضافي هو شريحة من الأعداد الصحيحة تحدّد الأبعاد التي سيتم استخدامها لبث المعاملات. يمكنك الاطّلاع على وصف تفصيلي للدلالات في صفحة البث.

لمزيد من المعلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - compare.

Le

يمكنك الاطّلاع أيضًا على XlaBuilder::Le.

تُجري هذه الدالة مقارنة less-or-equal-than على مستوى العناصر بين lhs وrhs.

\(lhs <= rhs\)

Le(lhs, rhs)

يجب أن تكون أشكال الوسيطات متشابهة أو متوافقة. راجِع مستندات البث لمعرفة معنى توافق الأشكال. تكون نتيجة العملية بشكل ناتج عن البث بين مصفوفتَي الإدخال. في هذا النوع، لا يتم تنفيذ العمليات بين مصفوفات ذات ترتيبات مختلفة، إلا إذا كان أحد المعامِلَين عددًا قياسيًا.

يتوفّر إصدار بديل من Le يتوافق مع البث بأبعاد مختلفة:

Le(lhs,rhs, broadcast_dimensions)

يجب استخدام هذا النوع من العملية لإجراء عمليات حسابية بين مصفوفات ذات ترتيبات مختلفة (مثل إضافة مصفوفة إلى متّجه).

المعامل broadcast_dimensions الإضافي هو شريحة من الأعداد الصحيحة تحدّد الأبعاد التي سيتم استخدامها لبث المعاملات. يمكنك الاطّلاع على وصف تفصيلي للدلالات في صفحة البث.

يجب أن يتيح Le إجمالي طلب يتجاوز أرقام النقطة العائمة، وذلك من خلال فرض ما يلي:

\[-NaN < -Inf < -Finite < -0 < +0 < +Finite < +Inf < +NaN.\]

LeTotalOrder(lhs,rhs, broadcast_dimensions)

لمزيد من المعلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - compare.

Lt

يمكنك الاطّلاع أيضًا على XlaBuilder::Lt.

تُجري هذه الدالة مقارنة أصغر من على مستوى العناصر بين lhs وrhs.

\(lhs < rhs\)

Lt(lhs, rhs)

يجب أن تكون أشكال الوسيطات متشابهة أو متوافقة. راجِع مستندات البث لمعرفة معنى توافق الأشكال. تكون نتيجة العملية بشكل ناتج عن البث بين مصفوفتَي الإدخال. في هذا النوع، لا يتم تنفيذ العمليات بين مصفوفات ذات ترتيبات مختلفة، إلا إذا كان أحد المعامِلَين عددًا قياسيًا.

يتوفّر خيار بديل مع إمكانية البث بأبعاد مختلفة لـ Lt:

Lt(lhs,rhs, broadcast_dimensions)

يجب استخدام هذا النوع من العملية لإجراء عمليات حسابية بين مصفوفات ذات ترتيبات مختلفة (مثل إضافة مصفوفة إلى متّجه).

المعامل broadcast_dimensions الإضافي هو شريحة من الأعداد الصحيحة تحدّد الأبعاد التي سيتم استخدامها لبث المعاملات. يمكنك الاطّلاع على وصف تفصيلي للدلالات في صفحة البث.

يتوفّر دعم لإجمالي الطلب على الأرقام العشرية في Lt، وذلك من خلال فرض ما يلي:

\[-NaN < -Inf < -Finite < -0 < +0 < +Finite < +Inf < +NaN.\]

LtTotalOrder(lhs,rhs, broadcast_dimensions)

لمزيد من المعلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - compare.

متقدّم

يمكنك الاطّلاع أيضًا على XlaBuilder::Complex.

تُجري هذه الدالة عملية تحويل على مستوى كل عنصر إلى قيمة مركّبة من زوج من القيم الحقيقية والتخيّلية، lhs وrhs.

Complex(lhs, rhs)

يجب أن تكون أشكال الوسيطات متشابهة أو متوافقة. راجِع مستندات البث لمعرفة معنى توافق الأشكال. تكون نتيجة العملية بشكل ناتج عن البث بين مصفوفتَي الإدخال. في هذا النوع، لا يتم تنفيذ العمليات بين مصفوفات ذات ترتيبات مختلفة، إلا إذا كان أحد المعامِلَين عددًا قياسيًا.

يتوفّر نوع بديل مع إمكانية البث بأبعاد مختلفة للنوع Complex:

Complex(lhs,rhs, broadcast_dimensions)

يجب استخدام هذا النوع من العملية لإجراء عمليات حسابية بين مصفوفات ذات ترتيبات مختلفة (مثل إضافة مصفوفة إلى متّجه).

المعامل broadcast_dimensions الإضافي هو شريحة من الأعداد الصحيحة تحدّد الأبعاد التي سيتم استخدامها لبث المعاملات. يمكنك الاطّلاع على وصف تفصيلي للدلالات في صفحة البث.

لمزيد من المعلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - complex.

ConcatInDim (دمج)

يمكنك الاطّلاع أيضًا على XlaBuilder::ConcatInDim.

تنشئ الدالة Concatenate مصفوفة من معاملات مصفوفات متعددة. تحتوي المصفوفة على عدد الأبعاد نفسه الذي تحتويه كل من معاملات مصفوفة الإدخال (التي يجب أن تحتوي على عدد الأبعاد نفسه الذي تحتويه كل منها)، كما تحتوي على الوسيطات بالترتيب الذي تم تحديده.

Concatenate(operands..., dimension)

باستثناء dimension، يجب أن تكون جميع السمات متطابقة. ويرجع ذلك إلى أنّ XLA لا تتوافق مع المصفوفات "غير المنتظمة". يُرجى أيضًا العِلم أنّه لا يمكن ربط القيم ذات البُعد 0 (لأنّه من المستحيل تسمية السمة التي يتم الربط على أساسها).

مثال أحادي الأبعاد:

Concat({ {2, 3}, {4, 5}, {6, 7} }, 0)
//Output:  {2, 3, 4, 5, 6, 7}

مثال ثنائي الأبعاد:

let a = { {1, 2},
         {3, 4},
         {5, 6} };

let b = { {7, 8} };

Concat({a, b}, 0)

//Output:  { {1, 2},
//          {3, 4},
//          {5, 6},
//          {7, 8} }

المخطط:

للحصول على معلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - concatenate.

الجملة الشرطية

يمكنك الاطّلاع أيضًا على XlaBuilder::Conditional.

Conditional(predicate, true_operand, true_computation, false_operand, false_computation)

تنفيذ true_computation إذا كانت قيمة predicate هي true، وتنفيذ false_computation إذا كانت قيمة predicate هي false، وعرض النتيجة

يجب أن تقبل الدالة true_computation وسيطة واحدة من النوع \(T_0\) ، وسيتم استدعاؤها باستخدام true_operand الذي يجب أن يكون من النوع نفسه. يجب أن تقبل الدالة false_computation وسيطة واحدة من النوع \(T_1\) ، وسيتم استدعاؤها باستخدام false_operand الذي يجب أن يكون من النوع نفسه. يجب أن يكون نوع القيمة المعروضة لكل من true_computation وfalse_computation هو نفسه.

يُرجى العِلم أنّه سيتم تنفيذ أحد الإجراءَين true_computation وfalse_computation فقط استنادًا إلى قيمة predicate.

Conditional(branch_index, branch_computations, branch_operands)

ينفّذ branch_computations[branch_index] ويعرض النتيجة. إذا كان branch_index عبارة عن S32 أصغر من 0 أو أكبر من أو يساوي N، يتم تنفيذ branch_computations[N-1] كفرع تلقائي.

يجب أن تقبل كل branch_computations[b] وسيطة واحدة من النوع \(T_b\) ، وسيتم استدعاؤها باستخدام branch_operands[b] الذي يجب أن يكون من النوع نفسه. يجب أن يكون نوع القيمة المعروضة لكل branch_computations[b] هو نفسه.

يُرجى العِلم أنّه سيتم تنفيذ أحد الإجراءَين branch_computations فقط استنادًا إلى قيمة branch_index.

لمزيد من المعلومات حول StableHLO، يُرجى الاطّلاع على ‫StableHLO - if.

ثابت

يمكنك الاطّلاع أيضًا على XlaBuilder::ConstantLiteral.

تُنشئ هذه الدالة output من قيمة ثابتة literal.

Constant(literal)

لمزيد من المعلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - ثابت.

ConvertElementType

يمكنك الاطّلاع أيضًا على XlaBuilder::ConvertElementType.

على غرار static_cast على مستوى العناصر في C++، تنفّذ ConvertElementType عملية تحويل على مستوى العناصر من شكل بيانات إلى شكل مستهدف. يجب أن تتطابق الأبعاد، وأن يكون التحويل على مستوى العناصر، مثلاً، تصبح عناصر s32 عناصر f32 من خلال روتين تحويل من s32 إلى f32.

ConvertElementType(operand, new_element_type)

يجب أن تتطابق أبعاد المعامِل وشكل الهدف. يجب ألا تكون أنواع عناصر المصدر والوجهة عبارة عن مجموعات.

ستنفّذ عملية تحويل، مثل T=s32 إلى U=f32، روتين تحويل من عدد صحيح إلى عدد عشري، مثل التقريب إلى أقرب عدد زوجي.

let a: s32[3] = {0, 1, 2};
let b: f32[3] = convert(a, f32);
then b == f32[3]{0.0, 1.0, 2.0}

لمزيد من المعلومات عن StableHLO، يُرجى الاطّلاع على StableHLO - convert.

Conv (الالتفاف)

يمكنك الاطّلاع أيضًا على XlaBuilder::Conv.

تحسب هذه الدالة عملية التفاف من النوع المستخدَم في الشبكات العصبية. في هذه الحالة، يمكن اعتبار الالتفاف على أنّه نافذة ذات n بُعد تتحرّك على مساحة أساسية ذات n بُعد، ويتم إجراء عملية حسابية لكل موضع ممكن للنافذة.

Conv يتم وضع تعليمات الالتفاف في قائمة الانتظار ضمن عملية الحساب، والتي تستخدم أرقام أبعاد الالتفاف التلقائية بدون تمديد.

يتم تحديد المساحة المتروكة بطريقة مختصرة على النحو التالي: SAME أو VALID. تضيف عملية التعبئة SAME إلى الإدخال (lhs) أصفارًا ليكون شكل الإخراج مماثلاً لشكل الإدخال عند عدم أخذ الخطوات في الاعتبار. تعني المساحة المتروكة الصالحة ببساطة عدم وجود مساحة متروكة.

Conv(lhs, rhs, window_strides, padding, feature_group_count, batch_group_count, precision_config, preferred_element_type)

تتوفّر مستويات متزايدة من عناصر التحكّم في Conv:

• ConvWithGeneralPadding
• ConvWithGeneralDimensions
• ConvGeneral
• ConvGeneralDilated

ليكن n هو عدد الأبعاد المكانية. الوسيطة lhs هي عبارة عن مصفوفة ذات (n+2) بُعد تصف المساحة الأساسية. يُطلق على هذا الاسم "الإدخال"، مع أنّ الجانب الأيسر هو أيضًا إدخال. في الشبكة العصبية، تكون هذه القيم هي عمليات التفعيل الخاصة بالمدخلات. السمات n+2 هي، بهذا الترتيب:

• batch: يمثّل كل إحداثي في هذا البُعد إدخالاً مستقلاً يتم إجراء الالتفاف له.
• z/depth/features: يحتوي كل موضع (y,x) في المساحة الأساسية على متّجه مرتبط به، ويتم إدخاله في هذه السمة.
• spatial_dims: يصف الأبعاد المكانية n التي تحدّد المساحة الأساسية التي تتحرّك النافذة عليها.

الوسيطة rhs هي عبارة عن مصفوفة (n+2) ذات أبعاد تصف فلتر/نواة/نافذة الالتفاف. السمات هي، بهذا الترتيب:

• output-z: تمثّل هذه السمة z الناتج.
• input-z: يجب أن يساوي حجم هذه السمة مضروبًا في feature_group_count حجم السمة z في الجانب الأيسر.
• spatial_dims: يصف الأبعاد المكانية n التي تحدّد النافذة ذات الأبعاد المتعددة التي تتحرّك في جميع أنحاء المنطقة الأساسية.

تحدّد الوسيطة window_strides خطوة النافذة الالتفافية في الأبعاد المكانية. على سبيل المثال، إذا كانت الخطوة في البُعد المكاني الأول هي 3، لا يمكن وضع النافذة إلا في الإحداثيات التي يكون فيها الفهرس المكاني الأول قابلاً للقسمة على 3.

تحدّد الوسيطة padding مقدار المساحة المتروكة التي سيتم تطبيقها على المساحة الأساسية. يمكن أن تكون قيمة المساحة المتروكة سالبة، وتشير القيمة المطلقة للمساحة المتروكة السالبة إلى عدد العناصر التي يجب إزالتها من البُعد المحدّد قبل إجراء الالتفاف. تحدّد padding[0] مساحة الحشو للسمة y، وتحدّد padding[1] مساحة الحشو للسمة x. يحتوي كل زوج على مسافة بادئة منخفضة كعنصر أول ومسافة بادئة عالية كعنصر ثانٍ. يتم تطبيق المساحة المتروكة المنخفضة في اتجاه الفهارس المنخفضة، بينما يتم تطبيق المساحة المتروكة العالية في اتجاه الفهارس العالية. على سبيل المثال، إذا كانت قيمة padding[1] هي (2,3)، سيتم إضافة صفرَين على اليمين و3 أصفار على اليسار في البُعد المكاني الثاني. استخدام الحشو هو بمثابة إدراج قيم الأصفار نفسها في الإدخال (lhs) قبل إجراء الالتفاف.

تحدّد الوسيطتان lhs_dilation وrhs_dilation عامل التمدد الذي سيتم تطبيقه على الجانب الأيسر والجانب الأيمن، على التوالي، في كل بُعد مكاني. إذا كان عامل التمدد في بُعد مكاني هو d، يتم ضمنيًا وضع d-1 ثقوب بين كل إدخال في هذا البُعد، ما يؤدي إلى زيادة حجم المصفوفة. يتم ملء الثقوب بقيمة no-op، والتي تعني أصفارًا بالنسبة إلى الالتفاف.

يُطلق على تمديد الجانب الأيمن أيضًا اسم الالتفاف التوسعي. لمزيد من التفاصيل، يمكنك الاطّلاع على tf.nn.atrous_conv2d. يُطلق على توسيع الجانب الأيمن أيضًا اسم الالتفاف المنقول. لمزيد من التفاصيل، يُرجى الاطّلاع على tf.nn.conv2d_transpose.

يمكن استخدام الوسيطة feature_group_count (القيمة التلقائية 1) لعمليات الالتفاف المجمّعة. يجب أن يكون feature_group_count قاسمًا لكل من سمة الإدخال وسمة الإخراج. إذا كانت قيمة feature_group_count أكبر من 1، يعني ذلك أنّ أبعاد الميزات المدخلة والمخرجة وأبعاد الميزات المخرجة rhs مقسّمة بالتساوي إلى العديد من المجموعات feature_group_count، وتتألف كل مجموعة من تسلسل فرعي متتالٍ من الميزات. يجب أن يكون بُعد ميزة الإدخال rhs مساويًا لبُعد ميزة الإدخال lhs مقسومًا على feature_group_count (وبالتالي، سيكون له حجم مجموعة من ميزات الإدخال). يتم استخدام المجموعات ذات الترتيب i معًا لاحتساب feature_group_count للعديد من الالتفافات المنفصلة. يتم ربط نتائج عمليات الالتفاف هذه معًا في سمة الإخراج.

بالنسبة إلى الالتفاف العميق، سيتم ضبط وسيطة feature_group_count على بُعد ميزة الإدخال، وسيتم إعادة تشكيل الفلتر من [filter_height, filter_width, in_channels, channel_multiplier] إلى [filter_height, filter_width, 1, in_channels * channel_multiplier]. لمزيد من التفاصيل، يمكنك الاطّلاع على tf.nn.depthwise_conv2d.

يمكن استخدام وسيطة batch_group_count (القيمة التلقائية 1) للفلاتر المجمّعة أثناء الانتشار العكسي. يجب أن يكون batch_group_count أحد قواسم حجم سمة الدفعة lhs (الإدخال). إذا كانت قيمة batch_group_count أكبر من 1، يعني ذلك أنّ حجم مجموعة النتائج يجب أن يكون input batch / batch_group_count. يجب أن يكون batch_group_count قاسمًا لحجم الميزة الناتج.

يتضمّن شكل الإخراج الأبعاد التالية، بهذا الترتيب:

• batch: يجب أن يساوي حجم هذه السمة مضروبًا في batch_group_count حجم السمة batch في الجانب الأيسر.
• ‫z: الحجم نفسه الذي يظهر به output-z على النواة (rhs)
• ‫spatial_dims: قيمة واحدة لكل موضع صالح لنافذة الالتفاف.

يوضّح الشكل أعلاه طريقة عمل الحقل batch_group_count. في الواقع، نقسّم كل مجموعة من الجانب الأيسر إلى batch_group_count مجموعات، ونفعل الشيء نفسه مع ميزات الإخراج. بعد ذلك، نجري عمليات التفاف زوجية لكل مجموعة من هذه المجموعات ونربط الناتج على طول بُعد ميزة الناتج. تظل الدلالات التشغيلية لجميع السمات الأخرى (المكانية والخاصة بالميزات) كما هي.

يتم تحديد مواضع النافذة الالتفافية الصالحة من خلال الخطوات وحجم المساحة الأساسية بعد إضافة المساحة المتروكة.

لوصف ما تفعله عملية الالتفاف، لنأخذ عملية التفاف ثنائية الأبعاد، ونختار بعض الإحداثيات الثابتة batch وz وy وx في الناتج. بعد ذلك، (y,x) هو موضع إحدى زوايا النافذة ضمن المساحة الأساسية (مثل الزاوية العلوية اليسرى، حسب طريقة تفسيرك للأبعاد المكانية). لدينا الآن نافذة ثنائية الأبعاد، مأخوذة من المساحة الأساسية، حيث ترتبط كل نقطة ثنائية الأبعاد بمتّجه أحادي الأبعاد، وبالتالي نحصل على مربّع ثلاثي الأبعاد. من النواة الالتفافية، بما أنّنا ثبّتنا الإحداثي الناتج z، لدينا أيضًا مربّع ثلاثي الأبعاد. للمربّعين الأبعاد نفسها، لذا يمكننا جمع حاصل ضرب العناصر المتناظرة بين المربّعين (على غرار الجداء النقطي). هذه هي قيمة الناتج.

يُرجى العِلم أنّه إذا كان output-z مثلاً ‫5، سيؤدي كل موضع في النافذة إلى إنشاء 5 قيم في الناتج ضمن السمة z للناتج. تختلف هذه القيم في الجزء المستخدَم من النواة الالتفافية، إذ يتوفّر مربّع ثلاثي الأبعاد منفصل من القيم المستخدَمة لكل إحداثي output-z. ويمكنك اعتبارها 5 عمليات التفاف منفصلة مع فلتر مختلف لكل منها.

في ما يلي رمز زائف لالتفاف ثنائي الأبعاد مع الحشو والخطوة:

for (b, oz, oy, ox) { // output coordinates
  value = 0;
  for (iz, ky, kx) { // kernel coordinates and input z
    iy = oy*stride_y + ky - pad_low_y;
    ix = ox*stride_x + kx - pad_low_x;
    if ((iy, ix) inside the base area considered without padding) {
      value += input(b, iz, iy, ix) * kernel(oz, iz, ky, kx);
    }
  }
  output(b, oz, oy, ox) = value;
}

يُستخدَم precision_config للإشارة إلى إعدادات الدقة. يحدّد المستوى ما إذا كان يجب أن تحاول الأجهزة إنشاء المزيد من تعليمات الرموز البرمجية للآلة لتوفير محاكاة أكثر دقة لنوع البيانات عند الحاجة (أي محاكاة f32 على وحدة معالجة Tensor Processing Unit التي لا تتوافق إلا مع عمليات ضرب المصفوفات bf16). يمكن أن تكون القيم DEFAULT أو HIGH أو HIGHEST. تفاصيل إضافية في أقسام MXU

‫preferred_element_type هو عنصر عددي من أنواع الإخراج ذات الدقة الأعلى/الأدنى المستخدَمة للتجميع. تقترح السمة preferred_element_type نوع التجميع للعملية المحدّدة، ولكنّ ذلك ليس مضمونًا. يتيح ذلك لبعض برامج الخلفية للأجهزة تجميع البيانات في نوع مختلف وتحويلها إلى نوع الإخراج المفضّل.

لمزيد من المعلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - الالتفاف.

ConvWithGeneralPadding

يمكنك الاطّلاع أيضًا على XlaBuilder::ConvWithGeneralPadding.

ConvWithGeneralPadding(lhs, rhs, window_strides, padding, feature_group_count, batch_group_count, precision_config, preferred_element_type)

كما هو الحال في Conv حيث يكون إعداد المساحة المتروكة صريحًا.

ConvWithGeneralDimensions

يمكنك الاطّلاع أيضًا على XlaBuilder::ConvWithGeneralDimensions.

ConvWithGeneralDimensions(lhs, rhs, window_strides, padding, dimension_numbers, feature_group_count, batch_group_count, precision_config, preferred_element_type)

هي نفسها Conv حيث تكون أرقام السمات واضحة.

ConvGeneral

يمكنك الاطّلاع أيضًا على XlaBuilder::ConvGeneral.

ConvGeneral(lhs, rhs, window_strides, padding, dimension_numbers, feature_group_count, batch_group_count, precision_config, preferred_element_type)

كما هو الحال في Conv حيث تكون أرقام السمات وإعدادات المساحة المتروكة محدّدة بوضوح

ConvGeneralDilated

يمكنك الاطّلاع أيضًا على XlaBuilder::ConvGeneralDilated.

ConvGeneralDilated(lhs, rhs, window_strides, padding, lhs_dilation, rhs_dilation, dimension_numbers, feature_group_count, batch_group_count, precision_config, preferred_element_type, window_reversal)

هي نفسها Conv حيث تكون إعدادات المساحة المتروكة وعوامل التمدد وأرقام الأبعاد واضحة.

نسخ

يمكنك الاطّلاع أيضًا على HloInstruction::CreateCopyStart.

يتم تقسيم Copy داخليًا إلى تعليمتَي HLO هما CopyStart وCopyDone. تعمل Copy وCopyStart وCopyDone كعناصر أساسية في HLO. قد تظهر هذه العمليات في عمليات تفريغ HLO، ولكن ليس من المفترض أن ينشئها المستخدمون النهائيون يدويًا.

Cos

راجِع أيضًاXlaBuilder::Cos.

جيب التمام العنصري x -> cos(x)

Cos(operand)

تتيح الدالة Cos أيضًا الوسيطة الاختيارية result_accuracy:

Cos(operand, result_accuracy)

لمزيد من المعلومات عن result_accuracy، يمكنك الاطّلاع على مقالة دقة النتائج.

لمزيد من المعلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - cosine.

عصا

يمكنك الاطّلاع أيضًا على XlaBuilder::Cosh.

جيب التمام الزائدي لكل عنصر x -> cosh(x)

Cosh(operand)

تتيح الدالة cosh أيضًا استخدام الوسيطة الاختيارية result_accuracy:

Cosh(operand, result_accuracy)

لمزيد من المعلومات عن result_accuracy، يمكنك الاطّلاع على مقالة دقة النتائج.

CustomCall

يمكنك الاطّلاع أيضًا على XlaBuilder::CustomCall.

استدعاء دالة يقدّمها المستخدم ضمن عملية حسابية

تتوفّر مستندات CustomCall في تفاصيل المطوّر - مكالمات XLA المخصّصة.

لمزيد من المعلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - custom_call.

درجة

يمكنك الاطّلاع أيضًا على XlaBuilder::Div.

تُجري هذه الدالة عملية قسمة كل عنصر من المقسوم lhs على العنصر المقابل له في المقسوم عليه rhs.

Div(lhs, rhs)

يؤدي تجاوز سعة قسمة الأعداد الصحيحة (قسمة الأعداد الصحيحة الموقّعة أو غير الموقّعة أو الباقي من القسمة على صفر أو قسمة الأعداد الصحيحة الموقّعة أو الباقي من قسمة INT_SMIN على -1) إلى إنتاج قيمة محددة التنفيذ.

يجب أن تكون أشكال الوسيطات متشابهة أو متوافقة. راجِع مستندات البث لمعرفة معنى توافق الأشكال. تكون نتيجة العملية بشكل ناتج عن البث بين مصفوفتَي الإدخال. في هذا النوع، لا يتم تنفيذ العمليات بين مصفوفات ذات ترتيبات مختلفة، إلا إذا كان أحد المعامِلَين عددًا قياسيًا.

يتوفّر نوع بديل من Div يتيح البث بأبعاد مختلفة:

Div(lhs,rhs, broadcast_dimensions)

يجب استخدام هذا النوع من العملية لإجراء عمليات حسابية بين مصفوفات ذات ترتيبات مختلفة (مثل إضافة مصفوفة إلى متّجه).

المعامل broadcast_dimensions الإضافي هو شريحة من الأعداد الصحيحة تحدّد الأبعاد التي سيتم استخدامها لبث المعاملات. يمكنك الاطّلاع على وصف تفصيلي للدلالات في صفحة البث.

لمزيد من المعلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - divide.

النطاق

يمكنك الاطّلاع أيضًا على HloInstruction::CreateDomain.

قد يظهر Domain في عمليات تفريغ HLO، ولكن ليس من المفترض أن ينشئه المستخدمون النهائيون يدويًا.

نقطة

يمكنك الاطّلاع أيضًا على XlaBuilder::Dot.

Dot(lhs, rhs, precision_config, preferred_element_type)

تعتمد الدلالات الدقيقة لهذه العملية على ترتيب المعامِلات:

تُجري العملية مجموع المنتجات على مستوى البُعد الثاني من lhs (أو البُعد الأول إذا كان يتضمّن بُعدًا واحدًا) والبُعد الأول من rhs. وهي السمات "المتعاقد عليها". يجب أن يكون حجم الأبعاد المختصرة لكل من lhs وrhs متطابقًا. في الواقع، يمكن استخدامها لإجراء ضرب نقطي بين المتجهات أو ضرب متجه/مصفوفة أو ضرب مصفوفة/مصفوفة.

يُستخدَم precision_config للإشارة إلى إعدادات الدقة. يحدّد المستوى ما إذا كان يجب أن تحاول الأجهزة إنشاء المزيد من تعليمات الرموز البرمجية للآلة لتوفير محاكاة أكثر دقة لنوع البيانات عند الحاجة (أي محاكاة f32 على وحدة معالجة Tensor Processing Unit التي لا تتوافق إلا مع عمليات ضرب المصفوفات bf16). يمكن أن تكون القيم DEFAULT أو HIGH أو HIGHEST. تفاصيل إضافية في أقسام MXU

‫preferred_element_type هو عنصر عددي من أنواع الإخراج ذات الدقة الأعلى/الأدنى المستخدَمة للتجميع. تنصح preferred_element_type باستخدام نوع التجميع للعملية المحدّدة، ولكن ليس مضمونًا أن يكون متاحًا. يتيح ذلك لبعض برامج الخلفية للأجهزة تجميع البيانات في نوع مختلف وتحويلها إلى نوع الإخراج المفضّل.

للحصول على معلومات عن StableHLO، يُرجى الاطّلاع على StableHLO - dot.

DotGeneral

يمكنك الاطّلاع أيضًا على XlaBuilder::DotGeneral.

DotGeneral(lhs, rhs, dimension_numbers, precision_config, preferred_element_type)

تشبه هذه السمة Dot، ولكنها تتيح تحديد أرقام أبعاد التعاقد والدفعات لكل من lhs وrhs.

تُجري DotGeneral مجموع المنتجات على السمات المتناقصة المحدّدة في dimension_numbers.

ليس من الضروري أن تتطابق أرقام سمات التعاقد المرتبطة من lhs وrhs، ولكن يجب أن تتطابق أحجام السمات.

مثال يتضمّن أرقام سمات التعاقد:

lhs = { {1.0, 2.0, 3.0},
        {4.0, 5.0, 6.0} }

rhs = { {1.0, 1.0, 1.0},
        {2.0, 2.0, 2.0} }

DotDimensionNumbers dnums;
dnums.add_lhs_contracting_dimensions(1);
dnums.add_rhs_contracting_dimensions(1);

DotGeneral(lhs, rhs, dnums) -> { { 6.0, 12.0},
                                 {15.0, 30.0} }

يجب أن تتطابق أحجام السمات لأرقام سمات الدُفعات المرتبطة من lhs وrhs.

مثال مع أرقام سمات الدُفعات (حجم الدفعة 2، مصفوفات 2x2):

lhs = { { {1.0, 2.0},
          {3.0, 4.0} },
        { {5.0, 6.0},
          {7.0, 8.0} } }

rhs = { { {1.0, 0.0},
          {0.0, 1.0} },
        { {1.0, 0.0},
          {0.0, 1.0} } }

DotDimensionNumbers dnums;
dnums.add_lhs_contracting_dimensions(2);
dnums.add_rhs_contracting_dimensions(1);
dnums.add_lhs_batch_dimensions(0);
dnums.add_rhs_batch_dimensions(0);

DotGeneral(lhs, rhs, dnums) -> {
    { {1.0, 2.0},
      {3.0, 4.0} },
    { {5.0, 6.0},
      {7.0, 8.0} } }

ويترتّب على ذلك أنّ رقم السمة الناتجة يبدأ بسمة الدفعة، ثم السمة lhs غير المجمَّعة/غير الدفعية، وأخيرًا السمة rhs غير المجمَّعة/غير الدفعية.

يُستخدَم precision_config للإشارة إلى إعدادات الدقة. يحدّد المستوى ما إذا كان يجب أن تحاول الأجهزة إنشاء المزيد من تعليمات الرموز البرمجية للآلة لتوفير محاكاة أكثر دقة لنوع البيانات عند الحاجة (أي محاكاة f32 على وحدة معالجة Tensor Processing Unit التي لا تتوافق إلا مع عمليات ضرب المصفوفات bf16). يمكن أن تكون القيم DEFAULT أو HIGH أو HIGHEST. يمكنك الاطّلاع على تفاصيل إضافية في أقسام "تجربة الوسائط المتعددة".

‫preferred_element_type هو عنصر عددي من أنواع الإخراج ذات الدقة الأعلى/الأدنى المستخدَمة للتجميع. تقترح السمة preferred_element_type نوع التجميع للعملية المحدّدة، ولكنّ ذلك ليس مضمونًا. يتيح ذلك لبعض برامج الخلفية للأجهزة تجميع البيانات في نوع مختلف وتحويلها إلى نوع الإخراج المفضّل.

لمزيد من المعلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - dot_general.

ScaledDot

يمكنك الاطّلاع أيضًا على XlaBuilder::ScaledDot.

ScaledDot(lhs, lhs_scale, rhs, rhs_scale, dimension_number, precision_config,preferred_element_type)

مشابه لـ DotGeneral

تُنشئ هذه الدالة عملية ضرب نقطي موسّعة مع المعامِلات "lhs" و"lhs_scale" و"rhs" و"rhs_scale"، مع تحديد أبعاد التجميع والدُفعات في "dimension_numbers".

RaggedDot

يمكنك الاطّلاع أيضًا على XlaBuilder::RaggedDot.

للاطّلاع على تفاصيل حول عملية احتساب RaggedDot، يُرجى الاطّلاع على StableHLO - chlo.ragged_dot.

DynamicReshape

يمكنك الاطّلاع أيضًا على XlaBuilder::DynamicReshape.

هذه العملية مطابقة وظيفيًا لعملية reshape، ولكن يتم تحديد شكل النتيجة بشكل ديناميكي من خلال output_shape.

DynamicReshape(operand, dim_sizes, new_size_bounds, dims_are_dynamic)

لمزيد من المعلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - dynamic_reshape.

DynamicSlice

يمكنك الاطّلاع أيضًا على XlaBuilder::DynamicSlice.

تستخرج الدالة DynamicSlice مصفوفة فرعية من مصفوفة الإدخال في dynamic start_indices. يتم تمرير حجم الشريحة في كل بُعد في size_indices، الذي يحدّد نقطة نهاية فواصل الشرائح الحصرية في كل بُعد: [البداية، البداية + الحجم). يجب أن يكون شكل start_indices أحادي الأبعاد، وأن يكون حجم البُعد مساويًا لعدد أبعاد operand.

DynamicSlice(operand, start_indices, slice_sizes)

يتم احتساب فهارس الشرائح الفعّالة من خلال تطبيق عملية التحويل التالية لكل فهرس i في [1, N) قبل تنفيذ الشريحة:

start_indices[i] = clamp(start_indices[i], 0, operand.dimension_size[i] - slice_sizes[i])

يضمن ذلك أن تكون الشريحة المستخرَجة دائمًا ضمن الحدود بالنسبة إلى صفيف المعامِل. إذا كانت الشريحة ضمن الحدود قبل تطبيق عملية التحويل، لن يكون للتحويل أي تأثير.

مثال أحادي الأبعاد:

let a = {0.0, 1.0, 2.0, 3.0, 4.0};
let s = {2};

DynamicSlice(a, s, {2});
// Result: {2.0, 3.0}

مثال ثنائي الأبعاد:

let b =
{ {0.0,  1.0,  2.0},
  {3.0,  4.0,  5.0},
  {6.0,  7.0,  8.0},
  {9.0, 10.0, 11.0} }
let s = {2, 1}

DynamicSlice(b, s, {2, 2});
//Result:
// { { 7.0,  8.0},
//   {10.0, 11.0} }

للحصول على معلومات حول StableHLO، يُرجى الاطّلاع على ‫StableHLO - dynamic_slice.

DynamicUpdateSlice

يمكنك الاطّلاع أيضًا على XlaBuilder::DynamicUpdateSlice.

تنشئ DynamicUpdateSlice نتيجة وهي قيمة مصفوفة الإدخال operand، مع استبدال شريحة update في start_indices. يحدّد شكل update شكل المصفوفة الفرعية للنتيجة التي يتم تعديلها. يجب أن يكون شكل start_indices أحادي الأبعاد، وأن يكون حجم البُعد مساويًا لعدد أبعاد operand.

DynamicUpdateSlice(operand, update, start_indices)

يتم احتساب فهارس الشرائح الفعّالة من خلال تطبيق عملية التحويل التالية لكل فهرس i في [1, N) قبل تنفيذ الشريحة:

start_indices[i] = clamp(start_indices[i], 0, operand.dimension_size[i] - update.dimension_size[i])

يضمن ذلك أن يكون الجزء المعدَّل دائمًا ضمن حدود مصفوفة المعامِلات. إذا كانت الشريحة ضمن الحدود قبل تطبيق عملية التحويل، لن يكون للتحويل أي تأثير.

مثال أحادي الأبعاد:

let a = {0.0, 1.0, 2.0, 3.0, 4.0}
let u = {5.0, 6.0}
let s = {2}

DynamicUpdateSlice(a, u, s)
// Result: {0.0, 1.0, 5.0, 6.0, 4.0}

مثال ثنائي الأبعاد:

let b =
{ {0.0,  1.0,  2.0},
  {3.0,  4.0,  5.0},
  {6.0,  7.0,  8.0},
  {9.0, 10.0, 11.0} }
let u =
{ {12.0, 13.0},
  {14.0, 15.0},
  {16.0, 17.0} }

let s = {1, 1}

DynamicUpdateSlice(b, u, s)
// Result:
// { {0.0,  1.0,  2.0},
//   {3.0, 12.0, 13.0},
//   {6.0, 14.0, 15.0},
//   {9.0, 16.0, 17.0} }

لمزيد من المعلومات حول StableHLO، يُرجى الاطّلاع على ‫StableHLO - dynamic_update_slice.

Erf

يمكنك الاطّلاع أيضًا على XlaBuilder::Erf.

دالة الخطأ لكل عنصر x -> erf(x) حيث:

\(\text{erf}(x) = \frac{2}{\sqrt{\pi} }\int_0^x e^{-t^2} \, dt\).

Erf(operand)

تتيح الدالة Erf أيضًا استخدام الوسيطة الاختيارية result_accuracy:

Erf(operand, result_accuracy)

لمزيد من المعلومات عن result_accuracy، يمكنك الاطّلاع على مقالة دقة النتائج.

ينتهي في

يمكنك الاطّلاع أيضًا على XlaBuilder::Exp.

الدالة الأسية الطبيعية لكل عنصر x -> e^x

Exp(operand)

تتيح Exp أيضًا استخدام الوسيطة الاختيارية result_accuracy:

Exp(operand, result_accuracy)

لمزيد من المعلومات عن result_accuracy، يمكنك الاطّلاع على مقالة دقة النتائج.

لمزيد من المعلومات عن StableHLO، يُرجى الاطّلاع على StableHLO - exponential.

Expm1

يمكنك الاطّلاع أيضًا على XlaBuilder::Expm1.

قيمة الأس الطبيعي لكل عنصر مطروحًا منها واحد x -> e^x - 1

Expm1(operand)

تتيح الدالة Expm1 أيضًا استخدام الوسيطة الاختيارية result_accuracy:

Expm1(operand, result_accuracy)

لمزيد من المعلومات عن result_accuracy، يمكنك الاطّلاع على مقالة دقة النتائج.

للحصول على معلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - exponential_minus_one.

Fft

يمكنك الاطّلاع أيضًا على XlaBuilder::Fft.

تنفّذ عملية XLA FFT تحويلات فورييه المباشرة والعكسية للمدخلات والمخرجات الحقيقية والمركّبة. تتوفّر تحويلات فورييه السريعة المتعدّدة الأبعاد على ما يصل إلى 3 محاور.

Fft(operand, ftt_type, fft_length)

لمزيد من المعلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - fft.

تحويل فورييه المتعدد الأبعاد

عند توفير أكثر من fft_length واحد، يكون ذلك مكافئًا لتطبيق سلسلة من عمليات تحويل فورييه السريع على كل محور من المحاور الداخلية. يُرجى العِلم أنّه في الحالتين real->complex وcomplex->real، يتم إجراء تحويل المحور الأقرب (فعليًا) أولاً (RFFT؛ آخر تحويل في IRFFT)، ولهذا السبب يكون المحور الأقرب هو المحور الذي يتغير حجمه. بعد ذلك، ستكون عمليات تحويل المحاور الأخرى معقّدة->معقّدة.

تفاصيل التنفيذ

تستند عملية تحويل فورييه السريع (FFT) لوحدة المعالجة المركزية إلى TensorFFT من Eigen. تستخدم وحدة معالجة الرسومات (GPU) خوارزمية تحويل فورييه السريع (FFT) من NVIDIA.

الطابق

يمكنك الاطّلاع أيضًا على XlaBuilder::Floor.

الجزء الصحيح من كل عنصر x -> ⌊x⌋.

Floor(operand)

لمزيد من المعلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - floor.

فيوجن

يمكنك الاطّلاع أيضًا على HloInstruction::CreateFusion.

تمثّل عملية Fusion تعليمات HLO وتعمل كعنصر أساسي في HLO. قد يظهر هذا الرمز في عمليات تفريغ HLO، ولكن ليس من المفترض أن ينشئه المستخدمون النهائيون يدويًا.

Gather

تجمع عملية XLA عدة شرائح (كل شريحة بإزاحة وقت تشغيل مختلفة محتملة) من مصفوفة إدخال.

لمزيد من المعلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - gather.

الدلالات العامة

يمكنك الاطّلاع أيضًا على XlaBuilder::Gather. للحصول على وصف أكثر وضوحًا، يُرجى الاطّلاع على قسم "الوصف غير الرسمي" أدناه.

gather(operand, start_indices, dimension_numbers, slice_sizes, indices_are_sorted)

لتسهيل الأمر، نصنّف السمات في مصفوفة الإخراج التي لا تظهر في offset_dims على أنّها batch_dims.

المخرجات هي مصفوفة تتضمّن batch_dims.size + offset_dims.size سمة.

يجب أن تساوي قيمة operand.rank مجموع قيمتَي offset_dims.size وcollapsed_slice_dims.size. يجب أيضًا أن تكون قيمة slice_sizes.size مساوية لقيمة operand.rank.

إذا كانت قيمة index_vector_dim تساوي start_indices.rank، سنعتبر ضمنيًا أنّ start_indices يتضمّن بُعدًا لاحقًا 1 (أي إذا كان شكل start_indices هو [6,7] وكانت قيمة index_vector_dim هي 2، سنعتبر ضمنيًا أنّ شكل start_indices هو [6,7,1]).

يتم احتساب حدود مصفوفة الإخراج على طول السمة i على النحو التالي:

1. إذا كانت i متوفّرة في batch_dims (أي تساوي batch_dims[k] لبعض k)، نختار حدود السمة المطابقة من start_indices.shape، مع تخطّي index_vector_dim (أي نختار start_indices.shape.dims[k] إذا كان k < index_vector_dim، وstart_indices.shape.dims[k+1] في الحالات الأخرى).

2. إذا كان i متوفّرًا في offset_dims (أي يساوي offset_dims[k] لبعض k)، نختار الحدّ المطابق من slice_sizes بعد أخذ collapsed_slice_dims في الاعتبار (أي نختار adjusted_slice_sizes[k] حيث adjusted_slice_sizes هو slice_sizes مع إزالة الحدود في الفهارس collapsed_slice_dims).

رياضيًا، يتم حساب فهرس المعامِل In الذي يتوافق مع فهرس الناتج Out على النحو التالي:

1. ليكن G = { Out[k] for k in batch_dims }. استخدِم G لتقسيم المتّجه S بحيث يكون S[i] = start_indices[Combine(G, i)] حيث إنّ Combine(A, b) تُدرِج b في الموضع index_vector_dim في A. يُرجى العِلم أنّ هذه السمة تكون محددة جيدًا حتى إذا كانت G فارغة: إذا كانت G فارغة، فإنّ S = start_indices.

2. أنشئ فهرسًا أوليًا، Sin، في operand باستخدام S من خلال توزيع S باستخدام start_index_map. في ما يلي المزيد من التفاصيل:

   1. Sin[start_index_map[k]] = S[k] if k < start_index_map.size.

   2. Sin[_] = 0 في الحالات الأخرى.

3. أنشئ فهرسًا Oin في operand من خلال توزيع الفهارس في سمات الإزاحة في Out وفقًا لمجموعة collapsed_slice_dims. في ما يلي المزيد من التفاصيل:

   1. ‫Oin[remapped_offset_dims(k)] = Out[offset_dims[k]] if k < offset_dims.size (يتم تحديد remapped_offset_dims أدناه).

   2. Oin[_] = 0 في الحالات الأخرى.

4. ‫In هي Oin + Sin حيث + هي عملية جمع على مستوى العناصر.

‫remapped_offset_dims هي دالة رتيبة مع نطاق [0, offset_dims.size) ومدى [0, operand.rank) \ collapsed_slice_dims. لذا، إذا كان، على سبيل المثال، إذا كان offset_dims.size هو 4 وoperand.rank هو 6 وcollapsed_slice_dims هو {0، 2}، فإنّ remapped_offset_dims هو {0→1، 1→3، 2→4، 3→5}.

في حال ضبط indices_are_sorted على "صحيح"، يمكن أن يفترض XLA أنّ المستخدم رتّب start_indices (ترتيب تصاعدي، بعد توزيع قيمه وفقًا start_index_map). إذا لم تكن كذلك، سيتم تحديد الدلالات حسب التنفيذ.

الوصف غير الرسمي والأمثلة

بشكل غير رسمي، يتطابق كل فهرس Out في مصفوفة الإخراج مع عنصر E في مصفوفة المعامِلات، ويتم حسابه على النحو التالي:

• نستخدم سمات المجموعة في Out للبحث عن فهرس بدء من start_indices.

• نستخدم start_index_map لربط الفهرس الأوّلي (الذي قد يكون حجمه أقل من operand.rank) بفهرس أوّلي "كامل" في operand.

• نقسم بشكل ديناميكي شريحة بحجم slice_sizes باستخدام الفهرس الكامل للبداية.

• نعيد تشكيل الشريحة من خلال تصغير سمات collapsed_slice_dims. بما أنّه يجب أن يكون لجميع أبعاد الشرائح المصغّرة حدّ يساوي 1، فإنّ عملية إعادة التشكيل هذه تكون صالحة دائمًا.

• نستخدم أبعاد الإزاحة في Out للفهرسة في هذا الجزء للحصول على عنصر الإدخال E المقابل لفهرس الإخراج Out.

تم ضبط index_vector_dim على start_indices.rank - 1 في جميع الأمثلة التالية. لا تؤدي القيم الأكثر إثارة للاهتمام في index_vector_dim إلى تغيير العملية بشكل أساسي، ولكنها تجعل التمثيل المرئي أكثر صعوبة.

للحصول على فكرة عن كيفية عمل كل ما سبق معًا، لنلقِ نظرة على مثال يجمع 5 شرائح من الشكل [8,6] من مصفوفة [16,11]. يمكن تمثيل موضع شريحة في مصفوفة [16,11] كمتجه فهرس بالشكل S64[2]، وبالتالي يمكن تمثيل مجموعة من 5 مواضع كمصفوفة S64[5,2].

يمكن بعد ذلك وصف سلوك عملية التجميع على أنّه تحويل فهرس يأخذ [G،O0،O1]، وهو فهرس في شكل الإخراج، ويربطه بعنصر في مصفوفة الإدخال بالطريقة التالية:

نختار أولاً متّجه (X,Y) من مصفوفة فهارس التجميع باستخدام G. يكون العنصر في مصفوفة الإخراج عند الفهرس [G,O0,O1] هو العنصر في مصفوفة الإدخال عند الفهرس [X+O0,Y+O1].

slice_sizes هي [8,6]، التي تحدد نطاق O₀ وO₁، وهذا بدوره يحدد حدود الشريحة.

تعمل عملية التجميع هذه كشريحة ديناميكية مجمّعة مع G كبعد مجمّع.

قد تكون فهارس التجميع متعدّدة الأبعاد. على سبيل المثال، يمكن ترجمة نسخة أكثر عمومية من المثال أعلاه باستخدام مصفوفة "جمع الفهارس" بالشكل [4,5,2] على النحو التالي:

مرة أخرى، يعمل هذا كشريحة ديناميكية مجمّعة G0 وG1 كسمات مجمّعة. لا يزال حجم الشريحة [8,6].

تعمّم عملية التجميع في XLA الدلالات غير الرسمية الموضّحة أعلاه بالطرق التالية:

1. يمكننا ضبط السمات التي تمثّل سمات الإزاحة في شكل الإخراج (السمات التي تحتوي على O0 وO1 في المثال الأخير). يتم تحديد سمات الدفعة الناتجة (السمات التي تحتوي على G0 وG1 في المثال الأخير) على أنّها سمات ناتجة ليست سمات إزاحة.

2. قد يكون عدد سمات الإزاحة في الناتج الظاهرة بشكل صريح في شكل الناتج أقل من عدد سمات الإزاحة في الإدخال. يجب أن يكون حجم شريحة الأبعاد "المفقودة"، والتي يتم إدراجها بشكل صريح على أنّها collapsed_slice_dims، هو 1. بما أنّ حجم الشريحة هو 1، فإنّ الفهرس الصالح الوحيد هو 0، ولا يؤدي حذفها إلى حدوث أي غموض.

3. قد يحتوي الجزء الذي تم استخراجه من مصفوفة "جمع الفهارس" (X وY في المثال الأخير) على عدد أقل من العناصر مقارنةً بعدد سمات مصفوفة الإدخال، ويحدّد الربط الواضح كيفية توسيع الفهرس ليتضمّن عدد السمات نفسه الذي تتضمّنه مصفوفة الإدخال.

كمثال أخير، نستخدم (2) و (3) لتنفيذ tf.gather_nd:

يتم استخدام G0 وG1 لتقسيم فهرس البداية من مصفوفة فهارس التجميع كالمعتاد، باستثناء أنّ فهرس البداية يحتوي على عنصر واحد فقط، وهو X. وبالمثل، هناك فهرس إزاحة واحد فقط للناتج بالقيمة O0. ومع ذلك، قبل استخدامها كفهارس في مصفوفة الإدخال، يتم توسيعها وفقًا لـ "تجميع ربط الفهرس" (start_index_map في الوصف الرسمي) و "ربط الإزاحة" (remapped_offset_dims في الوصف الرسمي) إلى [X,0] و[0,O0] على التوالي، ما يؤدي إلى [X,O0]. بعبارة أخرى، يرتبط فهرس الإخراج [G0,G1,O0] بفهرس الإدخال [GatherIndices[G0,G1,0],O0]، ما يمنحنا دلالات tf.gather_nd.

slice_sizes لهذا الطلب هو [1,11]. ويعني هذا بشكل بديهي أنّ كل فهرس X في مصفوفة فهارس التجميع يختار صفًا كاملاً، والنتيجة هي تسلسل جميع هذه الصفوف.

GetDimensionSize

يمكنك الاطّلاع أيضًا على XlaBuilder::GetDimensionSize.

تعرض هذه الدالة حجم البُعد المحدّد للمعامل. يجب أن يكون المعامِل على شكل مصفوفة.

GetDimensionSize(operand, dimension)

للحصول على معلومات حول StableHLO، يُرجى الاطّلاع على ‫StableHLO - get_dimension_size.

GetTupleElement

يمكنك الاطّلاع أيضًا على XlaBuilder::GetTupleElement.

فهارس في مجموعة بقيمة ثابتة في وقت الترجمة

يجب أن تكون القيمة ثابتة في وقت الترجمة حتى يتمكّن استنتاج الشكل من تحديد نوع القيمة الناتجة.

وهذا مشابه لـ std::get<int N>(t) في C++‎. من الناحية النظرية:

let v: f32[10] = f32[10]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
let s: s32 = 5;
let t: (f32[10], s32) = tuple(v, s);
let element_1: s32 = gettupleelement(t, 1); // Inferred shape matches s32.

يمكنك الاطّلاع أيضًا على tf.tuple.

GetTupleElement(tuple_data, index)

لمزيد من المعلومات حول StableHLO، يُرجى الاطّلاع على ‫StableHLO - get_tuple_element.

Imag

يمكنك الاطّلاع أيضًا على XlaBuilder::Imag.

الجزء التخيلي من شكل مركّب (أو حقيقي) على مستوى كل عنصر x -> imag(x). إذا كان المعامِل من نوع النقطة العائمة، يتم عرض 0.

Imag(operand)

لمزيد من المعلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - imag.

Infeed

يمكنك الاطّلاع أيضًا على XlaBuilder::Infeed.

Infeed(shape, config)

يقرأ عنصر بيانات واحدًا من واجهة البث الضمني Infeed للجهاز، ويفسّر البيانات على أنّها الشكل المحدّد وتصميمه، ويعرض XlaOp للبيانات. يُسمح بتنفيذ عمليات Infeed متعددة في عملية حسابية واحدة، ولكن يجب أن يكون هناك ترتيب إجمالي بين عمليات Infeed. على سبيل المثال، يكون للرمزين Infeed في الرمز أدناه ترتيب إجمالي لأنّ هناك تبعية بين حلقتَي while.

result1 = while (condition, init = init_value) {
  Infeed(shape)
  }

result2 = while (condition, init = result1) {
  Infeed(shape)
  }

لا تتوفّر أشكال الصفوف المتداخلة. بالنسبة إلى شكل المجموعة الفارغة، تكون عملية Infeed في الواقع عملية غير نشطة وتستمر بدون قراءة أي بيانات من Infeed للجهاز.

لمزيد من المعلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - infeed.

أمواج هادئة قصيرة

يمكنك الاطّلاع أيضًا على XlaBuilder::Iota.

Iota(shape, iota_dimension)

إنشاء قيمة حرفية ثابتة على الجهاز بدلاً من نقل بيانات محتملة الحجم من المضيف تنشئ هذه الدالة صفيفًا بالشكل المحدّد ويحتوي على قيم تبدأ من صفر وتزيد بمقدار واحد على طول السمة المحدّدة. بالنسبة إلى أنواع الفاصلة العائمة، يكون الصفيف الناتج مكافئًا ConvertElementType(Iota(...)) حيث يكون Iota من النوع المتكامل ويتم التحويل إلى نوع الفاصلة العائمة.

على سبيل المثال، تعرض الدالة Iota(s32[4, 8], 0)

[[0, 0, 0, 0, 0, 0, 0, 0 ],
 [1, 1, 1, 1, 1, 1, 1, 1 ],
 [2, 2, 2, 2, 2, 2, 2, 2 ],
 [3, 3, 3, 3, 3, 3, 3, 3 ]]

يمكن إرجاع المشتريات مقابل Iota(s32[4, 8], 1).

[[0, 1, 2, 3, 4, 5, 6, 7 ],
 [0, 1, 2, 3, 4, 5, 6, 7 ],
 [0, 1, 2, 3, 4, 5, 6, 7 ],
 [0, 1, 2, 3, 4, 5, 6, 7 ]]

للحصول على معلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - iota.

IsFinite

يمكنك الاطّلاع أيضًا على XlaBuilder::IsFinite.

تختبر هذه الدالة ما إذا كان كل عنصر من عناصر operand عددًا محدودًا، أي ليس موجبًا أو سالبًا بلا حدود، وليس NaN. تعرض هذه الدالة مصفوفة من قيم PRED بالشكل نفسه كالإدخال، حيث يكون كل عنصر true إذا كان عنصر الإدخال المقابل محدودًا فقط.

IsFinite(operand)

لمزيد من المعلومات حول StableHLO، يُرجى الاطّلاع على ‫StableHLO - is_finite.

السجل

يمكنك الاطّلاع أيضًا على XlaBuilder::Log.

اللوغاريتم الطبيعي لكل عنصر x -> ln(x)

Log(operand)

تتيح الدالة log أيضًا الوسيط الاختياري result_accuracy:

Log(operand, result_accuracy)

لمزيد من المعلومات عن result_accuracy، يمكنك الاطّلاع على مقالة دقة النتائج.

للحصول على معلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - log.

Log1p

يمكنك الاطّلاع أيضًا على XlaBuilder::Log1p.

اللوغاريتم الطبيعي المعدَّل x -> ln(1+x) لكل عنصر

Log1p(operand)

تتيح الدالة Log1p أيضًا الوسيط result_accuracy الاختياري:

Log1p(operand, result_accuracy)

لمزيد من المعلومات عن result_accuracy، يمكنك الاطّلاع على مقالة دقة النتائج.

للحصول على معلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - log_plus_one.

لوجستي

يمكنك الاطّلاع أيضًا على XlaBuilder::Logistic.

عملية حساب الدالة اللوجستية على مستوى العناصر x -> logistic(x)

Logistic(operand)

تتيح الدالة اللوجستية أيضًا الوسيطة الاختيارية result_accuracy:

Logistic(operand, result_accuracy)

لمزيد من المعلومات عن result_accuracy، يمكنك الاطّلاع على مقالة دقة النتائج.

للحصول على معلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - logistic.

خريطة

يمكنك الاطّلاع أيضًا على XlaBuilder::Map.

Map(operands..., computation, dimensions)

تطبِّق هذه الدالة دالة عددية على مصفوفات operands المحدّدة، ما يؤدي إلى إنشاء مصفوفة بالأبعاد نفسها حيث يكون كل عنصر هو نتيجة الدالة التي تم ربطها بالعناصر المقابلة في المصفوفات المُدخَلة.

الدالة التي تم ربطها هي عملية حسابية عشوائية مع شرط أن تتضمّن N مدخلاً من النوع العددي T ومخرجًا واحدًا من النوع S. يحتوي الناتج على الأبعاد نفسها التي تحتوي عليها المعامِلات، باستثناء أنّه يتم استبدال نوع العنصر T بنوع العنصر S.

على سبيل المثال: Map(op1, op2, op3, computation, par1) تربط elem_out <- computation(elem1, elem2, elem3, par1) بكل فهرس (متعدد الأبعاد) في صفائف الإدخال لإنتاج صفيف الإخراج.

لمزيد من المعلومات حول StableHLO، يمكنك الاطّلاع على StableHLO - map.

الحد الأقصى

يمكنك الاطّلاع أيضًا على XlaBuilder::Max.

تُجري هذه الدالة عملية الحد الأقصى على مستوى العناصر في الموترَين lhs وrhs.

Max(lhs, rhs)

يجب أن تكون أشكال الوسيطات متشابهة أو متوافقة. راجِع مستندات البث لمعرفة معنى توافق الأشكال. تكون نتيجة العملية بشكل ناتج عن البث بين مصفوفتَي الإدخال. في هذا النوع، لا يتم تنفيذ العمليات بين مصفوفات ذات ترتيبات مختلفة، إلا إذا كان أحد المعامِلَين عددًا قياسيًا.

يتوفّر إصدار بديل من Max يتوافق مع البث بأبعاد مختلفة:

Max(lhs,rhs, broadcast_dimensions)

يجب استخدام هذا النوع من العملية لإجراء عمليات حسابية بين مصفوفات ذات ترتيبات مختلفة (مثل إضافة مصفوفة إلى متّجه).

المعامل broadcast_dimensions الإضافي هو شريحة من الأعداد الصحيحة تحدّد الأبعاد التي سيتم استخدامها لبث المعاملات. يمكنك الاطّلاع على وصف تفصيلي للدلالات في صفحة البث.

للحصول على معلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - الحد الأقصى.

الحد الأدنى

يمكنك الاطّلاع أيضًا على XlaBuilder::Min.

تُجري عملية الحد الأدنى على مستوى العناصر في lhs وrhs.

Min(lhs, rhs)

يجب أن تكون أشكال الوسيطات متشابهة أو متوافقة. راجِع مستندات البث لمعرفة معنى توافق الأشكال. تكون نتيجة العملية بشكل ناتج عن البث بين مصفوفتَي الإدخال. في هذا النوع، لا يتم تنفيذ العمليات بين مصفوفات ذات ترتيبات مختلفة، إلا إذا كان أحد المعامِلَين عددًا قياسيًا.

يتوفّر صيغة بديلة تتوافق مع البث بأبعاد مختلفة للقيمة Min:

Min(lhs,rhs, broadcast_dimensions)

يجب استخدام هذا النوع من العملية لإجراء عمليات حسابية بين مصفوفات ذات ترتيبات مختلفة (مثل إضافة مصفوفة إلى متّجه).

المعامل broadcast_dimensions الإضافي هو شريحة من الأعداد الصحيحة تحدّد الأبعاد التي سيتم استخدامها لبث المعاملات. يمكنك الاطّلاع على وصف تفصيلي للدلالات في صفحة البث.

لمزيد من المعلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - الحد الأدنى.

Mul

يمكنك الاطّلاع أيضًا على XlaBuilder::Mul.

تُجري هذه الدالة عملية ضرب العناصر المقابلة في lhs وrhs.

Mul(lhs, rhs)

يجب أن تكون أشكال الوسيطات متشابهة أو متوافقة. راجِع مستندات البث لمعرفة معنى توافق الأشكال. تكون نتيجة العملية بشكل ناتج عن البث بين مصفوفتَي الإدخال. في هذا النوع، لا يتم تنفيذ العمليات بين مصفوفات ذات ترتيبات مختلفة، إلا إذا كان أحد المعامِلَين عددًا قياسيًا.

يتوفّر نوع بديل من Mul يتوافق مع البث بأبعاد مختلفة:

Mul(lhs,rhs, broadcast_dimensions)

يجب استخدام هذا النوع من العملية لإجراء عمليات حسابية بين مصفوفات ذات ترتيبات مختلفة (مثل إضافة مصفوفة إلى متّجه).

المعامل broadcast_dimensions الإضافي هو شريحة من الأعداد الصحيحة تحدّد الأبعاد التي سيتم استخدامها لبث المعاملات. يمكنك الاطّلاع على وصف تفصيلي للدلالات في صفحة البث.

لمزيد من المعلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - multiply.

Neg

يمكنك الاطّلاع أيضًا على XlaBuilder::Neg.

النفي على مستوى العناصر x -> -x

Neg(operand)

لمزيد من المعلومات عن StableHLO، يُرجى الاطّلاع على StableHLO - negate.

ليس

يمكنك الاطّلاع أيضًا على XlaBuilder::Not.

تمثّل x -> !(x) المعامل المنطقي not (ليس) على مستوى العناصر.

Not(operand)

لمزيد من المعلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - not.

OptimizationBarrier

يمكنك الاطّلاع أيضًا على XlaBuilder::OptimizationBarrier.

يمنع أي عملية تحسين من نقل العمليات الحسابية عبر الحاجز.

OptimizationBarrier(operand)

يضمن تقييم جميع المدخلات قبل أي عوامل تشغيل تعتمد على مخرجات الحاجز.

لمزيد من المعلومات عن StableHLO، يُرجى الاطّلاع على StableHLO - optimization_barrier.

أو

يمكنك الاطّلاع أيضًا على XlaBuilder::Or.

تُجري عملية OR على مستوى العناصر في lhs وrhs .

Or(lhs, rhs)

يجب أن تكون أشكال الوسيطات متشابهة أو متوافقة. راجِع مستندات البث لمعرفة معنى توافق الأشكال. تكون نتيجة العملية بشكل ناتج عن البث بين مصفوفتَي الإدخال. في هذا النوع، لا يتم تنفيذ العمليات بين مصفوفات ذات ترتيبات مختلفة، إلا إذا كان أحد المعامِلَين عددًا قياسيًا.

يتوفّر متغير بديل مع إمكانية البث بأبعاد مختلفة للدالة Or:

Or(lhs,rhs, broadcast_dimensions)

يجب استخدام هذا النوع من العملية لإجراء عمليات حسابية بين مصفوفات ذات ترتيبات مختلفة (مثل إضافة مصفوفة إلى متّجه).

المعامل broadcast_dimensions الإضافي هو شريحة من الأعداد الصحيحة تحدّد الأبعاد التي سيتم استخدامها لبث المعاملات. يمكنك الاطّلاع على وصف تفصيلي للدلالات في صفحة البث.

لمزيد من المعلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - or.

Outfeed

يمكنك الاطّلاع أيضًا على XlaBuilder::Outfeed.

يكتب المدخلات في موجز الخروج.

Outfeed(operand, shape_with_layout, outfeed_config)

يمثّل shape_with_layout الشكل المحدّد الذي نريد إخراجه.

لمزيد من المعلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - outfeed.

الوسادة

يمكنك الاطّلاع أيضًا على XlaBuilder::Pad.

Pad(operand, padding_value, padding_config)

توسّع هذه الدالة نطاق مصفوفة operand المحدّدة من خلال إضافة مساحة متروكة حول المصفوفة وكذلك بين عناصر المصفوفة باستخدام padding_value المحدّدة. تحدّد هذه السمة مقدار المساحة المتروكة على الحواف والمساحة المتروكة الداخلية لكل بُعد.padding_config

‫PaddingConfig هو حقل متكرّر من PaddingConfigDimension، ويحتوي على ثلاثة حقول لكل سمة: edge_padding_low وedge_padding_high وinterior_padding.

تحدّد edge_padding_low وedge_padding_high مقدار المساحة المتروكة المضافة في الطرف الأدنى (بجانب الفهرس 0) والطرف الأعلى (بجانب الفهرس الأعلى) لكل بُعد على التوالي. يمكن أن يكون مقدار المساحة المتروكة على الحواف سالبًا، وتشير القيمة المطلقة للمساحة السالبة إلى عدد العناصر التي يجب إزالتها من السمة المحدّدة.

تحدّد interior_padding مقدار المساحة المتروكة بين أي عنصرَين في كل بُعد، ويجب ألا تكون قيمة سالبة. يحدث الحشو الداخلي منطقيًا قبل الحشو على الحواف، لذا في حال كان الحشو على الحواف سالبًا، تتم إزالة العناصر من المعامِل المحشو داخليًا.

لا تؤدي هذه العملية أي إجراء إذا كانت جميع أزواج الحشو على الحواف هي (0, 0) وكانت جميع قيم الحشو الداخلية هي 0. يوضّح الشكل أدناه أمثلة على قيم edge_padding وinterior_padding المختلفة لمصفوفة ثنائية الأبعاد.

لمزيد من المعلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - pad.

المَعلمة

يمكنك الاطّلاع أيضًا على XlaBuilder::Parameter.

يمثّل Parameter إدخال وسيطة إلى عملية حسابية.

PartitionID

يمكنك الاطّلاع أيضًا على XlaBuilder::BuildPartitionId.

تُنتج partition_id العملية الحالية.

PartitionID(shape)

قد يظهر PartitionID في عمليات تفريغ HLO، ولكن ليس من المفترض أن ينشئه المستخدمون النهائيون يدويًا.

للحصول على معلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - partition_id.

PopulationCount

يمكنك الاطّلاع أيضًا على XlaBuilder::PopulationCount.

تحسب هذه الدالة عدد البتات التي تم ضبطها في كل عنصر من عناصر operand.

PopulationCount(operand)

لمزيد من المعلومات عن StableHLO، يُرجى الاطّلاع على StableHLO - popcnt.

Pow

يمكنك الاطّلاع أيضًا على XlaBuilder::Pow.

تُجري هذه الدالة عملية رفع كل عنصر من عناصر lhs إلى الأس rhs.

Pow(lhs, rhs)

يجب أن تكون أشكال الوسيطات متشابهة أو متوافقة. راجِع مستندات البث لمعرفة معنى توافق الأشكال. تكون نتيجة العملية بشكل ناتج عن البث بين مصفوفتَي الإدخال. في هذا النوع، لا يتم تنفيذ العمليات بين مصفوفات ذات ترتيبات مختلفة، إلا إذا كان أحد المعامِلَين عددًا قياسيًا.

يتوفّر إصدار بديل من Pow يتوافق مع البث بأبعاد مختلفة:

Pow(lhs,rhs, broadcast_dimensions)

يجب استخدام هذا النوع من العملية لإجراء عمليات حسابية بين مصفوفات ذات ترتيبات مختلفة (مثل إضافة مصفوفة إلى متّجه).

المعامل broadcast_dimensions الإضافي هو شريحة من الأعداد الصحيحة تحدّد الأبعاد التي سيتم استخدامها لبث المعاملات. يمكنك الاطّلاع على وصف تفصيلي للدلالات في صفحة البث.

لمزيد من المعلومات عن StableHLO، يُرجى الاطّلاع على StableHLO - power.

Real

يمكنك الاطّلاع أيضًا على XlaBuilder::Real.

الجزء الحقيقي من الشكل المركّب (أو الحقيقي) على مستوى كل عنصر. x -> real(x). إذا كان نوع المعامِل نقطة عائمة، تعرض الدالة Real القيمة نفسها.

Real(operand)

لمزيد من المعلومات عن StableHLO، يُرجى الاطّلاع على StableHLO - real.

Recv

يمكنك الاطّلاع أيضًا على XlaBuilder::Recv.

‫Recv وRecvWithTokens وRecvToHost هي عمليات تعمل كعناصر أساسية للتواصل في HLO. تظهر هذه العمليات عادةً في عمليات تفريغ HLO كجزء من عمليات الإدخال/الإخراج المنخفضة المستوى أو عمليات النقل بين الأجهزة، ولكن ليس من المفترض أن ينشئها المستخدمون النهائيون يدويًا.

Recv(shape, handle)

تتلقّى هذه العملية بيانات بالشكل المحدّد من تعليمات Send في عملية حسابية أخرى تشارك معها معرّف القناة نفسه. تعرض هذه الدالة XlaOp للبيانات المستلَمة.

لمزيد من المعلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - recv.

RecvDone

يمكنك الاطّلاع أيضًا على HloInstruction::CreateRecv وHloInstruction::CreateRecvDone.

على غرار Send، تمثّل واجهة برمجة التطبيقات الخاصة بالعميل لعملية Recv عملية التواصل المتزامن. ومع ذلك، يتم تقسيم التعليمات داخليًا إلى تعليمتَين من تعليمات HLO (Recv وRecvDone) لتفعيل عمليات نقل البيانات غير المتزامنة.

Recv(const Shape& shape, int64 channel_id)

تخصّص هذه السمة الموارد اللازمة لتلقّي البيانات من تعليمات Send تتضمّن channel_id نفسه. تعرض هذه السمة سياقًا للموارد المخصّصة، وتستخدمه تعليمات RecvDone التالية لانتظار اكتمال عملية نقل البيانات. السياق هو مجموعة من {مخزن مؤقت للاستلام (الشكل)، معرّف الطلب (U32)} ولا يمكن استخدامه إلا من خلال تعليمات RecvDone.

بالنظر إلى السياق الذي تم إنشاؤه بواسطة تعليمات Recv، ينتظر هذا الإجراء إلى أن يكتمل نقل البيانات ويعرض البيانات التي تم تلقّيها.

الحدّ

يمكنك الاطّلاع أيضًا على XlaBuilder::Reduce.

تطبِّق دالة اختزال على صفيف واحد أو أكثر بالتوازي.

Reduce(operands..., init_values..., computation, dimensions_to_reduce)

المكان:

• يجب أن تكون قيمة N أكبر من أو تساوي 1.
• يجب أن تكون عملية الحساب "ترابطية تقريبًا" (راجِع ما يلي).
• يجب أن تتطابق أبعاد جميع مصفوفات الإدخال.
• يجب أن تشكّل جميع القيم الأولية هوية ضمن computation.
• إذا كان N = 1، تكون قيمة Collate(T) هي T.
• إذا كان N > 1، Collate(T_0, ..., T_{N-1}) عبارة عن مجموعة من عناصر N من النوع T.

تقلّل هذه العملية من سمة واحدة أو أكثر لكل صفيف إدخال إلى قيم عددية. عدد أبعاد كل صفيف معروض هو number_of_dimensions(operand) - len(dimensions). يكون الناتج من العملية Collate(Q_0, ..., Q_N) حيث Q_i عبارة عن مصفوفة من النوع T_i، ويتم توضيح أبعادها أدناه.

يُسمح للأنظمة الخلفية المختلفة بإعادة ربط عملية احتساب التخفيض. ويمكن أن يؤدي ذلك إلى اختلافات عددية، لأنّ بعض دوال الاختزال، مثل الجمع، ليست ترابطية بالنسبة إلى الأرقام العشرية. ومع ذلك، إذا كان نطاق البيانات محدودًا، يكون جمع الأعداد العشرية قريبًا بما يكفي من أن يكون ترابطيًا لمعظم الاستخدامات العملية.

لمزيد من المعلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - reduce.

أمثلة

عند تقليل عدد العناصر في بُعد واحد في صفيف أحادي الأبعاد واحد يتضمّن القيم [10, 11, 12, 13]، باستخدام دالة تقليل f (هذا هو computation)، يمكن حساب ذلك على النحو التالي:

f(10, f(11, f(12, f(init_value, 13)))

ولكن هناك أيضًا العديد من الاحتمالات الأخرى، مثل

f(init_value, f(f(10, f(init_value, 11)), f(f(init_value, 12), f(init_value, 13))))

في ما يلي مثال تقريبي على الرمز الزائف يوضّح كيفية تنفيذ عملية التصغير، وذلك باستخدام عملية الجمع كعملية حسابية للتصغير مع قيمة أولية تبلغ 0.

result_shape <- remove all dims in dimensions from operand_shape

# Iterate over all elements in result_shape. The number of r's here is equal
# to the number of dimensions of the result.
for r0 in range(result_shape[0]), r1 in range(result_shape[1]), ...:
  # Initialize this result element
  result[r0, r1...] <- 0

  # Iterate over all the reduction dimensions
  for d0 in range(dimensions[0]), d1 in range(dimensions[1]), ...:
    # Increment the result element with the value of the operand's element.
    # The index of the operand's element is constructed from all ri's and di's
    # in the right order (by construction ri's and di's together index over the
    # whole operand shape).
    result[r0, r1...] += operand[ri... di]

في ما يلي مثال على تقليل حجم مصفوفة ثنائية الأبعاد (مصفوفة). الشكل يتضمّن بُعدَين، البُعد 0 بحجم 2 والبُعد 1 بحجم 3:

نتائج تقليل الأبعاد 0 أو 1 باستخدام دالة "إضافة":

يُرجى العِلم أنّ نتيجتَي الاختزال هما مصفوفتان أحاديتَا البُعد. يعرض المخطّط البياني أحد العناصر كعمود والآخر كصف لتسهيل العرض فقط.

للحصول على مثال أكثر تعقيدًا، إليك مصفوفة ثلاثية الأبعاد. عدد أبعادها هو 3، والبعد 0 بحجم 4، والبعد 1 بحجم 2، والبعد 2 بحجم 3. للتسهيل، يتم تكرار القيم من 1 إلى 6 في البُعد 0.

على غرار المثال الثنائي الأبعاد، يمكننا تقليل بُعد واحد فقط. إذا قلّلنا البُعد 0، على سبيل المثال، سنحصل على مصفوفة ثنائية الأبعاد تم فيها طيّ جميع القيم في البُعد 0 إلى قيمة عددية:

|  4   8  12 |
| 16  20  24 |

إذا قلّلنا السمة 2، سنحصل أيضًا على مصفوفة ثنائية الأبعاد تم فيها دمج جميع القيم في السمة 2 في قيمة عددية:

| 6  15 |
| 6  15 |
| 6  15 |
| 6  15 |

يُرجى العِلم أنّ الترتيب النسبي بين السمات المتبقية في الإدخال يتم الاحتفاظ به في الإخراج، ولكن قد يتم تعيين أرقام جديدة لبعض السمات (بما أنّ عدد السمات يتغيّر).

يمكننا أيضًا تقليل أبعاد متعددة. تؤدي إضافة سمات تقليل 0 و1 إلى إنشاء مصفوفة أحادية البعد [20, 28, 36].

يؤدي تقليل حجم المصفوفة الثلاثية الأبعاد على جميع أبعادها إلى إنتاج القيمة العددية 84.

Variadic Reduce

عند استخدام N > 1، يكون تطبيق دالة الاختزال أكثر تعقيدًا بعض الشيء، لأنّه يتم تطبيقه في الوقت نفسه على جميع المدخلات. يتم تقديم المعامِلات إلى عملية الحساب بالترتيب التالي:

• تشغيل القيمة المخفَّضة للمعامل الأول
• ...
• تشغيل قيمة مخفَّضة للمعامل رقم N
• قيمة الإدخال للمعامل الأول
• ...
• قيمة الإدخال للعامل الحسابي رقم N

على سبيل المثال، ضع في اعتبارك دالة الاختزال التالية التي يمكن استخدامها لحساب الحد الأقصى وargmax لمصفوفة أحادية البعد بالتوازي:

f: (Float, Int, Float, Int) -> Float, Int
f(max, argmax, value, index):
  if value >= max:
    return (value, index)
  else:
    return (max, argmax)

بالنسبة إلى مصفوفات الإدخال أحادية الأبعاد V = Float[N], K = Int[N] والقيم الأولية I_V = Float, I_K = Int، تكون النتيجة f_(N-1) لعملية الاختزال على مستوى سمة الإدخال الوحيدة مكافئة للتطبيق المتكرّر التالي:

f_0 = f(I_V, I_K, V_0, K_0)
f_1 = f(f_0.first, f_0.second, V_1, K_1)
...
f_(N-1) = f(f_(N-2).first, f_(N-2).second, V_(N-1), K_(N-1))

سيؤدي تطبيق هذا الاختزال على مصفوفة من القيم ومصفوفة من الفهارس التسلسلية (أي iota) إلى تكرار مشترك على المصفوفات، وسيعرض مجموعة تحتوي على القيمة القصوى والفهرس المطابق.

ReducePrecision

يمكنك الاطّلاع أيضًا على XlaBuilder::ReducePrecision.

تحاكي هذه الدالة تأثير تحويل قيم الفاصلة العائمة إلى تنسيق أقل دقة (مثل IEEE-FP16) ثم الرجوع إلى التنسيق الأصلي. يمكن تحديد عدد بتات الأس والجزء الكسري في التنسيق ذي الدقة المنخفضة بشكل عشوائي، على الرغم من أنّه قد لا تتوفّر جميع أحجام البتات في جميع عمليات التنفيذ على الأجهزة.

ReducePrecision(operand, exponent_bits, mantissa_bits)

والنتيجة هي صفيف من النوع T. يتم تقريب قيم الإدخال إلى أقرب قيمة يمكن تمثيلها باستخدام عدد محدد من بتات الجزء الكسري (باستخدام دلالات "التقريب إلى أقرب عدد زوجي")، ويتم حصر أي قيم تتجاوز النطاق المحدد بعدد بتات الأس في اللانهاية الموجبة أو السالبة. يتم الاحتفاظ بقيم NaN، ولكن قد يتم تحويلها إلى قيم NaN أساسية.

يجب أن يتضمّن التنسيق ذو الدقة الأقل بتًا واحدًا على الأقل للأس (من أجل التمييز بين القيمة صفر واللانهاية، لأنّ كليهما يتضمّن جزءًا كسريًا بقيمة صفر)، ويجب أن يتضمّن عددًا غير سالب من بتات الجزء الكسري. قد يتجاوز عدد بتات الأس أو الجزء الكسري القيمة المقابلة للنوع T، وفي هذه الحالة، يكون الجزء المقابل من عملية التحويل مجرد عملية لا تفعل شيئًا.

للحصول على معلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - reduce_precision.

ReduceScatter

يمكنك الاطّلاع أيضًا على XlaBuilder::ReduceScatter.

‫ReduceScatter هي عملية جماعية تنفّذ بشكل فعّال عملية AllReduce ثم توزّع النتيجة بتقسيمها إلى shard_count حزمة على طول scatter_dimension، وتتلقّى النسخة المتماثلة i في مجموعة النسخ المتماثلة الحزمة ith.

ReduceScatter(operand, computation, scatter_dimension, shard_count, replica_groups, channel_id, layout, use_global_device_ids)

• عندما يكون operand مجموعة من المصفوفات، يتم تنفيذ عملية reduce-scatter على كل عنصر من عناصر المجموعة.
• replica_groups هي قائمة بمجموعات النسخ المتماثلة التي يتم إجراء عملية التصغير بينها (يمكن استرداد معرّف النسخة المتماثلة الحالية باستخدام ReplicaId). ويحدّد ترتيب النسخ المتماثلة في كل مجموعة ترتيب توزيع نتيجة عملية التصغير. يجب أن يكون الحقل replica_groups فارغًا (وفي هذه الحالة تنتمي جميع النسخ المتطابقة إلى مجموعة واحدة)، أو أن يحتوي على عدد العناصر نفسه الذي يتضمّنه عدد النسخ المتطابقة. عندما يكون هناك أكثر من مجموعة نسخ متطابقة، يجب أن تكون جميعها بالحجم نفسه. على سبيل المثال، تنفّذ replica_groups = {0, 2}, {1, 3} عملية تقليل بين النسختين المتطابقتين 0 و2، و1 و3، ثم توزع النتيجة.
• shard_count هو حجم كل مجموعة من النسخ المتماثلة. نحتاج إلى ذلك في الحالات التي تكون فيها replica_groups فارغة. إذا لم يكن replica_groups فارغًا، يجب أن تكون قيمة shard_count مساوية لحجم كل مجموعة من النسخ المتطابقة.
• يتم استخدام channel_id للتواصل بين الوحدات: يمكن فقط لعمليات reduce-scatter التي لها channel_id نفسها التواصل مع بعضها البعض.
• layout يمكنك الاطّلاع على xla::shapes للحصول على مزيد من المعلومات حول التنسيقات.
• ‫use_global_device_ids هي علامة يحدّدها المستخدم. عندما تكون القيمة false(تلقائية)، تكون الأرقام في replica_groups هي ReplicaId عندما تكون true هي replica_groups التي تمثّل معرّفًا عامًا (ReplicaID*partition_count + partition_id). على سبيل المثال:
  • مع نسختَين متطابقتَين و4 أقسام،
  • replica_groups={ {0,1,4,5},{2,3,6,7} } and use_global_device_ids=true
  • group[0] = (0,0), (0,1), (1,0), (1,1)
  • group[1] = (0,2), (0,3), (1,2), (1,3)
  • حيث يمثّل كل زوج (replica_id, partition_id).

شكل الإخراج هو شكل الإدخال مع تصغيره scatter_dimension مرة بمقدار shard_count. على سبيل المثال، إذا كان هناك نسختان طبق الأصل وكانت قيمة المعامِل [1.0, 2.25] و[3.0, 5.25] على التوالي في النسختين، ستكون قيمة الناتج من هذه العملية حيث scatter_dim هي 0، [4.0] للنسخة الأولى و[7.5] للنسخة الثانية.

لمزيد من المعلومات حول StableHLO، يُرجى الاطّلاع على StableHLO - reduce_scatter.

ReduceScatter - Example 1 - StableHLO

في المثال أعلاه، هناك نسختان طبق الأصل تشاركان في عملية ReduceScatter. في كل نسخة طبق الأصل، يكون للمعامل الشكل f32[2,4]. يتم إجراء عملية تقليل شاملة (مجموع) على مستوى النسخ المتماثلة، ما يؤدي إلى إنتاج قيمة مخفَّضة بالشكل f32[2,4] على كل نسخة متماثلة. بعد ذلك، يتم تقسيم هذه القيمة المخفَّضة إلى جزأين على طول البُعد 1، بحيث يكون لكل جزء شكل f32[2,2]. يتلقّى كل نسخة طبق الأصل ضمن مجموعة العمليات الجزء الذي يتوافق مع موضعها في المجموعة. نتيجةً لذلك، يكون الناتج على كل نسخة طبق الأصل بالشكل f32[2,2].

ReduceWindow

يمكنك الاطّلاع أيضًا على XlaBuilder::ReduceWindow.

تطبِّق دالة تقليل على جميع العناصر في كل نافذة من سلسلة من مصفوفات متعددة الأبعاد، ما يؤدي إلى إنتاج مصفوفة واحدة أو مجموعة من مصفوفات N متعددة الأبعاد كناتج. تحتوي كل مصفوفة إخراج على عدد العناصر نفسه الذي يتضمّنه عدد المواضع الصالحة للنافذة. يمكن التعبير عن طبقة التجميع على أنّها ReduceWindow. على غرار Reduce، يتم دائمًا تمرير computation المطبَّق إلى init_values على يمين المعادلة.

ReduceWindow(operands..., init_values..., computation, window_dimensions, window_strides, padding)

المكان:

• يجب أن تكون قيمة N أكبر من أو تساوي 1.
• يجب أن تتطابق أبعاد جميع مصفوفات الإدخال.
• إذا كان N = 1، تكون قيمة Collate(T) هي T.
• إذا كان N > 1، Collate(T_0, ..., T_{N-1}) عبارة عن مجموعة من عناصر N من النوع (T0,...T{N-1}).

لمزيد من المعلومات عن StableHLO، يُرجى الاطّلاع على StableHLO - reduce_window.

ReduceWindow - Example 1

الإدخال هو مصفوفة بحجم [4x6]، وكلا window_dimensions وwindow_stride_dimensions هما [2x3].

// Create a computation for the reduction (maximum).
XlaComputation max;
{
  XlaBuilder builder(client_, "max");
  auto y = builder.Parameter(0, ShapeUtil::MakeShape(F32, {}), "y");
  auto x = builder.Parameter(1, ShapeUtil::MakeShape(F32, {}), "x");
  builder.Max(y, x);
  max = builder.Build().value();
}

// Create a ReduceWindow computation with the max reduction computation.
XlaBuilder builder(client_, "reduce_window_2x3");
auto shape = ShapeUtil::MakeShape(F32, {4, 6});
auto input = builder.Parameter(0, shape, "input");
builder.ReduceWindow(
    input,
    /*init_val=*/builder.ConstantLiteral(LiteralUtil::MinValue(F32)),
    *max,
    /*window_dimensions=*/{2, 3},
    /*window_stride_dimensions=*/{2, 3},
    Padding::kValid);