معناشناسی عملیات

در زیر معنای عملیات تعریف شده در رابط XlaBuilder را شرح می دهد. به طور معمول، این عملیات یک به یک به عملیات تعریف شده در رابط RPC در xla_data.proto نگاشت.

نکته ای در مورد نامگذاری: نوع داده تعمیم یافته ای که XLA با آن سروکار دارد، یک آرایه N بعدی است که عناصری از نوع یکنواخت (مانند شناور ۳۲ بیتی) را در خود نگه می دارد. در سراسر مستندات، آرایه برای نشان دادن یک آرایه با ابعاد دلخواه استفاده می شود. برای راحتی، موارد خاص نام های خاص و آشناتری دارند. به عنوان مثال یک بردار یک آرایه 1 بعدی و یک ماتریس یک آرایه دو بعدی است.

شکم

XlaBuilder::Abs نیز ببینید.

abs مبتنی بر عنصر x -> |x| .

Abs(operand)

استدلال ها تایپ کنید معناشناسی
operand XlaOp عملوند تابع

برای اطلاعات StableHLO به StableHLO-abs مراجعه کنید.

اضافه کنید

همچنین XlaBuilder::Add ببینید.

اضافه کردن عناصر lhs و rhs را انجام می دهد.

Add(lhs, rhs)

استدلال ها تایپ کنید معناشناسی
lhs XlaOp عملوند سمت چپ: آرایه ای از نوع T
rhs XlaOp عملوند سمت چپ: آرایه ای از نوع T

اشکال آرگومان ها باید یا مشابه یا سازگار باشند. مستندات پخش در مورد معنای سازگاری اشکال را ببینید. نتیجه یک عملیات شکلی دارد که حاصل پخش دو آرایه ورودی است. در این نوع، عملیات بین آرایه های رتبه های مختلف پشتیبانی نمی شود، مگر اینکه یکی از عملوندها یک اسکالر باشد.

یک نوع جایگزین با پشتیبانی از پخش با ابعاد مختلف برای افزودن وجود دارد:

Add(lhs,rhs, broadcast_dimensions)

استدلال ها تایپ کنید معناشناسی
lhs XlaOp عملوند سمت چپ: آرایه ای از نوع T
rhs XlaOp عملوند سمت چپ: آرایه ای از نوع T
پخش_بعد ArraySlice هر بعد از شکل عملوند مربوط به کدام بعد در شکل هدف است

این نوع عملیات باید برای عملیات حسابی بین آرایه های رتبه های مختلف (مانند افزودن یک ماتریس به بردار) استفاده شود.

عملوند اضافی broadcast_dimensions تکه ای از اعداد صحیح است که ابعاد مورد استفاده برای پخش عملوندها را مشخص می کند. معناشناسی به طور مفصل در صفحه پخش توضیح داده شده است.

برای اطلاعات StableHLO به StableHLO - add مراجعه کنید.

افزودن وابستگی

HloInstruction::AddDependency نیز ببینید.

AddDependency ممکن است در محفظه های HLO ظاهر شود، اما در نظر گرفته نشده است که آنها به صورت دستی توسط کاربران نهایی ساخته شوند.

بعد از همه

XlaBuilder::AfterAll نیز ببینید.

AfterAll تعداد متغیری توکن را می گیرد و یک توکن تولید می کند. توکن‌ها انواع اولیه‌ای هستند که می‌توان آن‌ها را بین عملیات‌های جانبی قرار داد تا سفارش را اجرا کنند. AfterAll می توان به عنوان پیوندی از نشانه ها برای سفارش عملیات پس از مجموعه ای از عملیات استفاده کرد.

AfterAll(tokens)

استدلال ها تایپ کنید معناشناسی
tokens وکتور XlaOp تعداد متغیر توکن ها

برای اطلاعات StableHLO به StableHLO - after_all مراجعه کنید.

همه جمع شوند

XlaBuilder::AllGather نیز ببینید.

الحاق بین کپی ها را انجام می دهد.

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

استدلال ها تایپ کنید معناشناسی
operand XlaOp آرایه ای برای الحاق بین کپی ها
all_gather_dimension int64 بعد الحاق
shard_count int64 اندازه هر گروه ماکت
replica_groups بردار بردارهای int64 گروه هایی که الحاق بین آنها انجام می شود
channel_id ChannelHandle اختیاری شناسه کانال اختیاری برای ارتباط متقابل ماژول
layout Layout اختیاری یک الگوی طرح‌بندی ایجاد می‌کند که طرح‌بندی منطبق را در آرگومان ثبت می‌کند
use_global_device_ids bool اختیاری اگر شناسه‌های موجود در پیکربندی ReplicaGroup یک شناسه جهانی را نشان دهند، مقدار true را برمی‌گرداند
  • replica_groups لیستی از گروه‌های replica است که الحاق بین آنها انجام می‌شود (شناسه replica برای ماکت فعلی را می‌توان با استفاده از ReplicaId بازیابی کرد). ترتیب تکرارها در هر گروه تعیین کننده ترتیب قرار گرفتن ورودی های آنها در نتیجه است. replica_groups یا باید خالی باشند (در این صورت همه کپی‌ها متعلق به یک گروه واحد هستند که از 0 تا N - 1 مرتب شده‌اند)، یا دارای همان تعداد عناصر با تعداد کپی‌ها باشند. برای مثال، replica_groups = {0, 2}, {1, 3} الحاق بین replica های 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) را به جای شناسه replica نشان دهند، درست برمی گردند. اگر این کاهش همه جانبه هم متقاطع و هم تکراری باشد، گروه بندی انعطاف پذیرتری از دستگاه ها را امکان پذیر می کند.

شکل خروجی شکل ورودی با all_gather_dimension است که shard_count بار بزرگتر شده است. به عنوان مثال، اگر دو replica وجود داشته باشد و عملوند دارای مقدار [1.0, 2.5] و [3.0, 5.25] به ترتیب روی دو replica باشد، آنگاه مقدار خروجی از این عملیات که در آن all_gather_dim 0 است در هر دو replica [1.0, 2.5, 3.0,5.25] خواهد بود.

API AllGather به طور داخلی به 2 دستورالعمل HLO ( AllGatherStart و AllGatherDone ) تجزیه می شود.

HloInstruction::CreateAllGatherStart نیز ببینید.

AllGatherStart ، AllGatherDone به عنوان اولیه در HLO خدمت می کنند. این عملیات ممکن است در انبارهای HLO ظاهر شوند، اما قرار نیست به صورت دستی توسط کاربران نهایی ساخته شوند.

برای اطلاعات StableHLO به StableHLO - all_gather مراجعه کنید.

همه کاهش

XlaBuilder::AllReduce نیز ببینید.

یک محاسبات سفارشی در بین کپی ها انجام می دهد.

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

استدلال ها تایپ کنید معناشناسی
operand XlaOp آرایه یا چند تایی از آرایه‌های خالی برای کاهش بین ماکت‌ها
computation XlaComputation محاسبه کاهش
replica_groups وکتور ReplicaGroup گروه هایی که بین آنها کاهش ها انجام می شود
channel_id ChannelHandle اختیاری شناسه کانال اختیاری برای ارتباط متقابل ماژول
shape_with_layout Shape اختیاری طرح بندی داده های منتقل شده را تعریف می کند
use_global_device_ids bool اختیاری اگر شناسه‌های موجود در پیکربندی ReplicaGroup یک شناسه جهانی را نشان دهند، مقدار true را برمی‌گرداند
  • هنگامی که operand چند آرایه است، کاهش همه روی هر عنصر تاپل انجام می شود.
  • replica_groups فهرستی از گروه‌های replica است که بین آن‌ها کاهش انجام می‌شود (شناسه replica برای replica فعلی را می‌توان با استفاده از ReplicaId بازیابی کرد). replica_groups یا باید خالی باشد (در این صورت همه replica ها متعلق به یک گروه واحد هستند)، یا دارای همان تعداد عناصر با تعداد Replica ها باشند. برای مثال، 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) را به جای شناسه replica نشان دهند، درست برمی گردند. اگر این کاهش همه جانبه هم متقاطع و هم تکراری باشد، گروه بندی انعطاف پذیرتری از دستگاه ها را امکان پذیر می کند.

شکل خروجی همان شکل ورودی است. به عنوان مثال، اگر دو replica وجود داشته باشد و عملوند دارای مقدار [1.0, 2.5] و [3.0, 5.25] به ترتیب روی دو replica باشد، آنگاه مقدار خروجی از این محاسبه عملیات و جمع در هر دو replica [4.0, 7.75] خواهد بود. اگر ورودی یک تاپلی باشد، خروجی نیز یک تاپل است.

محاسبه نتیجه AllReduce مستلزم داشتن یک ورودی از هر ماکت است، بنابراین اگر یک ماکت یک گره AllReduce را بیشتر از دیگری اجرا کند، آنگاه ماکت قبلی برای همیشه منتظر خواهد ماند. از آنجایی که ریپلیکاها همگی یک برنامه را اجرا می کنند، راه های زیادی برای این اتفاق وجود ندارد، اما زمانی ممکن است که شرایط حلقه while به داده های infeed بستگی داشته باشد و داده هایی که infeed باعث شوند حلقه while بارها بر روی یک ماکت تکرار شود.

API AllReduce به طور داخلی به 2 دستورالعمل HLO ( AllReduceStart و AllReduceDone ) تجزیه می شود.

HloInstruction::CreateAllReduceStart نیز ببینید.

AllReduceStart و AllReduceDone به عنوان اولیه در HLO عمل می کنند. این عملیات ممکن است در انبارهای HLO ظاهر شوند، اما قرار نیست به صورت دستی توسط کاربران نهایی ساخته شوند.

CrossReplicaSum

XlaBuilder::CrossReplicaSum نیز ببینید.

AllReduce با محاسبات جمع انجام می دهد.

CrossReplicaSum(operand, replica_groups)

استدلال ها تایپ کنید معناشناسی
operand XlaOp آرایه یا چند تایی از آرایه‌های خالی برای کاهش بین ماکت‌ها
replica_groups بردار بردارهای int64 گروه هایی که بین آنها کاهش ها انجام می شود

مجموع مقدار عملوند را در هر زیر گروه از replica ها برمی گرداند. همه ماکت ها یک ورودی به مجموع می دهند و همه ماکت ها مجموع حاصل را برای هر زیرگروه دریافت می کنند.

AllToAll

XlaBuilder::AllToAll نیز ببینید.

AllToAll یک عملیات جمعی است که داده ها را از همه هسته ها به همه هسته ها ارسال می کند. دو فاز دارد:

  1. فاز پراکندگی. در هر هسته، عملوند به تعداد بلوک‌های split_count در امتداد split_dimensions تقسیم می‌شود، و بلوک‌ها به همه هسته‌ها پراکنده می‌شوند، به عنوان مثال، بلوک ith ​​به هسته i ارسال می‌شود.
  2. مرحله جمع آوری هر هسته بلوک های دریافتی را در امتداد concat_dimension به هم متصل می کند.

هسته های شرکت کننده را می توان توسط:

  • replica_groups : هر ReplicaGroup حاوی لیستی از Replica IDهای شرکت کننده در محاسبه است (شناسه replica برای replica فعلی را می توان با استفاده از ReplicaId بازیابی کرد). AllToAll در زیر گروه ها به ترتیب مشخص شده اعمال خواهد شد. به عنوان مثال، replica_groups = { {1,2,3}, {4,5,0} } به این معنی است که یک AllToAll در کپی‌های {1, 2, 3} و در مرحله جمع‌آوری اعمال می‌شود و بلوک‌های دریافتی به همان ترتیب 1، 2، 3 به هم متصل می‌شوند. سپس، یک ترتیب دیگر AllToAll در replica‌های 0، 2 و 2 اعمال می‌شود. همچنین 4، 5، 0 است. اگر replica_groups خالی باشد، همه replica ها به ترتیب الحاق ظاهرشان به یک گروه تعلق دارند.

پیش نیازها:

  • اندازه بعد عملوند در split_dimension بر split_count قابل تقسیم است.
  • شکل عملوند تاپلی نیست.

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

استدلال ها تایپ کنید معناشناسی
operand XlaOp n آرایه ورودی بعدی
split_dimension int64 مقداری در بازه [0,n) که ابعادی را که عملوند در امتداد آن تقسیم می‌شود، نام‌گذاری می‌کند
concat_dimension int64 مقداری در بازه [0,n) که ابعادی را که بلوک‌های تقسیم شده در امتداد آن به هم متصل می‌شوند نام‌گذاری می‌کند.
split_count int64 تعداد هسته هایی که در این عملیات شرکت می کنند. اگر replica_groups خالی است، این باید تعداد replica ها باشد. در غیر این صورت، این باید برابر با تعداد کپی در هر گروه باشد.
replica_groups وکتور ReplicaGroup هر گروه حاوی لیستی از شناسه های ماکت است.
layout Layout اختیاری چیدمان حافظه مشخص شده توسط کاربر
channel_id ChannelHandle اختیاری شناسه منحصر به فرد برای هر جفت ارسال/بازگشت

برای اطلاعات بیشتر در مورد شکل ها و چیدمان ها به 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 شرکت دارند. در هر هسته، عملوند در امتداد بعد 1 به 4 قسمت تقسیم می شود، بنابراین هر قسمت دارای شکل f32 [4،4] است. 4 قسمت در تمام هسته ها پراکنده شده اند. سپس هر هسته قطعات دریافتی را در امتداد ابعاد 0 به ترتیب هسته 0-4 به هم متصل می کند. بنابراین خروجی هر هسته دارای شکل f32 [16,4] است.

AllToAll - مثال 2 - StableHLO

نمونه ای از جریان داده AllToAll برای StableHLO

در مثال بالا، 2 ماکت در AllToAll شرکت دارند. در هر ماکت، عملوند دارای شکل f32 [2،4] است. عملوند در امتداد بعد 1 به 2 قسمت تقسیم می شود، بنابراین هر قسمت شکل f32 [2،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)

استدلال ها تایپ کنید معناشناسی
input XlaOp آرایه N از نوع T
input_offsets XlaOp آرایه N از نوع T
send_sizes XlaOp آرایه N از نوع T
output XlaOp آرایه N از نوع T
output_offsets XlaOp آرایه N از نوع T
recv_sizes XlaOp آرایه N از نوع T
replica_groups وکتور ReplicaGroup هر گروه حاوی لیستی از شناسه های ماکت است.
channel_id ChannelHandle اختیاری شناسه منحصر به فرد برای هر جفت ارسال/بازگشت

تانسورهای ناهموار با مجموعه ای از سه تانسور تعریف می شوند:

  • 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]] در output [i] i نوشته خواهد شد.

برای مثال، اگر 2 کپی داشته باشیم:

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 : تانسور اندازه‌های recv ژنده‌دار.

تانسورهای *_offsets و *_sizes همگی باید یک شکل باشند.

دو شکل برای تانسورهای *_offsets و *_sizes پشتیبانی می شود:

  • [num_devices] که در آن‌ها Ragged-all-to-all ممکن است حداکثر یک به‌روزرسانی برای هر دستگاه راه دور در گروه replica ارسال کند. به عنوان مثال:
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] که در آن Ragged-all-to-all ممکن است به‌روزرسانی‌هایی را به num_updates ارسال کند، همان دستگاه راه دور (هر کدام با افست‌های متفاوت)، برای هر دستگاه راه دور در گروه replica.

به عنوان مثال:

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)

استدلال ها تایپ کنید معناشناسی
lhs XlaOp عملوند سمت چپ: آرایه ای از نوع T
rhs XlaOp عملوند سمت چپ: آرایه ای از نوع T

اشکال آرگومان ها باید یا مشابه یا سازگار باشند. مستندات پخش در مورد معنای سازگاری اشکال را ببینید. نتیجه یک عملیات شکلی دارد که حاصل پخش دو آرایه ورودی است. در این نوع، عملیات بین آرایه های رتبه های مختلف پشتیبانی نمی شود، مگر اینکه یکی از عملوندها یک اسکالر باشد.

یک نوع جایگزین با پشتیبانی از پخش با ابعاد مختلف برای And:

And(lhs,rhs, broadcast_dimensions)

استدلال ها تایپ کنید معناشناسی
lhs XlaOp عملوند سمت چپ: آرایه ای از نوع T
rhs XlaOp عملوند سمت چپ: آرایه ای از نوع T
پخش_بعد ArraySlice هر بعد از شکل عملوند مربوط به کدام بعد در شکل هدف است

این نوع عملیات باید برای عملیات حسابی بین آرایه های رتبه های مختلف (مانند افزودن یک ماتریس به بردار) استفاده شود.

عملوند اضافی broadcast_dimensions تکه ای از اعداد صحیح است که ابعاد مورد استفاده برای پخش عملوندها را مشخص می کند. معناشناسی به طور مفصل در صفحه پخش توضیح داده شده است.

برای اطلاعات StableHLO به StableHLO - and مراجعه کنید.

همگام

همچنین به HloInstruction::CreateAsyncStart ، HloInstruction::CreateAsyncUpdate ، HloInstruction::CreateAsyncDone مراجعه کنید.

AsyncDone ، AsyncStart و AsyncUpdate دستورالعمل های HLO داخلی هستند که برای عملیات Asynchronous استفاده می شوند و به عنوان اولیه در HLO عمل می کنند. این عملیات ممکن است در انبارهای HLO ظاهر شوند، اما قرار نیست به صورت دستی توسط کاربران نهایی ساخته شوند.

آتان 2

XlaBuilder::Atan2 نیز ببینید.

عملیات atan2 را از نظر عناصر بر روی lhs و rhs انجام می دهد.

Atan2(lhs, rhs)

استدلال ها تایپ کنید معناشناسی
lhs XlaOp عملوند سمت چپ: آرایه ای از نوع T
rhs XlaOp عملوند سمت چپ: آرایه ای از نوع T

اشکال آرگومان ها باید یا مشابه یا سازگار باشند. مستندات پخش در مورد معنای سازگاری اشکال را ببینید. نتیجه یک عملیات شکلی دارد که حاصل پخش دو آرایه ورودی است. در این نوع، عملیات بین آرایه های رتبه های مختلف پشتیبانی نمی شود، مگر اینکه یکی از عملوندها یک اسکالر باشد.

یک نوع جایگزین با پشتیبانی از پخش با ابعاد مختلف برای Atan2 وجود دارد:

Atan2(lhs,rhs, broadcast_dimensions)

استدلال ها تایپ کنید معناشناسی
lhs XlaOp عملوند سمت چپ: آرایه ای از نوع T
rhs XlaOp عملوند سمت چپ: آرایه ای از نوع T
پخش_بعد ArraySlice هر بعد از شکل عملوند مربوط به کدام بعد در شکل هدف است

این نوع عملیات باید برای عملیات حسابی بین آرایه های رتبه های مختلف (مانند افزودن یک ماتریس به بردار) استفاده شود.

عملوند اضافی broadcast_dimensions تکه ای از اعداد صحیح است که ابعاد مورد استفاده برای پخش عملوندها را مشخص می کند. معناشناسی به طور مفصل در صفحه پخش توضیح داده شده است.

برای اطلاعات StableHLO به StableHLO - atan2 مراجعه کنید.

BatchNormGrad

همچنین XlaBuilder::BatchNormGrad و مقاله نرمال سازی دسته اصلی را برای توضیح دقیق الگوریتم ببینید.

