İş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 bilgileri 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 belgelerine 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.

Ekleme için farklı boyutlu yayın desteği olan 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 broadcast_dimensions 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ı channel_id ile yapılan all-gather işlemleri birbirleriyle iletişim kurabilir.
• 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 true değerini döndürür. Bu, tüm azaltma işlemi hem bölümden bölüme hem de kopyadan kopyaya ise cihazların daha esnek bir şekilde gruplandırılmasını sağlar.

Çıkış şekli, giriş şeklinin all_gather_dimension katıshard_count büyüklüğündedir. Ö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şlemin çı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 bir 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 (geçerli 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ı channel_id ile yapılan all-reduce işlemleri birbirleriyle iletişim kurabilir.
• shape_with_layout: AllReduce'un düzenini verilen düzene zorlar. Bu, ayrı ayrı derlenen bir grup AllReduce işlemi için aynı düzeni garanti etmek 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 true değerini döndürür. Bu, tüm azaltma işlemi hem bölümden bölüme hem de kopyadan kopyaya ise 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şlenenin iki kopyadaki değeri sırasıyla [1.0, 2.5] ve [3.0, 5.25] ise 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şmesi için çok fazla yol yoktur ancak bir while döngüsünün koşulu infeed verilerine bağlı olduğunda ve infeed verileri while döngüsünün bir kopyada diğerinden daha fazla kez yinelemesine neden olduğunda bu durum mümkündür.

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şlevler 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 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ğıtma 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 (mevcut 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} }, AllToAll'un kopyalar {1, 2, 3} içinde ve toplama aşamasında uygulanacağı, alınan blokların 1, 2, 3 sırasıyla birleştirileceği anlamına gelir. Ardından, 4, 5, 0 kopyaları içinde 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ündükleri sırayla birleştirilerek tek bir gruba ait olur.

Ö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 0. boyut 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 vardır. Her kopya üzerinde 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, i. kopyaya input[input_offsets[i]:input_offsets[i]+send_sizes[i]] güncellemesi 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ş verisi 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 replika çı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], her bir uzak cihaz için, her bir uzak cihazın kopyalama grubunda, aynı uzak cihaza (her biri farklı uzaklıklarda) en fazla num_updates güncelleme gönderebilir.

Ö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 belgelerine 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.

And 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 broadcast_dimensions 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 başlıklı makalelere de 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 belgelerine 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 broadcast_dimensions 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 (operand olarak 4 boyutlu bir dizi ve özellik boyutu dizini l, toplu iş boyutu m ve uzamsal boyutlar 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 iş 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 hesaplanmadan BatchNormTraining çağrılmasına eşdeğerdir. Bunun yerine tahmini değerler olarak giriş mean ve variance kullanılır. Bu işlemin amacı çıkarımda gecikmeyi azaltmaktır. Bu nedenle BatchNormInference adı verilmiştir.

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

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 iş 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 öğesinden 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'a 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üşü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)

Dönüşümden önce ve sonraki temel boyut oranıyla değişecek olan son boyut dışında, işlenen ve hedef şeklin boyutları eşleşmelidir.

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 T' boyutunun giriş öğesinin T boyutuna eşit olmadığı durumu destekler. İşlemin tamamı kavramsal olarak bitcast 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ıdı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 boyut 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ış ş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, değeri 2.0f olan bir f32 skaleriyse 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. Anlamsal yapı, 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, girişleri ve composite_attributes'i alıp sonuçlar üreten bir işlemi kapsar. İşlemin anlamsal yapısı, ayrıştırma özelliğiyle uygulanır. Bileşik işlem, program anlamsal yapısını değiştirmeden ayrıştırılmış haliyle değiştirilebilir. Ayrıştırmanın satır içine yerleştirilmesinin aynı işlem anlamsal yapısını sağlamadığı durumlarda custom_call kullanılması tercih edilir.

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ğiyle 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ı makaleyi inceleyin.

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$. Eğer 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 yok sayı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. Bu durumda, küçük 2 boyut hariç tüm boyutlar grup boyutlarıdır.

a simetrik (Hermitian) pozitif tanımlı değilse sonuç uygulamaya bağlı olarak tanımlanı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 ve tf.reshape işlemine de bakın.

Bir dizinin boyutlarını tek bir 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 yer alan tek bir yeni boyutla değiştirilir. Yeni boyutun boyutu, orijinal boyutların boyutlarının çarpımına eşittir. dimensions içindeki en düşük boyut numarası, bu boyutları daraltan döngü yuvasında en yavaş değişen (en büyük) boyuttur ve en yüksek boyut numarası en hızlı değişen (en küçük) boyuttur. Daha fazla genel sıralama çökmesi 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)

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şitlik 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 belgelerine 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 sunan 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 broadcast_dimensions 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, kayan noktalı sayılar üzerinde 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 belgelerine 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 broadcast_dimensions 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 oluşan toplam sipariş desteklenir:

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

