در زیر معنای عملیات تعریف شده در رابط 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 یک عملیات جمعی است که داده ها را از همه هسته ها به همه هسته ها ارسال می کند. دو فاز دارد:
- فاز پراکندگی. در هر هسته، عملوند به تعداد بلوکهای
split_count
در امتدادsplit_dimensions
تقسیم میشود، و بلوکها به همه هستهها پراکنده میشوند، به عنوان مثال، بلوک ith به هسته i ارسال میشود. - مرحله جمع آوری هر هسته بلوک های دریافتی را در امتداد
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
در مثال بالا، 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
: اندازه این ابعاد Timesfeature_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:
If
i
is present inbatch_dims
(ie is equal tobatch_dims[k]
for somek
) then we pick the corresponding dimension bounds out ofstart_indices.shape
, skippingindex_vector_dim
(ie pickstart_indices.shape.dims
[k
] ifk
<index_vector_dim
andstart_indices.shape.dims
[k
+1
] otherwise).If
i
is present inoffset_dims
(ie equal tooffset_dims
[k
] for somek
) then we pick the corresponding bound out ofslice_sizes
after accounting forcollapsed_slice_dims
(ie we pickadjusted_slice_sizes
[k
] whereadjusted_slice_sizes
isslice_sizes
with the bounds at indicescollapsed_slice_dims
removed).
Formally, the operand index In
corresponding to a given output index Out
is calculated as follows:
Let
G
= {Out
[k
] fork
inbatch_dims
}. UseG
to slice out a vectorS
such thatS
[i
] =start_indices
[Combine(G
,i
)] where Combine(A, b) inserts b at positionindex_vector_dim
into A. Note that this is well defined even ifG
is empty: IfG
is empty thenS
=start_indices
.Create a starting index,
S
in
, intooperand
usingS
by scatteringS
usingstart_index_map
. دقیق تر:S
in
[start_index_map
[k
]] =S
[k
] ifk
<start_index_map.size
.S
in
[_
] =0
otherwise.
Create an index
O
in
intooperand
by scattering the indices at the offset dimensions inOut
according to thecollapsed_slice_dims
set. دقیق تر:O
in
[remapped_offset_dims
(k
)] =Out
[offset_dims
[k
]] ifk
<offset_dims.size
(remapped_offset_dims
is defined below).O
in
[_
] =0
otherwise.
In
isO
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 { 0
→ 1
, 1
→ 3
, 2
→ 4
, 3
→ 5
}.
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 fromstart_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 theoperand
.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 indexOut
.
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:
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 containingG
0
,G
1
in the last example) are defined to be the output dimensions that are not offset dimensions.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 of1
. Since they have a slice size of1
the only valid index for them is0
and eliding them does not introduce ambiguity.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)
isT
. - If
N > 1
,Collate(T_0, ..., T_{N-1})
is a tuple ofN
elements of typeT
.
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 usingReplicaId
). 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 replicas0
and2
, and1
and3
and then scatters the result. -
shard_count
is the size of each replica group. We need this in cases wherereplica_groups
are empty. Ifreplica_groups
is not empty,shard_count
must be equal to the size of each replica group. -
channel_id
is used for cross-module communication: onlyreduce-scatter
operations with the samechannel_id
can communicate with each other. -
layout
See xla::shapes for more information on layouts. -
use_global_device_ids
is a user-specified flag. Whenfalse
(default) the numbers inreplica_groups
areReplicaId
whentrue
thereplica_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
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)
isT
. - If
N > 1
,Collate(T_0, ..., T_{N-1})
is a tuple ofN
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
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
:
rng_default
: Backend specific algorithm with backend specific shape requirements.rng_three_fry
: ThreeFry counter-based PRNG algorithm. Theinitial_state
shape isu64[2]
with arbitrary values. سالمون و همکاران SC 2011. Parallel random numbers: as easy as 1, 2, 3.rng_philox
: Philox algorithm to generate random numbers in parallel. Theinitial_state
shape isu64[3]
with arbitrary values. سالمون و همکاران SC 2011. Parallel random numbers: as easy as 1, 2, 3.
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)
isT
. - If
N > 1
,Collate(T_0, ..., T_N)
is a tuple ofN
elements of typeT
.
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 haveupdate_window_dims.size + scatter_indices.rank - 1
dimensions.Bounds of dimension
i
in eachupdates
array must conform to the following:- If
i
is present inupdate_window_dims
(ie equal toupdate_window_dims
[k
] for somek
), then the bound of dimensioni
inupdates
must not exceed the corresponding bound ofoperand
after accounting for theinserted_window_dims
(ieadjusted_window_bounds
[k
], whereadjusted_window_bounds
contains the bounds ofoperand
with the bounds at indicesinserted_window_dims
removed). - If
i
is present inupdate_scatter_dims
(ie equal toupdate_scatter_dims
[k
] for somek
), then the bound of dimensioni
inupdates
must be equal to the corresponding bound ofscatter_indices
, skippingindex_vector_dim
(iescatter_indices.shape.dims
[k
], ifk
<index_vector_dim
andscatter_indices.shape.dims
[k+1
] otherwise).
- If
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 ofupdate_window_dims.size
andinserted_window_dims.size
.scatter_dims_to_operand_dims.size
must be equal toscatter_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:
- Let
G
= {U
[k
] fork
inupdate_scatter_dims
}. UseG
to look up an index vectorS
in thescatter_indices
array such thatS
[i
] =scatter_indices
[Combine(G
,i
)] where Combine(A, b) inserts b at positionsindex_vector_dim
into A. - Create an index
S
in
intooperand
usingS
by scatteringS
using thescatter_dims_to_operand_dims
map. رسمی تر:-
S
in
[scatter_dims_to_operand_dims
[k
]] =S
[k
] ifk
<scatter_dims_to_operand_dims.size
. -
S
in
[_
] =0
otherwise.
-
- Create an index
W
in
into eachoperands
array by scattering the indices atupdate_window_dims
inU
according toinserted_window_dims
. رسمی تر:-
W
in
[window_dims_to_operand_dims
(k
)] =U
[k
] ifk
is inupdate_window_dims
, wherewindow_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, ifupdate_window_dims.size
is4
,operand.rank
is6
, andinserted_window_dims
is {0
,2
} thenwindow_dims_to_operand_dims
is {0
→1
,1
→3
,2
→4
,3
→5
}). -
W
in
[_
] =0
otherwise.
-
-
I
isW
in
+S
in
where + is element-wise addition.
In summary, the scatter operation can be defined as follows.
- Initialize
output
withoperands
, ie for all indicesJ
, for all indicesO
in theoperands
[J
] array:
output
[J
][O
] =operands
[J
][O
] - For every index
U
in theupdates
[J
] array and the corresponding indexO
in theoperand
[J
] array, ifO
is a valid index foroutput
:
(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
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:
- Current value at the selected index in the output array
- 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 beforeSend
-
Send
happens beforeRecvDone
-
Recv
happens beforeRecvDone
-
Send
happens beforeSendDone
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
withi < j
that eithercomparator(value[i], value[j]) = comparator(value[j], value[i]) = false
orcomparator(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 of1
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
andj
need to be swapped, the comparator is called with2 * n
scalar parameters, where parameter2 * k
corresponds to the value at positioni
from thek-th
operand, and parameter2 * k + 1
corresponds to the value at positionj
from thek-th
operand. Usually, the comparator would thus compare parameters2 * k
and2 * 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 thei-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 typeT
, which is the result from the last execution of thebody
. - 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 .