گرادیان های هنجار دسته ای را محاسبه می کند.

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

استدلال ها تایپ کنید معناشناسی
operand XlaOp n آرایه بعدی باید نرمال شود (x)
scale XlaOp آرایه 1 بعدی (\(\gamma\))
batch_mean XlaOp آرایه 1 بعدی (\(\mu\))
batch_var XlaOp آرایه 1 بعدی (\(\sigma^2\))
grad_output XlaOp گرادیان ها به BatchNormTraining (\(\nabla y\))
epsilon float مقدار اپسیلون (\(\epsilon\))
feature_index int64 شاخص به بعد ویژگی در operand

برای هر ویژگی در بعد ویژگی ( feature_index شاخص بعد ویژگی در operand است)، این عملیات گرادیان ها را با توجه به operand ، offset و scale در تمام ابعاد دیگر محاسبه می کند. feature_index باید یک شاخص معتبر برای بعد ویژگی در operand باشد.

سه گرادیان با فرمول های زیر تعریف می شوند (با فرض یک آرایه 4 بعدی به عنوان 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 مقادیر لحظه‌ها را در ابعاد دسته‌ای و فضایی نشان می‌دهند.

نوع خروجی سه دسته است:

خروجی ها تایپ کنید معناشناسی
grad_operand XlaOp گرادیان با توجه به operand ورودی (\(\nabla x\))
grad_scale XlaOp گرادیان با توجه به ورودی ** scale ** (\(\nabla\gamma\))
grad_offset XlaOp گرادیان با توجه به offset ورودی (\(\nabla\beta\))

برای اطلاعات StableHLO به StableHLO - batch_norm_grad مراجعه کنید.

BatchNormInference

همچنین XlaBuilder::BatchNormInference و مقاله نرمال سازی دسته اصلی را برای توضیح دقیق الگوریتم ببینید.

یک آرایه را در ابعاد دسته ای و فضایی عادی می کند.

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

استدلال ها تایپ کنید معناشناسی
operand XlaOp n آرایه بعدی عادی شود
scale XlaOp آرایه 1 بعدی
offset XlaOp آرایه 1 بعدی
mean XlaOp آرایه 1 بعدی
variance XlaOp آرایه 1 بعدی
epsilon float ارزش اپسیلون
feature_index int64 شاخص به بعد ویژگی در operand

برای هر ویژگی در بعد ویژگی ( 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)

استدلال ها تایپ کنید معناشناسی
operand XlaOp n آرایه بعدی باید نرمال شود (x)
scale XlaOp آرایه 1 بعدی (\(\gamma\))
offset XlaOp آرایه 1 بعدی (\(\beta\))
epsilon float مقدار اپسیلون (\(\epsilon\))
feature_index int64 شاخص به بعد ویژگی در operand

برای هر ویژگی در بعد ویژگی ( feature_index شاخص بعد ویژگی در operand است)، این عملیات میانگین و واریانس را در تمام ابعاد دیگر محاسبه می کند و از میانگین و واریانس برای عادی سازی هر عنصر در operand استفاده می کند. feature_index باید یک شاخص معتبر برای بعد ویژگی در operand باشد.

الگوریتم برای هر دسته در operand به شرح زیر است \(x\) که شامل m عناصر با w و h به اندازه ابعاد فضایی است (با فرض اینکه operand یک آرایه 4 بعدی باشد):

  • میانگین دسته ای را محاسبه می کند \(\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^2 l=\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 است:

خروجی ها تایپ کنید معناشناسی
output XlaOp n آرایه بعدی با همان شکل operand ورودی (y)
batch_mean XlaOp آرایه 1 بعدی (\(\mu\))
batch_var XlaOp آرایه 1 بعدی (\(\sigma^2\))

batch_mean و batch_var گشتاورهایی هستند که در ابعاد دسته ای و فضایی با استفاده از فرمول های بالا محاسبه می شوند.

برای اطلاعات StableHLO به StableHLO - batch_norm_training مراجعه کنید.

بیت کست

HloInstruction::CreateBitcast نیز ببینید.

Bitcast ممکن است در حفره‌های HLO ظاهر شود، اما در نظر گرفته نشده است که توسط کاربران نهایی به صورت دستی ساخته شوند.

BitcastConvertType

XlaBuilder::BitcastConvertType نیز ببینید.

مشابه یک tf.bitcast در TensorFlow، عملیات بیتکست عنصری را از شکل داده به شکل هدف انجام می دهد. اندازه ورودی و خروجی باید مطابقت داشته باشند: به عنوان مثال، عناصر s32 از طریق روال بیت‌کست به عناصر f32 تبدیل می‌شوند و یک عنصر s32 به چهار عنصر s8 تبدیل می‌شود. بیت‌کست به‌عنوان یک بازیگر سطح پایین پیاده‌سازی می‌شود، بنابراین ماشین‌هایی با نمایش‌های ممیز شناور متفاوت نتایج متفاوتی خواهند داشت.

BitcastConvertType(operand, new_element_type)

استدلال ها تایپ کنید معناشناسی
operand XlaOp آرایه از نوع T با کم نور D
new_element_type PrimitiveType نوع U

ابعاد عملوند و شکل هدف باید مطابقت داشته باشند، جدای از آخرین بعد که با نسبت اندازه اولیه قبل و بعد از تبدیل تغییر می کند.

نوع عنصر مبدا و مقصد نباید چند تایی باشد.

برای اطلاعات StableHLO به StableHLO - bitcast_convert مراجعه کنید.

تبدیل بیتکست به نوع اولیه با عرض های مختلف

دستور 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)

استدلال ها تایپ کنید معناشناسی
operand XlaOp آرایه برای کپی کردن
broadcast_sizes ArraySlice<int64> اندازه های ابعاد جدید

ابعاد جدید در سمت چپ درج می شوند، یعنی اگر 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 - broadcast مراجعه کنید.

BroadcastInDim

XlaBuilder::BroadcastInDim نیز ببینید.

اندازه و تعداد ابعاد یک آرایه را با کپی کردن داده ها در آرایه گسترش می دهد.

BroadcastInDim(operand, out_dim_size, broadcast_dimensions)

استدلال ها تایپ کنید معناشناسی
operand XlaOp آرایه برای کپی کردن
out_dim_size ArraySlice<int64> اندازه ابعاد شکل هدف
broadcast_dimensions ArraySlice<int64> هر بعد از شکل عملوند مربوط به کدام بعد در شکل هدف است

مشابه Broadcast، اما امکان افزودن ابعاد در هر نقطه و گسترش ابعاد موجود با اندازه 1 را می دهد.

operand به شکل توصیف شده توسط out_dim_size پخش می شود. broadcast_dimensions ابعاد operand را به ابعاد شکل هدف نگاشت می‌کند، یعنی بعد i'م عملوند به بعد broadcast_dimension[i]'مین شکل خروجی نگاشت می‌شود. ابعاد operand باید اندازه 1 داشته باشد یا به اندازه ابعاد در شکل خروجی که به آن نگاشت شده اند باشد. ابعاد باقیمانده با ابعاد اندازه 1 پر می شود. پخش با ابعاد منحط سپس در امتداد این ابعاد منحط پخش می شود تا به شکل خروجی برسد. معناشناسی به طور مفصل در صفحه پخش توضیح داده شده است.

تماس بگیرید

XlaBuilder::Call نیز ببینید.

محاسبه ای را با آرگومان های داده شده فراخوانی می کند.

Call(computation, operands...)

استدلال ها تایپ کنید معناشناسی
computation XlaComputation محاسبات نوع T_0, T_1, ..., T_{N-1} -> S با N پارامتر از نوع دلخواه
operands دنباله ای از N XlaOp s N آرگومان از نوع دلخواه

آریتی و انواع operands باید با پارامترهای computation مطابقت داشته باشد. مجاز است که هیچ operands نداشته باشد.

CompositeCall

XlaBuilder::CompositeCall نیز ببینید.

عملیاتی متشکل از سایر عملیات StableHLO را در بر می گیرد و ورودی ها و ویژگی های ترکیبی را می گیرد و نتایج را تولید می کند. معناشناسی عملیات با ویژگی تجزیه پیاده سازی می شود. عملیات ترکیبی را می توان با تجزیه آن بدون تغییر معنایی برنامه جایگزین کرد. در مواردی که درون‌سازی تجزیه معنای عملیات یکسانی را ارائه نمی‌دهد، ترجیح دهید از custom_call استفاده کنید.

فیلد نسخه (به‌طور پیش‌فرض روی 0) برای نشان دادن زمانی که معنای کامپوزیت تغییر می‌کند استفاده می‌شود.

این عملیات به صورت kCall با ویژگی is_composite=true پیاده سازی می شود. فیلد decomposition با ویژگی computation مشخص می شود. ویژگی های frontend بقیه ویژگی ها را با پیشوند 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)

استدلال ها تایپ کنید معناشناسی
computation XlaComputation محاسبات نوع T_0, T_1, ..., T_{N-1} -> S با N پارامتر از نوع دلخواه
operands دنباله ای از N XlaOp s تعداد متغیر مقادیر
name string نام کامپوزیت
attributes string اختیاری فرهنگ لغت رشته ای اختیاری صفات
version اختیاری int64 شماره به نسخه به روز رسانی به معناشناسی عملیات ترکیبی

decomposition یک فیلد نامیده نمی شود، بلکه به عنوان یک ویژگی to_apply ظاهر می شود که به تابعی که شامل پیاده سازی سطح پایین تر است، یعنی to_apply=%funcname اشاره می کند.

اطلاعات بیشتر در مورد کامپوزیت و تجزیه را می توان در مشخصات StableHLO یافت.

Cbrt

XlaBuilder::Cbrt نیز ببینید.

عملیات ریشه مکعب از نظر عنصر x -> cbrt(x) .

Cbrt(operand)

استدلال ها تایپ کنید معناشناسی
operand XlaOp عملوند تابع

Cbrt از آرگومان optional result_accuracy نیز پشتیبانی می کند:

Cbrt(operand, result_accuracy)

استدلال ها تایپ کنید معناشناسی
operand XlaOp عملوند تابع
result_accuracy اختیاری ResultAccuracy انواع دقتی که کاربر می تواند برای عملیات های یکپارچه با چند پیاده سازی درخواست کند

برای اطلاعات بیشتر در مورد result_accuracy دقت نتیجه را ببینید.

برای اطلاعات StableHLO به StableHLO - cbrt مراجعه کنید.

سقف

XlaBuilder::Ceil نیز ببینید.

سقف عنصری x -> ⌈x⌉ .

Ceil(operand)

استدلال ها تایپ کنید معناشناسی
operand XlaOp عملوند تابع

برای اطلاعات StableHLO به StableHLO-ceil مراجعه کنید.

چولسکی

XlaBuilder::Cholesky نیز ببینید.

تجزیه Cholesky دسته ای از ماتریس های قطعی مثبت متقارن (Hermitian) را محاسبه می کند.

Cholesky(a, lower)

استدلال ها تایپ کنید معناشناسی
a XlaOp آرایه ای از نوع پیچیده یا ممیز شناور با ابعاد > 2.
lower bool از مثلث بالایی یا پایینی a استفاده کنیم.

اگر lower true باشد، ماتریس های مثلثی پایین l به گونه ای محاسبه می کند که $a = l باشد. l^T$. اگر lower false است، ماتریس‌های مثلثی بالا u طوری محاسبه می‌کند که\(a = u^T . u\).

بسته به مقدار lower داده های ورودی فقط از مثلث پایین/بالایی a خوانده می شود. مقادیر از مثلث دیگر نادیده گرفته می شوند. داده های خروجی در همان مثلث برگردانده می شوند. مقادیر در مثلث دیگر با پیاده سازی تعریف شده اند و ممکن است هر چیزی باشند.

اگر a دارای ابعاد بیشتر از 2 باشد، a به عنوان دسته ای از ماتریس ها در نظر گرفته می شود، که در آن همه ابعاد به جز 2 بعدی، ابعاد دسته ای هستند.

اگر a متقارن (Hermitian) مثبت قطعی نباشد، نتیجه اجرا تعریف می شود.

برای اطلاعات StableHLO به StableHLO - cholesky مراجعه کنید.

گیره

XlaBuilder::Clamp نیز ببینید.

یک عملوند را در محدوده بین یک مقدار حداقل و حداکثر قرار می دهد.

Clamp(min, operand, max)

استدلال ها تایپ کنید معناشناسی
min XlaOp آرایه از نوع T
operand XlaOp آرایه از نوع T
max XlaOp آرایه از نوع T

با توجه به یک عملوند و مقادیر حداقل و حداکثر، اگر در محدوده بین حداقل و حداکثر باشد، عملوند را برمی‌گرداند، در غیر این صورت اگر عملوند زیر این محدوده باشد، مقدار حداقل و اگر عملوند بالاتر از این محدوده باشد، مقدار حداکثر را برمی‌گرداند. یعنی 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)

استدلال ها تایپ کنید معناشناسی
operand XlaOp آرایه از نوع T
dimensions وکتور int64 به ترتیب، زیر مجموعه های متوالی از ابعاد T.

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)

استدلال ها تایپ کنید معناشناسی
operand XlaOp عملوند تابع

پخش جمعی

XlaBuilder::CollectiveBroadcast نیز ببینید.

داده ها را در بین کپی ها پخش می کند. داده ها از اولین شناسه replica در هر گروه به شناسه های دیگر در همان گروه ارسال می شود. اگر شناسه ماکتی در هیچ گروه ماکتی نباشد، خروجی روی آن ماکت یک تانسور متشکل از 0(s) به shape است.

CollectiveBroadcast(operand, replica_groups, channel_id)

استدلال ها تایپ کنید معناشناسی
operand XlaOp عملوند تابع
replica_groups وکتور ReplicaGroup هر گروه حاوی لیستی از شناسه های ماکت است
channel_id ChannelHandle اختیاری شناسه منحصر به فرد برای هر جفت ارسال/بازگشت

برای اطلاعات StableHLO به StableHLO - collective_broadcast مراجعه کنید.

CollectivePermute

XlaBuilder::CollectivePermute نیز ببینید.

CollectivePermute یک عملیات جمعی است که داده ها را در بین کپی ها ارسال و دریافت می کند.

CollectivePermute(operand, source_target_pairs, channel_id, inplace)

استدلال ها تایپ کنید معناشناسی
operand XlaOp n آرایه ورودی بعدی
source_target_pairs بردار <int64, int64> لیستی از جفت های (source_replica_id، target_replica_id). برای هر جفت، عملوند از replica مبدا به replica هدف ارسال می شود.
channel_id ChannelHandle اختیاری شناسه کانال اختیاری برای ارتباط متقابل ماژول
inpace bool اختیاری علامت گذاری کنید که آیا جایگشت باید در جای خود انجام شود

توجه داشته باشید که محدودیت های زیر در source_target_pairs وجود دارد:

  • هر دو جفت نباید شناسه ماکت هدف یکسانی داشته باشند، و نباید شناسه ماکت منبع یکسانی داشته باشند.
  • اگر یک Replica id در هیچ جفتی هدف نباشد، خروجی آن ماکت یک تانسور متشکل از 0(s) با همان شکل ورودی است.

API عملیات CollectivePermute به طور داخلی به 2 دستورالعمل HLO ( CollectivePermuteStart و CollectivePermuteDone ) تجزیه می شود.

HloInstruction::CreateCollectivePermuteStart نیز ببینید.

CollectivePermuteStart و CollectivePermuteDone به عنوان اولیه در HLO عمل می کنند. این عملیات ممکن است در انبارهای HLO ظاهر شوند، اما قرار نیست به صورت دستی توسط کاربران نهایی ساخته شوند.

برای اطلاعات StableHLO به StableHLO - collective_permute مراجعه کنید.

مقایسه کنید

XlaBuilder::Compare نیز ببینید.

مقایسه عنصری lhs و rhs موارد زیر را انجام می دهد:

معادله

همچنین XlaBuilder::Eq را ببینید.

از نظر عنصر برابر با مقایسه lhs و rhs انجام می دهد.

\(lhs = rhs\)

Eq(lhs, rhs)

استدلال ها تایپ کنید معناشناسی
lhs XlaOp عملوند سمت چپ: آرایه ای از نوع T
rhs XlaOp عملوند سمت چپ: آرایه ای از نوع T

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

یک نوع جایگزین با پشتیبانی پخش بعدی متفاوت برای EQ وجود دارد:

Eq(lhs,rhs, broadcast_dimensions)

استدلال ها تایپ کنید معناشناسی
LHS باسله عمل سمت چپ: آرایه ای از نوع t
RHS باسله عمل سمت چپ: آرایه ای از نوع t
broadcast_dimension چاودار کدام بعد در شکل هدف هر بعد از شکل عملگر مطابقت دارد

این نوع از عملیات باید برای عملیات حسابی بین آرایه های رده های مختلف (مانند اضافه کردن ماتریس به یک بردار) استفاده شود.

Operand Broadcast_Dimensions اضافی ، قطعه ای از اعداد صحیح است که ابعاد استفاده را برای پخش اپراند ها مشخص می کند. معناشناسی به تفصیل در صفحه پخش شرح داده شده است.

پشتیبانی از یک سفارش کلی نسبت به شماره نقطه شناور برای Eq ، با اجرای:

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

EqTotalOrder(lhs,rhs, broadcast_dimensions)

استدلال ها تایپ کنید معناشناسی
LHS باسله عمل سمت چپ: آرایه ای از نوع t
RHS باسله عمل سمت چپ: آرایه ای از نوع t
broadcast_dimension چاودار کدام بعد در شکل هدف هر بعد از شکل عملگر مطابقت دارد

برای اطلاعات StableHlo به StableHlo مراجعه کنید - مقایسه کنید .

Ne

همچنین به XlaBuilder::Ne مراجعه کنید.

عنصر عاقلانه را با مقایسه برابر با lhs و rhs انجام می دهد.

\(lhs != rhs\)

Ne(lhs, rhs)

استدلال ها تایپ کنید معناشناسی
LHS باسله عمل سمت چپ: آرایه ای از نوع t
RHS باسله عمل سمت چپ: آرایه ای از نوع t

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

یک نوع جایگزین با پشتیبانی پخش بعدی متفاوت برای NE وجود دارد:

Ne(lhs,rhs, broadcast_dimensions)

استدلال ها تایپ کنید معناشناسی
LHS باسله عمل سمت چپ: آرایه ای از نوع t
RHS باسله عمل سمت چپ: آرایه ای از نوع t
broadcast_dimension چاودار کدام بعد در شکل هدف هر بعد از شکل عملگر مطابقت دارد

این نوع از عملیات باید برای عملیات حسابی بین آرایه های رده های مختلف (مانند اضافه کردن ماتریس به یک بردار) استفاده شود.

Operand Broadcast_Dimensions اضافی ، قطعه ای از اعداد صحیح است که ابعاد استفاده را برای پخش اپراند ها مشخص می کند. معناشناسی به تفصیل در صفحه پخش شرح داده شده است.

پشتیبانی از یک سفارش کلی نسبت به شماره های شناور برای NE ، با اجرای:

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

NeTotalOrder(lhs,rhs, broadcast_dimensions)

