İşlem anlamı

Aşağıda, XlaBuilder arayüzünde tanımlanan işlemlerin semantiği açıklanmaktadır. Genellikle bu işlemler, xla_data.proto içindeki RPC arayüzünde tanımlanan işlemlerle bire bir eşlenir.

Adlandırmayla ilgili bir not: XLA'nın ele aldığı genelleştirilmiş veri türü, bazı tek tip türlerin (ör. 32 bit kayan nokta) öğelerini içeren N boyutlu bir dizidir. Belgelerde, rastgele boyutlu bir diziyi belirtmek için dizi kullanılır. Kolaylık sağlamak için özel durumlar daha spesifik ve bilinen adlara sahiptir. Örneğin, vektör 1 boyutlu bir dizi, matris ise 2 boyutlu bir dizidir.

Şekiller ve düzen ile Döşeme Düzeni'nde bir Op'un yapısı hakkında daha fazla bilgi edinin.

Mutlak

Ayrıca XlaBuilder::Abs başlıklı makaleyi inceleyin.

Öğe bazında mutlak değer x -> |x|.

Abs(operand)

StableHLO hakkında bilgi için StableHLO - abs başlıklı makaleyi inceleyin.

Ekle

Ayrıca XlaBuilder::Add başlıklı makaleyi inceleyin.

lhs ve rhs öğelerini öğe bazında toplar.

Add(lhs, rhs)

Bağımsız değişkenlerin şekilleri benzer veya uyumlu olmalıdır. Şekillerin uyumlu olmasıyla ilgili yayın dokümanlarına bakın. Bir işlemin sonucu, iki giriş dizisinin yayınlanmasıyla elde edilen bir şekle sahiptir. Bu varyantta, işlenenlerden biri skaler olmadığı sürece farklı sıralardaki diziler arasındaki işlemler desteklenmez.

Reklam için farklı boyutlu yayın desteği sunan alternatif bir varyant mevcuttur:

Add(lhs,rhs, broadcast_dimensions)

Bu işlem varyantı, farklı sıralardaki diziler arasında aritmetik işlemler (ör. matrise vektör ekleme) için kullanılmalıdır.

Ek yayın_boyutları işleneni, işlenenlerin yayınlanması için kullanılacak boyutları belirten bir tam sayı dilimidir. Semantikler, yayın sayfasında ayrıntılı olarak açıklanmaktadır.

StableHLO hakkında bilgi için StableHLO - add başlıklı makaleyi inceleyin.

AddDependency

Ayrıca HloInstruction::AddDependency başlıklı makaleyi inceleyin.

AddDependency, HLO dökümlerinde görünebilir ancak son kullanıcılar tarafından manuel olarak oluşturulması amaçlanmamıştır.

AfterAll

Ayrıca XlaBuilder::AfterAll başlıklı makaleyi inceleyin.

AfterAll, değişken sayıda jeton alır ve tek bir jeton üretir. Sıralamayı zorunlu kılmak için yan etki yaratan işlemler arasında işlenebilen temel türler olan jetonlar. AfterAll, bir dizi işlemden sonra bir işlemin sıralanması için jetonların birleştirilmesi olarak kullanılabilir.

AfterAll(tokens)

StableHLO hakkında bilgi için StableHLO - after_all başlıklı makaleyi inceleyin.

AllGather

Ayrıca XlaBuilder::AllGather başlıklı makaleyi inceleyin.

Replikalar arasında birleştirme işlemi gerçekleştirir.

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

• replica_groups, birleştirmenin gerçekleştirildiği kopya gruplarının listesidir (mevcut kopyanın kopya kimliği ReplicaId kullanılarak alınabilir). Her gruptaki kopyaların sırası, girişlerinin sonuçtaki sırasını belirler. replica_groups boş olmalıdır (bu durumda tüm replikalar tek bir gruba aittir ve 0 ile N - 1 arasında sıralanır) veya replika sayısı ile aynı sayıda öğe içermelidir. Örneğin, replica_groups = {0, 2}, {1, 3}, 0 ve 2 ile 1 ve 3 replikaları arasında birleştirme işlemi gerçekleştirir.
• shard_count, her çoğaltma grubunun boyutudur. Bu bilgi, replica_groups boş olduğunda gereklidir.
• channel_id modüller arası iletişim için kullanılır: Yalnızca aynı all-gather işlemler birbirleriyle iletişim kurabilir.channel_id
• use_global_device_ids ReplicaGroup yapılandırmasındaki kimlikler, kopya kimliği yerine (replica_id * partition_count + partition_id) değerinin genel kimliğini temsil ediyorsa doğru değerini döndürür. Bu, tüm azaltma hem bölümler arası hem de kopyalar arası olduğunda cihazların daha esnek bir şekilde gruplandırılmasını sağlar.

Çıkış şekli, giriş şeklinin all_gather_dimension katı büyüklüğündedir.shard_count Örneğin, iki kopya varsa ve işlenen, iki kopyada sırasıyla [1.0, 2.5] ve [3.0, 5.25] değerine sahipse all_gather_dim'nin 0 olduğu bu işlemden elde edilen çıkış değeri her iki kopyada da [1.0, 2.5, 3.0,5.25] olur.

AllGather API'si dahili olarak 2 HLO talimatına (AllGatherStart ve AllGatherDone) ayrıştırılır.

Ayrıca HloInstruction::CreateAllGatherStart başlıklı makaleyi inceleyin.

AllGatherStart, AllGatherDone, HLO'da temel öğeler olarak kullanılır. Bu işlemler HLO dökümlerinde görünebilir ancak son kullanıcılar tarafından manuel olarak oluşturulması amaçlanmamıştır.

StableHLO hakkında bilgi için StableHLO - all_gather başlıklı makaleyi inceleyin.

AllReduce

Ayrıca XlaBuilder::AllReduce başlıklı makaleyi inceleyin.

Kopyalar arasında özel bir hesaplama gerçekleştirir.

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

• operand, dizi demeti olduğunda, demetin her öğesi üzerinde all-reduce işlemi gerçekleştirilir.
• replica_groups, azaltmanın gerçekleştirildiği kopya gruplarının listesidir (mevcut kopyanın kopya kimliği ReplicaId kullanılarak alınabilir). replica_groups boş olmalıdır (bu durumda tüm kopyalar tek bir gruba aittir) veya kopya sayısı kadar öğe içermelidir. Örneğin, replica_groups = {0, 2}, {1, 3}, 0 ve 2 ile 1 ve 3 kopyaları arasında azaltma işlemi gerçekleştirir.
• channel_id modüller arası iletişim için kullanılır: Yalnızca aynı all-reduce işlemler birbirleriyle iletişim kurabilir.channel_id
• shape_with_layout: AllReduce'un düzenini belirtilen düzene zorlar. Bu, ayrı ayrı derlenen bir grup AllReduce işlemi için aynı düzenin kullanılmasını sağlamak amacıyla kullanılır.
• use_global_device_ids ReplicaGroup yapılandırmasındaki kimlikler, kopya kimliği yerine (replica_id * partition_count + partition_id) değerinin genel kimliğini temsil ediyorsa doğru değerini döndürür. Bu, tüm azaltma hem bölümler arası hem de kopyalar arası olduğunda cihazların daha esnek bir şekilde gruplandırılmasını sağlar.

Çıkış şekli, giriş şekliyle aynıdır. Örneğin, iki kopya varsa ve işlenen, iki kopyada sırasıyla [1.0, 2.5] ve [3.0, 5.25] değerine sahipse bu işlemden ve toplama hesaplamasından elde edilen çıkış değeri her iki kopyada da [4.0, 7.75] olur. Giriş bir demet ise çıkış da demet olur.

AllReduce işleminin sonucunu hesaplamak için her replikadan bir giriş olması gerekir. Bu nedenle, bir replika AllReduce düğümünü diğerinden daha fazla kez yürütürse önceki replika sonsuza kadar bekler. Tüm kopyalar aynı programı çalıştırdığından bu durumun gerçekleşme olasılığı düşüktür. Ancak bir while döngüsünün koşulu infeed verilerine bağlıysa ve infeed verileri while döngüsünün bir kopyada diğerinden daha fazla kez tekrarlanmasına neden oluyorsa bu durum gerçekleşebilir.

AllReduce API'si dahili olarak 2 HLO talimatına (AllReduceStart ve AllReduceDone) ayrıştırılır.

Ayrıca HloInstruction::CreateAllReduceStart başlıklı makaleyi inceleyin.

AllReduceStart ve AllReduceDone, HLO'da temel işlemler olarak kullanılır. Bu işlemler HLO dökümlerinde görünebilir ancak son kullanıcılar tarafından manuel olarak oluşturulması amaçlanmamıştır.

CrossReplicaSum

Ayrıca XlaBuilder::CrossReplicaSum başlıklı makaleyi inceleyin.

Toplama işlemiyle AllReduce gerçekleştirir.

CrossReplicaSum(operand, replica_groups)

Her bir kopya alt grubundaki işlenen değerinin toplamını döndürür. Tüm kopyalar toplama bir giriş sağlar ve tüm kopyalar her alt grup için sonuçlanan toplamı alır.

AllToAll

Ayrıca XlaBuilder::AllToAll başlıklı makaleyi inceleyin.

AllToAll, tüm çekirdeklerden tüm çekirdeklere veri gönderen toplu bir işlemdir. Bu süreç iki aşamadan oluşur:

1. Dağılma aşaması. Her çekirdekte, işlenen split_dimensions boyunca split_count sayıda bloğa bölünür ve bloklar tüm çekirdeklere dağıtılır. Örneğin, i. blok i. çekirdeğe gönderilir.
2. Toplama aşaması. Her çekirdek, alınan blokları concat_dimension boyunca birleştirir.

Katılımcı çekirdekler şu şekilde yapılandırılabilir:

• replica_groups: Her ReplicaGroup, hesaplamaya katılan kopya kimliklerinin bir listesini içerir (geçerli kopyanın kimliği ReplicaId kullanılarak alınabilir). AllToAll, belirtilen sırayla alt gruplar içinde uygulanır. Örneğin, replica_groups = { {1,2,3}, {4,5,0} }, kopyalar {1, 2, 3} içinde ve toplama aşamasında bir AllToAll uygulanacağı ve alınan blokların 1, 2, 3 sırasıyla birleştirileceği anlamına gelir. Ardından, 4, 5, 0 numaralı kopyalarda başka bir AllToAll uygulanır ve birleştirme sırası da 4, 5, 0 olur. replica_groups boşsa tüm kopyalar, görünme sırasına göre birleştirilmiş şekilde tek bir gruba aittir.

Ön koşullar:

• split_dimension üzerindeki işlenenin boyut boyutu, split_count ile bölünebilir.
• İşlenenin şekli demet değil.

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

Şekiller ve düzenler hakkında daha fazla bilgi için xla::shapes bölümüne bakın.

StableHLO hakkında bilgi için StableHLO - all_to_all başlıklı makaleyi inceleyin.

AllToAll - Example 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);

Yukarıdaki örnekte, Alltoall'a katılan 4 çekirdek vardır. Her çekirdekte, işlenen 1. boyut boyunca 4 parçaya bölünür. Bu nedenle, her parçanın şekli f32[4,4] olur. 4 bölüm tüm çekirdeklere dağıtılır. Ardından her çekirdek, alınan parçaları çekirdek 0-4 sırasıyla boyut 0 boyunca birleştirir. Bu nedenle, her çekirdekteki çıkışın şekli f32[16,4] olur.

AllToAll - Example 2 - StableHLO

Yukarıdaki örnekte, AllToAll'a katılan 2 kopya var. Her kopyada işlenen, f32[2,4] şeklindedir. İşlenen, 1. boyut boyunca 2 parçaya bölünür. Bu nedenle her parçanın şekli f32[2,2] olur. Bu iki bölüm, kopya grubundaki konumlarına göre kopyalar arasında değiştirilir. Her kopya, her iki işlenenden de kendi karşılık gelen bölümünü toplar ve bunları 0. boyut boyunca birleştirir. Sonuç olarak, her replikadaki çıkışın şekli f32[4,2] olur.

RaggedAllToAll

Ayrıca XlaBuilder::RaggedAllToAll başlıklı makaleyi inceleyin.

RaggedAllToAll, giriş ve çıkışın düzensiz tensörler olduğu toplu bir bire bir işlem gerçekleştirir.

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

Düzensiz tensörler üç tensör kümesiyle tanımlanır:

• data: datatensörü, en dış boyutu boyunca "düzensizdir". Bu boyut boyunca, dizine eklenmiş her öğe değişken boyuta sahiptir.
• offsets: offsets tensörü, data tensörünün en dıştaki boyutunu indeksler ve data tensörünün her düzensiz öğesinin başlangıç ofsetini temsil eder.
• sizes: sizes tensörü, data tensörünün her bir düzensiz öğesinin boyutunu temsil eder. Boyut, alt öğe birimleriyle belirtilir. Bir alt öğe, en dıştaki "düzensiz" boyut kaldırıldığında elde edilen "data" tensör şeklinin soneki olarak tanımlanır.
• offsets ve sizes tensörleri aynı boyutta olmalıdır.

Düzensiz tensör örneği:

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, her replikanın hedef replika çıkış perspektifinde ofsetlere sahip olacak şekilde parçalanmalıdır.

i. çıkış ofseti için mevcut kopya, input[input_offsets[i]:input_offsets[i]+input_sizes[i]] güncellemesini i. kopyaya gönderir. Bu güncelleme, i. kopyadaki output_i[output_offsets[i]:output_offsets[i]+send_sizes[i]] konumuna yazılır output.

Örneğin, 2 replikamız varsa:

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]

Düzensiz tümden tüm HLO'nun aşağıdaki bağımsız değişkenleri vardır:

• input: Düzensiz giriş verileri tensörü.
• output: Düzensiz çıkış verisi tensörü.
• input_offsets: Düzensiz giriş ofsetleri tensörü.
• send_sizes: ragged send sizes tensor.
• output_offsets: Hedef kopya çıkışındaki düzensiz ofset dizisi.
• recv_sizes: ragged recv sizes tensor.