NeTotalOrder(lhs,rhs, broadcast_dimensions)

StableHLO hakkında bilgi 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 belgelerine 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.

Almanya'da 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 broadcast_dimensions 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 büyük 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 öğeleri arasında öğ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 belgelerine 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 broadcast_dimensions 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 değerleri arasında öğ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 belgelerine 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 broadcast_dimensions 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 belgelerine 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 broadcast_dimensions 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ının toplam siparişini desteklemek için şunlar zorunlu kılını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 belgelerine 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 broadcast_dimensions 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 oluşan bir dizi oluşturur. Dizi, her bir giriş dizisi işleneniyle 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 boyutu adlandırmak 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)

predicate, true ise true_computation'yı, predicate, false ise false_computation'ü yürütür ve sonucu döndürü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 veya false_computation işlemlerinden 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 bilgileri 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 oluşturur.

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 bir veri şeklinden hedef şekle öğe bazında dönüştürme işlemi gerçekleştirir. Boyutlar eşleşmelidir ve dönüştürme öğe bazında yapılır. Örneğin, s32 öğeler, s32-to-f32 dönüştürme rutini aracılığıyla f32 öğelere dönüşü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 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 (Konvolüsyon)

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 dolgusu, 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 boyutların 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ırayla verilir:

• 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ı açıklar.

rhs bağımsız değişkeni, evrişimli filtreyi/çekirdeği/pencereyi açıklayan (n+2) boyutlu bir dizidir. Boyutlar şu sırayla verilir:

• output-z: Çıkışın z boyutu.
• input-z: Bu boyutun boyutu ile feature_group_count çarpıldığında, lhs'deki z boyutunun boyutuna eşit olmalıdır.
• spatial_dims: Temel alan üzerinde hareket eden n boyutlu pencereyi tanımlayan n uzamsal boyutları 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 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 çiftin ilk öğesi düşük dolgu, ikinci öğesi ise yüksek dolgudur. 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 birinin arasına d-1 boşluk yerleştirilir ve dizinin boyutu artırılır. Boşluklar, işlem yapmayan bir değerle doldurulur. Bu değer, evrişim için sıfır anlamına gelir.

Sağ tarafın genişletilmesine boşluklu evrişim de denir. Daha fazla bilgi için tf.nn.atrous_conv2d başlıklı makaleyi inceleyin. Sol tarafın genişletilmesine transpoze evrişim de 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üğü, her grubun da ardışık bir özellik alt dizisinden oluştuğu anlamına gelir. 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ş özellikleri grubunun boyutuna zaten sahiptir). i'inci gruplar, birçok ayrı evrişim için feature_group_count hesaplamak üzere birlikte kullanılır. Bu evrişimlerin sonuçları, çıkış özelliği boyutunda birleştirilir.