استدلال ها تایپ کنید معناشناسی
LHS باسله عمل سمت چپ: آرایه ای از نوع t
RHS باسله عمل سمت چپ: آرایه ای از نوع t
broadcast_dimension چاودار کدام بعد در شکل هدف هر بعد از شکل عملگر مطابقت دارد

برای اطلاعات StableHlo به StableHlo مراجعه کنید - مقایسه کنید .

جنرال الکتریک

همچنین به XlaBuilder::Ge مراجعه کنید.

مقایسه عناصر عاقلانه و بیشتر از مقایسه با lhs و rhs را انجام می دهد.

\(lhs >= rhs\)

Ge(lhs, rhs)

استدلال ها تایپ کنید معناشناسی
LHS باسله عمل سمت چپ: آرایه ای از نوع t
RHS باسله عمل سمت چپ: آرایه ای از نوع t

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

یک نوع جایگزین با پشتیبانی پخش بعدی متفاوت برای GE وجود دارد:

Ge(lhs,rhs, broadcast_dimensions)

استدلال ها تایپ کنید معناشناسی
LHS باسله عمل سمت چپ: آرایه ای از نوع t
RHS باسله عمل سمت چپ: آرایه ای از نوع t
broadcast_dimension چاودار کدام بعد در شکل هدف هر بعد از شکل عملگر مطابقت دارد

این نوع از عملیات باید برای عملیات حسابی بین آرایه های رده های مختلف (مانند اضافه کردن ماتریس به یک بردار) استفاده شود.

Operand Broadcast_Dimensions اضافی ، قطعه ای از اعداد صحیح است که ابعاد استفاده را برای پخش اپراند ها مشخص می کند. معناشناسی به تفصیل در صفحه پخش شرح داده شده است.

پشتیبانی از سفارش کلی بیش از شماره های نقطه شناور برای GT ، با اجرای:

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

GtTotalOrder(lhs,rhs, broadcast_dimensions)

استدلال ها تایپ کنید معناشناسی
LHS باسله عمل سمت چپ: آرایه ای از نوع t
RHS باسله عمل سمت چپ: آرایه ای از نوع t
broadcast_dimension چاودار کدام بعد در شکل هدف هر بعد از شکل عملگر مطابقت دارد

برای اطلاعات StableHlo به StableHlo مراجعه کنید - مقایسه کنید .

GT

همچنین به XlaBuilder::Gt مراجعه کنید.

مقایسه بیشتر از عنصر مقایسه بیشتر از lhs و rhs را انجام می دهد.

\(lhs > rhs\)

Gt(lhs, rhs)

استدلال ها تایپ کنید معناشناسی
LHS باسله عمل سمت چپ: آرایه ای از نوع t
RHS باسله عمل سمت چپ: آرایه ای از نوع t

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

یک نوع جایگزین با پشتیبانی پخش بعدی متفاوت برای GT وجود دارد:

Gt(lhs,rhs, broadcast_dimensions)

استدلال ها تایپ کنید معناشناسی
LHS باسله عمل سمت چپ: آرایه ای از نوع t
RHS باسله عمل سمت چپ: آرایه ای از نوع t
broadcast_dimension چاودار کدام بعد در شکل هدف هر بعد از شکل عملگر مطابقت دارد

این نوع از عملیات باید برای عملیات حسابی بین آرایه های رده های مختلف (مانند اضافه کردن ماتریس به یک بردار) استفاده شود.

Operand Broadcast_Dimensions اضافی ، قطعه ای از اعداد صحیح است که ابعاد استفاده را برای پخش اپراند ها مشخص می کند. معناشناسی به تفصیل در صفحه پخش شرح داده شده است.

برای اطلاعات StableHlo به StableHlo مراجعه کنید - مقایسه کنید .

لی

همچنین به XlaBuilder::Le مراجعه کنید.

مقایسه عناصر عاقلانه از مقایسه با lhs و rhs را انجام می دهد.

\(lhs <= rhs\)

Le(lhs, rhs)

استدلال ها تایپ کنید معناشناسی
LHS باسله عمل سمت چپ: آرایه ای از نوع t
RHS باسله عمل سمت چپ: آرایه ای از نوع t

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

یک نوع جایگزین با پشتیبانی پخش بعدی متفاوت برای LE وجود دارد:

Le(lhs,rhs, broadcast_dimensions)

استدلال ها تایپ کنید معناشناسی
LHS باسله عمل سمت چپ: آرایه ای از نوع t
RHS باسله عمل سمت چپ: آرایه ای از نوع t
broadcast_dimension چاودار کدام بعد در شکل هدف هر بعد از شکل عملگر مطابقت دارد

این نوع از عملیات باید برای عملیات حسابی بین آرایه های رده های مختلف (مانند اضافه کردن ماتریس به یک بردار) استفاده شود.

Operand Broadcast_Dimensions اضافی ، قطعه ای از اعداد صحیح است که ابعاد استفاده را برای پخش اپراند ها مشخص می کند. معناشناسی به تفصیل در صفحه پخش شرح داده شده است.

پشتیبانی از سفارش کلی نسبت به شماره های نقطه شناور برای LE ، با اجرای:

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

LeTotalOrder(lhs,rhs, broadcast_dimensions)

استدلال ها تایپ کنید معناشناسی
LHS باسله عمل سمت چپ: آرایه ای از نوع t
RHS باسله عمل سمت چپ: آرایه ای از نوع t
broadcast_dimension چاودار کدام بعد در شکل هدف هر بعد از شکل عملگر مطابقت دارد

برای اطلاعات StableHlo به StableHlo مراجعه کنید - مقایسه کنید .

آن

همچنین به XlaBuilder::Lt مراجعه کنید.

مقایسه کمتری از عناصر lhs و rhs را انجام می دهد.

\(lhs < rhs\)

Lt(lhs, rhs)

استدلال ها تایپ کنید معناشناسی
LHS باسله عمل سمت چپ: آرایه ای از نوع t
RHS باسله عمل سمت چپ: آرایه ای از نوع t

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

یک نوع جایگزین با پشتیبانی پخش بعدی متفاوت برای LT وجود دارد:

Lt(lhs,rhs, broadcast_dimensions)

استدلال ها تایپ کنید معناشناسی
LHS باسله عمل سمت چپ: آرایه ای از نوع t
RHS باسله عمل سمت چپ: آرایه ای از نوع t
broadcast_dimension چاودار کدام بعد در شکل هدف هر بعد از شکل عملگر مطابقت دارد

این نوع از عملیات باید برای عملیات حسابی بین آرایه های رده های مختلف (مانند اضافه کردن ماتریس به یک بردار) استفاده شود.

Operand Broadcast_Dimensions اضافی ، قطعه ای از اعداد صحیح است که ابعاد استفاده را برای پخش اپراند ها مشخص می کند. معناشناسی به تفصیل در صفحه پخش شرح داده شده است.

پشتیبانی از یک سفارش کلی نسبت به شماره نقطه شناور برای LT ، با اجرای:

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

LtTotalOrder(lhs,rhs, broadcast_dimensions)

استدلال ها تایپ کنید معناشناسی
LHS باسله عمل سمت چپ: آرایه ای از نوع t
RHS باسله عمل سمت چپ: آرایه ای از نوع t
broadcast_dimension چاودار کدام بعد در شکل هدف هر بعد از شکل عملگر مطابقت دارد

برای اطلاعات StableHlo به StableHlo مراجعه کنید - مقایسه کنید .

مجتمع

همچنین به XlaBuilder::Complex مراجعه کنید.

تبدیل عنصر عاقلانه به یک مقدار پیچیده از یک جفت از مقادیر واقعی و خیالی ، lhs و rhs را انجام می دهد.

Complex(lhs, rhs)

استدلال ها تایپ کنید معناشناسی
LHS باسله عمل سمت چپ: آرایه ای از نوع t
RHS باسله عمل سمت چپ: آرایه ای از نوع t

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

یک نوع جایگزین با پشتیبانی پخش بعدی متفاوت برای پیچیده وجود دارد:

Complex(lhs,rhs, broadcast_dimensions)

استدلال ها تایپ کنید معناشناسی
LHS باسله عمل سمت چپ: آرایه ای از نوع t
RHS باسله عمل سمت چپ: آرایه ای از نوع t
broadcast_dimension چاودار کدام بعد در شکل هدف هر بعد از شکل عملگر مطابقت دارد

این نوع از عملیات باید برای عملیات حسابی بین آرایه های رده های مختلف (مانند اضافه کردن ماتریس به یک بردار) استفاده شود.

Operand Broadcast_Dimensions اضافی ، قطعه ای از اعداد صحیح است که ابعاد استفاده را برای پخش اپراند ها مشخص می کند. معناشناسی به تفصیل در صفحه پخش شرح داده شده است.

برای اطلاعات stablehlo به stablehlo - مجتمع مراجعه کنید.

concatindim (concatenate)

همچنین به XlaBuilder::ConcatInDim مراجعه کنید.

Concatenate آرایه ای را از چندین آرایه آرایه تشکیل می دهد. آرایه دارای همان ابعاد است که هر یک از آرایه های آرایه ورودی (که باید همان تعداد ابعاد را با یکدیگر داشته باشند) و حاوی آرگومان هایی به ترتیب مشخص شده است.

Concatenate(operands..., dimension)

استدلال ها تایپ کنید معناشناسی
operands دنباله n XlaOp n آرایه های نوع T با ابعاد [L0 ، L1 ، ...]. به n> = 1 نیاز دارد.
dimension int64 مقدار در فاصله [0, N) که ابعادی را که بین operands قرار می گیرد ، نامگذاری می کند.

به استثنای dimension تمام ابعاد باید یکسان باشند. این امر به این دلیل است که XLA از آرایه های "خزنده" پشتیبانی نمی کند. همچنین توجه داشته باشید که مقادیر 0 بعدی را نمی توان هماهنگ کرد (زیرا نامگذاری ابعادی که در طول آن اتفاق می افتد غیرممکن است).

مثال 1 بعدی:

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

مثال 2 بعدی:

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)

استدلال ها تایپ کنید معناشناسی
predicate XlaOp مقیاس PRED
true_operand XlaOp استدلال از نوع \(T_0\)
true_computation XlaComputation xlacomputation نوع \(T_0 \to S\)
false_operand XlaOp استدلال از نوع \(T_1\)
false_computation XlaComputation xlacomputation نوع \(T_1 \to S\)

اگر predicate true باشد ، اگر predicate false باشد ، و نتیجه را برگردانید false_computation true_computation اجرا می کند و نتیجه را برمی گرداند.

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_index XlaOp مقیاس S32
branch_computations دنباله n XlaComputation xlacomputations از نوع \(T_0 \to S , T_1 \to S , ..., T_{N-1} \to S\)
branch_operands دنباله n XlaOp استدلال از نوع \(T_0 , T_1 , ..., T_{N-1}\)

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_index ، فقط یکی از branch_computations اجرا می شود.

برای اطلاعات StableHlo به StableHlo مراجعه کنید - اگر .

ثابت

همچنین به XlaBuilder::ConstantLiteral مراجعه کنید.

output از یک literal ثابت تولید می کند.

Constant(literal)

استدلال ها تایپ کنید معناشناسی
literal LiteralSlice نمای مداوم از یک Literal موجود

برای اطلاعات StableHlo به StableHlo - ثابت مراجعه کنید.

نوع مبدل

همچنین به XlaBuilder::ConvertElementType مراجعه کنید.

ConvertElementType مشابه با یک عنصر static_cast در C ++ ، یک عمل تبدیل عنصر از یک شکل داده به شکل هدف را انجام می دهد. ابعاد باید مطابقت داشته باشد ، و تبدیل یک عنصر از نظر عناصر است. EG عناصر s32 از طریق روال تبدیل s32 -to- f32 به عناصر f32 تبدیل می شوند.

ConvertElementType(operand, new_element_type)

استدلال ها تایپ کنید معناشناسی
operand XlaOp آرایه ای از نوع T با Dims D
new_element_type PrimitiveType تو را تایپ کنید

ابعاد عمل و شکل هدف باید مطابقت داشته باشد. انواع عناصر منبع و مقصد نباید Tuples باشد.

تبدیل مانند T=s32 به U=f32 یک روال تبدیل INT به شناور نرمال کننده مانند دور به شبانه را انجام می دهد.

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 - تبدیل کنید .

Conv (Convolution)

همچنین به XlaBuilder::Conv مراجعه کنید.

محاسبه پیچ و خم از نوع مورد استفاده در شبکه های عصبی را محاسبه می کند. در اینجا ، می توان به عنوان یک پنجره N بعدی که در یک منطقه پایه n بعدی حرکت می کند ، تصور کرد و یک محاسبات برای هر موقعیت ممکن از پنجره انجام می شود.

Conv یک دستورالعمل حلقوی را بر روی محاسبه می کند ، که از اعداد ابعاد پیش فرض Convolution بدون اتساع استفاده می کند.

بالشتک به صورت کوتاه به صورت یکسان یا معتبر مشخص می شود. لنت های مشابه ورودی ( lhs ) را با صفحات به گونه ای که خروجی در هنگام عدم توجه به حساب ، همان شکل ورودی را دارد. بالشتک معتبر به سادگی به معنای بدون بالشتک است.

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

استدلال ها تایپ کنید معناشناسی
lhs XlaOp (N+2)-آرایه ای از ورودی ها
rhs XlaOp (N+2)-آرایه بعدی از وزن هسته
window_strides ArraySlice<int64> آرایه ای از گام های هسته
padding Padding نماد بالشتک
feature_group_count int64 تعداد گروه های ویژگی
batch_group_count int64 تعداد گروه های دسته ای
precision_config PrecisionConfig اختیاری enum برای سطح دقت
preferred_element_type PrimitiveType اختیاری enum از نوع عنصر مقیاس

افزایش سطح کنترل برای Conv در دسترس است:

بگذارید n تعداد ابعاد مکانی باشد. استدلال lhs یک آرایه بعدی (N+2) است که منطقه پایه را توصیف می کند. به این ورودی گفته می شود ، حتی اگر البته RHS نیز یک ورودی باشد. در یک شبکه عصبی ، اینها فعال سازی ورودی هستند. ابعاد N+2 به این ترتیب است:

  • batch : هر مختصات در این بعد نشانگر ورودی مستقل است که برای آن حلق آویز انجام می شود.
  • z/depth/features : هر موقعیت (y ، x) در ناحیه پایه دارای یک بردار مرتبط با آن است که به این بعد می رود.
  • spatial_dims : ابعاد مکانی n را توصیف می کند که ناحیه پایه ای را که پنجره از آن حرکت می کند تعریف می کند.

آرگومان rhs یک آرایه بعدی (N+2) است که توصیف فیلتر/هسته/پنجره Convolutional را توصیف می کند. ابعاد به این ترتیب است:

  • output-z : ابعاد z از خروجی.
  • input-z : اندازه این ابعاد Times feature_group_count باید با اندازه z در LHS برابر باشد.
  • spatial_dims : ابعاد مکانی n را توصیف می کند که پنجره ND را که در ناحیه پایه حرکت می کند ، تعریف می کند.

آرگومان window_strides قدم پنجره حلقوی را در ابعاد مکانی مشخص می کند. به عنوان مثال ، اگر قدم در اولین بعد فضایی 3 باشد ، پنجره فقط در مختصات قرار می گیرد که اولین شاخص مکانی توسط 3 قابل تقسیم است.

آرگومان padding میزان بالشتک صفر را که در منطقه پایه اعمال می شود ، مشخص می کند. مقدار بالشتک می تواند منفی باشد - مقدار مطلق بالشتک منفی تعداد عناصر را برای حذف از بعد مشخص شده قبل از انجام حلق آویز نشان می دهد. padding[0] بالشتک را برای ابعاد y و padding[1] بالشتک را برای ابعاد x مشخص می کند. هر جفت دارای بالشتک کم به عنوان عنصر اول و بالشتک بالا به عنوان عنصر دوم است. بالشتک کم در جهت شاخص های پایین اعمال می شود در حالی که بالشتک بالا در جهت شاخص های بالاتر اعمال می شود. به عنوان مثال ، اگر padding[1] (2,3) باشد ، در سمت چپ و 3 صفر در سمت راست در بعد مکانی دوم یک بالشتک وجود خواهد داشت. استفاده از بالشتک معادل قرار دادن همان مقادیر صفر در ورودی ( lhs ) قبل از انجام حلقوی است.

آرگومان های lhs_dilation و rhs_dilation فاکتور اتساع را که به ترتیب در LHS و RHS اعمال می شود ، به ترتیب در هر بعد فضایی مشخص می کند. اگر ضریب اتساع در یک بعد مکانی D باشد ، سوراخ های D-1 به طور ضمنی بین هر یک از ورودی ها در آن بعد قرار می گیرند و اندازه آرایه را افزایش می دهند. سوراخ ها با یک مقدار No-Op پر شده اند ، که برای Convolution به معنی صفرها است.

اتساع RHS نیز به هم می رسد. برای اطلاعات بیشتر ، به tf.nn.atrous_conv2d مراجعه کنید. اتساع LHS نیز به هم پیوسته است. برای اطلاعات بیشتر ، به 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-Th برای محاسبه 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 در LHS برابر باشد.
  • z : همان اندازه output-z در هسته ( rhs ).
  • spatial_dims : یک مقدار برای هر مکان معتبر از پنجره حلقوی.

شکل بالا نشان می دهد که چگونه قسمت batch_group_count کار می کند. به طور موثری ، ما هر دسته از LHS را به گروه های batch_group_count خرد می کنیم و همین کار را برای ویژگی های خروجی انجام می دهیم. سپس ، برای هر یک از این گروه ها ما پیچیدگی های جفت را انجام می دهیم و خروجی را در طول بعد ویژگی خروجی جمع می کنیم. معانی عملیاتی تمام ابعاد دیگر (ویژگی و مکانی) یکسان است.

مکان های معتبر پنجره حلقوی توسط گام ها و اندازه ناحیه پایه پس از بالشتک تعیین می شود.

برای توصیف آنچه که یک حلقوی انجام می دهد ، یک نتیجه 2D را در نظر بگیرید و برخی از مختصات batch ثابت ، z ، y ، x در خروجی انتخاب کنید. سپس (y,x) موقعیتی از گوشه ای از پنجره در ناحیه پایه است (به عنوان مثال گوشه سمت چپ فوقانی ، بسته به نحوه تفسیر ابعاد مکانی). اکنون یک پنجره 2D داریم که از قسمت پایه گرفته شده است ، جایی که هر نقطه 2D با یک بردار 1D همراه است ، بنابراین یک جعبه سه بعدی دریافت می کنیم. از هسته حلقوی ، از آنجا که مختصات خروجی z را ثابت کردیم ، یک جعبه سه بعدی نیز داریم. این دو جعبه ابعاد یکسانی دارند ، بنابراین می توانیم جمع محصولات عناصر عناصر بین دو جعبه (مشابه یک محصول DOT) را بگیریم. این مقدار خروجی است.

توجه داشته باشید که اگر output-z به عنوان مثال باشد ، 5 ، سپس هر موقعیت از پنجره 5 مقدار را در خروجی به بعد z از خروجی تولید می کند. این مقادیر در کدام قسمت از هسته حلقوی استفاده می شود - یک جعبه سه بعدی جداگانه از مقادیر استفاده شده برای هر مختصات output-z وجود دارد. بنابراین می توانید از آن به عنوان 5 پیچیدگی جداگانه با یک فیلتر متفاوت برای هر یک از آنها فکر کنید.