*_offsets ve *_sizes tensörlerinin tümü aynı şekle sahip olmalıdır.

*_offsets ve *_sizes tensörleri için iki şekil desteklenir:

• [num_devices]. Burada, her bir uzak cihaza en fazla bir güncelleme gönderilebilir. Örneğin:

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], burada ragged-all-to-all, num_updates güncellemesini aynı uzak cihaza (her biri farklı uzaklıklarda) gönderebilir. Bu, kopya grubundaki her uzak cihaz için geçerlidir.

Örneğin:

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

ve

Ayrıca XlaBuilder::And başlıklı makaleyi inceleyin.

İki tensör (lhs ve rhs) üzerinde öğe bazında VE işlemi gerçekleştirir.

And(lhs, rhs)

Bağımsız değişkenlerin şekilleri benzer veya uyumlu olmalıdır. Şekillerin uyumlu olmasıyla ilgili yayın dokümanlarına bakın. Bir işlemin sonucu, iki giriş dizisinin yayınlanmasıyla elde edilen bir şekle sahiptir. Bu varyantta, işlenenlerden biri skaler olmadığı sürece farklı sıralardaki diziler arasındaki işlemler desteklenmez.

Android için farklı boyutlu yayın desteği sunan alternatif bir varyant mevcuttur:

And(lhs,rhs, broadcast_dimensions)

Bu işlem varyantı, farklı sıralardaki diziler arasında aritmetik işlemler (ör. matrise vektör ekleme) için kullanılmalıdır.

Ek yayın_boyutları işleneni, işlenenlerin yayınlanması için kullanılacak boyutları belirten bir tam sayı dilimidir. Semantikler, yayın sayfasında ayrıntılı olarak açıklanmaktadır.

StableHLO hakkında bilgi için StableHLO - and başlıklı makaleyi inceleyin.

Asenk.

Ayrıca HloInstruction::CreateAsyncStart, HloInstruction::CreateAsyncUpdate, HloInstruction::CreateAsyncDone sayfalarına da göz atın.

AsyncDone, AsyncStart ve AsyncUpdate, Asenkron işlemler için kullanılan ve HLO'da temel öğeler olarak işlev gören dahili HLO talimatlarıdır. Bu işlemler, HLO dökümlerinde görünebilir ancak son kullanıcılar tarafından manuel olarak oluşturulması amaçlanmamıştır.

Atan2

Ayrıca XlaBuilder::Atan2 başlıklı makaleyi inceleyin.

lhs ve rhs üzerinde öğe bazında atan2 işlemi gerçekleştirir.

Atan2(lhs, rhs)

Bağımsız değişkenlerin şekilleri benzer veya uyumlu olmalıdır. Şekillerin uyumlu olmasıyla ilgili yayın dokümanlarına bakın. Bir işlemin sonucu, iki giriş dizisinin yayınlanmasıyla elde edilen bir şekle sahiptir. Bu varyantta, işlenenlerden biri skaler olmadığı sürece farklı sıralardaki diziler arasındaki işlemler desteklenmez.

Atan2 için farklı boyutlu yayın desteği sunan alternatif bir varyant mevcuttur:

Atan2(lhs,rhs, broadcast_dimensions)

Bu işlem varyantı, farklı sıralardaki diziler arasında aritmetik işlemler (ör. matrise vektör ekleme) için kullanılmalıdır.

Ek yayın_boyutları işleneni, işlenenlerin yayınlanması için kullanılacak boyutları belirten bir tam sayı dilimidir. Semantikler, yayın sayfasında ayrıntılı olarak açıklanmaktadır.

StableHLO bilgileri için StableHLO - atan2 başlıklı makaleyi inceleyin.

BatchNormGrad

Algoritmanın ayrıntılı açıklaması için XlaBuilder::BatchNormGrad ve orijinal toplu normalleştirme makalesine de bakın.

Toplu normalleştirmenin gradyanlarını hesaplar.

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

İşlem, özellik boyutundaki her özellik için (feature_index, operand içindeki özellik boyutunun dizinidir) diğer tüm boyutlarda operand, offset ve scale ile ilgili gradyanları hesaplar. feature_index, operand içindeki özellik boyutu için geçerli bir dizin olmalıdır.

Üç gradyan aşağıdaki formüllerle tanımlanır (4 boyutlu bir dizinin operand olduğu ve özellik boyutu dizininin l, toplu iş boyutunun m, uzamsal boyutların w ve h olduğu varsayılır):