Derinlik yönünde 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 bölümüne bakın.

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, batch_group_count ile çarpıldığında lhs'deki batch boyutunun boyutuna eşit olmalıdır.
• z: Çekirdek üzerindeki output-z ile aynı boyutta (rhs).
• spatial_dims: Evrişimli pencerenin her geçerli yerleşimi için bir değer.

Yukarıdaki şekilde batch_group_count alanının nasıl çalıştığı gösterilmektedir. Her bir lhs grubu batch_group_count gruba bölünür ve çıkış özellikleri için de aynı işlem yapılır. Ardından, bu grupların her biri için ikili sarmalar yapılır ve çıkış, çıkış özelliği boyutu boyunca birleştirilir. Diğer tüm boyutların (özellik ve uzamsal) 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ını seçelim. Ardından (y,x), pencerenin temel alan içindeki bir köşesinin konumudur (ör. uzamsal boyutları nasıl yorumladığınıza bağlı olarak sol üst köşe). Artık temel alandan alınmış 2 boyutlu bir penceremiz var. Bu pencerede her 2 boyutlu nokta 1 boyutlu bir vektörle ilişkilendiriliyor. Böylece 3 boyutlu bir kutu elde ediyoruz. Konvolüsyonel çekirdekten, çıkış koordinatı z'yi sabitlediğimiz için 3 boyutlu bir kutumuz da var. İki kutu aynı boyutlara sahip olduğundan, iki kutu arasındaki öğe bazında çarpımların toplamını alabiliriz (nokta çarpımına benzer). Bu, çıkış değeridir.

output-z değeri ö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ı konvolüsyon 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 olduğu 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ı (sıfıra göre işaretli/işaretsiz bölme/kalan veya INT_SMIN ile -1'nin işaretli bölme/kalanı), uygulamaya göre tanımlanmış bir değer üretir.

Bağımsız değişkenlerin şekilleri benzer veya uyumlu olmalıdır. Şekillerin uyumlu olmasıyla ilgili yayın belgelerine 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 broadcast_dimensions 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 "daraltı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 toplu boyut numaralarının belirtilmesine olanak tanır.

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

lhs ve rhs kaynaklı ilişkili sözleşme boyutu numaralarının aynı olması gerekmez ancak aynı boyut ölçülerine sahip olmaları gerekir.

Sözleşme boyutu 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 ürünlerinden alınan ilişkili parti boyut numaraları aynı boyutlara sahip olmalıdır.

Grup boyutu numaraları içeren örnek (grup boyutu 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 benzer.

"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 start_indices konumunda bir alt dizi çıkarır. Her boyuttaki dilimin boyutu, her boyuttaki özel dilim aralıklarının varış 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)

Etkin 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üştürme uygulanmadan önce sınırlarda ise dönüştürmenin 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ış bir dilimdir. 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)

Etkin 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 sınırlı olmasını sağlar. Dönüşüm uygulanmadan önce dilim sınırlıysa dönüşümün 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 bilgileri 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 üstel 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.

Öğeler 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 FFT işlemlerinin basamaklı olarak uygulanmasına 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şlev 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ı ofsetinde) birleştirir.

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