در اینجا شبه کد برای یک حلقوی 2D با بالشتک و قدم زدن وجود دارد:

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 برای نشان دادن پیکربندی دقیق استفاده می شود. این سطح نشان می دهد که آیا سخت افزار باید سعی در ایجاد دستورالعمل های کد ماشین بیشتر برای ارائه تقلید دقیق تر dtype در صورت لزوم (یعنی تقلید F32 در TPU که فقط از Matmuls BF16 پشتیبانی می کند). مقادیر ممکن است DEFAULT ، HIGH ، HIGHEST باشد. جزئیات بیشتر در بخش های MXU .

preferred_element_type یک عنصر مقیاس پذیر از انواع خروجی با دقت بالاتر/پایین است که برای تجمع استفاده می شود. preferred_element_type نوع تجمع را برای عملیات داده شده توصیه می کند ، اما تضمین نمی شود. این اجازه می دهد تا برخی از بکهای سخت افزاری در عوض در یک نوع متفاوت جمع شوند و به نوع خروجی مورد نظر تبدیل شوند.

برای اطلاعات StableHlo به StableHlo - Convolution مراجعه کنید.

convwithgeneralpadding

همچنین به XlaBuilder::ConvWithGeneralPadding مراجعه کنید.

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

همان Conv که پیکربندی بالشتک صریح است.

استدلال ها تایپ کنید معناشناسی
lhs XlaOp (N+2)-آرایه ای از ورودی ها
rhs XlaOp (N+2)-آرایه بعدی از وزن هسته
window_strides ArraySlice<int64> آرایه ای از گام های هسته
padding ArraySlice< pair<int64,int64>> آرایه ای از بالشتک (کم ، زیاد)
feature_group_count int64 تعداد گروه های ویژگی
batch_group_count int64 تعداد گروه های دسته ای
precision_config PrecisionConfig اختیاری enum برای سطح دقت
preferred_element_type PrimitiveType اختیاری enum از نوع عنصر مقیاس

convwithgeneraldimensions

همچنین به XlaBuilder::ConvWithGeneralDimensions مراجعه کنید.

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

همان Conv که اعداد ابعاد صریح است.

استدلال ها تایپ کنید معناشناسی
lhs XlaOp (N+2)-آرایه ای از ورودی ها
rhs XlaOp (N+2)-آرایه بعدی از وزن هسته
window_strides ArraySlice<int64> آرایه ای از گام های هسته
padding Padding نماد بالشتک
dimension_numbers ConvolutionDimensionNumbers تعداد ابعاد
feature_group_count int64 تعداد گروه های ویژگی
batch_group_count int64 تعداد گروه های دسته ای
precision_config PrecisionConfig اختیاری enum برای سطح دقت
preferred_element_type PrimitiveType اختیاری enum از نوع عنصر مقیاس

مربوط به

همچنین به XlaBuilder::ConvGeneral مراجعه کنید.

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

همان جا که در Conv اعداد ابعاد و پیکربندی بالشتک صریح است

استدلال ها تایپ کنید معناشناسی
lhs XlaOp (N+2)-آرایه ای از ورودی ها
rhs XlaOp (N+2)-آرایه بعدی از وزن هسته
window_strides ArraySlice<int64> آرایه ای از گام های هسته
padding ArraySlice< pair<int64,int64>> آرایه ای از بالشتک (کم ، زیاد)
dimension_numbers ConvolutionDimensionNumbers تعداد ابعاد
feature_group_count int64 تعداد گروه های ویژگی
batch_group_count int64 تعداد گروه های دسته ای
precision_config PrecisionConfig اختیاری enum برای سطح دقت
preferred_element_type PrimitiveType اختیاری enum از نوع عنصر مقیاس

مجذیه

همچنین به 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 جا که پیکربندی بالشتک ، فاکتورهای اتساع و اعداد ابعاد صریح است.

استدلال ها تایپ کنید معناشناسی
lhs XlaOp (N+2)-آرایه ای از ورودی ها
rhs XlaOp (N+2)-آرایه بعدی از وزن هسته
window_strides ArraySlice<int64> آرایه ای از گام های هسته
padding ArraySlice< pair<int64,int64>> آرایه ای از بالشتک (کم ، زیاد)
lhs_dilation ArraySlice<int64> آرایه فاکتور اتساع ND LHS
rhs_dilation ArraySlice<int64> آرایه فاکتور اتساع ND RHS
dimension_numbers ConvolutionDimensionNumbers تعداد ابعاد
feature_group_count int64 تعداد گروه های ویژگی
batch_group_count int64 تعداد گروه های دسته ای
precision_config PrecisionConfig اختیاری enum برای سطح دقت
preferred_element_type PrimitiveType اختیاری enum از نوع عنصر مقیاس
window_reversal vector<bool> پرچم برای استفاده منطقی قبل از استفاده از Concolution استفاده می شود

کپی کنید

همچنین HloInstruction::CreateCopyStart مراجعه کنید.

Copy داخلی در 2 دستورالعمل HLO CopyStart و CopyDone تجزیه شده است. Copy همراه با CopyStart و CopyDone به عنوان ابتدایی در HLO استفاده می شود. این OPS ممکن است در زباله های HLO ظاهر شود ، اما قرار نیست آنها توسط کاربران نهایی به صورت دستی ساخته شوند.

Cos

همچنین به XlaBuilder::Cos مراجعه کنید.

COSINE X- عناصر x -> cos(x) .

Cos(operand)

استدلال ها تایپ کنید معناشناسی
operand XlaOp عمل به عملکرد

COS همچنین از آرگومان اختیاری result_accuracy پشتیبانی می کند:

Cos(operand, result_accuracy)

استدلال ها تایپ کنید معناشناسی
operand XlaOp عمل به عملکرد
result_accuracy ResultAccuracy اختیاری انواع دقت که کاربر می تواند با اجرای چندگانه درخواست های Unary را درخواست کند

برای کسب اطلاعات بیشتر در مورد result_accuracy ، به دقت نتیجه مراجعه کنید.

برای اطلاعات StableHlo به StableHlo - Cosine مراجعه کنید.

کوش

همچنین به XlaBuilder::Cosh مراجعه کنید.

عناصر Hyperbolic Cosine x -> cosh(x) .

Cosh(operand)

استدلال ها تایپ کنید معناشناسی
operand XlaOp عمل به عملکرد

COSH همچنین از آرگومان اختیاری result_accuracy پشتیبانی می کند:

Cosh(operand, result_accuracy)

استدلال ها تایپ کنید معناشناسی
operand XlaOp عمل به عملکرد
result_accuracy ResultAccuracy اختیاری انواع دقت که کاربر می تواند با اجرای چندگانه درخواست های Unary را درخواست کند

برای کسب اطلاعات بیشتر در مورد result_accuracy ، به دقت نتیجه مراجعه کنید.

سفارشی

همچنین به XlaBuilder::CustomCall مراجعه کنید.

در یک محاسبه با یک تابع ارائه شده توسط کاربر تماس بگیرید.

مستندات CustomCall در جزئیات توسعه دهنده ارائه شده است - تماس های سفارشی XLA

برای اطلاعات StableHlo به StableHlo - custom_call مراجعه کنید.

بخش

همچنین به XlaBuilder::Div مراجعه کنید.

بخش عناصر عاقلانه lhs و Divisor rhs را انجام می دهد.

Div(lhs, rhs)

استدلال ها تایپ کنید معناشناسی
LHS باسله عمل سمت چپ: آرایه ای از نوع t
RHS باسله عمل سمت چپ: آرایه ای از نوع t

سرریز تقسیم بندی عدد صحیح (تقسیم/تقسیم امضا نشده/باقیمانده توسط صفر یا تقسیم شده/باقیمانده از INT_SMIN با -1 ) مقدار مشخصی را تولید می کند.

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

یک نوع جایگزین با پشتیبانی پخش بعدی متفاوت برای DIV وجود دارد:

Div(lhs,rhs, broadcast_dimensions)

استدلال ها تایپ کنید معناشناسی
LHS باسله عمل سمت چپ: آرایه ای از نوع t
RHS باسله عمل سمت چپ: آرایه ای از نوع t
broadcast_dimension چاودار کدام بعد در شکل هدف هر بعد از شکل عملگر مطابقت دارد

این نوع از عملیات باید برای عملیات حسابی بین آرایه های رده های مختلف (مانند اضافه کردن ماتریس به یک بردار) استفاده شود.

Operand Broadcast_Dimensions اضافی ، قطعه ای از اعداد صحیح است که ابعاد استفاده را برای پخش اپراند ها مشخص می کند. معناشناسی به تفصیل در صفحه پخش شرح داده شده است.

برای اطلاعات StableHlo به StableHlo - Divide مراجعه کنید.

دامنه

همچنین HloInstruction::CreateDomain مراجعه کنید.

Domain ممکن است در زباله های HLO ظاهر شود ، اما قرار نیست توسط کاربران نهایی به صورت دستی ساخته شود.

نقطه

همچنین به XlaBuilder::Dot مراجعه کنید.

Dot(lhs, rhs, precision_config, preferred_element_type)

استدلال ها تایپ کنید معناشناسی
lhs XlaOp آرایه ای از نوع t
rhs XlaOp آرایه ای از نوع t
precision_config PrecisionConfig اختیاری enum برای سطح دقت
preferred_element_type PrimitiveType اختیاری enum از نوع عنصر مقیاس

معناشناسی دقیق این عملیات به صفوف عملیات ها بستگی دارد:

ورودی خروجی معناشناسی
بردار [N] dot بردار [N] اسکالر محصول وکتور
ماتریس [MXK] وکتور dot [k] بردار [م] ضرب ماتریس-بردار
ماتریس ماتریس [MXK] dot [KXN] ماتریس [MXN] ضرب ماتریس ماتریس

این عملیات مجموع محصولات را در ابعاد دوم lhs (یا اولین مورد در صورت 1 بعد) و بعد اول rhs انجام می دهد. این ابعاد "قرارداد" است. ابعاد پیمانکاری lhs و rhs باید از همان اندازه باشد. در عمل ، می توان از آن برای انجام محصولات نقطه بین بردارها ، ضرب بردار/ماتریس یا ضرب ماتریس/ماتریس استفاده کرد.

precision_config برای نشان دادن پیکربندی دقیق استفاده می شود. این سطح نشان می دهد که آیا سخت افزار باید سعی در ایجاد دستورالعمل های کد ماشین بیشتر برای ارائه تقلید دقیق تر dtype در صورت لزوم (یعنی تقلید F32 در TPU که فقط از Matmuls BF16 پشتیبانی می کند). مقادیر ممکن است DEFAULT ، HIGH ، HIGHEST باشد. جزئیات بیشتر در بخش های MXU .

preferred_element_type یک عنصر مقیاس پذیر از انواع خروجی با دقت بالاتر/پایین است که برای تجمع استفاده می شود. preferred_element_type نوع تجمع را برای عملیات داده شده توصیه می کند ، اما تضمین نمی شود. این اجازه می دهد تا برخی از بکهای سخت افزاری در عوض در یک نوع متفاوت جمع شوند و به نوع خروجی مورد نظر تبدیل شوند.

برای اطلاعات StableHlo به StableHlo - dot مراجعه کنید.

وابسته به ضخیم

همچنین به XlaBuilder::DotGeneral مراجعه کنید.

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

استدلال ها تایپ کنید معناشناسی
lhs XlaOp آرایه ای از نوع t
rhs XlaOp آرایه ای از نوع t
dimension_numbers DotDimensionNumbers اعداد ابعاد پیمانکاری و دسته ای
precision_config PrecisionConfig اختیاری enum برای سطح دقت
preferred_element_type PrimitiveType اختیاری enum از نوع عنصر مقیاس

مشابه DOT ​​، اما اجازه می دهد تا اعداد ابعاد پیمانکاری و دسته ای برای lhs و rhs مشخص شود.

زمینه های dotdimensionNumbers تایپ کنید معناشناسی
lhs_contracting_dimensions int64 مکرر اعداد ابعاد پیمانکاری lhs
rhs_contracting_dimensions int64 مکرر اعداد ابعاد پیمانکاری rhs
lhs_batch_dimensions int64 مکرر اعداد ابعاد دسته ای lhs
rhs_batch_dimensions int64 مکرر اعداد ابعاد دسته ای 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} } }
ورودی خروجی معناشناسی
[B0 ، M ، K] dot [B0 ، K ، N] [B0 ، M ، N] دسته ماتول
[B0 ، B1 ، M ، K] dot [B0 ، B1 ، K ، N] [B0 ، B1 ، M ، N] دسته ماتول

از این رو نتیجه می گیرد که شماره بعد حاصل با بعد دسته ای ، سپس lhs بعد غیر پیمانکاری/غیر دسته ای و در نهایت بعد rhs غیر پیمانکار/غیر دسته ای شروع می شود.

precision_config برای نشان دادن پیکربندی دقیق استفاده می شود. این سطح نشان می دهد که آیا سخت افزار باید سعی در ایجاد دستورالعمل های کد ماشین بیشتر برای ارائه تقلید دقیق تر dtype در صورت لزوم (یعنی تقلید F32 در TPU که فقط از Matmuls BF16 پشتیبانی می کند). مقادیر ممکن است DEFAULT ، HIGH ، HIGHEST باشد. جزئیات اضافی را می توان در بخش های MXU یافت .

preferred_element_type یک عنصر مقیاس پذیر از انواع خروجی با دقت بالاتر/پایین است که برای تجمع استفاده می شود. preferred_element_type نوع تجمع را برای عملیات داده شده توصیه می کند ، اما تضمین نمی شود. این اجازه می دهد تا برخی از بکهای سخت افزاری در عوض در یک نوع متفاوت جمع شوند و به نوع خروجی مورد نظر تبدیل شوند.

برای اطلاعات StableHlo به StableHlo - dot_general مراجعه کنید.

در مقیاس کوچک

همچنین به XlaBuilder::ScaledDot مراجعه کنید.

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

استدلال ها تایپ کنید معناشناسی
lhs XlaOp آرایه ای از نوع t
rhs XlaOp آرایه ای از نوع t
lhs_scale XlaOp آرایه ای از نوع t
rhs_scale XlaOp آرایه ای از نوع t
dimension_number ScatterDimensionNumbers اعداد ابعاد برای عملکرد پراکندگی
precision_config PrecisionConfig enum برای سطح دقت
preferred_element_type PrimitiveType اختیاری enum از نوع عنصر مقیاس

مشابه dotgeneral .

با ابعاد پیمانکاری و دسته ای که در "DIMENSION_NUMBERS" مشخص شده است ، یک OP مقیاس مقیاس با Operands 'LHS' ، 'LHS_SCALE' ، 'RHS' و 'RHS_SCALE' ایجاد می کند.

خنجر

همچنین به XlaBuilder::RaggedDot مراجعه کنید.

برای تجزیه محاسبه RaggedDot ، به StableHlo - chlo.ragged_dot مراجعه کنید

شکل گیری پویا

همچنین به XlaBuilder::DynamicReshape مراجعه کنید.

این عمل از نظر عملکردی با تغییر شکل یکسان است ، اما شکل نتیجه به صورت پویا از طریق Output_Shape مشخص می شود.

DynamicReshape(operand, dim_sizes, new_size_bounds, dims_are_dynamic)

استدلال ها تایپ کنید معناشناسی
operand XlaOp n آرایه بعدی از نوع t
dim_sizes بردار XlaOP اندازه بردار بعدی n
new_size_bounds بردار int63 n بردار بعدی مرزها
dims_are_dynamic بردار bool n دینامیکی ابعادی کم

برای اطلاعات StableHlo به StableHlo - Dynamic_reshape مراجعه کنید.

دینامیکس

همچنین به XlaBuilder::DynamicSlice مراجعه کنید.

Dynamicslice یک زیر آرایه را از آرایه ورودی در Dynamic start_indices استخراج می کند. The size of the slice in each dimension is passed in size_indices , which specify the end point of exclusive slice intervals in each dimension: [start, start + size). The shape of start_indices must be 1-dimensional, with dimension size equal to the number of dimensions of operand .

DynamicSlice(operand, start_indices, slice_sizes)

استدلال ها تایپ کنید معناشناسی
operand XlaOp N dimensional array of type T
start_indices sequence of N XlaOp List of N scalar integers containing the starting indices of the slice for each dimension. Value must be greater than or equal to zero.
size_indices ArraySlice<int64> List of N integers containing the slice size for each dimension. Each value must be strictly greater than zero, and start + size must be less than or equal to the size of the dimension to avoid wrapping modulo dimension size.

The effective slice indices are computed by applying the following transformation for each index i in [1, N) before performing the slice:

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

This ensures that the extracted slice is always in-bounds with respect to the operand array. If the slice is in-bounds before the transformation is applied, the transformation has no effect.

1-dimensional example:

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

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

2-dimensional example:

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

For StableHLO information see StableHLO - dynamic_slice .

DynamicUpdateSlice

See also XlaBuilder::DynamicUpdateSlice .

DynamicUpdateSlice generates a result which is the value of the input array operand , with a slice update overwritten at start_indices . The shape of update determines the shape of the sub-array of the result which is updated. The shape of start_indices must be 1-dimensional, with dimension size equal to the number of dimensions of operand .

DynamicUpdateSlice(operand, update, start_indices)

استدلال ها تایپ کنید معناشناسی
operand XlaOp N dimensional array of type T
update XlaOp N dimensional array of type T containing the slice update. Each dimension of update shape must be strictly greater than zero, and start + update must be less than or equal to the operand size for each dimension to avoid generating out-of-bounds update indices.
start_indices sequence of N XlaOp List of N scalar integers containing the starting indices of the slice for each dimension. Value must be greater than or equal to zero.

The effective slice indices are computed by applying the following transformation for each index i in [1, N) before performing the slice:

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

This ensures that the updated slice is always in-bounds with respect to the operand array. If the slice is in-bounds before the transformation is applied, the transformation has no effect.

1-dimensional example:

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}

2-dimensional example:

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

For StableHLO information see StableHLO - dynamic_update_slice .

Erf

See also XlaBuilder::Erf .

Element-wise error function x -> erf(x) where:

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

Erf(operand)

استدلال ها تایپ کنید معناشناسی
operand XlaOp The operand to the function

Erf also supports the optional result_accuracy argument:

Erf(operand, result_accuracy)

استدلال ها تایپ کنید معناشناسی
operand XlaOp The operand to the function
result_accuracy optional ResultAccuracy The types of accuracy the user can request for unary ops with multiple implementations

For more information on result_accuracy see Result Accuracy .

انقضا

See also XlaBuilder::Exp .

Element-wise natural exponential x -> e^x .

Exp(operand)

استدلال ها تایپ کنید معناشناسی
operand XlaOp The operand to the function

Exp also supports the optional result_accuracy argument:

Exp(operand, result_accuracy)

استدلال ها تایپ کنید معناشناسی
operand XlaOp The operand to the function
result_accuracy optional ResultAccuracy The types of accuracy the user can request for unary ops with multiple implementations

For more information on result_accuracy see Result Accuracy .

For StableHLO information see StableHLO - exponential .

Expm1

See also XlaBuilder::Expm1 .

Element-wise natural exponential minus one x -> e^x - 1 .

Expm1(operand)

استدلال ها تایپ کنید معناشناسی
operand XlaOp The operand to the function