\[ \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 ve batch_var girişleri, toplu iş ve uzamsal boyutlardaki anlık değerleri temsil eder.

Çıkış türü, üç tutamdan oluşan bir demettir:

StableHLO hakkında bilgi için StableHLO - batch_norm_grad başlıklı makaleyi inceleyin.

BatchNormInference

Algoritmanın ayrıntılı açıklaması için XlaBuilder::BatchNormInference ve orijinal toplu normalleştirme makalesine de bakın.

Bir diziyi toplu ve uzamsal boyutlarda normalleştirir.

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

İşlem, özellik boyutundaki her özellik için (feature_index, operand içindeki özellik boyutunun dizinidir) diğer tüm boyutlardaki ortalamayı ve varyansı hesaplar ve operand içindeki her öğeyi normalleştirmek için ortalamayı ve varyansı kullanır. feature_index, operand içindeki özellik boyutu için geçerli bir dizin olmalıdır.

BatchNormInference, her bir toplu işlem için mean ve variance değerleri hesaplanmadan BatchNormTraining işlevini çağırmaya eş değerdir. Bunun yerine, tahmini değerler olarak giriş mean ve variance kullanılır. Bu işlemin amacı, çıkarım sürecindeki gecikmeyi azaltmaktır. Bu nedenle BatchNormInference olarak adlandırılır.

Çıkış, girişle operand aynı şekle sahip n boyutlu, normalleştirilmiş bir dizidir.

StableHLO bilgileri için StableHLO - batch_norm_inference başlıklı makaleyi inceleyin.

BatchNormTraining

Algoritmanın ayrıntılı açıklaması için XlaBuilder::BatchNormTraining ve the original batch normalization paper sayfalarına da bakın.

Bir diziyi toplu ve uzamsal boyutlarda normalleştirir.

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

İşlem, özellik boyutundaki her özellik için (feature_index, operand içindeki özellik boyutunun dizinidir) diğer tüm boyutlardaki ortalamayı ve varyansı hesaplar ve operand içindeki her öğeyi normalleştirmek için ortalamayı ve varyansı kullanır. feature_index, operand içindeki özellik boyutu için geçerli bir dizin olmalıdır.

operand \(x\) içinde m öğe içeren her toplu işlem için algoritma şu şekilde çalışır: w ve h, uzamsal boyutların boyutu olarak kabul edilir (operand'nın 4 boyutlu bir dizi olduğu varsayılır):

• Özellik boyutundaki her özellik l için toplu iş ortalamasını \(\mu_l\) hesaplar: \(\mu_l=\frac{1}{mwh}\sum_{i=1}^m\sum_{j=1}^w\sum_{k=1}^h x_{ijkl}\)

• Toplu varyansı hesaplar \(\sigma^2_l\): $\sigma^2l=\frac{1}{mwh}\sum{i=1}^m\sum{j=1}^w\sum{k=1}^h (x_{ijkl} - \mu_l)^2$

• Normalleştirir, ölçeklendirir ve kaydırır: \(y_{ijkl}=\frac{\gamma_l(x_{ijkl}-\mu_l)}{\sqrt[2]{\sigma^2_l+\epsilon} }+\beta_l\)

Genellikle küçük bir sayı olan epsilon değeri, sıfıra bölme hatalarını önlemek için eklenir.

Çıkış türü, üç XlaOp'dan oluşan bir demettir:

batch_mean ve batch_var, yukarıdaki formüller kullanılarak toplu ve uzamsal boyutlarda hesaplanan anlardır.

StableHLO bilgileri için StableHLO - batch_norm_training başlıklı makaleyi inceleyin.

Bitcast

Ayrıca HloInstruction::CreateBitcast başlıklı makaleyi inceleyin.

Bitcast, HLO dökümlerinde görünebilir ancak son kullanıcılar tarafından manuel olarak oluşturulması amaçlanmamıştır.

BitcastConvertType

Ayrıca XlaBuilder::BitcastConvertType başlıklı makaleyi inceleyin.

TensorFlow'daki tf.bitcast işlevine benzer şekilde, bir veri şeklinden hedef şekle öğe bazında bitcast işlemi gerçekleştirir. Giriş ve çıkış boyutu eşleşmelidir: Örneğin, bitcast rutiniyle s32 öğeleri f32 öğelerine dönüştürülür ve bir s32 öğesi dört s8 öğesine dönüşür. Bitcast, düşük düzeyli bir yayın olarak uygulanır. Bu nedenle, farklı kayan nokta gösterimlerine sahip makineler farklı sonuçlar verir.

BitcastConvertType(operand, new_element_type)

İşlenen ve hedef şeklin boyutları, son boyut hariç eşleşmelidir. Son boyut, dönüştürmeden önce ve sonraki temel boyutun oranıyla değişir.

Kaynak ve hedef öğe türleri demet olmamalıdır.

StableHLO bilgileri için StableHLO - bitcast_convert başlıklı makaleyi inceleyin.

Farklı genişlikteki temel türe bitcast dönüştürme

BitcastConvert HLO talimatı, çıkış öğesi türünün boyutunun T' giriş öğesinin boyutuna T eşit olmadığı durumu destekler. İşlemin tamamı kavramsal olarak bir bit yayın olduğundan ve temel baytları değiştirmediğinden çıkış öğesinin şekli değişmelidir. B = sizeof(T), B' = sizeof(T') için iki olası durum vardır.

İlk olarak, B > B' olduğunda çıkış şekli, B/B' boyutunda yeni bir en küçük boyuta sahip olur. Örneğin:

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

Etkili ölçeklendirme faktörleri için kural aynı kalır:

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

Alternatif olarak, B' > B için talimat, giriş şeklinin son mantıksal boyutunun B'/B'ye eşit olmasını gerektirir ve bu boyut dönüştürme sırasında bırakılır:

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

Farklı bit genişlikleri arasındaki dönüşümlerin öğe bazında olmadığını unutmayın.

Yayın

Ayrıca XlaBuilder::Broadcast başlıklı makaleyi inceleyin.

Dizideki verileri kopyalayarak diziye boyutlar ekler.

Broadcast(operand, broadcast_sizes)

Yeni boyutlar sola eklenir. Örneğin, broadcast_sizes değerleri {a0, ..., aN} içeriyorsa ve işlenen şeklin boyutları {b0, ..., bM} ise çıkışın şeklinin boyutları {a0, ..., aN, b0, ..., bM} olur.

Yeni boyutlar, işlenenin kopyalarına göre dizine eklenir. Örneğin:

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

Örneğin, operand, 2.0f değeriyle bir skaler f32 ise ve broadcast_sizes, {2, 3} ise sonuç, f32[2, 3] şekline sahip bir dizi olur ve sonuçtaki tüm değerler 2.0f olur.

StableHLO bilgileri için StableHLO - yayın başlıklı makaleyi inceleyin.

BroadcastInDim

Ayrıca XlaBuilder::BroadcastInDim başlıklı makaleyi inceleyin.

Dizideki verileri kopyalayarak dizinin boyutunu ve boyut sayısını genişletir.

BroadcastInDim(operand, out_dim_size, broadcast_dimensions)

Yayın'a benzer ancak boyutların herhangi bir yere eklenmesine ve mevcut boyutların 1 boyutla genişletilmesine olanak tanır.

operand, out_dim_size ile tanımlanan şekle yayınlanır. broadcast_dimensions, operand boyutlarını hedef şeklin boyutlarıyla eşler. Yani işlenen değerin i'inci boyutu, çıkış şeklinin broadcast_dimension[i]'inci boyutuyla eşlenir. operand boyutları 1 boyutuna sahip olmalı veya çıkış şeklindeki eşlendikleri boyutla aynı boyutta olmalıdır. Kalan boyutlar 1 boyutlu olarak doldurulur. Dejenere boyutlu yayın, çıkış şekline ulaşmak için bu dejenere boyutlar boyunca yayın yapar. Semantikler, yayın sayfasında ayrıntılı olarak açıklanmıştır.

Telefon

Ayrıca XlaBuilder::Call başlıklı makaleyi inceleyin.

Belirtilen bağımsız değişkenlerle bir hesaplama başlatır.

Call(computation, operands...)

operands öğesinin arite ve türleri, computation öğesinin parametreleriyle eşleşmelidir. operands olmamasına izin verilir.

CompositeCall

Ayrıca XlaBuilder::CompositeCall başlıklı makaleyi inceleyin.

Diğer StableHLO işlemlerinden oluşan (oluşturulan) bir işlemi kapsar, girişleri ve composite_attributes'i alır ve sonuçlar üretir. İşlemin semantiği, ayrıştırma özelliğiyle uygulanır. Birleşik işlem, program semantiğini değiştirmeden ayrıştırılmış haliyle değiştirilebilir. Ayrıştırmanın satır içine yerleştirilmesinin aynı işlem anlamlarını sağlamadığı durumlarda custom_call kullanmayı tercih edin.

Sürüm alanı (varsayılan olarak 0'dır), bir bileşiğin semantiğinin ne zaman değiştiğini belirtmek için kullanılır.

Bu işlem, is_composite=true özelliğine sahip bir kCall olarak uygulanır. decomposition alanı, computation özelliğiyle belirtilir. Ön uç özellikleri, composite. ile başlayan kalan özellikleri depolar.

Örnek CompositeCall işlemi:

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)

Bir işlemin decomposition alanı, çağrılan bir alan değildir.Bunun yerine, daha düşük düzeyli uygulamayı içeren işleve işaret eden bir to_apply özelliği olarak görünür. Örneğin: to_apply=%funcname

Birleştirme ve ayrıştırma hakkında daha fazla bilgiyi StableHLO Spesifikasyonu'nda bulabilirsiniz.

Cbrt

Ayrıca XlaBuilder::Cbrt başlıklı makaleyi inceleyin.

Öğe bazında küp kök işlemi x -> cbrt(x).

Cbrt(operand)

Cbrt, isteğe bağlı result_accuracy bağımsız değişkenini de destekler:

Cbrt(operand, result_accuracy)

result_accuracy hakkında daha fazla bilgi için Sonuç Doğruluğu başlıklı makaleyi inceleyin.

StableHLO hakkında bilgi için StableHLO - cbrt başlıklı makaleye bakın.

Tavan

Ayrıca XlaBuilder::Ceil başlıklı makaleyi inceleyin.

Öğe bazında tavan x -> ⌈x⌉.

Ceil(operand)

StableHLO bilgileri için StableHLO - ceil başlıklı makaleyi inceleyin.

Cholesky

Ayrıca XlaBuilder::Cholesky başlıklı makaleyi inceleyin.

Bir grup simetrik (Hermitian) pozitif tanımlı matrisin Cholesky ayrıştırmasını hesaplar.

Cholesky(a, lower)

lower, true ise $a = l olacak şekilde alt üçgen matrisler l hesaplar . l^T$. lower, false ise u üst üçgen matrislerini\(a = u^T . u\)olacak şekilde hesaplar.

Giriş verileri, lower değerine bağlı olarak yalnızca a öğesinin alt/üst üçgeninden okunur. Diğer üçgendeki değerler yoksayılır. Çıkış verileri aynı üçgende döndürülür. Diğer üçgendeki değerler uygulamaya bağlıdır ve herhangi bir değer olabilir.

a 2'den fazla boyuta sahipse a, matris grubu olarak değerlendirilir. Burada, küçük 2 boyut hariç tüm boyutlar grup boyutlarıdır.

a simetrik (Hermitian) pozitif tanımlı değilse sonuç uygulamaya bağlıdır.

StableHLO hakkında bilgi için StableHLO - cholesky başlıklı makaleyi inceleyin.

Sınır

Ayrıca XlaBuilder::Clamp başlıklı makaleyi inceleyin.

Bir işleneni minimum ve maksimum değer arasındaki aralıkla sınırlar.

Clamp(min, operand, max)

Bir işlenen, minimum ve maksimum değerler verildiğinde, işlenen minimum ve maksimum değerler arasındaysa işleneni, bu aralığın altındaysa minimum değeri, bu aralığın üstündeyse maksimum değeri döndürür. Yani clamp(a, x, b) = min(max(a, x), b).

Üç dizinin de şekli aynı olmalıdır. Alternatif olarak, yayının kısıtlanmış bir biçimi olarak min ve/veya max, T türünde bir skaler olabilir.

Skaler min ve max içeren örnek:

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 bilgileri için StableHLO - clamp başlıklı makaleyi inceleyin.

Daralt

Ayrıca XlaBuilder::Collapse başlıklı makaleyi inceleyin. ve tf.reshape işlemi.

Bir dizinin boyutlarını tek boyutta daraltır.

Collapse(operand, dimensions)

Collapse, işlenenin boyutlarının verilen alt kümesini tek bir boyutla değiştirir. Giriş bağımsız değişkenleri, T türünde rastgele bir dizi ve derleme zamanında sabit boyut dizinleri vektörüdür. Boyut dizinleri, T'nin boyutlarının sıralı (düşükten yükseğe boyut numaraları) ve ardışık bir alt kümesi olmalıdır. Bu nedenle, {0, 1, 2}, {0, 1} veya {1, 2} değerlerinin tamamı geçerli boyut kümeleridir ancak {1, 0} veya {0, 2} geçerli değildir. Bu boyutlar, boyut sırasındaki aynı konumda, yeni boyutun boyutu orijinal boyutların çarpımına eşit olacak şekilde tek bir yeni boyutla değiştirilir. dimensions içindeki en düşük boyut numarası, bu boyutları daraltan döngü yuvasında en yavaş değişen boyuttur (en büyük), en yüksek boyut numarası ise en hızlı değişen boyuttur (en küçük). Daha fazla genel sıralama daraltma işlemi gerekiyorsa tf.reshape operatörüne bakın.

Örneğin, v 24 öğeden oluşan bir dizi olsun:

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

Ayrıca XlaBuilder::Clz başlıklı makaleyi inceleyin.

Baştaki sıfırları öğe bazında sayar.

Clz(operand)

CollectiveBroadcast

Ayrıca XlaBuilder::CollectiveBroadcast başlıklı makaleyi inceleyin.

Verileri kopyalar arasında yayınlar. Veriler, her gruptaki ilk kopya kimliğinden aynı gruptaki diğer kimliklere gönderilir. Bir kopya kimliği herhangi bir kopya grubunda değilse bu kopyadaki çıkış, shape içinde 0'lardan oluşan bir tensördür.

CollectiveBroadcast(operand, replica_groups, channel_id)

StableHLO bilgileri için StableHLO - collective_broadcast başlıklı makaleyi inceleyin.

CollectivePermute

Ayrıca XlaBuilder::CollectivePermute başlıklı makaleyi inceleyin.

CollectivePermute, kopyalar arasında veri gönderip alan bir toplu işlemdir.

CollectivePermute(operand, source_target_pairs, channel_id, inplace)

source_target_pairs ile ilgili aşağıdaki kısıtlamalar olduğunu unutmayın:

• Herhangi iki çift aynı hedef kopya kimliğine ve aynı kaynak kopya kimliğine sahip olmamalıdır.
• Bir kopya kimliği herhangi bir çiftte hedef değilse bu kopyadaki çıkış, girişle aynı şekle sahip 0'lardan oluşan bir tensördür.

CollectivePermute işleminin API'si dahili olarak 2 HLO talimatına (CollectivePermuteStart ve CollectivePermuteDone) ayrıştırılır.

Ayrıca HloInstruction::CreateCollectivePermuteStart başlıklı makaleyi inceleyin.

CollectivePermuteStart ve CollectivePermuteDone, HLO'da temel işlemler olarak kullanılır. Bu işlemler HLO dökümlerinde görünebilir ancak son kullanıcılar tarafından manuel olarak oluşturulması amaçlanmamıştır.

StableHLO hakkında bilgi için StableHLO - collective_permute başlıklı makaleyi inceleyin.

Karşılaştır

Ayrıca XlaBuilder::Compare başlıklı makaleyi inceleyin.

Aşağıdakilerin lhs ve rhs öğelerini öğe bazında karşılaştırır:

Eq

Ayrıca XlaBuilder::Eq başlıklı makaleyi inceleyin.

lhs ve rhs için öğe bazında eşittir karşılaştırması yapar.

\(lhs = rhs\)

Eq(lhs, rhs)

Bağımsız değişkenlerin şekilleri benzer veya uyumlu olmalıdır. Şekillerin uyumlu olmasıyla ilgili yayın dokümanlarına bakın. Bir işlemin sonucu, iki giriş dizisinin yayınlanmasıyla elde edilen bir şekle sahiptir. Bu varyantta, işlenenlerden biri skaler olmadığı sürece farklı sıralardaki diziler arasındaki işlemler desteklenmez.

Eq için farklı boyutlu yayın desteği olan alternatif bir varyant mevcuttur:

Eq(lhs,rhs, broadcast_dimensions)

Bu işlem varyantı, farklı sıralardaki diziler arasında aritmetik işlemler (ör. matrise vektör ekleme) için kullanılmalıdır.

Ek yayın_boyutları işleneni, işlenenlerin yayınlanması için kullanılacak boyutları belirten bir tam sayı dilimidir. Semantikler, yayın sayfasında ayrıntılı olarak açıklanmaktadır.

Şunlar zorunlu kılınarak Eq için kayan noktalı sayılardan büyük toplam sipariş desteklenir:

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

EqTotalOrder(lhs,rhs, broadcast_dimensions)

StableHLO hakkında bilgi edinmek için StableHLO - karşılaştırma başlıklı makaleyi inceleyin.

Ne

Ayrıca XlaBuilder::Ne başlıklı makaleyi inceleyin.

lhs ve rhs için öğe bazında eşit değildir karşılaştırması yapar.

\(lhs != rhs\)

Ne(lhs, rhs)

Bağımsız değişkenlerin şekilleri benzer veya uyumlu olmalıdır. Şekillerin uyumlu olmasıyla ilgili yayın dokümanlarına bakın. Bir işlemin sonucu, iki giriş dizisinin yayınlanmasıyla elde edilen bir şekle sahiptir. Bu varyantta, işlenenlerden biri skaler olmadığı sürece farklı sıralardaki diziler arasındaki işlemler desteklenmez.

Ne için farklı boyutlu yayın desteği sunan alternatif bir varyant mevcuttur:

Ne(lhs,rhs, broadcast_dimensions)

Bu işlem varyantı, farklı sıralardaki diziler arasında aritmetik işlemler (ör. matrise vektör ekleme) için kullanılmalıdır.

Ek yayın_boyutları işleneni, işlenenlerin yayınlanması için kullanılacak boyutları belirten bir tam sayı dilimidir. Semantikler, yayın sayfasında ayrıntılı olarak açıklanmaktadır.

Ne için, aşağıdakiler zorunlu kılınarak kayan noktalı sayılardan daha yüksek toplam sipariş desteklenir:

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

NeTotalOrder(lhs,rhs, broadcast_dimensions)

StableHLO hakkında bilgi edinmek için StableHLO - karşılaştırma başlıklı makaleyi inceleyin.

Ge

Ayrıca XlaBuilder::Ge başlıklı makaleyi inceleyin.

lhs ve rhs öğeleri arasında greater-or-equal-than karşılaştırması yapar.

\(lhs >= rhs\)

Ge(lhs, rhs)

Bağımsız değişkenlerin şekilleri benzer veya uyumlu olmalıdır. Şekillerin uyumlu olmasıyla ilgili yayın dokümanlarına bakın. Bir işlemin sonucu, iki giriş dizisinin yayınlanmasıyla elde edilen bir şekle sahiptir. Bu varyantta, işlenenlerden biri skaler olmadığı sürece farklı sıralardaki diziler arasındaki işlemler desteklenmez.

Almanca için farklı boyutlu yayın desteği sunan alternatif bir varyant mevcuttur:

Ge(lhs,rhs, broadcast_dimensions)

Bu işlem varyantı, farklı sıralardaki diziler arasında aritmetik işlemler (ör. matrise vektör ekleme) için kullanılmalıdır.

Ek yayın_boyutları işleneni, işlenenlerin yayınlanması için kullanılacak boyutları belirten bir tam sayı dilimidir. Semantikler, yayın sayfasında ayrıntılı olarak açıklanmaktadır.

Aşağıdakiler zorunlu kılınarak Gt için kayan nokta sayılarından daha yüksek bir toplam sipariş desteklenir:

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

GtTotalOrder(lhs,rhs, broadcast_dimensions)

StableHLO hakkında bilgi edinmek için StableHLO - karşılaştırma başlıklı makaleyi inceleyin.

Gt

Ayrıca XlaBuilder::Gt başlıklı makaleyi inceleyin.

lhs ve rhs için öğe bazında büyüktür karşılaştırması yapar.

\(lhs > rhs\)

Gt(lhs, rhs)

Bağımsız değişkenlerin şekilleri benzer veya uyumlu olmalıdır. Şekillerin uyumlu olmasıyla ilgili yayın dokümanlarına bakın. Bir işlemin sonucu, iki giriş dizisinin yayınlanmasıyla elde edilen bir şekle sahiptir. Bu varyantta, işlenenlerden biri skaler olmadığı sürece farklı sıralardaki diziler arasındaki işlemler desteklenmez.

Gt için farklı boyutlu yayın desteği içeren alternatif bir varyant mevcuttur:

Gt(lhs,rhs, broadcast_dimensions)

Bu işlem varyantı, farklı sıralardaki diziler arasında aritmetik işlemler (ör. matrise vektör ekleme) için kullanılmalıdır.

Ek yayın_boyutları işleneni, işlenenlerin yayınlanması için kullanılacak boyutları belirten bir tam sayı dilimidir. Semantikler, yayın sayfasında ayrıntılı olarak açıklanmaktadır.

StableHLO hakkında bilgi edinmek için StableHLO - karşılaştırma başlıklı makaleyi inceleyin.

Le

Ayrıca XlaBuilder::Le başlıklı makaleyi inceleyin.

lhs ve rhs için öğe bazında less-or-equal-than karşılaştırması yapar.

\(lhs <= rhs\)

Le(lhs, rhs)

Bağımsız değişkenlerin şekilleri benzer veya uyumlu olmalıdır. Şekillerin uyumlu olmasıyla ilgili yayın dokümanlarına bakın. Bir işlemin sonucu, iki giriş dizisinin yayınlanmasıyla elde edilen bir şekle sahiptir. Bu varyantta, işlenenlerden biri skaler olmadığı sürece farklı sıralardaki diziler arasındaki işlemler desteklenmez.

Le için farklı boyutlu yayın desteği sunan alternatif bir varyant mevcuttur:

Le(lhs,rhs, broadcast_dimensions)

Bu işlem varyantı, farklı sıralardaki diziler arasında aritmetik işlemler (ör. matrise vektör ekleme) için kullanılmalıdır.

Ek yayın_boyutları işleneni, işlenenlerin yayınlanması için kullanılacak boyutları belirten bir tam sayı dilimidir. Semantikler, yayın sayfasında ayrıntılı olarak açıklanmaktadır.

Le için, aşağıdakiler zorunlu kılınarak kayan noktalı sayılar üzerinde toplam sipariş desteklenir:

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

LeTotalOrder(lhs,rhs, broadcast_dimensions)

StableHLO hakkında bilgi edinmek için StableHLO - karşılaştırma başlıklı makaleyi inceleyin.

Lt

Ayrıca XlaBuilder::Lt başlıklı makaleyi inceleyin.

lhs ve rhs için öğe bazında küçüktür karşılaştırması yapar.

\(lhs < rhs\)

Lt(lhs, rhs)

Bağımsız değişkenlerin şekilleri benzer veya uyumlu olmalıdır. Şekillerin uyumlu olmasıyla ilgili yayın dokümanlarına bakın. Bir işlemin sonucu, iki giriş dizisinin yayınlanmasıyla elde edilen bir şekle sahiptir. Bu varyantta, işlenenlerden biri skaler olmadığı sürece farklı sıralardaki diziler arasındaki işlemler desteklenmez.

Lt için farklı boyutlu yayın desteği sunan alternatif bir varyant mevcuttur:

Lt(lhs,rhs, broadcast_dimensions)

Bu işlem varyantı, farklı sıralardaki diziler arasında aritmetik işlemler (ör. matrise vektör ekleme) için kullanılmalıdır.

Ek yayın_boyutları işleneni, işlenenlerin yayınlanması için kullanılacak boyutları belirten bir tam sayı dilimidir. Semantikler, yayın sayfasında ayrıntılı olarak açıklanmaktadır.

Kayan nokta sayılarından oluşan toplam siparişin desteklenmesi için şu işlemler uygulanır:

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

LtTotalOrder(lhs,rhs, broadcast_dimensions)

StableHLO hakkında bilgi edinmek için StableHLO - karşılaştırma başlıklı makaleyi inceleyin.

Karmaşık

Ayrıca XlaBuilder::Complex başlıklı makaleyi inceleyin.

lhs ve rhs gerçek ve hayali değer çiftinden karmaşık bir değere öğe bazında dönüştürme işlemi yapar.

Complex(lhs, rhs)

Bağımsız değişkenlerin şekilleri benzer veya uyumlu olmalıdır. Şekillerin uyumlu olmasıyla ilgili yayın dokümanlarına bakın. Bir işlemin sonucu, iki giriş dizisinin yayınlanmasıyla elde edilen bir şekle sahiptir. Bu varyantta, işlenenlerden biri skaler olmadığı sürece farklı sıralardaki diziler arasındaki işlemler desteklenmez.

Complex için farklı boyutlu yayın desteği sunan alternatif bir varyant mevcuttur:

Complex(lhs,rhs, broadcast_dimensions)

Bu işlem varyantı, farklı sıralardaki diziler arasında aritmetik işlemler (ör. matrise vektör ekleme) için kullanılmalıdır.

Ek yayın_boyutları işleneni, işlenenlerin yayınlanması için kullanılacak boyutları belirten bir tam sayı dilimidir. Semantikler, yayın sayfasında ayrıntılı olarak açıklanmaktadır.

StableHLO hakkında bilgi için StableHLO - complex başlıklı makaleyi inceleyin.

ConcatInDim (Birleştir)

Ayrıca XlaBuilder::ConcatInDim başlıklı makaleyi inceleyin.

CONCATENATE, birden fazla dizi işlenenden bir dizi oluşturur. Dizi, giriş dizisi işlenenlerinin her biriyle aynı sayıda boyuta sahiptir (bunlar da birbirleriyle aynı sayıda boyuta sahip olmalıdır) ve bağımsız değişkenleri belirtildikleri sırayla içerir.

Concatenate(operands..., dimension)

dimension hariç tüm boyutlar aynı olmalıdır. Bunun nedeni, XLA'nın "düzensiz" dizileri desteklememesidir. Ayrıca, 0 boyutlu değerlerin birleştirilemeyeceğini (birleştirmenin gerçekleştiği boyuta ad vermek mümkün olmadığından) unutmayın.

1 boyutlu örnek:

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

2 boyutlu örnek:

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

Diyagram:

StableHLO bilgileri için StableHLO - concatenate başlıklı makaleyi inceleyin.

Şart Kipi

Ayrıca XlaBuilder::Conditional başlıklı makaleyi inceleyin.

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

true_computation, predicate değeri true ise, false_computation, predicate değeri false ise yürütülür ve sonuç döndürülür.

true_computation, \(T_0\) türünde tek bir bağımsız değişken almalı ve aynı türde olması gereken true_operand ile çağrılmalıdır. false_computation, \(T_1\) türünde tek bir bağımsız değişken almalı ve aynı türde olması gereken false_operand ile çağrılmalıdır. true_computation ve false_computation'nin döndürülen değerinin türü aynı olmalıdır.

predicate değerine bağlı olarak yalnızca true_computation ve false_computation değerlerinden birinin yürütüleceğini unutmayın.

Conditional(branch_index, branch_computations, branch_operands)

branch_computations[branch_index] işlevini yürütür ve sonucu döndürür. branch_index, S32 ise ve < 0 veya >= N ise branch_computations[N-1] varsayılan dal olarak yürütülür.

Her branch_computations[b], \(T_b\) türünde tek bir bağımsız değişken almalı ve aynı türde olması gereken branch_operands[b] ile çağrılmalıdır. Her branch_computations[b] için döndürülen değerin türü aynı olmalıdır.

branch_index değerine bağlı olarak branch_computations işlemlerinden yalnızca birinin yürütüleceğini unutmayın.

StableHLO hakkında bilgi için StableHLO - if başlıklı makaleyi inceleyin.

Sabit

Ayrıca XlaBuilder::ConstantLiteral başlıklı makaleyi inceleyin.

Sabit bir literal değerinden output değeri üretir.

Constant(literal)

StableHLO bilgileri için StableHLO - constant başlıklı makaleyi inceleyin.

ConvertElementType

Ayrıca XlaBuilder::ConvertElementType başlıklı makaleyi inceleyin.

C++'taki öğe bazında static_cast işlemine benzer şekilde, ConvertElementType, veri şeklinden hedef şekle öğe bazında dönüştürme işlemi gerçekleştirir. Boyutlar eşleşmelidir ve dönüşüm öğe bazında yapılır. Örneğin, s32 öğeleri, s32-to-f32 dönüşüm rutiniyle f32 öğelerine dönüştürülür.

ConvertElementType(operand, new_element_type)

İşlenen ve hedef şeklin boyutları eşleşmelidir. Kaynak ve hedef öğe türleri demet olmamalıdır.

T=s32 ile U=f32 arasındaki dönüşüm gibi bir dönüşüm, round-to-nearest-even gibi bir normalleştirme int-to-float dönüşüm rutini gerçekleştirir.

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 hakkında bilgi için StableHLO - convert başlıklı makaleyi inceleyin.

Conv (Convolution)

Ayrıca XlaBuilder::Conv başlıklı makaleyi inceleyin.

Nöral ağlarda kullanılan türde bir konvolüsyon hesaplar. Burada, bir evrişim, n boyutlu bir taban alanı üzerinde hareket eden n boyutlu bir pencere olarak düşünülebilir ve pencerenin olası her konumu için bir hesaplama yapılır.

Conv Hesaplamaya, genişleme olmadan varsayılan evrişim boyutu numaralarını kullanan bir evrişim talimatı ekler.

Doldurma, SAME veya VALID olarak kısa bir şekilde belirtilir. SAME dolgu, adımlama dikkate alınmadığında çıkışın girişle aynı şekle sahip olması için girişi (lhs) sıfırlarla doldurur. VALID dolgusu, dolgu olmadığı anlamına gelir.

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

Conv için artan düzeylerde kontroller mevcuttur:

• ConvWithGeneralPadding
• ConvWithGeneralDimensions
• ConvGeneral
• ConvGeneralDilated

n, uzamsal boyut sayısı olsun. lhs bağımsız değişkeni, taban alanını açıklayan (n+2) boyutlu bir dizidir. Bu, giriş olarak adlandırılır. Elbette sağ taraf da bir giriştir. Nöral ağda bunlar giriş etkinleştirmeleridir. n+2 boyutları şu sıradadır:

• batch: Bu boyuttaki her koordinat, konvolüsyonun gerçekleştirildiği bağımsız bir girişi temsil eder.
• z/depth/features: Temel alandaki her (y,x) konumunun, bu boyuta giren ilişkili bir vektörü vardır.
• spatial_dims: Pencerenin hareket ettiği temel alanı tanımlayan n uzamsal boyutlarını açıklar.

rhs bağımsız değişkeni, evrişimli filtre/çekirdek/pencereyi açıklayan (n+2) boyutlu bir dizidir. Boyutlar şu sıradadır:

• output-z: Çıkışın z boyutu.
• input-z: Bu boyutun feature_group_count ile çarpımı, lhs'deki z boyutunun boyutuna eşit olmalıdır.
• spatial_dims: Taban alan üzerinde hareket eden n boyutlu pencereyi tanımlayan n uzamsal boyutlarını açıklar.

window_strides bağımsız değişkeni, evrişimli pencerenin uzamsal boyutlardaki adımını belirtir. Örneğin, ilk uzamsal boyuttaki adım 3 ise pencere yalnızca ilk uzamsal dizinin 3'e bölünebildiği koordinatlara yerleştirilebilir.

padding bağımsız değişkeni, temel alana uygulanacak sıfır dolgusunun miktarını belirtir. Doldurma miktarı negatif olabilir. Negatif doldurmanın mutlak değeri, evrişim işlemi yapılmadan önce belirtilen boyuttan kaldırılacak öğe sayısını gösterir. padding[0], y boyutu için dolguyu, padding[1] ise x boyutu için dolguyu belirtir. Her çiftte, ilk öğe olarak düşük dolgu, ikinci öğe olarak yüksek dolgu bulunur. Düşük dolgu, daha düşük dizinler yönünde, yüksek dolgu ise daha yüksek dizinler yönünde uygulanır. Örneğin, padding[1] değeri (2,3) ise ikinci uzamsal boyutta solda 2 sıfır, sağda ise 3 sıfır ile doldurma işlemi yapılır. Dolgu kullanmak, evrişim işlemi yapılmadan önce aynı sıfır değerlerini girişe (lhs) eklemeye eşdeğerdir.

lhs_dilation ve rhs_dilation bağımsız değişkenleri, her bir uzamsal boyutta sırasıyla sol ve sağ tarafa uygulanacak genişleme faktörünü belirtir. Bir uzamsal boyuttaki genişleme faktörü d ise bu boyuttaki girişlerin her biri arasına örtülü olarak d-1 boşluk yerleştirilir ve dizinin boyutu artar. Boşluklar, hiçbir işlem yapmayan bir değerle doldurulur. Bu değer, evrişim için sıfır anlamına gelir.

Sağ taraftaki genişlemeye atrous convolution da denir. Daha fazla bilgi için tf.nn.atrous_conv2d başlıklı makaleyi inceleyin. Sol tarafın genişletilmesine transpoze edilmiş konvolüsyon da denir. Daha fazla bilgi için tf.nn.conv2d_transpose başlıklı makaleyi inceleyin.

feature_group_count bağımsız değişkeni (varsayılan değer 1), gruplandırılmış evrişimler için kullanılabilir. feature_group_count, hem giriş hem de çıkış özelliği boyutunun böleni olmalıdır. feature_group_count 1'den büyükse giriş ve çıkış özelliği boyutunun ve rhs çıkış özelliği boyutunun kavramsal olarak eşit şekilde birçok feature_group_count grubuna bölündüğü anlamına gelir. Her grup, ardışık bir özellik alt dizisinden oluşur. rhs öğesinin giriş özelliği boyutu, lhs giriş özelliği boyutunun feature_group_count ile bölünmesiyle elde edilen değere eşit olmalıdır (bu nedenle, giriş özelliklerinden oluşan bir grubun boyutuna sahiptir). i'inci gruplar, birçok ayrı evrişim için feature_group_count değerini hesaplamak üzere birlikte kullanılır. Bu evrişimlerin sonuçları, çıkış özelliği boyutunda birleştirilir.

Derinlemesine evrişim için feature_group_count bağımsız değişkeni giriş özelliği boyutuna ayarlanır ve filtre [filter_height, filter_width, in_channels, channel_multiplier] şeklinden [filter_height, filter_width, 1, in_channels * channel_multiplier] şekline dönüştürülür. Daha fazla bilgi için tf.nn.depthwise_conv2d başlıklı makaleyi inceleyin.

batch_group_count (varsayılan değer 1) bağımsız değişkeni, geri yayılım sırasında gruplandırılmış filtreler için kullanılabilir. batch_group_count, lhs (giriş) toplu iş boyutunun bir böleni olmalıdır. batch_group_count değeri 1'den büyükse çıkış toplu iş boyutunun input batch / batch_group_count olması gerekir. batch_group_count, çıkış özelliği boyutunun böleni olmalıdır.

Çıkış şekli, şu sırayla şu boyutlara sahiptir:

• batch: Bu boyutun boyutu ile batch_group_count çarpıldığında, lhs'deki batch boyutunun boyutu elde edilmelidir.
• z: Çekirdekteki output-z ile aynı boyutta (rhs).
• spatial_dims: Evrişimli pencerenin geçerli her yerleşimi için bir değer.

Yukarıdaki şekilde batch_group_count alanının işleyiş şekli gösterilmektedir. Aslında, her bir sol taraf toplu işini batch_group_count gruba ayırırız ve aynı işlemi çıkış özellikleri için de yaparız. Ardından, bu grupların her biri için ikili evrişimler yaparız ve çıkışı, çıkış özelliği boyutu boyunca birleştiririz. Diğer tüm boyutların (özellik ve mekansal) operasyonel semantiği aynı kalır.

Evrişimli pencerenin geçerli yerleşimleri, adımlara ve dolgu sonrası taban alanının boyutuna göre belirlenir.

Bir konvolüsyonun ne yaptığını açıklamak için 2 boyutlu bir konvolüsyonu ele alalım ve çıkışta sabit batch, z, y, x koordinatları seçelim. Ardından (y,x), temel alan içindeki bir pencere köşesinin konumudur (ör. uzamsal boyutları nasıl yorumladığınıza bağlı olarak sol üst köşe). Artık taban alanından alınmış bir 2 boyutlu penceremiz var. Burada her 2 boyutlu nokta 1 boyutlu bir vektörle ilişkilendiriliyor. Böylece 3 boyutlu bir kutu elde ediyoruz. Evrişimli çekirdekten, çıkış koordinatını z düzelttiğimiz için 3 boyutlu bir kutumuz da var. İki kutunun boyutları aynı olduğundan, iki kutu arasındaki öğe bazında çarpımların toplamını alabiliriz (iç çarpıma benzer). Bu, çıkış değeridir.

output-z örneğin 5 ise pencerenin her konumu, çıkışın z boyutunda 5 değer üretir. Bu değerler, evrişimli çekirdeğin hangi bölümünün kullanıldığına göre değişir. Her output-z koordinatı için kullanılan değerlerin ayrı bir 3D kutusu vardır. Bu nedenle, her biri için farklı bir filtreyle 5 ayrı evrişim olarak düşünebilirsiniz.

Doldurma ve adım atma ile 2 boyutlu bir evrişim için sözde kod aşağıda verilmiştir:

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, hassasiyet yapılandırmasını belirtmek için kullanılır. Bu düzey, gerektiğinde daha doğru dtype emülasyonu sağlamak için donanımın daha fazla makine kodu talimatı oluşturmaya çalışıp çalışmayacağını belirler (ör. yalnızca bf16 matmul'ları destekleyen bir TPU'da f32'yi emüle etme). Değerler DEFAULT, HIGH veya HIGHEST olabilir. Ek ayrıntıları MXU bölümlerinde bulabilirsiniz.

preferred_element_type, birikim için kullanılan daha yüksek/düşük hassasiyetli çıkış türlerinin skaler bir öğesidir. preferred_element_type, söz konusu işlem için birikim türünü önerir ancak bu garanti edilmez. Bu, bazı donanım arka uçlarının bunun yerine farklı bir türde birikmesine ve tercih edilen çıkış türüne dönüştürülmesine olanak tanır.

StableHLO bilgileri için StableHLO - convolution başlıklı makaleyi inceleyin.

ConvWithGeneralPadding

Ayrıca XlaBuilder::ConvWithGeneralPadding başlıklı makaleyi inceleyin.

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

Doldurma yapılandırmasının açık olduğu Conv ile aynıdır.

ConvWithGeneralDimensions

Ayrıca XlaBuilder::ConvWithGeneralDimensions başlıklı makaleyi inceleyin.

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

Boyut numaralarının açıkça belirtildiği Conv ile aynıdır.

ConvGeneral

Ayrıca XlaBuilder::ConvGeneral başlıklı makaleyi inceleyin.

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

Boyut numaralarının ve dolgu yapılandırmasının açık olduğu Conv ile aynıdır.

ConvGeneralDilated

Ayrıca XlaBuilder::ConvGeneralDilated başlıklı makaleyi inceleyin.

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)

Dolgu yapılandırması, genişleme faktörleri ve boyut numaralarının açık olduğu Conv ile aynıdır.

Kopyala

Ayrıca HloInstruction::CreateCopyStart başlıklı makaleyi inceleyin.

Copy, dahili olarak 2 HLO talimatına (CopyStart ve CopyDone) ayrıştırılır. Copy, CopyStart ve CopyDone ile birlikte HLO'da temel öğeler olarak kullanılır. Bu işlemler HLO dökümlerinde görünebilir ancak son kullanıcılar tarafından manuel olarak oluşturulması amaçlanmamıştır.

Cos

Ayrıca XlaBuilder::Cos başlıklı makaleye bakın.

Öğe bazında kosinüs x -> cos(x).

Cos(operand)

Cos, isteğe bağlı result_accuracy bağımsız değişkenini de destekler:

Cos(operand, result_accuracy)

result_accuracy hakkında daha fazla bilgi için Sonuç Doğruluğu başlıklı makaleyi inceleyin.

StableHLO hakkında bilgi için StableHLO - cosine başlıklı makaleyi inceleyin.

Cosh

Ayrıca XlaBuilder::Cosh başlıklı makaleyi inceleyin.

Öğe bazında hiperbolik kosinüs x -> cosh(x).

Cosh(operand)

Cosh, isteğe bağlı result_accuracy bağımsız değişkenini de destekler:

Cosh(operand, result_accuracy)

result_accuracy hakkında daha fazla bilgi için Sonuç Doğruluğu başlıklı makaleyi inceleyin.

CustomCall

Ayrıca XlaBuilder::CustomCall başlıklı makaleyi inceleyin.

Bir hesaplama içinde kullanıcı tarafından sağlanan bir işlevi çağırma.

CustomCall belgeleri, Geliştirici ayrıntıları - XLA Özel Çağrıları bölümünde sağlanır.

StableHLO hakkında bilgi için StableHLO - custom_call başlıklı makaleyi inceleyin.

Div

Ayrıca XlaBuilder::Div başlıklı makaleyi inceleyin.

Bölünen lhs ve bölen rhs üzerinde öğe bazında bölme işlemi yapar.

Div(lhs, rhs)

Tamsayı bölme taşması (işaretli/işaretsiz bölme/sıfıra bölme veya INT_SMIN ile -1'ın işaretli bölme/kalanı), uygulamaya bağlı bir değer üretir.

Bağımsız değişkenlerin şekilleri benzer veya uyumlu olmalıdır. Şekillerin uyumlu olmasıyla ilgili yayın dokümanlarına bakın. Bir işlemin sonucu, iki giriş dizisinin yayınlanmasıyla elde edilen bir şekle sahiptir. Bu varyantta, işlenenlerden biri skaler olmadığı sürece farklı sıralardaki diziler arasındaki işlemler desteklenmez.

Div için farklı boyutlu yayın desteği sunan alternatif bir varyant mevcuttur:

Div(lhs,rhs, broadcast_dimensions)

Bu işlem varyantı, farklı sıralardaki diziler arasında aritmetik işlemler (ör. matrise vektör ekleme) için kullanılmalıdır.

Ek yayın_boyutları işleneni, işlenenlerin yayınlanması için kullanılacak boyutları belirten bir tam sayı dilimidir. Semantikler, yayın sayfasında ayrıntılı olarak açıklanmaktadır.

StableHLO hakkında bilgi için StableHLO - divide başlıklı makaleyi inceleyin.

Alan

Ayrıca HloInstruction::CreateDomain başlıklı makaleyi inceleyin.

Domain, HLO dökümlerinde görünebilir ancak son kullanıcılar tarafından manuel olarak oluşturulması amaçlanmamıştır.

Nokta

Ayrıca XlaBuilder::Dot başlıklı makaleyi inceleyin.

Dot(lhs, rhs, precision_config, preferred_element_type)

Bu işlemin tam anlamı, işlenenlerin sıralamasına bağlıdır:

İşlem, lhs'nın ikinci boyutunda (veya 1 boyutu varsa ilk boyutunda) ve rhs'nin ilk boyutunda ürünlerin toplamını gerçekleştirir. Bunlar "kısaltılmış" boyutlardır. lhs ve rhs'nin daraltılmış boyutları aynı boyutta olmalıdır. Pratikte, vektörler arasında nokta çarpımı, vektör/matris çarpımı veya matris/matris çarpımı yapmak için kullanılabilir.

precision_config, hassasiyet yapılandırmasını belirtmek için kullanılır. Bu düzey, gerektiğinde daha doğru dtype emülasyonu sağlamak için donanımın daha fazla makine kodu talimatı oluşturmaya çalışıp çalışmayacağını belirler (ör. yalnızca bf16 matmul'ları destekleyen bir TPU'da f32'yi emüle etme). Değerler DEFAULT, HIGH veya HIGHEST olabilir. Ek ayrıntıları MXU bölümlerinde bulabilirsiniz.

preferred_element_type, birikim için kullanılan daha yüksek/düşük hassasiyetli çıkış türlerinin skaler bir öğesidir. preferred_element_type, söz konusu işlem için birikim türünü önerir ancak bu garanti edilmez. Bu, bazı donanım arka uçlarının bunun yerine farklı bir türde birikmesine ve tercih edilen çıkış türüne dönüştürülmesine olanak tanır.

StableHLO hakkında bilgi için StableHLO - dot başlıklı makaleyi inceleyin.

DotGeneral

Ayrıca XlaBuilder::DotGeneral başlıklı makaleyi inceleyin.

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

Nokta'ya benzer ancak hem lhs hem de rhs için sözleşme ve parti boyut numaralarının belirtilmesine olanak tanır.

DotGeneral, dimension_numbers içinde belirtilen daraltma boyutları üzerinden ürünlerin toplamını gerçekleştirir.

lhs ve rhs'den gelen ilişkili sözleşme boyutu numaralarının aynı olması gerekmez ancak aynı boyutlara sahip olması gerekir.

Sözleşme boyut numaralarını içeren örnek:

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 ve rhs kaynaklı ilişkili parti boyut numaraları aynı boyutlara sahip olmalıdır.

Toplu boyut numaraları içeren örnek (toplu boyut 2, 2x2 matrisler):

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

Bu nedenle, ortaya çıkan boyut numarası önce toplu boyutla, ardından lhs sözleşme yapılmayan/toplu olmayan boyutla ve son olarak rhs sözleşme yapılmayan/toplu olmayan boyutla başlar.

precision_config, hassasiyet yapılandırmasını belirtmek için kullanılır. Bu düzey, gerektiğinde daha doğru dtype emülasyonu sağlamak için donanımın daha fazla makine kodu talimatı oluşturmaya çalışıp çalışmayacağını belirler (ör. yalnızca bf16 matmul'ları destekleyen bir TPU'da f32'yi emüle etme). Değerler DEFAULT, HIGH veya HIGHEST olabilir. Ek ayrıntıları MXU bölümlerinde bulabilirsiniz.

preferred_element_type, birikim için kullanılan daha yüksek/düşük hassasiyetli çıkış türlerinin skaler bir öğesidir. preferred_element_type, söz konusu işlem için birikim türünü önerir ancak bu garanti edilmez. Bu, bazı donanım arka uçlarının bunun yerine farklı bir türde birikmesine ve tercih edilen çıkış türüne dönüştürülmesine olanak tanır.

StableHLO bilgileri için StableHLO - dot_general başlıklı makaleyi inceleyin.

ScaledDot

Ayrıca XlaBuilder::ScaledDot başlıklı makaleyi inceleyin.

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

DotGeneral ile benzerdir.

"dimension_numbers" içinde belirtilen daraltma ve grup boyutlarıyla birlikte "lhs", "lhs_scale", "rhs" ve "rhs_scale" işlenenleriyle ölçeklendirilmiş nokta çarpımı işlemi oluşturur.

RaggedDot

Ayrıca XlaBuilder::RaggedDot başlıklı makaleyi inceleyin.

RaggedDot hesaplamasının dökümü için StableHLO - chlo.ragged_dot başlıklı makaleyi inceleyin.

DynamicReshape

Ayrıca XlaBuilder::DynamicReshape başlıklı makaleyi inceleyin.

Bu işlem, işlevsel olarak reshape ile aynıdır ancak sonuç şekli, output_shape aracılığıyla dinamik olarak belirtilir.

DynamicReshape(operand, dim_sizes, new_size_bounds, dims_are_dynamic)

StableHLO hakkında bilgi için StableHLO - dynamic_reshape başlıklı makaleyi inceleyin.

DynamicSlice

Ayrıca XlaBuilder::DynamicSlice başlıklı makaleyi inceleyin.

DynamicSlice, giriş dizisinden dinamik bir alt dizi çıkarır start_indices. Her boyuttaki dilimin boyutu, her boyutta özel dilim aralıklarının bitiş noktasını belirten size_indices içinde iletilir: [başlangıç, başlangıç + boyut). start_indices şekli, operand boyut sayısına eşit boyutlu, 1 boyutlu olmalıdır.

DynamicSlice(operand, start_indices, slice_sizes)

Etkili dilim dizinleri, dilimleme işlemi gerçekleştirilmeden önce [1, N) içindeki her dizin i için aşağıdaki dönüşüm uygulanarak hesaplanır:

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

Bu, çıkarılan dilimin her zaman işlenen dizisiyle sınırlı olmasını sağlar. Dilim, dönüşüm uygulanmadan önce sınırlardaysa dönüşümün herhangi bir etkisi olmaz.

1 boyutlu örnek:

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 boyutlu örnek:

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

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

StableHLO bilgileri için StableHLO - dynamic_slice başlıklı makaleyi inceleyin.

DynamicUpdateSlice

Ayrıca XlaBuilder::DynamicUpdateSlice başlıklı makaleyi inceleyin.

DynamicUpdateSlice, giriş dizisinin değeri olan bir sonuç oluşturur operand. Bu sonuçta update dilimi start_indices konumunda üzerine yazılmış olarak bulunur. update şekli, güncellenen sonucun alt dizisinin şeklini belirler. start_indices şekli, operand boyutlarının sayısına eşit boyutlu, 1 boyutlu olmalıdır.

DynamicUpdateSlice(operand, update, start_indices)

Etkili dilim dizinleri, dilimleme işlemi gerçekleştirilmeden önce [1, N) içindeki her dizin i için aşağıdaki dönüşüm uygulanarak hesaplanır:

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

Bu, güncellenen dilimin her zaman işlenen dizisiyle ilgili olarak sınırların içinde olmasını sağlar. Dilim, dönüşüm uygulanmadan önce sınırlardaysa dönüşümün herhangi bir etkisi olmaz.

1 boyutlu örnek:

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 boyutlu örnek:

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

let s = {1, 1}

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

StableHLO hakkında bilgi için StableHLO - dynamic_update_slice başlıklı makaleyi inceleyin.

Erf

Ayrıca XlaBuilder::Erf başlıklı makaleyi inceleyin.

Öğe bazında hata fonksiyonu x -> erf(x). Burada:

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

Erf(operand)

Erf, isteğe bağlı result_accuracy bağımsız değişkenini de destekler:

Erf(operand, result_accuracy)

result_accuracy hakkında daha fazla bilgi için Sonuç Doğruluğu başlıklı makaleyi inceleyin.

Süre sonu

Ayrıca XlaBuilder::Exp başlıklı makaleyi inceleyin.

Öğe bazında doğal eksponansiyel x -> e^x.

Exp(operand)

Exp, isteğe bağlı result_accuracy bağımsız değişkenini de destekler:

Exp(operand, result_accuracy)

result_accuracy hakkında daha fazla bilgi için Sonuç Doğruluğu başlıklı makaleyi inceleyin.

StableHLO hakkında bilgi için StableHLO - exponential başlıklı makaleyi inceleyin.

Expm1

Ayrıca XlaBuilder::Expm1 başlıklı makaleyi inceleyin.

Öğe bazında doğal eksponansiyel eksi bir x -> e^x - 1.

Expm1(operand)

Expm1, isteğe bağlı result_accuracy bağımsız değişkenini de destekler:

Expm1(operand, result_accuracy)

result_accuracy hakkında daha fazla bilgi için Sonuç Doğruluğu başlıklı makaleyi inceleyin.

StableHLO bilgileri için StableHLO - exponential_minus_one başlıklı makaleyi inceleyin.

Fft

Ayrıca XlaBuilder::Fft başlıklı makaleyi inceleyin.

XLA FFT işlemi, gerçek ve karmaşık girişler/çıkışlar için ileri ve ters Fourier dönüşümlerini uygular. En fazla 3 eksende çok boyutlu FFT'ler desteklenir.

Fft(operand, ftt_type, fft_length)

StableHLO bilgileri için StableHLO - fft başlıklı makaleyi inceleyin.

Çok boyutlu FFT

Birden fazla fft_length sağlandığında bu, en içteki eksenlerin her birine kademeli FFT işlemleri uygulamaya eşdeğerdir. Gerçek->karmaşık ve karmaşık->gerçek durumlarında en içteki eksen dönüşümünün (etkili bir şekilde) önce gerçekleştirildiğini (RFFT; IRFFT için son) unutmayın. Bu nedenle, boyutu değişen en içteki eksendir. Diğer eksen dönüşümleri ise karmaşık->karmaşık olur.

Uygulama ayrıntıları

CPU FFT, Eigen'ın TensorFFT'si tarafından desteklenir. GPU FFT, cuFFT'yi kullanır.

Kat

Ayrıca XlaBuilder::Floor başlıklı makaleyi inceleyin.

Öğe bazında taban x -> ⌊x⌋.

Floor(operand)

StableHLO bilgileri için StableHLO - floor başlıklı makaleyi inceleyin.

Karma

Ayrıca HloInstruction::CreateFusion başlıklı makaleyi inceleyin.

Fusion işlemi, HLO talimatlarını temsil eder ve HLO'da temel bir işlem olarak kullanılır. Bu işlem, HLO dökümlerinde görünebilir ancak son kullanıcılar tarafından manuel olarak oluşturulması amaçlanmamıştır.

Gather

XLA toplama işlemi, bir giriş dizisinin birkaç dilimini (her dilim potansiyel olarak farklı bir çalışma zamanı uzaklığında) birleştirir.

StableHLO hakkında bilgi edinmek için StableHLO - gather başlıklı makaleyi inceleyin.

Genel Semantik

Ayrıca XlaBuilder::Gather başlıklı makaleyi inceleyin. Daha anlaşılır bir açıklama için aşağıdaki "Gayriresmi Açıklama" bölümüne bakın.

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

Kolaylık sağlamak için, çıkış dizisindeki offset_dims içinde olmayan boyutları batch_dims olarak etiketliyoruz.

Çıkış, batch_dims.size + offset_dims.size boyutlu bir dizidir.

operand.rank, offset_dims.size ve collapsed_slice_dims.size değerlerinin toplamına eşit olmalıdır. Ayrıca, slice_sizes.size, operand.rank değerine eşit olmalıdır.

index_vector_dim, start_indices.rank değerine eşitse start_indices değerinin sonunda 1 boyutu olduğunu varsayarız (ör. start_indices şekli [6,7] ise ve index_vector_dim değeri 2 ise start_indices şeklinin [6,7,1] olduğunu varsayarız).

i boyutu boyunca çıkış dizisinin sınırları aşağıdaki gibi hesaplanır:

1. i, batch_dims içinde varsa (yani bazı k için batch_dims[k] değerine eşitse) start_indices.shape içinden ilgili boyut sınırlarını seçeriz ve index_vector_dim'ı atlarız (yani k < index_vector_dim ise start_indices.shape.dims[k] değerini, aksi takdirde start_indices.shape.dims[k+1] değerini seçeriz).

2. i, offset_dims içinde varsa (ör. bazı k için offset_dims[k] değerine eşitse) collapsed_slice_dims dikkate alındıktan sonra slice_sizes içinden ilgili sınır seçilir (ör. adjusted_slice_sizes[k] seçilir. Burada adjusted_slice_sizes, slice_sizes olup collapsed_slice_dims dizinlerindeki sınırlar kaldırılmıştır).

Resmi olarak, belirli bir çıkış dizinine Out karşılık gelen işlenen dizini In aşağıdaki şekilde hesaplanır:

1. G = { Out[k] for k in batch_dims } olsun. G'yı kullanarak S[i] = start_indices[Combine(G, i)] olacak şekilde bir S vektörü oluşturun. Burada Combine(A, b), b'yi index_vector_dim konumunda A'ya ekler. G boş olsa bile bunun iyi tanımlandığını unutmayın: G boşsa S = start_indices olur.

2. Sin kullanarak S dağıtarak start_index_map ile operand içinde başlangıç dizini oluşturun.S Daha açık şekilde belirtmek gerekirse:

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

   2. Aksi durumda Sin[_] = 0.

3. Dizinleri collapsed_slice_dims kümesine göre Out içindeki ofset boyutlarına dağıtarak Oin dizinini operand içine oluşturun. Daha açık şekilde belirtmek gerekirse:

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

   2. Aksi durumda Oin[_] = 0.

4. In, Oin + Sin şeklindedir. Burada + öğe bazında toplama anlamına gelir.

remapped_offset_dims, [0, offset_dims.size) tanım kümesi ve [0, operand.rank) \ collapsed_slice_dims görüntü kümesi olan monoton bir fonksiyondur. Örneğin, offset_dims.size, 4, operand.rank, 6 ve collapsed_slice_dims, {0, 2} ise remapped_offset_dims, {0→1, 1→3, 2→4, 3→5} olur.

indices_are_sorted doğru değerine ayarlanırsa XLA, start_indices değerlerinin kullanıcı tarafından (değerleri start_index_map'e göre dağıtıldıktan sonra) sıralandığını (artana göre) varsayabilir. Aksi takdirde, semantikler uygulamaya göre tanımlanır.

Gayri Resmi Açıklama ve Örnekler

Çıkış dizisindeki her Out indeksi, işlenen dizisindeki bir E öğesine karşılık gelir ve şu şekilde hesaplanır:

• Out içindeki toplu boyutları kullanarak start_indices içinden bir başlangıç dizini ararız.

• start_index_map, başlangıç dizinini (boyutu operand.rank değerinden küçük olabilir) operand içindeki "tam" bir başlangıç diziniyle eşlemek için kullanılır.

• Tam başlangıç dizinini kullanarak slice_sizes boyutunda bir dilimi dinamik olarak dilimliyoruz.

• collapsed_slice_dims boyutlarını daraltarak dilimi yeniden şekillendiririz. Daraltılmış tüm dilim boyutlarının sınırı 1 olmalıdır. Bu nedenle, bu yeniden şekillendirme her zaman geçerlidir.

• Out içindeki ofset boyutlarını kullanarak bu dilimi dizine ekleyip çıkış dizini Out'ya karşılık gelen giriş öğesi E'yi elde ederiz.

index_vector_dim, sonraki tüm örneklerde start_indices.rank - 1 olarak ayarlanmıştır. index_vector_dim için daha ilginç değerler, işlemi temelde değiştirmez ancak görsel temsili daha karmaşık hale getirir.

Yukarıdakilerin tümünün nasıl bir araya geldiğini anlamak için [16,11] dizisinden [8,6] şeklindeki 5 dilimi toplayan bir örneğe bakalım. Bir dilimin [16,11] dizisindeki konumu, S64[2] şeklindeki bir dizin vektörü olarak gösterilebilir. Bu nedenle, 5 konumun kümesi S64[5,2] dizisi olarak gösterilebilir.

Toplama işleminin davranışı, [G,O0,O1] değerini alan, çıkış şeklindeki bir dizini ve bunu giriş dizisindeki bir öğeyle aşağıdaki şekilde eşleyen bir dizin dönüşümü olarak gösterilebilir:

Öncelikle G kullanarak gather_indices dizisinden bir (X,Y) vektörü seçeriz. Çıkış dizisindeki [G,O0,O1] dizinindeki öğe, giriş dizisindeki [X+O0,Y+O1] dizinindeki öğedir.

slice_sizes, O₀ ve O₁ aralığını belirleyen [8,6]'dir. Bu da dilimin sınırlarını belirler.

Bu toplama işlemi, toplu boyut olarak G ile toplu dinamik dilim görevi görür.

Toplama dizinleri çok boyutlu olabilir. Örneğin, [4,5,2] şeklindeki bir "dizinleri toplama" dizisini kullanan yukarıdaki örneğin daha genel bir sürümü, dizinleri şu şekilde çevirir:

Bu, toplu dinamik dilim G0 ve toplu boyutlar G1 olarak işlev görür. Dilim boyutu hâlâ [8,6].

XLA'daki toplama işlemi, yukarıda belirtilen gayriresmi semantiği aşağıdaki şekillerde genelleştirir:

1. Çıkış şeklindeki hangi boyutların ofset boyutları (son örnekte O0, O1 içeren boyutlar) olduğunu yapılandırabiliriz. Çıkış toplu iş boyutları (son örnekte G0, G1 içeren boyutlar), kaydırılmış boyutlar olmayan çıkış boyutları olarak tanımlanır.

2. Çıkış şeklindeki açıkça mevcut olan çıkış dengeleme boyutlarının sayısı, giriş boyutlarının sayısından daha az olabilir. collapsed_slice_dims olarak açıkça listelenen bu "eksik" boyutların dilim boyutu 1 olmalıdır. 1 dilim boyutuna sahip olduklarından, bunlar için geçerli tek dizin 0'dir ve bunları atlamak belirsizliğe yol açmaz.

3. "Dizinleri Topla" dizisinden çıkarılan dilim (son örnekteki (X, Y)) giriş dizisinin boyut sayısından daha az öğeye sahip olabilir ve dizinin girişle aynı sayıda boyuta sahip olacak şekilde nasıl genişletileceğini açık bir eşleme belirler.

Son bir örnek olarak, tf.gather_nd öğesini uygulamak için (2) ve (3) değerlerini kullanırız:

G0 ve G1, başlangıç dizinini her zamanki gibi gather_indices dizisinden ayırmak için kullanılır. Ancak başlangıç dizininde yalnızca bir öğe (X) bulunur. Benzer şekilde, yalnızca bir çıkış telafi indeksi vardır ve değeri O0'dir. Ancak, giriş dizininde dizin olarak kullanılmadan önce bunlar sırasıyla "Toplama Dizini Eşleme" (resmi açıklamada start_index_map) ve "Ofset Eşleme" (resmi açıklamada remapped_offset_dims) uyarınca [X,0] ve [0,O0] olarak genişletilir ve [X,O0] olarak toplanır. Diğer bir deyişle, çıkış dizini [G0,G1,O0], giriş dizini [GatherIndices[G0,G1,0],O0] ile eşlenir. Bu da bize tf.gather_nd için semantiği verir.

slice_sizes için [1,11]. Bu, sezgisel olarak, gather_indices dizisindeki her dizinin X bir satırın tamamını seçtiği ve sonucun tüm bu satırların birleştirilmesi olduğu anlamına gelir.

GetDimensionSize

Ayrıca XlaBuilder::GetDimensionSize başlıklı makaleyi inceleyin.

İşlenenin verilen boyutunun büyüklüğünü döndürür. İşlenen, dizi şeklinde olmalıdır.

GetDimensionSize(operand, dimension)

StableHLO hakkında bilgi için StableHLO - get_dimension_size başlıklı makaleyi inceleyin.

GetTupleElement

Ayrıca XlaBuilder::GetTupleElement başlıklı makaleyi inceleyin.

Derleme zamanında sabit değerle bir demeti dizine ekler.

Şekil çıkarımı, sonuçta elde edilen değerin türünü belirleyebilmesi için değer, derleme zamanı sabiti olmalıdır.

Bu, C++'taki std::get<int N>(t) ile benzerdir. Kavramsal olarak:

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.

Ayrıca tf.tuple başlıklı makaleyi inceleyin.

GetTupleElement(tuple_data, index)

StableHLO bilgileri için StableHLO - get_tuple_element başlıklı makaleyi inceleyin.

Imag

Ayrıca XlaBuilder::Imag başlıklı makaleyi inceleyin.

Karmaşık (veya gerçek) bir şeklin öğe bazında sanal kısmı. x -> imag(x). İşlenen, kayan nokta türündeyse 0 değerini döndürür.

Imag(operand)

StableHLO hakkında bilgi için StableHLO - imag başlıklı makaleyi inceleyin.

Yayın içi

Ayrıca XlaBuilder::Infeed başlıklı makaleyi inceleyin.

Infeed(shape, config)

Cihazın örtülü feed içi yayın arayüzünden tek bir veri öğesi okur, verileri belirtilen şekil ve düzen olarak yorumlar ve verilerin XlaOp değerini döndürür. Bir hesaplamada birden fazla feed içi işleme izin verilir ancak feed içi işlemler arasında toplam bir sıra olmalıdır. Örneğin, aşağıdaki kodda iki Infeed, while döngüleri arasında bağımlılık olduğundan toplam sıraya sahiptir.

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

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

İç içe yerleştirilmiş demet şekilleri desteklenmez. Boş bir demet şekli için Infeed işlemi aslında hiçbir şey yapmaz ve cihazın Infeed'inden herhangi bir veri okunmadan devam eder.

StableHLO hakkında bilgi için StableHLO - infeed başlıklı makaleyi inceleyin.

Iota

Ayrıca XlaBuilder::Iota başlıklı makaleyi inceleyin.

Iota(shape, iota_dimension)

Potansiyel olarak büyük bir ana makine aktarımı yerine cihazda sabit bir değişmez oluşturur. Belirtilen şekle sahip ve sıfırdan başlayıp belirtilen boyut boyunca birer birer artan değerler içeren bir dizi oluşturur. Kayan nokta türleri için oluşturulan dizi, ConvertElementType(Iota(...)) ile eşdeğerdir. Burada Iota, tam sayı türündedir ve dönüşüm, kayan nokta türüne yapılır.

Örneğin, Iota(s32[4, 8], 0) şu sonucu döndürür:

[[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) karşılığında iade

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

StableHLO hakkında bilgi için StableHLO - iota başlıklı makaleyi inceleyin.

IsFinite

Ayrıca XlaBuilder::IsFinite başlıklı makaleyi inceleyin.

operand öğesinin her bir öğesinin sonlu olup olmadığını (yani pozitif veya negatif sonsuzluk olup olmadığını ve NaN olup olmadığını) test eder. Girişle aynı şekle sahip bir PRED değerleri dizisi döndürür. Burada her öğe, yalnızca karşılık gelen giriş öğesi sonluysa true olur.

IsFinite(operand)

StableHLO bilgileri için StableHLO - is_finite başlıklı makaleyi inceleyin.

Günlük

Ayrıca XlaBuilder::Log başlıklı makaleyi inceleyin.

Öğe bazında doğal logaritma x -> ln(x).

Log(operand)

Log, isteğe bağlı result_accuracy bağımsız değişkenini de destekler:

Log(operand, result_accuracy)

result_accuracy hakkında daha fazla bilgi için Sonuç Doğruluğu başlıklı makaleyi inceleyin.

StableHLO hakkında bilgi için StableHLO - log başlıklı makaleyi inceleyin.

Log1p

Ayrıca XlaBuilder::Log1p başlıklı makaleyi inceleyin.

Öğe bazında kaydırılmış doğal logaritma x -> ln(1+x).

Log1p(operand)

Log1p, isteğe bağlı result_accuracy bağımsız değişkenini de destekler:

Log1p(operand, result_accuracy)

result_accuracy hakkında daha fazla bilgi için Sonuç Doğruluğu başlıklı makaleyi inceleyin.

StableHLO bilgileri için StableHLO - log_plus_one başlıklı makaleyi inceleyin.

Lojistik

Ayrıca XlaBuilder::Logistic başlıklı makaleyi inceleyin.

Öğe bazında lojistik fonksiyon hesaplaması x -> logistic(x).

Logistic(operand)

Logistic, isteğe bağlı result_accuracy bağımsız değişkenini de destekler:

Logistic(operand, result_accuracy)

result_accuracy hakkında daha fazla bilgi için Sonuç Doğruluğu başlıklı makaleyi inceleyin.

StableHLO hakkında bilgi için StableHLO - logistic başlıklı makaleyi inceleyin.

Harita

Ayrıca XlaBuilder::Map başlıklı makaleyi inceleyin.

Map(operands..., computation, dimensions)

Belirli operands dizilerine bir skaler işlev uygulayarak aynı boyutlarda bir dizi oluşturur. Bu dizideki her öğe, giriş dizilerindeki karşılık gelen öğelere uygulanan eşlenmiş işlevin sonucudur.

Eşlenen işlev, N adet skaler türde T girişi ve tek bir S türünde çıkışı olan rastgele bir hesaplamadır. Çıkış, T öğe türü S ile değiştirilmesi dışında işlenenlerle aynı boyutlara sahiptir.

Örneğin: Map(op1, op2, op3, computation, par1), giriş dizilerindeki her (çok boyutlu) dizinde elem_out <- computation(elem1, elem2, elem3, par1) işlevini uygulayarak çıkış dizisini oluşturur.

StableHLO hakkında bilgi için StableHLO - map başlıklı makaleyi inceleyin.

Maks.

Ayrıca XlaBuilder::Max başlıklı makaleyi inceleyin.

lhs ve rhs tensörlerinde öğe bazında maksimum işlem gerçekleştirir.

Max(lhs, rhs)

Bağımsız değişkenlerin şekilleri benzer veya uyumlu olmalıdır. Şekillerin uyumlu olmasıyla ilgili yayın dokümanlarına bakın. Bir işlemin sonucu, iki giriş dizisinin yayınlanmasıyla elde edilen bir şekle sahiptir. Bu varyantta, işlenenlerden biri skaler olmadığı sürece farklı sıralardaki diziler arasındaki işlemler desteklenmez.

Max için farklı boyutlu yayın desteği sunan alternatif bir varyant mevcuttur:

Max(lhs,rhs, broadcast_dimensions)

Bu işlem varyantı, farklı sıralardaki diziler arasında aritmetik işlemler (ör. matrise vektör ekleme) için kullanılmalıdır.

Ek yayın_boyutları işleneni, işlenenlerin yayınlanması için kullanılacak boyutları belirten bir tam sayı dilimidir. Semantikler, yayın sayfasında ayrıntılı olarak açıklanmaktadır.

StableHLO hakkında bilgi için StableHLO - maximum başlıklı makaleyi inceleyin.

Min.

Ayrıca XlaBuilder::Min başlıklı makaleyi inceleyin.

lhs ve rhs üzerinde öğe bazında minimum işlemi gerçekleştirir.

Min(lhs, rhs)

Bağımsız değişkenlerin şekilleri benzer veya uyumlu olmalıdır. Şekillerin uyumlu olmasıyla ilgili yayın dokümanlarına bakın. Bir işlemin sonucu, iki giriş dizisinin yayınlanmasıyla elde edilen bir şekle sahiptir. Bu varyantta, işlenenlerden biri skaler olmadığı sürece farklı sıralardaki diziler arasındaki işlemler desteklenmez.

Min için farklı boyutlu yayın desteği sunan alternatif bir varyant mevcuttur:

Min(lhs,rhs, broadcast_dimensions)

Bu işlem varyantı, farklı sıralardaki diziler arasında aritmetik işlemler (ör. matrise vektör ekleme) için kullanılmalıdır.

Ek yayın_boyutları işleneni, işlenenlerin yayınlanması için kullanılacak boyutları belirten bir tam sayı dilimidir. Semantikler, yayın sayfasında ayrıntılı olarak açıklanmaktadır.

StableHLO hakkında bilgi için StableHLO - minimum başlıklı makaleyi inceleyin.

Mul

Ayrıca XlaBuilder::Mul başlıklı makaleyi inceleyin.

lhs ve rhs öğelerinin çarpımını gerçekleştirir.

Mul(lhs, rhs)

Bağımsız değişkenlerin şekilleri benzer veya uyumlu olmalıdır. Şekillerin uyumlu olmasıyla ilgili yayın dokümanlarına bakın. Bir işlemin sonucu, iki giriş dizisinin yayınlanmasıyla elde edilen bir şekle sahiptir. Bu varyantta, işlenenlerden biri skaler olmadığı sürece farklı sıralardaki diziler arasındaki işlemler desteklenmez.

Mul için farklı boyutlu yayın desteği sunan alternatif bir varyant mevcuttur:

Mul(lhs,rhs, broadcast_dimensions)

Bu işlem varyantı, farklı sıralardaki diziler arasında aritmetik işlemler (ör. matrise vektör ekleme) için kullanılmalıdır.

Ek yayın_boyutları işleneni, işlenenlerin yayınlanması için kullanılacak boyutları belirten bir tam sayı dilimidir. Semantikler, yayın sayfasında ayrıntılı olarak açıklanmaktadır.

StableHLO hakkında bilgi için StableHLO - multiply başlıklı makaleye bakın.

Neg

Ayrıca XlaBuilder::Neg başlıklı makaleyi inceleyin.

Öğe bazında olumsuzlama x -> -x.

Neg(operand)

StableHLO bilgileri için StableHLO - negate başlıklı makaleye bakın.

Değil

Ayrıca XlaBuilder::Not başlıklı makaleyi inceleyin.

Öğe bazında mantıksal değil x -> !(x).

Not(operand)

StableHLO hakkında bilgi için StableHLO - not başlıklı makaleyi inceleyin.

OptimizationBarrier

Ayrıca XlaBuilder::OptimizationBarrier başlıklı makaleyi inceleyin.

Hesaplamaların bariyerin ötesine geçmesini engelleyen tüm optimizasyon geçişlerini engeller.

OptimizationBarrier(operand)

Tüm girişlerin, bariyerin çıkışlarına bağlı olan operatörlerden önce değerlendirilmesini sağlar.

StableHLO hakkında bilgi için StableHLO - optimization_barrier başlıklı makaleyi inceleyin.

Alternatif seçenek:

Ayrıca XlaBuilder::Or başlıklı makaleyi inceleyin.

lhs ve rhs üzerinde öğe bazında OR işlemi gerçekleştirir .

Or(lhs, rhs)

Bağımsız değişkenlerin şekilleri benzer veya uyumlu olmalıdır. Şekillerin uyumlu olmasıyla ilgili yayın dokümanlarına bakın. Bir işlemin sonucu, iki giriş dizisinin yayınlanmasıyla elde edilen bir şekle sahiptir. Bu varyantta, işlenenlerden biri skaler olmadığı sürece farklı sıralardaki diziler arasındaki işlemler desteklenmez.

Or için farklı boyutlu yayın desteği sunan alternatif bir varyant mevcuttur:

Or(lhs,rhs, broadcast_dimensions)

Bu işlem varyantı, farklı sıralardaki diziler arasında aritmetik işlemler (ör. matrise vektör ekleme) için kullanılmalıdır.

Ek yayın_boyutları işleneni, işlenenlerin yayınlanması için kullanılacak boyutları belirten bir tam sayı dilimidir. Semantikler, yayın sayfasında ayrıntılı olarak açıklanmaktadır.

StableHLO hakkında bilgi için StableHLO - or başlıklı makaleyi inceleyin.

Çıkış

Ayrıca XlaBuilder::Outfeed başlıklı makaleyi inceleyin.

Girişleri feed'e yazar.

Outfeed(operand, shape_with_layout, outfeed_config)

shape_with_layout, beslemek istediğimiz şekli belirtir.

StableHLO hakkında bilgi için StableHLO - outfeed başlıklı makaleyi inceleyin.

Ped

Ayrıca XlaBuilder::Pad başlıklı makaleyi inceleyin.

Pad(operand, padding_value, padding_config)

Verilen operand dizisini, dizi etrafında ve dizi öğeleri arasında verilen padding_value ile doldurarak genişletir. padding_config her boyut için kenar dolgusunun ve iç dolgunun miktarını belirtir.

PaddingConfig, PaddingConfigDimension öğesinin yinelenen bir alanıdır. Bu alan, her boyut için üç alan içerir: edge_padding_low, edge_padding_high ve interior_padding.

edge_padding_low ve edge_padding_high, her bir boyutun düşük uç kısmına (0 dizininin yanında) ve yüksek uç kısmına (en yüksek dizininin yanında) eklenen dolgu miktarını belirtir. Kenar dolgusu miktarı negatif olabilir. Negatif dolgunun mutlak değeri, belirtilen boyuttan kaldırılacak öğe sayısını gösterir.

interior_padding, her boyuttaki iki öğe arasına eklenen dolgu miktarını belirtir ve negatif olamaz. İç dolgu, kenar dolgusundan önce mantıksal olarak gerçekleşir. Bu nedenle, negatif kenar dolgusu durumunda öğeler, iç dolgulu işlenenden kaldırılır.

Kenar dolgusu çiftlerinin tümü (0, 0) ve iç dolgu değerlerinin tümü 0 ise bu işlem hiçbir şey yapmaz. Aşağıdaki şekilde, iki boyutlu bir dizi için farklı edge_padding ve interior_padding değerlerine ilişkin örnekler gösterilmektedir.

StableHLO bilgileri için StableHLO - pad başlıklı makaleyi inceleyin.

Parametre

Ayrıca XlaBuilder::Parameter başlıklı makaleyi inceleyin.

Parameter, bir hesaplamaya yapılan bağımsız değişken girişini temsil eder.

PartitionID

Ayrıca XlaBuilder::BuildPartitionId başlıklı makaleyi inceleyin.

Geçerli işlemin partition_id değerini üretir.

PartitionID(shape)

PartitionID, HLO dökümlerinde görünebilir ancak son kullanıcılar tarafından manuel olarak oluşturulması amaçlanmamıştır.

StableHLO hakkında bilgi için StableHLO - partition_id başlıklı makaleyi inceleyin.

PopulationCount

Ayrıca XlaBuilder::PopulationCount başlıklı makaleyi inceleyin.

operand öğesinin her bir öğesinde ayarlanan bit sayısını hesaplar.

PopulationCount(operand)

StableHLO bilgileri için StableHLO - popcnt başlıklı makaleyi inceleyin.

Pow

Ayrıca XlaBuilder::Pow başlıklı makaleyi inceleyin.

lhs'nın rhs ile öğe bazında üssünü alır.

Pow(lhs, rhs)

Bağımsız değişkenlerin şekilleri benzer veya uyumlu olmalıdır. Şekillerin uyumlu olmasıyla ilgili yayın dokümanlarına bakın. Bir işlemin sonucu, iki giriş dizisinin yayınlanmasıyla elde edilen bir şekle sahiptir. Bu varyantta, işlenenlerden biri skaler olmadığı sürece farklı sıralardaki diziler arasındaki işlemler desteklenmez.

Pow için farklı boyutlu yayın desteği sunan alternatif bir varyant mevcuttur:

Pow(lhs,rhs, broadcast_dimensions)

Bu işlem varyantı, farklı sıralardaki diziler arasında aritmetik işlemler (ör. matrise vektör ekleme) için kullanılmalıdır.

Ek yayın_boyutları işleneni, işlenenlerin yayınlanması için kullanılacak boyutları belirten bir tam sayı dilimidir. Semantikler, yayın sayfasında ayrıntılı olarak açıklanmaktadır.

StableHLO hakkında bilgi için StableHLO - power başlıklı makaleyi inceleyin.

Real

Ayrıca XlaBuilder::Real başlıklı makaleyi inceleyin.

Karmaşık (veya gerçek) bir şeklin öğe bazında gerçek kısmı. x -> real(x). İşlenen, kayan nokta türündeyse Real aynı değeri döndürür.

Real(operand)

StableHLO hakkında bilgi için StableHLO - real başlıklı makaleyi inceleyin.

Recv

Ayrıca XlaBuilder::Recv başlıklı makaleyi inceleyin.

Recv, RecvWithTokens ve RecvToHost, HLO'da iletişim temel birimleri olarak kullanılan işlemlerdir. Bu işlemler genellikle HLO dökümlerinde düşük düzeyli giriş/çıkış veya cihazlar arası aktarımın bir parçası olarak görünür ancak son kullanıcılar tarafından manuel olarak oluşturulması amaçlanmamıştır.

Recv(shape, handle)

Aynı kanal herkese açık adını paylaşan başka bir hesaplamadaki Send talimatından belirtilen şekle ait verileri alır. Alınan veriler için bir XlaOp döndürür.

StableHLO hakkında bilgi için StableHLO - recv başlıklı makaleyi inceleyin.

RecvDone

Ayrıca HloInstruction::CreateRecv ve HloInstruction::CreateRecvDone politikalarını da inceleyin.

Send'ye benzer şekilde, Recv işleminin istemci API'si senkron iletişimi temsil eder. Ancak, talimat, eşzamansız veri aktarımlarını etkinleştirmek için dahili olarak 2 HLO talimatına (Recv ve RecvDone) ayrıştırılır.

Recv(const Shape& shape, int64 channel_id)

Aynı channel_id ile Send talimatından veri almak için gereken kaynakları ayırır. Ayrılan kaynaklar için bir bağlam döndürür. Bu bağlam, veri aktarımının tamamlanmasını beklemek üzere sonraki bir RecvDone talimatı tarafından kullanılır. Bağlam, {alma arabelleği (şekil), istek tanımlayıcısı (U32)} demetidir ve yalnızca RecvDone talimatı tarafından kullanılabilir.

Recv talimatıyla oluşturulan bir bağlam verildiğinde, veri aktarımının tamamlanmasını bekler ve alınan verileri döndürür.

Azaltma

Ayrıca XlaBuilder::Reduce başlıklı makaleyi inceleyin.

Bir veya daha fazla diziye paralel olarak azaltma işlevi uygular.

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

Burada:

• N, 1'e eşit veya 1'den büyük olmalıdır.
• Hesaplama "kabaca" birleştirici olmalıdır (aşağıya bakın).
• Tüm giriş dizileri aynı boyutlara sahip olmalıdır.
• Tüm başlangıç değerleri, computation altında bir kimlik oluşturmalıdır.
• N = 1 ise Collate(T) T olur.
• N > 1, Collate(T_0, ..., T_{N-1}), T türünde N öğeli bir demettir.

Bu işlem, her giriş dizisinin bir veya daha fazla boyutunu skalerlere indirger. Döndürülen her dizinin boyut sayısı number_of_dimensions(operand) - len(dimensions)'dır. İşlemin çıkışı Collate(Q_0, ..., Q_N)'dır. Burada Q_i, T_i türünde bir dizidir ve boyutları aşağıda açıklanmıştır.

Farklı arka uçların, azaltma hesaplamasını yeniden ilişkilendirmesine izin verilir. Bu durum, toplama gibi bazı azaltma işlevleri kayan sayılar için birleştirici olmadığından sayısal farklılıklara yol açabilir. Ancak verilerin aralığı sınırlıysa kayan nokta toplama, çoğu pratik kullanım için yeterince ilişkilidir.

StableHLO hakkında bilgi için StableHLO - reduce başlıklı makaleyi inceleyin.

Örnekler

Değerleri [10, 11, 12, 13] olan tek bir 1 boyutlu dizide tek bir boyut boyunca indirgeme yapıldığında ve indirgeme işlevi f (bu computation) kullanıldığında bu işlem şu şekilde hesaplanabilir:

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

ancak başka birçok olasılık da vardır. Örneğin:

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

Aşağıda, indirgemenin nasıl uygulanabileceğine dair kaba bir sözde kod örneği verilmiştir. Bu örnekte, indirgeme hesaplaması olarak toplama işlemi kullanılır ve başlangıç değeri 0'dır.

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]

Aşağıda, 2 boyutlu bir diziyi (matris) küçültme örneği verilmiştir. Şeklin 2 boyutu vardır: 2 boyutlu 0. boyut ve 3 boyutlu 1. boyut:

"Ekleme" işleviyle 0 veya 1 boyutunu azaltmanın sonuçları:

Her iki azaltma sonucunun da 1 boyutlu diziler olduğunu unutmayın. Diyagramda, yalnızca görsel kolaylık sağlamak için biri sütun, diğeri satır olarak gösterilir.

Daha karmaşık bir örnek için 3 boyutlu bir diziye göz atın. Boyut sayısı 3'tür. Boyut 0'ın boyutu 4, boyut 1'in boyutu 2 ve boyut 2'nin boyutu 3'tür. Kolay anlaşılması için 1-6 arasındaki değerler 0. boyutta tekrarlanır.

2D örneğine benzer şekilde, yalnızca bir boyutu azaltabiliriz. Örneğin, 0. boyutu küçültürsek 0. boyuttaki tüm değerlerin tek bir değere indirgendiği 2 boyutlu bir dizi elde ederiz:

|  4   8  12 |
| 16  20  24 |

2. boyutu küçültürsek 2. boyuttaki tüm değerlerin tek bir değere indirgendiği 2 boyutlu bir dizi elde ederiz:

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

Girişteki kalan boyutlar arasındaki göreli sıranın çıkışta korunduğunu ancak boyut sayısının değişmesi nedeniyle bazı boyutlara yeni sayılar atanabileceğini unutmayın.

Ayrıca birden fazla boyutu da azaltabiliriz. 0 ve 1 boyutlarını azaltarak [20, 28, 36] 1 boyutlu dizisi elde edilir.

3D diziyi tüm boyutları üzerinde küçültmek, skaler 84 değerini üretir.

Variadic Reduce

N > 1 olduğunda, tüm girişlere aynı anda uygulandığı için azaltma işlevinin uygulanması biraz daha karmaşıktır. İşlenenler, hesaplamaya aşağıdaki sırayla sağlanır:

• İlk işlenen için azaltılmış değer çalıştırma
• ...
• N. işlenen için azaltılmış değer çalıştırma
• İlk işlenen için giriş değeri
• ...
• N. işlenen için giriş değeri

Örneğin, 1 boyutlu bir dizinin maksimum değerini ve argmaks değerini paralel olarak hesaplamak için kullanılabilecek aşağıdaki azaltma işlevini ele alalım:

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

1 boyutlu giriş dizileri V = Float[N], K = Int[N] ve başlangıç değerleri I_V = Float, I_K = Int için, yalnızca giriş boyutu boyunca azaltmanın sonucu f_(N-1) aşağıdaki yinelemeli uygulamaya eşdeğerdir:

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

Bu azaltma işlemini bir değer dizisine ve sıralı dizinler dizisine (ör. iota) uygulamak, diziler üzerinde birlikte yineleme yapar ve maksimum değeri ve eşleşen dizini içeren bir demet döndürür.

ReducePrecision

Ayrıca XlaBuilder::ReducePrecision başlıklı makaleyi inceleyin.

Kayan nokta değerlerinin daha düşük hassasiyetli bir biçime (ör. IEEE-FP16) ve tekrar orijinal biçime dönüştürülmesinin etkisini modeller. Düşük hassasiyetli biçimdeki üs ve mantis bitlerinin sayısı rastgele belirtilebilir. Ancak tüm bit boyutları tüm donanım uygulamalarında desteklenmeyebilir.

ReducePrecision(operand, exponent_bits, mantissa_bits)

Sonuç, T türünde bir dizidir. Giriş değerleri, verilen mantis bit sayısı ile gösterilebilen en yakın değere yuvarlanır ("ties to even" semantiği kullanılarak) ve üs bitlerinin sayısı tarafından belirtilen aralığı aşan tüm değerler pozitif veya negatif sonsuza sabitlenir. NaN değerleri, standart NaN değerlerine dönüştürülse de korunur.

Daha düşük hassasiyetli biçimde, en az bir üs biti olmalıdır (sıfır değerini sonsuzluktan ayırt etmek için, çünkü her ikisinin de mantisası sıfırdır) ve negatif olmayan sayıda mantisa biti olmalıdır. Üs veya mantis bitlerinin sayısı, T türünün karşılık gelen değerini aşabilir. Bu durumda, dönüşümün ilgili kısmı basitçe bir işlem yapmaz.

StableHLO bilgileri için StableHLO - reduce_precision başlıklı makaleyi inceleyin.

ReduceScatter

Ayrıca XlaBuilder::ReduceScatter başlıklı makaleyi inceleyin.

ReduceScatter, etkili bir şekilde AllReduce işlemi yapan ve ardından sonucu shard_count bloğa bölerek dağıtan toplu bir işlemdir. Kopyalama grubundaki scatter_dimension ve kopyalama i, ith parçayı alır.

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

• operand bir dizi demeti olduğunda, her demet öğesi üzerinde reduce-scatter işlemi gerçekleştirilir.
• replica_groups, azaltmanın gerçekleştirildiği kopya gruplarının listesidir (geçerli kopyanın kopya kimliği ReplicaId kullanılarak alınabilir). Her gruptaki kopyaların sırası, tüm azaltma sonucunun dağıtılacağı sırayı belirler. replica_groups boş olmalıdır (bu durumda tüm kopyalar tek bir gruba aittir) veya kopya sayısı kadar öğe içermelidir. Birden fazla kopya grubu olduğunda hepsinin aynı boyutta olması gerekir. Örneğin, replica_groups = {0, 2}, {1, 3}, 0 ve 2 ile 1 ve 3 kopyaları arasında azaltma işlemi gerçekleştirir ve sonucu dağıtır.
• shard_count, her çoğaltma grubunun boyutudur. Bu bilgi, replica_groups boş olduğunda gereklidir. replica_groups boş değilse shard_count, her kopya grubunun boyutuna eşit olmalıdır.
• channel_id, modüller arası iletişim için kullanılır: Yalnızca aynı channel_id ile yapılan reduce-scatter işlemleri birbirleriyle iletişim kurabilir.
• layout Düzenler hakkında daha fazla bilgi için xla::shapes bölümüne bakın.
• use_global_device_ids, kullanıcı tarafından belirtilen bir işarettir. false(varsayılan) replica_groups içindeki sayılar true olduğunda ReplicaId olur. true replica_groups, (ReplicaID*partition_count + partition_id) değerinin genel kimliğini temsil eder. Örneğin:
  • 2 kopya ve 4 bölümle
  • 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)
  • Burada her çift (replica_id, partition_id) şeklindedir.

Çıkış şekli, giriş şeklinin scatter_dimension kez shard_count kat küçültülmüş halidir. Örneğin, iki kopya varsa ve işlenenin iki kopyada sırasıyla [1.0, 2.25] ve [3.0, 5.25] değerleri varsa scatter_dim değerinin 0 olduğu bu işlemden elde edilen çıkış değeri, ilk kopya için [4.0], ikinci kopya için [7.5] olur.

StableHLO hakkında bilgi için StableHLO - reduce_scatter başlıklı makaleyi inceleyin.

ReduceScatter - Example 1 - StableHLO

Yukarıdaki örnekte, ReduceScatter'a katılan 2 kopya vardır. Her replikada işlenen, f32[2,4] şeklindedir. Replikalar arasında bir all-reduce (toplama) işlemi gerçekleştirilir ve her replikada f32[2,4] şeklindeki indirgenmiş bir değer üretilir. Bu küçültülmüş değer daha sonra 1. boyut boyunca 2 parçaya bölünür. Böylece her parçanın şekli f32[2,2] olur. İşlem grubundaki her kopya, gruptaki konumuna karşılık gelen parçayı alır. Sonuç olarak, her kopyadaki çıkışın şekli f32[2,2] olur.

ReduceWindow

Ayrıca XlaBuilder::ReduceWindow başlıklı makaleyi inceleyin.

N çok boyutlu diziden oluşan bir dizinin her penceresindeki tüm öğelere bir azaltma işlevi uygulayarak çıktı olarak tek bir çok boyutlu dizi veya N çok boyutlu diziden oluşan bir demet üretir. Her çıkış dizisi, pencerenin geçerli konumlarının sayısı kadar öğe içerir. Havuzlama katmanı, ReduceWindow olarak ifade edilebilir. Reduce'ye benzer şekilde, uygulanan computation her zaman soldaki init_values'den geçirilir.

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

Burada:

• N, 1'e eşit veya 1'den büyük olmalıdır.
• Tüm giriş dizileri aynı boyutlara sahip olmalıdır.
• N = 1 ise Collate(T) T olur.
• N > 1, Collate(T_0, ..., T_{N-1}), (T0,...T{N-1}) türünde N öğeli bir demettir.

StableHLO bilgileri için StableHLO - reduce_window başlıklı makaleyi inceleyin.

ReduceWindow - Example 1

Giriş, [4x6] boyutunda bir matristir. window_dimensions ve window_stride_dimensions değerleri [2x3] şeklindedir.

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