Genel Anlamsal Yapı

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, [6,7] şeklindeyse ve index_vector_dim, 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ı batch_dims[k] için k'e eşitse) start_indices.shape içinden karşılık gelen 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, collapsed_slice_dims dizinlerindeki sınırlar kaldırılmış slice_sizes değeridir).

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. S[i] = start_indices[Combine(G, i)] olacak şekilde bir vektör S oluşturmak için G kullanın. 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. S kullanarak operand içine Sin başlangıç dizini oluşturun. Bunu yapmak için start_index_map kullanarak S dağıtın. 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. Oin dizinlerini collapsed_slice_dims kümesine göre Out içindeki ofset boyutlarında dağıtarak operand içine bir dizin oluşturun. Daha net bir şekilde ifade etmek 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, + öğe bazında toplama işlemi olmak üzere Oin + Sin'dir.

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 true olarak ayarlanırsa XLA, start_indices değerlerinin kullanıcı tarafından sıralandığını (değerleri start_index_map'e göre dağıtıldıktan sonra artan sırada) varsayabilir. Sıralanmamışlarsa anlamsal yapı 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.

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

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

• collapsed_slice_dims boyutlarını daraltarak dilimi yeniden şekillendiririz. Tüm daraltılmış dilim boyutlarının 1 sınırı olması gerektiğinden 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 ayarlanır. index_vector_dim için daha ilginç değerler işlemi temelden değiştirmez ancak görsel gösterimi daha hantal 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 dizinde bulunan ve bunu aşağıdaki şekilde giriş dizisindeki bir öğeyle eşleyen bir dizin dönüşümü olarak gösterilebilir:

Öncelikle G kullanılarak gather_indices dizisinden bir (X,Y) vektörü seçilir. Çı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 örnekteki O0, O1 içeren boyutlar) olduğunu yapılandırabiliriz. Çıkış toplu iş boyutları (son örnekteki G0, G1 içeren boyutlar), ofset boyutları olmayan çıkış boyutları olarak tanımlanır.

2. Çıkış şeklindeki çıkış ofseti 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. Dilim boyutu 1 olduğundan, bunlar için geçerli olan tek dizin 0'dir ve bunların çıkarılması 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 toplanan dizinler 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ş dizisinde dizin olarak kullanılmadan önce bunlar sırasıyla "Dizin Eşlemeyi Topla" (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şletilerek [X,O0] olarak toplanır. Diğer bir deyişle, çıkış dizini [G0,G1,O0], giriş dizini [GatherIndices[G0,G1,0],O0] ile eşlenerek tf.gather_nd için semantiği verir.

slice_sizes için kılıf [1,11]. Bu, sezgisel olarak, gather_indices dizisindeki her dizinin X bir satırın tamamını seçtiği ve sonucun 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 bilgileri 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 bir değere sahip bir demeti dizine ekler.

Şekil çıkarımı, sonuçta elde edilen değerin türünü belirleyebilmesi için değer, derleme zamanında sabit 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.

Feed 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 öğesini okur, verileri verilen şekil ve düzen olarak yorumlar ve verilerin XlaOp değerini döndürür. Bir hesaplamada birden fazla feed içi işlem yapılabilir ancak feed içi işlemler arasında toplam bir sıra olmalıdır. Örneğin, aşağıdaki kodda iki Infeed değeri arasında toplam bir sıra vardır çünkü while döngüleri arasında bir bağımlılık vardır.

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. Bu dizideki 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 işlevi, 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)

Belirtilen operands dizilerine bir skaler işlev uygular. Her öğenin, giriş dizilerindeki karşılık gelen öğelere uygulanan eşlenmiş işlevin sonucu olduğu aynı boyutlarda bir dizi oluşturur.

Eşlenen işlev, N adet skaler türde T girişi ve S türünde tek bir çıkışı olması kısıtlamasıyla rastgele bir hesaplamadır. Çıkış, öğe türü T, 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 belgelerine 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 broadcast_dimensions 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 belgelerine 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 broadcast_dimensions 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 belgelerine 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 broadcast_dimensions 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 - 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.

Optimizasyon geçişlerinin, hesaplamaları bariyerin ötesine taşımasını 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 belgelerine 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 olan 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 broadcast_dimensions 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.

Pad

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

Pad(operand, padding_value, padding_config)