Expm1 also supports the optional result_accuracy argument:

Expm1(operand, result_accuracy)

استدلال ها تایپ کنید معناشناسی
operand XlaOp The operand to the function
result_accuracy optional ResultAccuracy The types of accuracy the user can request for unary ops with multiple implementations

For more information on result_accuracy see Result Accuracy .

For StableHLO information see StableHLO - exponential_minus_one .

Fft

See also XlaBuilder::Fft .

The XLA FFT operation implements the forward and inverse Fourier Transforms for real and complex inputs/outputs. Multidimensional FFTs on up to 3 axes are supported.

Fft(operand, ftt_type, fft_length)

استدلال ها تایپ کنید معناشناسی
operand XlaOp The array we are Fourier transforming.
fft_type FftType جدول زیر را ببینید.
fft_length ArraySlice<int64> The time-domain lengths of the axes being transformed. This is needed in particular for IRFFT to right-size the innermost axis, since RFFT(fft_length=[16]) has the same output shape as RFFT(fft_length=[17]) .
FftType معناشناسی
FFT Forward complex-to-complex FFT. Shape is unchanged.
IFFT Inverse complex-to-complex FFT. Shape is unchanged.
RFFT Forward real-to-complex FFT. Shape of the innermost axis is reduced to fft_length[-1] // 2 + 1 if fft_length[-1] is a non-zero value, omitting the reversed conjugate part of the transformed signal beyond the Nyquist frequency.
IRFFT Inverse real-to-complex FFT (ie takes complex, returns real). Shape of the innermost axis is expanded to fft_length[-1] if fft_length[-1] is a non-zero value, inferring the part of the transformed signal beyond the Nyquist frequency from the reverse conjugate of the 1 to fft_length[-1] // 2 + 1 entries.

For StableHLO information see StableHLO - fft .

Multidimensional FFT

When more than 1 fft_length is provided, this is equivalent to applying a cascade of FFT operations to each of the innermost axes. Note that for the real->complex and complex->real cases, the innermost axis transform is (effectively) performed first (RFFT; last for IRFFT), which is why the innermost axis is the one which changes size. Other axis transforms will then be complex->complex.

جزئیات پیاده سازی

CPU FFT is backed by Eigen's TensorFFT. GPU FFT uses cuFFT.

طبقه

See also XlaBuilder::Floor .

Element-wise floor x -> ⌊x⌋ .

Floor(operand)

استدلال ها تایپ کنید معناشناسی
operand XlaOp The operand to the function

For StableHLO information see StableHLO - floor .

فیوژن

See also HloInstruction::CreateFusion .

Fusion operation represents HLO instructions and serves as a primitive in HLO. This op may appear in HLO dumps but is not intended to be constructed manually by end users.

جمع کنید

The XLA gather operation stitches together several slices (each slice at a potentially different runtime offset) of an input array.

For StableHLO information see StableHLO - gather .

General Semantics

See also XlaBuilder::Gather . For a more intuitive description, see the "Informal Description" section below.

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

استدلال ها تایپ کنید معناشناسی
operand XlaOp The array we're gathering from.
start_indices XlaOp Array containing the starting indices of the slices we gather.
dimension_numbers GatherDimensionNumbers The dimension in start_indices that "contains" the starting indices. See below for a detailed description.
slice_sizes ArraySlice<int64> slice_sizes[i] is the bounds for the slice on dimension i .
indices_are_sorted bool Whether the indices are guaranteed to be sorted by the caller.

For convenience, we label dimensions in the output array not in offset_dims as batch_dims .

The output is an array with batch_dims.size + offset_dims.size dimensions.

The operand.rank must equal the sum of offset_dims.size and collapsed_slice_dims.size . Also, slice_sizes.size has to be equal to operand.rank .

If index_vector_dim is equal to start_indices.rank we implicitly consider start_indices to have a trailing 1 dimension (ie if start_indices was of shape [6,7] and index_vector_dim is 2 then we implicitly consider the shape of start_indices to be [6,7,1] ).

The bounds for the output array along dimension i is computed as follows:

  1. If i is present in batch_dims (ie is equal to batch_dims[k] for some k ) then we pick the corresponding dimension bounds out of start_indices.shape , skipping index_vector_dim (ie pick start_indices.shape.dims [ k ] if k < index_vector_dim and start_indices.shape.dims [ k + 1 ] otherwise).

  2. If i is present in offset_dims (ie equal to offset_dims [ k ] for some k ) then we pick the corresponding bound out of slice_sizes after accounting for collapsed_slice_dims (ie we pick adjusted_slice_sizes [ k ] where adjusted_slice_sizes is slice_sizes with the bounds at indices collapsed_slice_dims removed).

Formally, the operand index In corresponding to a given output index Out is calculated as follows:

  1. Let G = { Out [ k ] for k in batch_dims }. Use G to slice out a vector S such that S [ i ] = start_indices [Combine( G , i )] where Combine(A, b) inserts b at position index_vector_dim into A. Note that this is well defined even if G is empty: If G is empty then S = start_indices .

  2. Create a starting index, S in , into operand using S by scattering S using start_index_map . دقیق تر:

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

    2. S in [ _ ] = 0 otherwise.

  3. Create an index O in into operand by scattering the indices at the offset dimensions in Out according to the collapsed_slice_dims set. دقیق تر:

    1. O in [ remapped_offset_dims ( k )] = Out [ offset_dims [ k ]] if k < offset_dims.size ( remapped_offset_dims is defined below).

    2. O in [ _ ] = 0 otherwise.

  4. In is O in + S in where + is element-wise addition.

remapped_offset_dims is a monotonic function with domain [ 0 , offset_dims.size ) and range [ 0 , operand.rank ) \ collapsed_slice_dims . So if, eg, offset_dims.size is 4 , operand.rank is 6 and collapsed_slice_dims is { 0 , 2 } then remapped_offset_dims is { 01 , 13 , 24 , 35 }.

If indices_are_sorted is set to true then XLA can assume that start_indices are sorted (in ascending order, after scattering its values according to start_index_map ) by the user. If they are not then the semantics are implementation defined.

Informal Description and Examples

Informally, every index Out in the output array corresponds to an element E in the operand array, computed as follows:

  • We use the batch dimensions in Out to look up a starting index from start_indices .

  • We use start_index_map to map the starting index (whose size may be less than operand.rank) to a "full" starting index into the operand .

  • We dynamic-slice out a slice with size slice_sizes using the full starting index.

  • We reshape the slice by collapsing the collapsed_slice_dims dimensions. Since all collapsed slice dimensions must have a bound of 1, this reshape is always legal.

  • We use the offset dimensions in Out to index into this slice to get the input element, E , corresponding to output index Out .

index_vector_dim is set to start_indices.rank - 1 in all of the examples that follow. More interesting values for index_vector_dim do not change the operation fundamentally, but make the visual representation more cumbersome.

To get an intuition on how all of the above fits together, let's look at an example that gathers 5 slices of shape [8,6] from a [16,11] array. The position of a slice into the [16,11] array can be represented as an index vector of shape S64[2] , so the set of 5 positions can be represented as a S64[5,2] array.

The behavior of the gather operation can then be depicted as an index transformation that takes [ G , O 0 , O 1 ], an index in the output shape, and maps it to an element in the input array in the following way:

We first select an ( X , Y ) vector from the gather indices array using G . The element in the output array at index [ G , O 0 , O 1 ] is then the element in the input array at index [ X + O 0 , Y + O 1 ].

slice_sizes is [8,6] , which decides the range of O 0 and O 1 , and this in turn decides the bounds of the slice.

This gather operation acts as a batch dynamic slice with G as the batch dimension.

The gather indices may be multidimensional. For instance, a more general version of the example above using a "gather indices" array of shape [4,5,2] would translate indices like this:

Again, this acts as a batch dynamic slice G 0 and G 1 as the batch dimensions. The slice size is still [8,6] .

The gather operation in XLA generalizes the informal semantics outlined above in the following ways:

  1. We can configure which dimensions in the output shape are the offset dimensions (dimensions containing O 0 , O 1 in the last example). The output batch dimensions (dimensions containing G 0 , G 1 in the last example) are defined to be the output dimensions that are not offset dimensions.

  2. The number of output offset dimensions explicitly present in the output shape may be smaller than the input number of dimensions. These "missing" dimensions, which are listed explicitly as collapsed_slice_dims , must have a slice size of 1 . Since they have a slice size of 1 the only valid index for them is 0 and eliding them does not introduce ambiguity.

  3. The slice extracted from the "Gather Indices" array (( X , Y ) in the last example) may have fewer elements than the input array's number of dimensions, and an explicit mapping dictates how the index should be expanded to have the same number of dimensions as the input.

As a final example, we use (2) and (3) to implement tf.gather_nd :

G 0 and G 1 are used to slice out a starting index from the gather indices array as usual, except the starting index has only one element, X . Similarly, there is only one output offset index with the value O 0 . However, before being used as indices into the input array, these are expanded in accordance to "Gather Index Mapping" ( start_index_map in the formal description) and "Offset Mapping" ( remapped_offset_dims in the formal description) into [ X , 0 ] and [ 0 , O 0 ] respectively, adding up to [ X , O 0 ]. In other words, the output index [ G 0 , G 1 , O 0 ] maps to the input index [ GatherIndices [ G 0 , G 1 , 0 ], O 0 ] which gives us the semantics for tf.gather_nd .

slice_sizes for this case is [1,11] . Intuitively this means that every index X in the gather indices array picks an entire row and the result is the concatenation of all these rows.

GetDimensionSize

See also XlaBuilder::GetDimensionSize .

Returns the size of the given dimension of the operand. The operand must be array shaped.

GetDimensionSize(operand, dimension)

استدلال ها تایپ کنید معناشناسی
operand XlaOp n dimensional input array
dimension int64 A value in the interval [0, n) that specifies the dimension

For StableHLO information see StableHLO - get_dimension_size .

GetTupleElement

See also XlaBuilder::GetTupleElement .

Indexes into a tuple with a compile-time-constant value.

The value must be a compile-time-constant so that shape inference can determine the type of the resulting value.

This is analogous to std::get<int N>(t) in 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.

See also tf.tuple .

GetTupleElement(tuple_data, index)

استدلال تایپ کنید معناشناسی
tuple_data XlaOP The tuple
index int64 Index of tuple shape

For StableHLO information see StableHLO - get_tuple_element .

تصویر

See also XlaBuilder::Imag .

Element-wise imaginary part of a complex (or real) shape. x -> imag(x) . If the operand is a floating point type, returns 0.

Imag(operand)

استدلال ها تایپ کنید معناشناسی
operand XlaOp The operand to the function

For StableHLO information see StableHLO - imag .

Infeed

See also XlaBuilder::Infeed .

Infeed(shape, config)

استدلال تایپ کنید معناشناسی
shape Shape Shape of the data read from the Infeed interface. The layout field of the shape must be set to match the layout of the data sent to the device; otherwise its behavior is undefined.
config optional string Configuration of the op.

Reads a single data item from the implicit Infeed streaming interface of the device, interpreting the data as the given shape and its layout, and returns a XlaOp of the data. Multiple Infeed operations are allowed in a computation, but there must be a total order among the Infeed operations. For example, two Infeed 's in the code below have a total order since there is a dependency between the while loops.

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

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

Nested tuple shapes are not supported. For an empty tuple shape, the Infeed operation is effectively a no-op and proceeds without reading any data from the Infeed of the device.

For StableHLO information see StableHLO - infeed .

آیوتا

See also XlaBuilder::Iota .

Iota(shape, iota_dimension)

Builds a constant literal on device rather than a potentially large host transfer. Creates an array that has specified shape and holds values starting at zero and incrementing by one along the specified dimension. For floating-point types, the produced array is equivalent to ConvertElementType(Iota(...)) where the Iota is of integral type and the conversion is to the floating-point type.

استدلال ها تایپ کنید معناشناسی
shape Shape Shape of the array created by Iota()
iota_dimension int64 The dimension to increment along.

For example, Iota(s32[4, 8], 0) returns

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

[[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 ]]

For StableHLO information see StableHLO - iota .

IsFinite

See also XlaBuilder::IsFinite .

Tests whether each element of operand is finite, ie, is not positive or negative infinity, and is not NaN . Returns an array of PRED values with the same shape as the input, where each element is true if and only if the corresponding input element is finite.

IsFinite(operand)

استدلال ها تایپ کنید معناشناسی
operand XlaOp The operand to the function

For StableHLO information see StableHLO - is_finite .

ورود به سیستم

See also XlaBuilder::Log .

Element-wise natural logarithm x -> ln(x) .

Log(operand)

استدلال ها تایپ کنید معناشناسی
operand XlaOp The operand to the function

Log also supports the optional result_accuracy argument:

Log(operand, result_accuracy)

استدلال ها تایپ کنید معناشناسی
operand XlaOp The operand to the function
result_accuracy optional ResultAccuracy The types of accuracy the user can request for unary ops with multiple implementations

For more information on result_accuracy see Result Accuracy .

For StableHLO information see StableHLO - log .

Log1p

See also XlaBuilder::Log1p .

Element-wise shifted natural logarithm x -> ln(1+x) .

Log1p(operand)

استدلال ها تایپ کنید معناشناسی
operand XlaOp The operand to the function

Log1p also supports the optional result_accuracy argument:

Log1p(operand, result_accuracy)

استدلال ها تایپ کنید معناشناسی
operand XlaOp The operand to the function
result_accuracy optional ResultAccuracy The types of accuracy the user can request for unary ops with multiple implementations

For more information on result_accuracy see Result Accuracy .

For StableHLO information see StableHLO - log_plus_one .

لجستیک

See also XlaBuilder::Logistic .

Element-wise logistic function computation x -> logistic(x) .

Logistic(operand)

استدلال ها تایپ کنید معناشناسی
operand XlaOp The operand to the function

Logistic also supports the optional result_accuracy argument:

Logistic(operand, result_accuracy)

استدلال ها تایپ کنید معناشناسی
operand XlaOp The operand to the function
result_accuracy optional ResultAccuracy The types of accuracy the user can request for unary ops with multiple implementations

For more information on result_accuracy see Result Accuracy .

For StableHLO information see StableHLO - logistic .

نقشه

See also XlaBuilder::Map .

Map(operands..., computation, dimensions)

استدلال ها تایپ کنید معناشناسی
operands sequence of N XlaOp s N arrays of types T 0..T {N-1}
computation XlaComputation Computation of type T_0, T_1, .., T_{N + M -1} -> S with N parameters of type T and M of arbitrary type.
dimensions int64 array Array of map dimensions
static_operands sequence of N XlaOp s Static ops for the map operation

Applies a scalar function over the given operands arrays, producing an array of the same dimensions where each element is the result of the mapped function applied to the corresponding elements in the input arrays.

The mapped function is an arbitrary computation with the restriction that it has N inputs of scalar type T and a single output with type S . The output has the same dimensions as the operands except that the element type T is replaced with S.

For example: Map(op1, op2, op3, computation, par1) maps elem_out <- computation(elem1, elem2, elem3, par1) at each (multi-dimensional) index in the input arrays to produce the output array.

For StableHLO information see StableHLO - map .

حداکثر

See also XlaBuilder::Max .

Performs element-wise max operation on tensors lhs and rhs .

Max(lhs, rhs)

استدلال ها تایپ کنید معناشناسی
lhs XlaOp Left-hand-side operand: array of type T
rhs XlaOp Left-hand-side operand: array of type T

The arguments' shapes have to be either similar or compatible. See the broadcasting documentation about what it means for shapes to be compatible. The result of an operation has a shape which is the result of broadcasting the two input arrays. In this variant, operations between arrays of different ranks are not supported, unless one of the operands is a scalar.

An alternative variant with different-dimensional broadcasting support exists for Max:

Max(lhs,rhs, broadcast_dimensions)

استدلال ها تایپ کنید معناشناسی
lhs XlaOp Left-hand-side operand: array of type T
rhs XlaOp Left-hand-side operand: array of type T
broadcast_dimension ArraySlice Which dimension in the target shape each dimension of the operand shape corresponds to

This variant of the operation should be used for arithmetic operations between arrays of different ranks (such as adding a matrix to a vector).

The additional broadcast_dimensions operand is a slice of integers specifying the dimensions to use for broadcasting the operands. The semantics are described in detail on the broadcasting page .

For StableHLO information see StableHLO - maximum .

حداقل

See also XlaBuilder::Min .

Performs element-wise min operation on lhs and rhs .

Min(lhs, rhs)

استدلال ها تایپ کنید معناشناسی
lhs XlaOp Left-hand-side operand: array of type T
rhs XlaOp Left-hand-side operand: array of type T

The arguments' shapes have to be either similar or compatible. See the broadcasting documentation about what it means for shapes to be compatible. The result of an operation has a shape which is the result of broadcasting the two input arrays. In this variant, operations between arrays of different ranks are not supported, unless one of the operands is a scalar.

An alternative variant with different-dimensional broadcasting support exists for Min:

Min(lhs,rhs, broadcast_dimensions)

استدلال ها تایپ کنید معناشناسی
lhs XlaOp Left-hand-side operand: array of type T
rhs XlaOp Left-hand-side operand: array of type T
broadcast_dimension ArraySlice Which dimension in the target shape each dimension of the operand shape corresponds to

This variant of the operation should be used for arithmetic operations between arrays of different ranks (such as adding a matrix to a vector).

The additional broadcast_dimensions operand is a slice of integers specifying the dimensions to use for broadcasting the operands. The semantics are described in detail on the broadcasting page .

For StableHLO information see StableHLO - minimum .

مول

See also XlaBuilder::Mul .

Performs element-wise product of lhs and rhs .

Mul(lhs, rhs)

استدلال ها تایپ کنید معناشناسی
lhs XlaOp Left-hand-side operand: array of type T
rhs XlaOp Left-hand-side operand: array of type T

The arguments' shapes have to be either similar or compatible. See the broadcasting documentation about what it means for shapes to be compatible. The result of an operation has a shape which is the result of broadcasting the two input arrays. In this variant, operations between arrays of different ranks are not supported, unless one of the operands is a scalar.

An alternative variant with different-dimensional broadcasting support exists for Mul:

Mul(lhs,rhs, broadcast_dimensions)

استدلال ها تایپ کنید معناشناسی
lhs XlaOp Left-hand-side operand: array of type T
rhs XlaOp Left-hand-side operand: array of type T
broadcast_dimension ArraySlice Which dimension in the target shape each dimension of the operand shape corresponds to

This variant of the operation should be used for arithmetic operations between arrays of different ranks (such as adding a matrix to a vector).

The additional broadcast_dimensions operand is a slice of integers specifying the dimensions to use for broadcasting the operands. The semantics are described in detail on the broadcasting page .

For StableHLO information see StableHLO - multiply .

منفی

See also XlaBuilder::Neg .

Element-wise negation x -> -x .

Neg(operand)

استدلال ها تایپ کنید معناشناسی
operand XlaOp The operand to the function

For StableHLO information see StableHLO - negate

نه

See also XlaBuilder::Not .

Element-wise logical not x -> !(x) .

Not(operand)

استدلال ها تایپ کنید معناشناسی
operand XlaOp The operand to the function

For StableHLO information see StableHLO - not .

OptimizationBarrier

See also XlaBuilder::OptimizationBarrier .

Blocks any optimization pass from moving computations across the barrier.

OptimizationBarrier(operand)

استدلال ها تایپ کنید معناشناسی
operand XlaOp The operand to the function

Ensures that all inputs are evaluated before any operators that depend on the barrier's outputs.

For StableHLO information see StableHLO - optimization_barrier .

یا

See also XlaBuilder::Or .

Performs element-wise OR of lhs and rhs .

Or(lhs, rhs)

استدلال ها تایپ کنید معناشناسی
lhs XlaOp Left-hand-side operand: array of type T
rhs XlaOp Left-hand-side operand: array of type T

The arguments' shapes have to be either similar or compatible. See the broadcasting documentation about what it means for shapes to be compatible. The result of an operation has a shape which is the result of broadcasting the two input arrays. In this variant, operations between arrays of different ranks are not supported, unless one of the operands is a scalar.

An alternative variant with different-dimensional broadcasting support exists for Or:

Or(lhs,rhs, broadcast_dimensions)

استدلال ها تایپ کنید معناشناسی
lhs XlaOp Left-hand-side operand: array of type T
rhs XlaOp Left-hand-side operand: array of type T
broadcast_dimension ArraySlice Which dimension in the target shape each dimension of the operand shape corresponds to

This variant of the operation should be used for arithmetic operations between arrays of different ranks (such as adding a matrix to a vector).

The additional broadcast_dimensions operand is a slice of integers specifying the dimensions to use for broadcasting the operands. The semantics are described in detail on the broadcasting page .

For StableHLO information see StableHLO - or .

Outfeed

See also XlaBuilder::Outfeed .

Writes inputs to the outfeed.

Outfeed(operand, shape_with_layout, outfeed_config)

استدلال ها تایپ کنید معناشناسی
operand XlaOp array of type T
shape_with_layout Shape Defines the layout of the data transferred
outfeed_config string Constant of config for the Outfeed instruction

shape_with_layout communicates the laid out shape that we want to outfeed.

For StableHLO information see StableHLO - outfeed .

پد

See also XlaBuilder::Pad .

Pad(operand, padding_value, padding_config)

استدلال ها تایپ کنید معناشناسی
operand XlaOp array of type T
padding_value XlaOp scalar of type T to fill in the added padding
padding_config PaddingConfig padding amount on both edges (low, high) and between the elements of each dimension

Expands the given operand array by padding around the array as well as between the elements of the array with the given padding_value . padding_config specifies the amount of edge padding and the interior padding for each dimension.

PaddingConfig is a repeated field of PaddingConfigDimension , which contains three fields for each dimension: edge_padding_low , edge_padding_high , and interior_padding .

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

interior_padding specifies the amount of padding added between any two elements in each dimension; it may not be negative. Interior padding occurs logically before edge padding, so in the case of negative edge padding, elements are removed from the interior-padded operand.

This operation is a no-op if the edge padding pairs are all (0, 0) and the interior padding values are all 0. The figure below shows examples of different edge_padding and interior_padding values for a two-dimensional array.

For StableHLO information see StableHLO - pad .

پارامتر

See also XlaBuilder::Parameter .

Parameter represents an argument input to a computation.

PartitionID

See also XlaBuilder::BuildPartitionId .

Produces partition_id of the current process.

PartitionID(shape)

استدلال ها تایپ کنید معناشناسی
shape Shape Shape of the data

PartitionID may appear in HLO dumps but it is not intended to be constructed manually by end users.

For StableHLO information see StableHLO - partition_id .

PopulationCount

See also XlaBuilder::PopulationCount .

Computes the number of bits set in each element of operand .

PopulationCount(operand)

استدلال ها تایپ کنید معناشناسی
operand XlaOp The operand to the function

For StableHLO information see StableHLO - popcnt .

پاو

See also XlaBuilder::Pow .

Performs element-wise exponentiation of lhs by rhs .

Pow(lhs, rhs)

استدلال ها تایپ کنید معناشناسی
lhs XlaOp Left-hand-side operand: array of type T
rhs XlaOp Left-hand-side operand: array of type T

The arguments' shapes have to be either similar or compatible. See the broadcasting documentation about what it means for shapes to be compatible. The result of an operation has a shape which is the result of broadcasting the two input arrays. In this variant, operations between arrays of different ranks are not supported, unless one of the operands is a scalar.

An alternative variant with different-dimensional broadcasting support exists for Pow:

Pow(lhs,rhs, broadcast_dimensions)

استدلال ها تایپ کنید معناشناسی
lhs XlaOp Left-hand-side operand: array of type T
rhs XlaOp Left-hand-side operand: array of type T
broadcast_dimension ArraySlice Which dimension in the target shape each dimension of the operand shape corresponds to

This variant of the operation should be used for arithmetic operations between arrays of different ranks (such as adding a matrix to a vector).

The additional broadcast_dimensions operand is a slice of integers specifying the dimensions to use for broadcasting the operands. The semantics are described in detail on the broadcasting page .

For StableHLO information see StableHLO - power .

واقعی

See also XlaBuilder::Real .

Element-wise real part of a complex (or real) shape. x -> real(x) . If the operand is a floating point type, Real returns the same value.

Real(operand)

استدلال ها تایپ کنید معناشناسی
operand XlaOp The operand to the function

For StableHLO information see StableHLO - real .

recv

See also XlaBuilder::Recv .

Recv , RecvWithTokens , and RecvToHost are operations that serve as communication primitives in HLO. These ops typically appear in HLO dumps as part of low-level input/output or cross-device transfer, but they are not intended to be constructed manually by end users.

Recv(shape, handle)

استدلال ها تایپ کنید معناشناسی
shape Shape shape of the data to receive
handle ChannelHandle unique identifier for each send/recv pair

Receives data of the given shape from a Send instruction in another computation that shares the same channel handle. Returns a XlaOp for the received data.

For StableHLO information see StableHLO - recv .

RecvDone

See also HloInstruction::CreateRecv and HloInstruction::CreateRecvDone .

Similar to Send , the client API of Recv operation represents synchronous communication. However, the instruction is internally decomposed into 2 HLO instructions ( Recv and RecvDone ) to enable asynchronous data transfers.

Recv(const Shape& shape, int64 channel_id)

Allocates resources required to receive data from a Send instruction with the same channel_id. Returns a context for the allocated resources, which is used by a following RecvDone instruction to wait for the completion of the data transfer. The context is a tuple of {receive buffer (shape), request identifier (U32)} and it can only be used by a RecvDone instruction.

Given a context created by a Recv instruction, waits for the data transfer to complete and return the received data.

کاهش دهید

See also XlaBuilder::Reduce .

Applies a reduction function to one or more arrays in parallel.

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

استدلال ها تایپ کنید معناشناسی
operands Sequence of N XlaOp N arrays of types T_0,..., T_{N-1} .
init_values Sequence of N XlaOp N scalars of types T_0,..., T_{N-1} .
computation XlaComputation computation of type T_0,..., T_{N-1}, T_0, ...,T_{N-1} -> Collate(T_0,..., T_{N-1}) .
dimensions_to_reduce int64 array unordered array of dimensions to reduce.

کجا:

  • N is required to be greater or equal to 1.
  • The computation has to be "roughly" associative (see below).
  • All input arrays must have the same dimensions.
  • All initial values have to form an identity under computation .
  • If N = 1 , Collate(T) is T .
  • If N > 1 , Collate(T_0, ..., T_{N-1}) is a tuple of N elements of type T .

This operation reduces one or more dimensions of each input array into scalars. The number of dimensions of each returned array is number_of_dimensions(operand) - len(dimensions) . The output of the op is Collate(Q_0, ..., Q_N) where Q_i is an array of type T_i , the dimensions of which are described below.

Different backends are allowed to reassociate the reduction computation. This can lead to numerical differences, as some reduction functions like addition are not associative for floats. However, if the range of the data is limited, floating-point addition is close enough to be associative for most practical uses.

For StableHLO information see StableHLO - reduce .

نمونه ها

When reducing across one dimension in a single 1D array with values [10, 11, 12, 13] , with reduction function f (this is computation ) then that could be computed as

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

but there are also many other possibilities, eg

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

The following is a rough pseudo-code example of how reduction could be implemented, using summation as the reduction computation with an initial value of 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]

Here's an example of reducing a 2D array (matrix). The shape has 2 dimensions, dimension 0 of size 2 and dimension 1 of size 3:

Results of reducing dimensions 0 or 1 with an "add" function:

Note that both reduction results are 1D arrays. The diagram shows one as column and another as row just for visual convenience.

For a more complex example, here is a 3D array. Its number of dimensions is 3, dimension 0 of size 4, dimension 1 of size 2 and dimension 2 of size 3. For simplicity, the values 1 to 6 are replicated across dimension 0.

Similarly to the 2D example, we can reduce just one dimension. If we reduce dimension 0, for example, we get a 2-dimensional array where all values across dimension 0 were folded into a scalar:

|  4   8  12 |
| 16  20  24 |

If we reduce dimension 2, we also get a 2-dimensional array where all values across dimension 2 were folded into a scalar:

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

Note that the relative order between the remaining dimensions in the input is preserved in the output, but some dimensions may get assigned new numbers (since the number of dimensions changes).

We can also reduce multiple dimensions. Add-reducing dimensions 0 and 1 produces the 1D array [20, 28, 36] .

Reducing the 3D array over all its dimensions produces the scalar 84 .

Variadic Reduce

When N > 1 , reduce function application is slightly more complex, as it is applied simultaneously to all inputs. The operands are supplied to the computation in the following order:

  • Running reduced value for the first operand
  • ...
  • Running reduced value for the N'th operand
  • Input value for the first operand
  • ...
  • Input value for the N'th operand

For example, consider the following reduction function, which can be used to compute the max and the argmax of a 1-D array in parallel:

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

For 1-D Input arrays V = Float[N], K = Int[N] , and init values I_V = Float, I_K = Int , the result f_(N-1) of reducing across the only input dimension is equivalent to the following recursive application:

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

Applying this reduction to an array of values, and an array of sequential indices (ie iota), will co-iterate over the arrays, and return a tuple containing the maximal value and the matching index.

ReducePrecision

See also XlaBuilder::ReducePrecision .

Models the effect of converting floating-point values to a lower-precision format (such as IEEE-FP16) and back to the original format. The number of exponent and mantissa bits in the lower-precision format can be specified arbitrarily, although all bit sizes may not be supported on all hardware implementations.

ReducePrecision(operand, exponent_bits, mantissa_bits)

استدلال ها تایپ کنید معناشناسی
operand XlaOp array of floating-point type T .
exponent_bits int32 number of exponent bits in lower-precision format
mantissa_bits int32 number of mantissa bits in lower-precision format

The result is an array of type T . The input values are rounded to the nearest value representable with the given number of mantissa bits (using "ties to even" semantics), and any values that exceed the range specified by the number of exponent bits are clamped to positive or negative infinity. NaN values are retained, although they may be converted to canonical NaN values.

The lower-precision format must have at least one exponent bit (in order to distinguish a zero value from an infinity, since both have a zero mantissa), and must have a non-negative number of mantissa bits. The number of exponent or mantissa bits may exceed the corresponding value for type T ; the corresponding portion of the conversion is then simply a no-op.

For StableHLO information see StableHLO - reduce_precision .

ReduceScatter

See also XlaBuilder::ReduceScatter .

ReduceScatter is a collective operation that effectively does an AllReduce and then scatters the result by splitting it into shard_count blocks along the scatter_dimension and replica i in the replica group receives the ith shard.

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

استدلال ها تایپ کنید معناشناسی
operand XlaOp Array or a non-empty tuple of arrays to reduce across replicas.
computation XlaComputation Reduction computation
scatter_dimension int64 Dimension to scatter.
shard_count int64 Number of blocks to split scatter_dimension
replica_groups ReplicaGroup vector Groups between which the reductions are performed
channel_id optional ChannelHandle Optional channel ID for cross-module communication
layout optional Layout user-specified memory layout
use_global_device_ids optional bool user-specified flag
  • When operand is a tuple of arrays, the reduce-scatter is performed on each element of the tuple.
  • replica_groups is a list of replica groups between which the reduction is performed (replica id for the current replica can be retrieved using ReplicaId ). The order of replicas in each group determines the order in which the all-reduce result will be scattered. replica_groups must either be empty (in which case all replicas belong to a single group), or contain the same number of elements as the number of replicas. When there are more than one replica groups, they all must be of the same size. For example, replica_groups = {0, 2}, {1, 3} performs reduction between the replicas 0 and 2 , and 1 and 3 and then scatters the result.
  • shard_count is the size of each replica group. We need this in cases where replica_groups are empty. If replica_groups is not empty, shard_count must be equal to the size of each replica group.
  • channel_id is used for cross-module communication: only reduce-scatter operations with the same channel_id can communicate with each other.
  • layout See xla::shapes for more information on layouts.
  • use_global_device_ids is a user-specified flag. When false (default) the numbers in replica_groups are ReplicaId when true the replica_groups represent a global id of ( ReplicaID * partition_count + partition_id ). به عنوان مثال:
    • With 2 replicas and 4 partitions,
    • 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)
    • where each pair is (replica_id, partition_id).

The output shape is the input shape with the scatter_dimension made shard_count times smaller. For example, if there are two replicas and the operand has the value [1.0, 2.25] and [3.0, 5.25] respectively on the two replicas, then the output value from this op where scatter_dim is 0 will be [4.0] for the first replica and [7.5] for the second replica.

For StableHLO information see StableHLO - reduce_scatter .

ReduceScatter - Example 1 - StableHLO

An example of ReduceScatter dataflow for StableHLO

In the above example, there are 2 replicas participating in the ReduceScatter. On each replica, the operand has shape f32[2,4]. An all-reduce (sum) is performed across the replicas, producing a reduced value of shape f32[2,4] on each replica. This reduced value is then split into 2 parts along dimension 1, so each part has shape f32[2,2]. Each replica within the process group receives the part corresponding to its position in the group. As a result, the output on each replica has shape f32[2,2].

ReduceWindow

See also XlaBuilder::ReduceWindow .

Applies a reduction function to all elements in each window of a sequence of N multi-dimensional arrays, producing a single or a tuple of N multi-dimensional arrays as output. Each output array has the same number of elements as the number of valid positions of the window. A pooling layer can be expressed as a ReduceWindow . Similar to Reduce , the applied computation is always passed the init_values on the left-hand side.

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

استدلال ها تایپ کنید معناشناسی
operands N XlaOps A sequence of N multi-dimensional arrays of types T_0,..., T_{N-1} , each representing the base area on which the window is placed.
init_values N XlaOps The N starting values for the reduction, one for each of the N operands. See Reduce for details.
computation XlaComputation Reduction function of type T_0, ..., T_{N-1}, T_0, ..., T_{N-1} -> Collate(T_0, ..., T_{N-1}) , to apply to elements in each window of all the input operands.
window_dimensions ArraySlice<int64> array of integers for window dimension values
window_strides ArraySlice<int64> array of integers for window stride values
base_dilations ArraySlice<int64> array of integers for base dilation values
window_dilations ArraySlice<int64> array of integers for window dilation values
padding Padding padding type for window (Padding::kSame, which pads so as to have the same output shape as input if the stride is 1, or Padding::kValid, which uses no padding and "stops" the window once it no longer fits)

کجا:

  • N is required to be greater or equal to 1.
  • All input arrays must have the same dimensions.
  • If N = 1 , Collate(T) is T .
  • If N > 1 , Collate(T_0, ..., T_{N-1}) is a tuple of N elements of type (T0,...T{N-1}) .

For StableHLO information see StableHLO - reduce_window .

ReduceWindow - Example 1

Input is a matrix of size [4x6] and both window_dimensions and window_stride_dimensions are [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);

Stride of 1 in a dimension specifies that the position of a window in the dimension is 1 element away from its adjacent window. In order to specify that no windows overlap with each other, window_stride_dimensions should be equal to window_dimensions. The figure below illustrates the use of two different stride values. Padding is applied to each dimension of the input and the calculations are the same as though the input came in with the dimensions it has after padding.

For a non-trivial padding example, consider computing reduce-window minimum (initial value is MAX_FLOAT ) with dimension 3 and stride 2 over the input array [10000, 1000, 100, 10, 1] . Padding kValid computes minimums over two valid windows: [10000, 1000, 100] and [100, 10, 1] , resulting in the output [100, 1] . Padding kSame first pads the array so that the shape after the reduce-window would be the same as input for stride one by adding initial elements on both sides, getting [MAX_VALUE, 10000, 1000, 100, 10, 1, MAX_VALUE] . Running reduce-window over the padded array operates on three windows [MAX_VALUE, 10000, 1000] , [1000, 100, 10] , [10, 1, MAX_VALUE] , and yields [1000, 10, 1] .

The evaluation order of the reduction function is arbitrary and may be non-deterministic. Therefore, the reduction function should not be overly sensitive to reassociation. See the discussion about associativity in the context of Reduce for more details.

ReduceWindow - Example 2 - StableHLO

An example of ReduceWindow dataflow for StableHLO

In the above example:

Input) The operand has an input shape of S32[3,2]. With a values of [[1,2],[3,4],[5,6]]

Step 1) Base dilation with factor 2 along the row dimension inserts holes between each row of the operand. Padding of 2 rows at the top and 1 row at the bottom is applied after dilation. As a result, the tensor becomes taller.

Step 2) A window of shape [2,1] is defined, with window dilation [3,1]. This means each window selects two elements from the same column, but the second element is taken three rows below the first rather than directly beneath it.

Step 3) The windows are then slid across the operand with stride [4,1]. This causes the window to move down four rows at a time, while shifting one column at a time horizontally. Padding cells are filled with the init_value (in this case init_value = 0 ). Values 'falling into' dilation cells are ignored. Because of the stride and padding, some windows overlap only zeros and holes, while others overlap real input values.

Step 4) Within each window, the elements are combined using the reduction function (a, b) → a + b, starting from an initial value of 0. The top two windows see only padding and holes, so their results are 0. The bottom windows capture the values 3 and 4 from the input and return those as results.

Results) The final output has shape S32[2,2], with values: [[0,0],[3,4]]

رم

See also XlaBuilder::Rem .

Performs element-wise remainder of dividend lhs and divisor rhs .

The sign of the result is taken from the dividend, and the absolute value of the result is always less than the divisor's absolute value.

Rem(lhs, rhs)

استدلال ها تایپ کنید معناشناسی
lhs XlaOp Left-hand-side operand: array of type T
rhs XlaOp Left-hand-side operand: array of type T

The arguments' shapes have to be either similar or compatible. See the broadcasting documentation about what it means for shapes to be compatible. The result of an operation has a shape which is the result of broadcasting the two input arrays. In this variant, operations between arrays of different ranks are not supported, unless one of the operands is a scalar.

An alternative variant with different-dimensional broadcasting support exists for Rem:

Rem(lhs,rhs, broadcast_dimensions)

استدلال ها تایپ کنید معناشناسی
lhs XlaOp Left-hand-side operand: array of type T
rhs XlaOp Left-hand-side operand: array of type T
broadcast_dimension ArraySlice Which dimension in the target shape each dimension of the operand shape corresponds to

This variant of the operation should be used for arithmetic operations between arrays of different ranks (such as adding a matrix to a vector).

The additional broadcast_dimensions operand is a slice of integers specifying the dimensions to use for broadcasting the operands. The semantics are described in detail on the broadcasting page .