Verilen operand dizisini, dizi etrafında ve dizinin öğ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 alanının tekrar eden bir alanıdır. PaddingConfigDimension, 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 dizinin 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 mantıksal olarak önce 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) ise ve iç dolgu değerlerinin tümü 0 ise bu işlem etkisizdir. Aşağıdaki şekilde, iki boyutlu bir dizi için farklı edge_padding ve interior_padding değerlerinin örnekleri 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 bilgileri 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 belgelerine 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 broadcast_dimensions 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 öğeleri olarak işlev gören işlemlerdir. Bu işlemler genellikle HLO dökümlerinde düşük seviyeli 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 kimliğini paylaşan başka bir hesaplamadaki Send talimatından belirli şekle sahip veriler alır. Alınan veriler için bir XlaOp döndürür.

StableHLO bilgileri 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 daha büyük olmalıdır.
• Hesaplama "kabaca" ilişkili 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 öğelerden oluşan 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 işlemi, çoğu pratik kullanım için yeterince ilişkilidir.

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

Örnekler

[10, 11, 12, 13] değerlerine sahip tek bir 1 boyutlu dizide tek bir boyut boyunca indirgeme yapıldığında, indirgeme işlevi f (bu computation) ise 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, 0 başlangıç değeriyle toplama işlemini kullanarak indirgemenin nasıl uygulanabileceğine dair kaba bir sözde kod örneği verilmiştir.

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:

"Ekle" işleviyle 0 veya 1 boyutunu küçültmenin 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 olarak 3 boyutlu bir dizi verelim. Boyut sayısı 3'tür. Boyut 0'ın boyutu 4, boyut 1'in boyutu 2 ve boyut 2'nin boyutu 3'tür. Basitlik için 1 ile 6 arasındaki değerler boyut 0'da tekrarlanır.

2D örneğine benzer şekilde, yalnızca bir boyutu azaltabiliriz. Örneğin, boyutu 0'ı küçültürsek boyutu 0'daki tüm değerlerin bir skalere katlandığı 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.

Birden fazla boyutu da azaltabiliriz. 0 ve 1 boyutlarını azaltarak [20, 28, 36] 1 boyutlu dizisini elde ederiz.

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

Variadic Reduce

N > 1 olduğunda, tüm girişlere aynı anda uygulandığı için reduce 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ırılıyor
• ...
• N. işlenen için azaltılmış değer çalıştırılıyor
• İ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 argmax 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ğerlerini daha düşük hassasiyetli bir biçime (ör. IEEE-FP16) ve tekrar orijinal biçime dönüştürmenin 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 ikisinde de sıfır mantis vardır) ve negatif olmayan sayıda mantis biti olmalıdır. Üs veya mantis bitlerinin sayısı, T türü için karşılık gelen değeri aşabilir. Bu durumda, dönüşümün ilgili kısmı basitçe hiç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 bloklara 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 replika grubu olduğunda tüm gruplar aynı boyutta olmalıdır. Ö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) olduğunda replica_groups içindeki sayılar true olduğunda ReplicaId olur. replica_groups, (ReplicaID*partition_count + partition_id) öğesinin 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 küçültülmüş halidir. Örneğin, iki kopya varsa ve işlenen, iki kopyada sırasıyla [1.0, 2.25] ve [3.0, 5.25] değerine sahipse scatter_dim'nin 0 olduğu bu işlemin çı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ı makaleye bakın.

ReduceScatter - Example 1 - StableHLO

Yukarıdaki örnekte, ReduceScatter'a katılan 2 kopya vardır. Her replikada işlenen, f32[2,4] şeklindedir. Kopyalar arasında bir all-reduce (toplama) işlemi gerçekleştirilir ve her kopyada f32[2,4] şeklindeki indirgenmiş bir değer elde edilir. 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 grubu içindeki 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. Bir havuz oluşturma katmanı ReduceWindow olarak ifade edilebilir. Reduce'ye benzer şekilde, uygulanan computation her zaman soldaki init_values'in önüne geçer.

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 öğelerden oluşan bir demettir.

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

ReduceWindow - Example 1

Giriş, [4x6] boyutunda bir matristir ve hem window_dimensions hem de window_stride_dimensions [2x3] boyutundadır.

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