For StableHLO information see StableHLO - remainder .

ReplicaId

See also XlaBuilder::ReplicaId .

Returns the unique ID (U32 scalar) of the replica.

ReplicaId()

The unique ID of each replica is an unsigned integer in the interval [0, N) , where N is the number of replicas. Since all the replicas are running the same program, a ReplicaId() call in the program will return a different value on each replica.

For StableHLO information see StableHLO - replica_id .

تغییر شکل دهید

See also XlaBuilder::Reshape . and the Collapse operation.

Reshapes the dimensions of an array into a new configuration.

Reshape(operand, dimensions)

استدلال ها تایپ کنید معناشناسی
operand XlaOp array of type T
dimensions int64 vector vector of sizes of new dimensions

Conceptually, reshape first flattens an array into a one-dimensional vector of data values, and then refines this vector into a new shape. The input arguments are an arbitrary array of type T, a compile-time-constant vector of dimension indices, and a compile-time-constant vector of dimension sizes for the result. The dimensions vector determines the size of the output array. The value at index 0 in dimensions is the size of dimension 0, the value at index 1 is the size of dimension 1, and so on. The product of the dimensions dimensions must equal the product of the operand's dimension sizes. When refining the collapsed array into the multidimensional array defined by dimensions , the dimensions in dimensions are ordered from slowest varying (most major) and to fastest varying (most minor).

For example, let v be an array of 24 elements:

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} } };

let v012_24 = Reshape(v, {24});
then v012_24 == 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};

let v012_83 = Reshape(v, {8,3});
then v012_83 == 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} };

As a special case, reshape can transform a single-element array to a scalar and vice versa. به عنوان مثال،

Reshape(f32[1x1] { {5} }, {}) == 5;
Reshape(5, {1,1}) == f32[1x1] { {5} };

For StableHLO information see StableHLO - reshape .

Reshape (explicit)

See also XlaBuilder::Reshape .

Reshape(shape, operand)

Reshape op that uses an explicit target shape.

استدلال ها تایپ کنید معناشناسی
shape Shape Output shape of type T
operand XlaOp array of type T

Rev (reverse)

See also XlaBuilder::Rev .

Rev(operand, dimensions)

استدلال ها تایپ کنید معناشناسی
operand XlaOp array of type T
dimensions ArraySlice<int64> dimensions to reverse

Reverses the order of elements in the operand array along the specified dimensions , generating an output array of the same shape. Each element of the operand array at a multidimensional index is stored into the output array at a transformed index. The multidimensional index is transformed by reversing the index in each dimension to be reversed (ie, if a dimension of size N is one of the reversing dimensions, its index i is transformed into N - 1 - i).

One use for the Rev operation is to reverse the convolution weight array along the two window dimensions during the gradient computation in neural networks.

For StableHLO information see StableHLO - reverse .

RngNormal

See also XlaBuilder::RngNormal .

Constructs an output of a given shape with random numbers generated following the \(N(\mu, \sigma)\) normal distribution. پارامترها \(\mu\) و \(\sigma\), and output shape have to have a floating point elemental type. The parameters furthermore have to be scalar valued.

RngNormal(mu, sigma, shape)

استدلال ها تایپ کنید معناشناسی
mu XlaOp Scalar of type T specifying mean of generated numbers
sigma XlaOp Scalar of type T specifying standard deviation of generated
shape Shape Output shape of type T

For StableHLO information see StableHLO - rng .

RngUniform

See also XlaBuilder::RngUniform .

Constructs an output of a given shape with random numbers generated following the uniform distribution over the interval \([a,b)\). The parameters and output element type have to be a boolean type, an integral type or a floating point types, and the types have to be consistent. The CPU and GPU backends currently only support F64, F32, F16, BF16, S64, U64, S32 and U32. Furthermore, the parameters need to be scalar valued. اگر \(b <= a\) the result is implementation-defined.

RngUniform(a, b, shape)

استدلال ها تایپ کنید معناشناسی
a XlaOp Scalar of type T specifying lower limit of interval
b XlaOp Scalar of type T specifying upper limit of interval
shape Shape Output shape of type T

For StableHLO information see StableHLO - rng .

RngBitGenerator

See also XlaBuilder::RngBitGenerator .

Generates an output with a given shape filled with uniform random bits using the specified algorithm (or backend default) and returns an updated state (with the same shape as initial state) and the generated random data.

Initial state is the initial state of the current random number generation. It and the required shape and valid values are dependent on the algorithm used.

The output is guaranteed to be a deterministic function of the initial state but it is not guaranteed to be deterministic between backends and different compiler versions.

RngBitGenerator(algorithm, initial_state, shape)

استدلال ها تایپ کنید معناشناسی
algorithm RandomAlgorithm PRNG algorithm to be used.
initial_state XlaOp Initial state for the PRNG algorithm.
shape Shape Output shape for generated data.

Available values for algorithm :

For StableHLO information see StableHLO - rng_bit_generator .

RngGetAndUpdateState

See also HloInstruction::CreateRngGetAndUpdateState .

The API of the various Rng operations are internally decomposed into HLO instructions including RngGetAndUpdateState .

RngGetAndUpdateState serves as a primitive in HLO. This op may appear in HLO dumps, but it is not intended to be constructed manually by end users.

گرد

See also XlaBuilder::Round .

Element-wise rounding, ties away from zero.

Round(operand)

استدلال ها تایپ کنید معناشناسی
operand XlaOp The operand to the function

RoundNearestAfz

See also XlaBuilder::RoundNearestAfz .

Performs element-wise rounding towards the nearest integer, breaking ties away from zero.

RoundNearestAfz(operand)

استدلال ها تایپ کنید معناشناسی
operand XlaOp The operand to the function

For StableHLO information see StableHLO - round_nearest_afz .

RoundNearestEven

See also XlaBuilder::RoundNearestEven .

Element-wise rounding, ties to the nearest even.

RoundNearestEven(operand)

استدلال ها تایپ کنید معناشناسی
operand XlaOp The operand to the function

For StableHLO information see StableHLO - round_nearest_even .

Rsqrt

See also XlaBuilder::Rsqrt .

Element-wise reciprocal of square root operation x -> 1.0 / sqrt(x) .

Rsqrt(operand)

استدلال ها تایپ کنید معناشناسی
operand XlaOp The operand to the function

Rsqrt also supports the optional result_accuracy argument:

Rsqrt(operand, result_accuracy)

استدلال ها تایپ کنید معناشناسی
operand XlaOp The operand to the function
result_accuracy optional ResultAccuracy The types of accuracy the user can request for unary ops with multiple implementations

For more information on result_accuracy see Result Accuracy .

For StableHLO information see StableHLO - rsqrt .

پراکنده کردن

See also XlaBuilder::Scatter .

The XLA scatter operation generates a sequence of results which are the values of the input array operands , with several slices (at indices specified by scatter_indices ) updated with the sequence of values in updates using update_computation .

Scatter(operands..., scatter_indices, updates..., update_computation, dimension_numbers, indices_are_sorted, unique_indices)

استدلال ها تایپ کنید معناشناسی
operands Sequence of N XlaOp N arrays of types T_0, ..., T_N to be scattered into.
scatter_indices XlaOp Array containing the starting indices of the slices that must be scattered to.
updates Sequence of N XlaOp N arrays of types T_0, ..., T_N . updates[i] contains the values that must be used for scattering operands[i] .
update_computation XlaComputation Computation to be used for combining the existing values in the input array and the updates during scatter. This computation should be of type T_0, ..., T_N, T_0, ..., T_N -> Collate(T_0, ..., T_N) .
index_vector_dim int64 The dimension in scatter_indices that contains the starting indices.
update_window_dims ArraySlice<int64> The set of dimensions in updates shape that are window dimensions .
inserted_window_dims ArraySlice<int64> The set of window dimensions that must be inserted into updates shape.
scatter_dims_to_operand_dims ArraySlice<int64> A dimensions map from the scatter indices to the operand index space. This array is interpreted as mapping i to scatter_dims_to_operand_dims[i] . It has to be one-to-one and total.
dimension_number ScatterDimensionNumbers Dimension numbers for scatter operation
indices_are_sorted bool Whether the indices are guaranteed to be sorted by the caller.
unique_indices bool Whether the indices are guaranteed to be unique by the caller.

کجا:

  • N is required to be greater or equal to 1.
  • operands [ 0 ], ..., operands [ N-1 ] must all have the same dimensions.
  • updates [ 0 ], ..., updates [ N-1 ] must all have the same dimensions.
  • If N = 1 , Collate(T) is T .
  • If N > 1 , Collate(T_0, ..., T_N) is a tuple of N elements of type T .

If index_vector_dim is equal to scatter_indices.rank we implicitly consider scatter_indices to have a trailing 1 dimension.

We define update_scatter_dims of type ArraySlice<int64> as the set of dimensions in updates shape that are not in update_window_dims , in ascending order.

The arguments of scatter should follow these constraints:

  • Each updates array must have update_window_dims.size + scatter_indices.rank - 1 dimensions.

  • Bounds of dimension i in each updates array must conform to the following:

    • If i is present in update_window_dims (ie equal to update_window_dims [ k ] for some k ), then the bound of dimension i in updates must not exceed the corresponding bound of operand after accounting for the inserted_window_dims (ie adjusted_window_bounds [ k ], where adjusted_window_bounds contains the bounds of operand with the bounds at indices inserted_window_dims removed).
    • If i is present in update_scatter_dims (ie equal to update_scatter_dims [ k ] for some k ), then the bound of dimension i in updates must be equal to the corresponding bound of scatter_indices , skipping index_vector_dim (ie scatter_indices.shape.dims [ k ], if k < index_vector_dim and scatter_indices.shape.dims [ k+1 ] otherwise).
  • update_window_dims must be in ascending order, not have any repeating dimension numbers, and be in the range [0, updates.rank) .

  • inserted_window_dims must be in ascending order, not have any repeating dimension numbers, and be in the range [0, operand.rank) .

  • operand.rank must equal the sum of update_window_dims.size and inserted_window_dims.size .

  • scatter_dims_to_operand_dims.size must be equal to scatter_indices.shape.dims [ index_vector_dim ], and its values must be in the range [0, operand.rank) .

For a given index U in each updates array, the corresponding index I in the corresponding operands array into which this update has to be applied is computed as follows:

  1. Let G = { U [ k ] for k in update_scatter_dims }. Use G to look up an index vector S in the scatter_indices array such that S [ i ] = scatter_indices [Combine( G , i )] where Combine(A, b) inserts b at positions index_vector_dim into A.
  2. Create an index S in into operand using S by scattering S using the scatter_dims_to_operand_dims map. رسمی تر:
    1. S in [ scatter_dims_to_operand_dims [ k ]] = S [ k ] if k < scatter_dims_to_operand_dims.size .
    2. S in [ _ ] = 0 otherwise.
  3. Create an index W in into each operands array by scattering the indices at update_window_dims in U according to inserted_window_dims . رسمی تر:
    1. W in [ window_dims_to_operand_dims ( k )] = U [ k ] if k is in update_window_dims , where window_dims_to_operand_dims is the monotonic function with domain [ 0 , update_window_dims.size ) and range [ 0 , operand.rank ) \ inserted_window_dims . (For example, if update_window_dims.size is 4 , operand.rank is 6 , and inserted_window_dims is { 0 , 2 } then window_dims_to_operand_dims is { 01 , 13 , 24 , 35 }).
    2. W in [ _ ] = 0 otherwise.
  4. I is W in + S in where + is element-wise addition.

In summary, the scatter operation can be defined as follows.

  • Initialize output with operands , ie for all indices J , for all indices O in the operands [ J ] array:
    output [ J ][ O ] = operands [ J ][ O ]
  • For every index U in the updates [ J ] array and the corresponding index O in the operand [ J ] array, if O is a valid index for output :
    (output [ 0 ][ O ], ..., output [ N-1 ][ O ]) = update_computation ( output [ 0 ][ O ], ..., , output [ N-1 ][ O ], updates [ 0 ][ U ], ..., updates [ N-1 ][ U ])

The order in which updates are applied is non-deterministic. So, when multiple indices in updates refer to the same index in operands , the corresponding value in output will be non-deterministic.

Note that the first parameter that is passed into the update_computation will always be the current value from the output array and the second parameter will always be the value from the updates array. This is important specifically for cases when the update_computation is not commutative .

If indices_are_sorted is set to true then XLA can assume that scatter_indices are sorted (in ascending order, after scattering its values according to scatter_dims_to_operand_dims ) by the user. If they are not then the semantics are implementation defined.

If unique_indices is set to true then XLA can assume that all elements scattered to are unique. So XLA could use non-atomic operations. If unique_indices is set to true and the indices being scattered to are not unique then the semantics is implementation defined.

Informally, the scatter op can be viewed as an inverse of the gather op, ie the scatter op updates the elements in the input that are extracted by the corresponding gather op.

For a detailed informal description and examples, refer to the "Informal Description" section under Gather .

For StableHLO information see StableHLO - scatter .

Scatter - Example 1 - StableHLO

An example of Scatter dataflow for StableHLO

In the above image, each row of the table is an example of one update index example. Let's review stepwise from left(Update Index) to right(Result Index):

Input) input has shape S32[2,3,4,2]. scatter_indices have shape S64[2,2,3,2]. updates have shape S32[2,2,3,1,2].

Update Index) As part of the input we are given update_window_dims:[3,4] . This tell us that updates 's dim 3 and dim 4 are window dimensions, highlighted in yellow. This allows us to derive that update_scatter_dims = [0,1,2].

Update Scatter Index) Shows us the extracted updated_scatter_dims for each. (The non-yellow of column Update Index)

Start Index) Looking at the scatter_indices tensor image we can see that our values from the previous step (Update scatter Index), give us the location of the start index. From index_vector_dim we are also told the dimension of the starting_indices that contains the starting indices, which for scatter_indices is dim 3 with a size 2.

Full Start Index) scatter_dims_to_operand_dims = [2,1] tells us the first element of the index vector goes to operand dim 2. The second element of the index vector goes to operand dim 1. The remaining operand dimensions are filled with 0.

Full Batching Index) We can see the purple highlighted area is shown in this column(full batching index), the update scatter index column, and update index column.

Full Window Index) Computed from the update_window_dimensions [3,4].

Result Index) The addition of Full Start Index, Full Batching Index, and Full Window Index in the operand tensor. Notice the green highlighted regions correspond to the operand figure as well. The last row is skipped because it falls outside of operand tensor.

انتخاب کنید

See also XlaBuilder::Select .

Constructs an output array from elements of two input arrays, based on the values of a predicate array.

Select(pred, on_true, on_false)

استدلال ها تایپ کنید معناشناسی
pred XlaOp array of type PRED
on_true XlaOp array of type T
on_false XlaOp array of type T

The arrays on_true and on_false must have the same shape. This is also the shape of the output array. The array pred must have the same dimensionality as on_true and on_false , with the PRED element type.

For each element P of pred , the corresponding element of the output array is taken from on_true if the value of P is true , and from on_false if the value of P is false . As a restricted form of broadcasting , pred can be a scalar of type PRED . In this case, the output array is taken wholly from on_true if pred is true , and from on_false if pred is false .

Example with non-scalar pred :

let pred: PRED[4] = {true, false, false, true};
let v1: s32[4] = {1, 2, 3, 4};
let v2: s32[4] = {100, 200, 300, 400};
==>
Select(pred, v1, v2) = s32[4]{1, 200, 300, 4};

Example with scalar pred :

let pred: PRED = true;
let v1: s32[4] = {1, 2, 3, 4};
let v2: s32[4] = {100, 200, 300, 400};
==>
Select(pred, v1, v2) = s32[4]{1, 2, 3, 4};

Selections between tuples are supported. Tuples are considered to be scalar types for this purpose. If on_true and on_false are tuples (which must have the same shape!) then pred has to be a scalar of type PRED .

For StableHLO information see StableHLO - select

SelectAndScatter

See also XlaBuilder::SelectAndScatter .

This operation can be considered as a composite operation that first computes ReduceWindow on the operand array to select an element from each window, and then scatters the source array to the indices of the selected elements to construct an output array with the same shape as the operand array. The binary select function is used to select an element from each window by applying it across each window, and it is called with the property that the first parameter's index vector is lexicographically less than the second parameter's index vector. The select function returns true if the first parameter is selected and returns false if the second parameter is selected, and the function must hold transitivity (ie, if select(a, b) and select(b, c) are true , then select(a, c) is also true ) so that the selected element does not depend on the order of the elements traversed for a given window.

The function scatter is applied at each selected index in the output array. It takes two scalar parameters:

  1. Current value at the selected index in the output array
  2. The scatter value from source that applies to the selected index

It combines the two parameters and returns a scalar value that's used to update the value at the selected index in the output array. Initially, all indices of the output array are set to init_value .

The output array has the same shape as the operand array and the source array must have the same shape as the result of applying a ReduceWindow operation on the operand array. SelectAndScatter can be used to backpropagate the gradient values for a pooling layer in a neural network.

SelectAndScatter(operand, select, window_dimensions, window_strides, padding, source, init_value, scatter)

استدلال ها تایپ کنید معناشناسی
operand XlaOp array of type T over which the windows slide
select XlaComputation binary computation of type T, T -> PRED , to apply to all elements in each window; returns true if the first parameter is selected and returns false if the second parameter is selected
window_dimensions ArraySlice<int64> array of integers for window dimension values
window_strides ArraySlice<int64> array of integers for window stride values
padding Padding padding type for window (Padding::kSame or Padding::kValid)
source XlaOp array of type T with the values to scatter
init_value XlaOp scalar value of type T for the initial value of the output array
scatter XlaComputation binary computation of type T, T -> T , to apply each scatter source element with its destination element

The figure below shows examples of using SelectAndScatter , with the select function computing the maximal value among its parameters. Note that when the windows overlap, as in the figure (2) below, an index of the operand array may be selected multiple times by different windows. In the figure, the element of value 9 is selected by both of the top windows (blue and red) and the binary addition scatter function produces the output element of value 8 (2 + 6).

The evaluation order of the scatter function is arbitrary and may be non-deterministic. Therefore, the scatter function should not be overly sensitive to reassociation. See the discussion about associativity in the context of Reduce for more details.

For StableHLO information see StableHLO - select_and_scatter .

ارسال کنید

See also XlaBuilder::Send .

Send , SendWithTokens , and SendToHost are operations that serve as communication primitives in HLO. These ops typically appear in HLO dumps as part of low-level input/output or cross-device transfer, but they are not intended to be constructed manually by end users.

Send(operand, handle)

استدلال ها تایپ کنید معناشناسی
operand XlaOp data to send (array of type T)
handle ChannelHandle unique identifier for each send/recv pair

Sends the given operand data to a Recv instruction in another computation that shares the same channel handle. Does not return any data.

Similar to the Recv operation, the client API of Send operation represents synchronous communication, and is internally decomposed into 2 HLO instructions ( Send and SendDone ) to enable asynchronous data transfers. See also HloInstruction::CreateSend and HloInstruction::CreateSendDone .

Send(HloInstruction operand, int64 channel_id)

Initiates an asynchronous transfer of the operand to the resources allocated by the Recv instruction with the same channel id. Returns a context, which is used by a following SendDone instruction to wait for the completion of the data transfer. The context is a tuple of {operand (shape), request identifier (U32)} and it can only be used by a SendDone instruction.

For StableHLO information see StableHLO - send .

SendDone

See also HloInstruction::CreateSendDone .

SendDone(HloInstruction context)

Given a context created by a Send instruction, waits for the data transfer to complete. The instruction does not return any data.

Scheduling of channel instructions

The execution order of the 4 instructions for each channel ( Recv , RecvDone , Send , SendDone ) is as below.

  • Recv happens before Send
  • Send happens before RecvDone
  • Recv happens before RecvDone
  • Send happens before SendDone

When the backend compilers generate a linear schedule for each computation that communicates via channel instructions, there must not be cycles across the computations. For example, below schedules lead to deadlocks.

SetDimensionSize

See also XlaBuilder::SetDimensionSize .

Sets the dynamic size of XlaOp's given dimension. The operand must be array shaped.

SetDimensionSize(operand, val, dimension)

استدلال ها تایپ کنید معناشناسی
operand XlaOp n dimensional input array.
val XlaOp int32 representing the runtime dynamic size.
dimension int64 A value in the interval [0, n) that specifies the dimension.

Pass through the operand as result, with dynamic dimension tracked by the compiler.

Padded values will be ignored by downstream reduction ops.

let v: f32[10] = f32[10]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
let five: s32 = 5;
let six: s32 = 6;

// Setting dynamic dimension size doesn't change the upper bound of the static
// shape.
let padded_v_five: f32[10] = set_dimension_size(v, five, /*dimension=*/0);
let padded_v_six: f32[10] = set_dimension_size(v, six, /*dimension=*/0);

// sum == 1 + 2 + 3 + 4 + 5
let sum:f32[] = reduce_sum(padded_v_five);
// product == 1 * 2 * 3 * 4 * 5
let product:f32[] = reduce_product(padded_v_five);

// Changing padding size will yield different result.
// sum == 1 + 2 + 3 + 4 + 5 + 6
let sum:f32[] = reduce_sum(padded_v_six);

ShiftLeft

See also XlaBuilder::ShiftLeft .

Performs element-wise left-shift operation on lhs by rhs number of bits.

ShiftLeft(lhs, rhs)

استدلال ها تایپ کنید معناشناسی
lhs XlaOp Left-hand-side operand: array of type T
rhs XlaOp Left-hand-side operand: array of type T

The arguments' shapes have to be either similar or compatible. See the broadcasting documentation about what it means for shapes to be compatible. The result of an operation has a shape which is the result of broadcasting the two input arrays. In this variant, operations between arrays of different ranks are not supported, unless one of the operands is a scalar.

An alternative variant with different-dimensional broadcasting support exists for ShiftLeft:

ShiftLeft(lhs,rhs, broadcast_dimensions)

استدلال ها تایپ کنید معناشناسی
lhs XlaOp Left-hand-side operand: array of type T
rhs XlaOp Left-hand-side operand: array of type T
broadcast_dimension ArraySlice Which dimension in the target shape each dimension of the operand shape corresponds to

This variant of the operation should be used for arithmetic operations between arrays of different ranks (such as adding a matrix to a vector).

The additional broadcast_dimensions operand is a slice of integers specifying the dimensions to use for broadcasting the operands. The semantics are described in detail on the broadcasting page .

For StableHLO information see StableHLO - shift_left .

ShiftRightArithmetic

See also XlaBuilder::ShiftRightArithmetic .

Performs element-wise arithmetic right-shift operation on lhs by rhs number of bits.

ShiftRightArithmetic(lhs, rhs)

استدلال ها تایپ کنید معناشناسی
lhs XlaOp Left-hand-side operand: array of type T
rhs XlaOp Left-hand-side operand: array of type T

The arguments' shapes have to be either similar or compatible. See the broadcasting documentation about what it means for shapes to be compatible. The result of an operation has a shape which is the result of broadcasting the two input arrays. In this variant, operations between arrays of different ranks are not supported, unless one of the operands is a scalar.

An alternative variant with different-dimensional broadcasting support exists for ShiftRightArithmetic:

ShiftRightArithmetic(lhs,rhs, broadcast_dimensions)

Arguments تایپ کنید معناشناسی
lhs XlaOp Left-hand-side operand: array of type T
rhs XlaOp Left-hand-side operand: array of type T
broadcast_dimension ArraySlice Which dimension in the target shape each dimension of the operand shape corresponds to

This variant of the operation should be used for arithmetic operations between arrays of different ranks (such as adding a matrix to a vector).

The additional broadcast_dimensions operand is a slice of integers specifying the dimensions to use for broadcasting the operands. The semantics are described in detail on the broadcasting page .

For StableHLO information see StableHLO - shift_right_arithmetic .

ShiftRightLogical

See also XlaBuilder::ShiftRightLogical .

Performs element-wise logical right-shift operation on lhs by rhs number of bits.

ShiftRightLogical(lhs, rhs)

Arguments تایپ کنید معناشناسی
lhs XlaOp Left-hand-side operand: array of type T
rhs XlaOp Left-hand-side operand: array of type T

The arguments' shapes have to be either similar or compatible. See the broadcasting documentation about what it means for shapes to be compatible. The result of an operation has a shape which is the result of broadcasting the two input arrays. In this variant, operations between arrays of different ranks are not supported, unless one of the operands is a scalar.

An alternative variant with different-dimensional broadcasting support exists for ShiftRightLogical:

ShiftRightLogical(lhs,rhs, broadcast_dimensions)

Arguments تایپ کنید معناشناسی
lhs XlaOp Left-hand-side operand: array of type T
rhs XlaOp Left-hand-side operand: array of type T
broadcast_dimension ArraySlice Which dimension in the target shape each dimension of the operand shape corresponds to

This variant of the operation should be used for arithmetic operations between arrays of different ranks (such as adding a matrix to a vector).

The additional broadcast_dimensions operand is a slice of integers specifying the dimensions to use for broadcasting the operands. The semantics are described in detail on the broadcasting page .

For StableHLO information see StableHLO - shift_right_logical .

امضا کنید

See also XlaBuilder::Sign .

Sign(operand) Element-wise sign operation x -> sgn(x) where

\[\text{sgn}(x) = \begin{cases} -1 & x < 0\\ -0 & x = -0\\ NaN & x = NaN\\ +0 & x = +0\\ 1 & x > 0 \end{cases}\]

using the comparison operator of the element type of operand .

Sign(operand)

Arguments تایپ کنید معناشناسی
operand XlaOp The operand to the function

For StableHLO information see StableHLO - sign .

گناه

Sin(operand) Element-wise sine x -> sin(x) .

See also XlaBuilder::Sin .

Sin(operand)

Arguments تایپ کنید معناشناسی
operand XlaOp The operand to the function

Sin also supports the optional result_accuracy argument:

Sin(operand, result_accuracy)

Arguments تایپ کنید معناشناسی
operand XlaOp The operand to the function
result_accuracy optional ResultAccuracy The types of accuracy the user can request for unary ops with multiple implementations

For more information on result_accuracy see Result Accuracy .

For StableHLO information see StableHLO - sine .

برش

See also XlaBuilder::Slice .

Slicing extracts a sub-array from the input array. The sub-array has the same number of dimensions as the input and contains the values inside a bounding box within the input array where the dimensions and indices of the bounding box are given as arguments to the slice operation.

Slice(operand, start_indices, limit_indices, strides)

Arguments تایپ کنید معناشناسی
operand XlaOp N dimensional array of type T
start_indices ArraySlice<int64> List of N integers containing the starting indices of the slice for each dimension. Values must be greater than or equal to zero.
limit_indices ArraySlice<int64> List of N integers containing the ending indices (exclusive) for the slice for each dimension. Each value must be greater than or equal to the respective start_indices value for the dimension and less than or equal to the size of the dimension.
strides ArraySlice<int64> List of N integers that decides the input stride of the slice. The slice picks every strides[d] element in dimension d .

1-dimensional example:

let a = {0.0, 1.0, 2.0, 3.0, 4.0}
Slice(a, {2}, {4})
// Result: {2.0, 3.0}

2-dimensional example:

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

Slice(b, {2, 1}, {4, 3})
// Result:
//   { { 7.0,  8.0},
//     {10.0, 11.0} }

For StableHLO information see StableHLO - slice .

مرتب کردن

See also XlaBuilder::Sort .

Sort(operands, comparator, dimension, is_stable)

Arguments تایپ کنید معناشناسی
operands ArraySlice<XlaOp> The operands to sort.
comparator XlaComputation The comparator computation to use.
dimension int64 The dimension along which to sort.
is_stable bool Whether stable sorting should be used.

If only one operand is provided:

  • If the operand is a 1-dimensional tensor (an array), the result is a sorted array. If you want to sort the array into ascending order, the comparator should perform a less-than comparison. Formally, after the array is sorted, it holds for all index positions i, j with i < j that either comparator(value[i], value[j]) = comparator(value[j], value[i]) = false or comparator(value[i], value[j]) = true .

  • If the operand has higher number of dimensions, the operand is sorted along the provided dimension. For example, for a 2-dimensional tensor (a matrix), a dimension value of 0 will independently sort every column, and a dimension value of 1 will independently sort each row. If no dimension number is provided, then the last dimension is chosen by default. For the dimension which is sorted, the same sorting order applies as in the 1-dimensional case.

If n > 1 operands are provided:

  • All n operands must be tensors with the same dimensions. The element types of the tensors may be different.

  • All operands are sorted together, not individually. Conceptually the operands are treated as a tuple. When checking whether the elements of each operand at index positions i and j need to be swapped, the comparator is called with 2 * n scalar parameters, where parameter 2 * k corresponds to the value at position i from the k-th operand, and parameter 2 * k + 1 corresponds to the value at position j from the k-th operand. Usually, the comparator would thus compare parameters 2 * k and 2 * k + 1 with each other and possibly use other parameter pairs as tie breakers.

  • The result is a tuple that consists of the operands in sorted order (along the provided dimension, as above). The i-th operand of the tuple corresponds to the i-th operand of Sort.

For example, if there are three operands operand0 = [3, 1] , operand1 = [42, 50] , operand2 = [-3.0, 1.1] , and the comparator compares only the values of operand0 with less-than, then the output of the sort is the tuple ([1, 3], [50, 42], [1.1, -3.0]) .

If is_stable is set to true, the sort is guaranteed to be stable, that is, if there are elements which are considered to be equal by the comparator, the relative order of the equal values is preserved. Two elements e1 and e2 are equal if and only if comparator(e1, e2) = comparator(e2, e1) = false . By default, is_stable is set to false.

For StableHLO information see StableHLO - sort .

Sqrt

See also XlaBuilder::Sqrt .

Element-wise square root operation x -> sqrt(x) .

Sqrt(operand)

Arguments تایپ کنید معناشناسی
operand XlaOp The operand to the function

Sqrt also supports the optional result_accuracy argument:

Sqrt(operand, result_accuracy)

Arguments تایپ کنید معناشناسی
operand XlaOp The operand to the function
result_accuracy optional ResultAccuracy The types of accuracy the user can request for unary ops with multiple implementations

For more information on result_accuracy see Result Accuracy .

For StableHLO information see StableHLO - sqrt .

فرعی

See also XlaBuilder::Sub .

Performs element-wise subtraction of lhs and rhs .

Sub(lhs, rhs)

Arguments تایپ کنید معناشناسی
lhs XlaOp Left-hand-side operand: array of type T
rhs XlaOp Left-hand-side operand: array of type T

The arguments' shapes have to be either similar or compatible. See the broadcasting documentation about what it means for shapes to be compatible. The result of an operation has a shape which is the result of broadcasting the two input arrays. In this variant, operations between arrays of different ranks are not supported, unless one of the operands is a scalar.

An alternative variant with different-dimensional broadcasting support exists for Sub:

Sub(lhs,rhs, broadcast_dimensions)

Arguments تایپ کنید Semantics
lhs XlaOp Left-hand-side operand: array of type T
rhs XlaOp Left-hand-side operand: array of type T
broadcast_dimension ArraySlice Which dimension in the target shape each dimension of the operand shape corresponds to

This variant of the operation should be used for arithmetic operations between arrays of different ranks (such as adding a matrix to a vector).

The additional broadcast_dimensions operand is a slice of integers specifying the dimensions to use for broadcasting the operands. The semantics are described in detail on the broadcasting page .

For StableHLO information see StableHLO - subtract .

قهوهای مایل به زرد

See also XlaBuilder::Tan .

Element-wise tangent x -> tan(x) .

Tan(operand)

Arguments تایپ کنید معناشناسی
operand XlaOp The operand to the function

Tan also supports the optional result_accuracy argument:

Tan(operand, result_accuracy)

Arguments تایپ کنید معناشناسی
operand XlaOp The operand to the function
result_accuracy optional ResultAccuracy The types of accuracy the user can request for unary ops with multiple implementations

For more information on result_accuracy see Result Accuracy .

For StableHLO information see StableHLO - tan .

Tanh

See also XlaBuilder::Tanh .

Element-wise hyperbolic tangent x -> tanh(x) .

Tanh(operand)

Arguments تایپ کنید Semantics
operand XlaOp The operand to the function

Tanh also supports the optional result_accuracy argument:

Tanh(operand, result_accuracy)

Arguments تایپ کنید معناشناسی
operand XlaOp The operand to the function
result_accuracy optional ResultAccuracy The types of accuracy the user can request for unary ops with multiple implementations

For more information on result_accuracy see Result Accuracy .

For StableHLO information see StableHLO - tanh .

TopK

See also XlaBuilder::TopK .

TopK finds the values and indices of the k largest or smallest elements for the last dimension of the given tensor.

TopK(operand, k, largest)

Arguments تایپ کنید Semantics
operand XlaOp The tensor from which to extract the top k elements. The tensor must have greater or equal to one dimensions. The size of the last dimension of the tensor must be greater or equal to k .
k int64 The number of elements to extract.
largest bool Whether to extract the largest or smallest k elements.

For a 1-dimensional input tensor (an array), finds the k largest or smallest entries in the array and outputs a tuple of two arrays (values, indices) . Thus values[j] is the j -th largest/smallest entry in operand , and its index is indices[j] .

For an input tensor with more than 1 dimension, computes the top k entries along the last dimension, preserving all other dimensions (rows) in the output. Thus, for an operand of shape [A, B, ..., P, Q] where Q >= k the output is a tuple (values, indices) where:

values.shape = indices.shape = [A, B, ..., P, k]

If two elements within a row are equal, the lower-index element appears first.

جابجا شود

See also the tf.reshape operation.

Transpose(operand, permutation)

Arguments تایپ کنید Semantics
operand XlaOp The operand to transpose.
permutation ArraySlice<int64> How to permute the dimensions.

Permutes the operand dimensions with the given permutation, so ∀ i . 0 ≤ i < number of dimensions ⇒ input_dimensions[permutation[i]] = output_dimensions[i] .

This is the same as Reshape(operand, permutation, Permute(permutation, operand.shape.dimensions)).

For StableHLO information see StableHLO - transpose .

TriangularSolve

See also XlaBuilder::TriangularSolve .

Solves systems of linear equations with lower or upper triangular coefficient matrices by forward- or back-substitution. Broadcasting along leading dimensions, this routine solves one of the matrix systems op(a) * x = b , or x * op(a) = b , for the variable x , given a and b , where op(a) is either op(a) = a , or op(a) = Transpose(a) , or op(a) = Conj(Transpose(a)) .

TriangularSolve(a, b, left_side, lower, unit_diagonal, transpose_a)

Arguments تایپ کنید Semantics
a XlaOp a > 2 dimensional array of a complex or floating-point type with shape [..., M, M] .
b XlaOp a > 2 dimensional array of the same type with shape [..., M, K] if left_side is true, [..., K, M] otherwise.
left_side bool indicates whether to solve a system of the form op(a) * x = b ( true ) or x * op(a) = b ( false ).
lower bool whether to use the upper or lower triangle of a .
unit_diagonal bool if true , the diagonal elements of a are assumed to be 1 and not accessed.
transpose_a Transpose whether to use a as is, transpose it or take its conjugate transpose.

Input data is read only from the lower/upper triangle of a , depending on the value of lower . Values from the other triangle are ignored. Output data is returned in the same triangle; the values in the other triangle are implementation-defined and may be anything.

If the number of dimensions of a and b are greater than 2, they are treated as batches of matrices, where all except the minor 2 dimensions are batch dimensions. a and b must have equal batch dimensions.

For StableHLO information see StableHLO - triangular_solve .

چندتایی

See also XlaBuilder::Tuple .

A tuple containing a variable number of data handles, each of which has its own shape.

Tuple(elements)

استدلال ها تایپ کنید Semantics
elements vector of XlaOp N array of type T

This is analogous to std::tuple in 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);

Tuples can be deconstructed (accessed) via the GetTupleElement operation.

For StableHLO information see StableHLO - tuple .

در حالی که

See also XlaBuilder::While .

While(condition, body, init)

Arguments تایپ کنید Semantics
condition XlaComputation XlaComputation of type T -> PRED which defines the termination condition of the loop.
body XlaComputation XlaComputation of type T -> T which defines the body of the loop.
init T Initial value for the parameter of condition and body .

Sequentially executes the body until the condition fails. This is similar to a typical while loop in many other languages except for the differences and restrictions listed below.

  • A While node returns a value of type T , which is the result from the last execution of the body .
  • The shape of the type T is statically determined and must be the same across all iterations.

The T parameters of the computations are initialized with the init value in the first iteration and are automatically updated to the new result from body in each subsequent iteration.

One main use case of the While node is to implement the repeated execution of training in neural networks. Simplified pseudocode is shown below with a graph that represents the computation. The code can be found in while_test.cc . The type T in this example is a Tuple consisting of an int32 for the iteration count and a vector[10] for the accumulator. For 1000 iterations, the loop keeps adding a constant vector to the accumulator.

// Pseudocode for the computation.
init = {0, zero_vector[10]} // Tuple of int32 and float[10].
result = init;
while (result(0) < 1000) {
  iteration = result(0) + 1;
  new_vector = result(1) + constant_vector[10];
  result = {iteration, new_vector};
}

For StableHLO information see StableHLO - while .

Xor

See also XlaBuilder::Xor .

Performs element-wise XOR of lhs and rhs .

Xor(lhs, rhs)

Arguments تایپ کنید Semantics
lhs XlaOp Left-hand-side operand: array of type T
rhs XlaOp Left-hand-side operand: array of type T

The arguments' shapes have to be either similar or compatible. See the broadcasting documentation about what it means for shapes to be compatible. The result of an operation has a shape which is the result of broadcasting the two input arrays. In this variant, operations between arrays of different ranks are not supported, unless one of the operands is a scalar.

An alternative variant with different-dimensional broadcasting support exists for Xor:

Xor(lhs,rhs, broadcast_dimensions)

Arguments تایپ کنید معناشناسی
lhs XlaOp Left-hand-side operand: array of type T
rhs XlaOp Left-hand-side operand: array of type T
broadcast_dimension ArraySlice Which dimension in the target shape each dimension of the operand shape corresponds to

This variant of the operation should be used for arithmetic operations between arrays of different ranks (such as adding a matrix to a vector).

The additional broadcast_dimensions operand is a slice of integers specifying the dimensions to use for broadcasting the operands. The semantics are described in detail on the broadcasting page .

For StableHLO information see StableHLO - xor .