İşlem anlamı

bookmark_border Koleksiyonlar ile düzeninizi koruyun İçeriği tercihlerinize göre kaydedin ve kategorilere ayırın.

Aşağıda, XlaBuilder arayüzünde tanımlanan işlemlerin semantikleri açıklanmaktadır. Bu işlemler genellikle xla_data.proto'teki RPC arayüzünde tanımlanan işlemlerle bire bir eşlenir.

Adlandırmayla ilgili not: XLA'nın ele aldığı genelleştirilmiş veri türü, belirli bir türden (ör. 32 bitlik kayan nokta) öğeler içeren N boyutlu bir dizidir. Belge boyunca, keyfi boyutlu bir diziyi belirtmek için dizi kullanılır. Kolaylık sağlamak için özel durumlar daha spesifik ve tanıdık isimlere sahiptir. Örneğin, vektör 1 boyutlu bir dizi, matris ise 2 boyutlu bir dizidir.

AfterAll

Ayrıca XlaBuilder::AfterAll sayfasını da inceleyin.

AfterAll, değişken sayıda jeton alır ve tek bir jeton oluşturur. Jetonlar, sıralamayı zorunlu kılmak için yan etki gösteren işlemler arasında işlenebilir olan ilkel türlerdir. AfterAll, bir işlemi bir dizi işlemden sonra sıralamak için jetonların bir birleşimi olarak kullanılabilir.

AfterAll(operands)

AllGather

Ayrıca XlaBuilder::AllGather sayfasını da inceleyin.

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

AllGather(operand, all_gather_dim, shard_count, replica_group_ids, channel_id)

• replica_groups, aralarında birleştirme işleminin yapıldığı kopya gruplarının bir listesidir (mevcut kopyanın kopya kimliği ReplicaId kullanılarak alınabilir). Her gruptaki kopyaların sırası, girişlerinin sonuçta bulunduğu sırayı belirler. replica_groups, boş olmalıdır (bu durumda tüm kopyalar 0 ile N - 1 arasında sıralanmış tek bir gruba aittir) veya kopya sayısıyla 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 kopya grubunun boyutudur. replica_groups değerlerinin boş olduğu durumlarda buna ihtiyacımız vardır.
• channel_id, modüller arası iletişim için kullanılır: Yalnızca aynı channel_id değerine sahip all-gather işlemleri birbirleriyle iletişim kurabilir.

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

AllReduce

Ayrıca XlaBuilder::AllReduce sayfasını da inceleyin.

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

AllReduce(operand, computation, replica_group_ids, channel_id)

• operand bir dizi tuple olduğunda, tüm azaltma işlemi tuple'in her öğesinde gerçekleştirilir.
• replica_groups, azaltmanın yapıldığı kopya gruplarının listesidir (mevcut kopyanın kopya kimliği ReplicaId kullanılarak alınabilir). replica_groups, boş olmalıdır (bu durumda tüm kopyalar tek bir gruba aittir) veya kopya sayısıyla aynı sayıda öğ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 değerine sahip all-reduce işlemleri birbirleriyle iletişim kurabilir.

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

AllReduce sonucunun hesaplanması için her bir replikadan bir giriş alınması gerekir. Bu nedenle, bir replika bir AllReduce düğümünü diğerinden daha fazla kez yürütürse eski replika sonsuza kadar bekler. Kopyaların tümü aynı programı çalıştırdığından bunun gerçekleşmesi için pek çok yol yoktur ancak bir while döngüsünün koşulu, feed'den gelen verilere bağlı olduğunda ve feed'e eklenen veriler while döngüsünün bir kopyada diğerinden daha fazla iterasyon yapmasına neden olduğunda bu durum mümkündür.

AllToAll

Ayrıca XlaBuilder::AllToAll sayfasını da inceleyin.

AllToAll, tüm çekirdeklerden tüm çekirdeklere veri gönderen toplu bir işlemdir. İki aşamadan oluşur:

1. Dağıtım aşaması. Her çekirdekte, operan split_dimensions boyunca split_count sayıda bloka bölünür ve bloklar tüm çekirdeklere dağıtılır (ör. 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 aşağıdaki yöntemlerle yapılandırılabilir:

• replica_groups: Her ReplicaGroup, hesaplamaya katılan kopya kimliklerinin bir listesini içerir (mevcut kopyanın kopya kimliği ReplicaId kullanılarak alınabilir). AllToAll, alt gruplar içinde belirtilen sırada uygulanır. Örneğin, replica_groups = { {1,2,3}, {4,5,0} }, {1, 2, 3} kopyalarında ve toplama aşamasında bir AllToAll işlevinin uygulanacağı ve alınan blokların 1, 2, 3 sırasıyla birleştirileceği anlamına gelir. Ardından, 4, 5, 0 kopyalarında 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 dize birleştirme sırasına göre tek bir gruba aittir.

Ön koşullar:

• split_dimension üzerindeki işlenenin boyutu split_count'e bölünebilir.
• İşlenenin şekli tuple değil.

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

Aşağıda Alltoall örneği gösterilmektedir.

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

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

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, mean, variance, grad_output, epsilon, feature_index)

İşlem, özellik boyutundaki her özellik için (feature_index, operand'daki özellik boyutunun dizinidir) diğer tüm boyutlarda operand, offset ve scale ile ilgili gradyanları hesaplar. feature_index, operand'teki ö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 boyut m ve uzamsal boyutlar w ve h 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}$$

mean ve variance girişleri, toplu ve uzamsal boyutlardaki an değerlerini temsil eder.

Çıkış türü, üç tutamaktan oluşan bir tuple'dir:

BatchNormInference

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

Bir diziyi toplu ve mekansal boyutlar arasında normalize eder.

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

İşlem, özellik boyutundaki her özellik için (feature_index, operand'daki özellik boyutunun dizinidir) diğer tüm boyutlardaki ortalamayı ve varyansı hesaplar ve operand'daki 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 grup için mean ve variance hesaplanmadan BatchNormTraining çağrılmasına eşdeğerdir. Bunun yerine, tahmini değerler olarak mean ve variance girişlerini kullanır. Bu işlemin amacı, çıkarımdaki gecikmeyi azaltmaktır. Bu nedenle, BatchNormInference adı verilmiştir.

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

BatchNormTraining

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

Bir diziyi toplu ve mekansal boyutlar arasında normalize eder.

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

İşlem, özellik boyutundaki her özellik için (feature_index, operand'daki özellik boyutunun dizinidir) diğer tüm boyutlardaki ortalamayı ve varyansı hesaplar ve operand'daki 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.

Algoritma, operand $x$ 'deki möğelerini içeren her bir grup için aşağıdaki gibidir (operand'ün 4 boyutlu bir dizi olduğu varsayılır):wh

• Özellik boyutundaki her l özelliği için toplu ortalamayı hesaplar: $\mu_l=\frac{1}{mwh}\sum_{i=1}^m\sum_{j=1}^w\sum_{k=1}^h x_{ijkl}$ $\mu_l$

• Grup varyansını 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$

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

Çıkış türü, üç XlaOp'ten oluşan bir tuple'dir:

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

BitcastConvertType

Ayrıca XlaBuilder::BitcastConvertType sayfasını da inceleyin.

TensorFlow'daki tf.bitcast işlevine benzer şekilde, bir veri şeklinden hedef şekle öğe bazında bitcast işlemi gerçekleştirir. Giriş ve çıkış boyutu eşleşmelidir: Ör. s32 öğeleri, bitcast rutini aracılığıyla f32 öğesi olur ve bir s32 öğesi dört s8 öğesi olur. Bitcast, düşük düzey bir yayın olarak uygulandığından farklı kayan nokta gösterimlerine sahip makineler farklı sonuçlar verir.

BitcastConvertType(operand, new_element_type)

Operanın ve hedef şeklin boyutları, dönüşümden önce ve sonra ilkel boyutun oranına göre değişecek son boyut dışında eşleşmelidir.

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

Bitcast dönüştürme işlemi farklı genişlikte ilkel türe dönüştürme

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

Öncelikle, B > B' olduğunda çıkış şekli, B/B' boyutunda yeni bir en küçük boyut kazanır. Örneğin:

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

Etkili skalerler 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'e eşit olmasını gerektirir ve bu boyut dönüşüm sırasında atlanı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 sayfasını da inceleyin.

Dizideki verileri kopyalayarak bir diziye boyut ekler.

Broadcast(operand, broadcast_sizes)

Yeni boyutlar sola eklenir. Yani broadcast_sizes {a0, ..., aN} değerlerine sahipse ve operand şekli {b0, ..., bM} boyutlarına sahipse çıkışın şekli {a0, ..., aN, b0, ..., bM} boyutlarına sahiptir.

Yeni boyutlar, işlenenin kopyalarına dizine girer.

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

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

BroadcastInDim

Ayrıca XlaBuilder::BroadcastInDim sayfasını da inceleyin.

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

BroadcastInDim(operand, out_dim_size, broadcast_dimensions)

Yayınlamaya benzer ancak boyutları istediğiniz yere eklemenize ve mevcut boyutları 1 boyutuyla genişletmenize olanak tanır.

operand, out_dim_size tarafından tanımlanan şekle yayınlanır. broadcast_dimensions, operand boyutlarını hedef şeklin boyutlarıyla eşler.Yani, işlenenin i. boyutu, çıkış şeklinin broadcast_dimension[i] boyutuyla eşlenir. operand boyutlarının boyutu 1 olmalıdır veya eşlendikleri çıkış şeklindeki boyutla aynı olmalıdır. Kalan boyutlar 1 boyutunda boyutlarla doldurulur. Ardından, çıkış şekline ulaşmak için dejenere boyut yayını bu dejenere boyutlar boyunca yayınlanır. Anlamlar yayınlama sayfasında ayrıntılı olarak açıklanmıştır.

Telefon

Ayrıca XlaBuilder::Call sayfasını da inceleyin.

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

Call(computation, args...)

args işlevinin arity değeri ve türleri, computation işlevinin parametreleriyle eşleşmelidir. args olmamasına izin verilir.

CompositeCall

Ayrıca XlaBuilder::CompositeCall sayfasını da inceleyin.

Girişler ve composite_attributes alarak ve sonuç üreterek diğer StableHLO işlemlerinden oluşan bir işlemi kapsar. İşlemin semantikleri, ayrıştırma özelliği tarafından uygulanır. Kompozit işlem, program semantiklerini değiştirmeden ayrıştırmasıyla değiştirilebilir. Ayrıştırmanın satır içine yerleştirilmesinin aynı işlem anlamını sağlamadığı durumlarda custom_call işlevini kullanmayı tercih edin.

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

Bu işlem, is_composite=true özelliğine sahip bir kCall olarak uygulanır. decomposition alanı, computation özelliği tarafından belirtilir. Ön uç özellikleri, kalan özellikleri composite. ön ekiyle 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"
}

Call(computation, args..., name, composite_attributes, version)

Cholesky

Ayrıca XlaBuilder::Cholesky sayfasını da inceleyin.

Simetrik (hermetik) pozitif tanımlı matrislerden oluşan bir grubun Cholesky ayrışımını hesaplar.

Cholesky(a, lower)

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

Giriş verileri, lower değerine bağlı olarak yalnızca a'ün alt/üst üçgeninden okunur. Diğer üçgendeki değerler yoksayılır. Çıkış verileri aynı üçgende döndürülür; diğer üçgendeki değerler uygulama tarafından tanımlanır ve herhangi bir şey olabilir.

a'nin 2'den fazla boyutu varsa a, küçük 2 boyut dışındaki tüm boyutların paket boyutu olduğu bir matris grubu olarak değerlendirilir.

a simetrik (Hermiyen) pozitif kesin değilse sonuç uygulama tarafından tanımlanır.

Sınır

Ayrıca XlaBuilder::Clamp sayfasını da inceleyin.

Bir operand'ı minimum ve maksimum değer arasındaki aralığa sıkıştırır.

Clamp(min, operand, max)

Bir operatör ve minimum ve maksimum değerler verildiğinde, operatör minimum ile maksimum arasındaki aralıktaysa operatörü, aksi takdirde operatör bu aralığın altındaysa minimum değeri veya operatör bu aralığın üzerindeyse maksimum değeri döndürür. Yani clamp(a, x, b) = min(max(a, x), b).

Üç dizi de aynı şekilde olmalıdır. Alternatif olarak, yayınlama işleminin kısıtlanmış bir şekli olarak min ve/veya max, T türündeki 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};

Daralt

Ayrıca XlaBuilder::Collapse ve tf.reshape işlemine de bakın.

Bir dizinin boyutlarını tek bir boyuta daraltır.

Collapse(operand, dimensions)

Daraltma, işlenenin boyutlarının belirli alt kümesini tek bir boyutla değiştirir. Giriş bağımsız değişkenleri, T türündeki rastgele bir dizi ve boyut dizinlerinin derleme zamanında sabit bir vektörüdür. Boyut dizinleri, T boyutlarının sıralı (düşükten yükseğe boyut numaraları) art arda gelen alt kümesi olmalıdır. Bu nedenle, {0, 1, 2}, {0, 1} veya {1, 2} geçerli boyut kümeleridir ancak {1, 0} veya {0, 2} geçerli değildir. Bunlar, boyut sırasındaki aynı konumda tek bir yeni boyutla değiştirilir. Yeni boyut boyutu, orijinal boyut boyutlarının çarpımına eşittir. dimensions içindeki en düşük boyut numarası, bu boyutları daraltan döngü yuvalarında en yavaş değişen boyuttur (en büyük) ve en yüksek boyut numarası en hızlı değişen boyuttur (en küçük). Daha genel bir daraltma sıralaması gerekiyorsa tf.reshape operatörüne bakın.

Örneğin, v'nin 24 öğe içeren bir dizi olduğunu varsayalım:

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

CollectivePermute

Ayrıca XlaBuilder::CollectivePermute sayfasını da inceleyin.

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

CollectivePermute(operand, source_target_pairs)

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

• Hiçbir 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 söz konusu kopyadaki çıkış, girişle aynı şekle sahip 0'lardan oluşan bir tenzordur.

Birleştirme

Ayrıca XlaBuilder::ConcatInDim sayfasını da inceleyin.

Birleştir işlevi, birden fazla dizi operandından bir dizi oluşturur. Dizi, giriş dizisi operatörlerinin her biri ile aynı sayıda boyuta sahiptir (bu operatörlerin boyut sayısı birbirinin aynı olmalıdır) ve bağımsız değişkenleri belirtildikleri sırada 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 de unutmayın (birleştirmenin gerçekleştiği boyutu adlandırmak mümkün olmadığından).

1 boyutlu örnek:

Concat({ {2, 3}, {4, 5}, {6, 7} }, 0)
>>> {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)
>>> {
{1, 2},
{3, 4},
{5, 6},
{7, 8},
}

Diyagram:

Şart Kipi

Ayrıca XlaBuilder::Conditional sayfasını da inceleyin.

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

pred değeri true ise true_computation, pred değeri false ise false_computation işlevini yürütür ve sonucu döndürür.

true_computation, $T_0$ türündeki tek bir bağımsız değişken almalıdır ve aynı türde olması gereken true_operand ile çağrılır. false_computation, $T_1$ türündeki tek bir bağımsız değişken almalıdır ve aynı türde olması gereken false_operand ile çağrılır. true_computation ve false_computation için döndürülen değerin türü aynı olmalıdır.

pred değerine bağlı olarak true_computation ve false_computation'ten yalnızca 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, < 0 veya >= N olan bir S32 ise branch_computations[N-1] varsayılan dal olarak yürütülür.

Her branch_computations[b], $T_b$ türündeki tek bir bağımsız değişken almalıdır ve aynı türde olması gereken branch_operands[b] ile çağrılı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'ten yalnızca birinin yürütüleceğini unutmayın.

Conv (konvolüsyon)

Ayrıca XlaBuilder::Conv sayfasını da inceleyin.

ConvWithGeneralPadding ile aynıdır ancak dolgu, SAME veya VALID olarak kısaca belirtilir. SAME dolgu, sarmalama dikkate alınmadığında çıkışın girişle aynı şekle sahip olması için girişi (lhs) sıfırlarla doldurur. VALID dolgu, dolgu olmadığı anlamına gelir.

ConvWithGeneralPadding (konvolüsyon)

Ayrıca XlaBuilder::ConvWithGeneralPadding sayfasını da inceleyin.

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

n, uzamsal boyutların sayısı olsun. lhs bağımsız değişkeni, taban alanını tanımlayan (n+2) boyutlu bir dizidir. Buna giriş denir. Sağ taraf da giriştir. Nöral ağda bunlar giriş aktivasyonlarıdır. n+2 boyutu şu sırayladır:

• batch: Bu boyuttaki her koordinat, üzerinde convolve işleminin yapıldığı 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 mekansal boyutlarını tanımlar.

rhs bağımsız değişkeni, konvolusyon filtresini/çekirdeğini/penceresini açıklayan (n+2) boyutlu bir dizidir. Boyutlar şu sırayladır:

• output-z: Çıktının z boyutu.
• input-z: Bu boyutun boyutu çarpı feature_group_count, sol taraftaki z boyutunun boyutuna eşit olmalıdır.
• spatial_dims: Temel alan üzerinde hareket eden n boyutlu pencereyi tanımlayan n mekansal boyutlarını açıklar.

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

padding bağımsız değişkeni, temel alana uygulanacak sıfır dolgu miktarını belirtir. Doldurma miktarı negatif olabilir. Negatif dolgunun mutlak değeri, toplama işlemi yapılmadan önce belirtilen boyuttan kaldırılacak öğe sayısını gösterir. padding[0], y boyutu için dolguyu, padding[1] ise x boyutu için dolguyu belirtir. Her çiftte, ilk öğe olarak düşük dolgu, ikinci öğe olarak yüksek dolgu bulunur. Düşük dolgu, düşük endeksler yönünde, yüksek dolgu ise yüksek endeksler yönünde uygulanır. Örneğin, padding[1] (2,3) ise ikinci mekansal boyutta solda 2 sıfır, sağda ise 3 sıfır ile doldurma yapılır. Dolgu kullanmak, aynı sıfır değerlerini, toplama işlemi yapmadan önce 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 tarafa ve sağ tarafa uygulanacak genişleme faktörünü belirtir. Bir uzamsal boyuttaki genişleme faktörü d ise söz konusu boyuttaki girişlerin her biri arasına d-1 boşluk yerleştirilir ve böylece dizinin boyutu artar. Boşluklar, işlemsiz bir değerle doldurulur. Bu değer, toplama işlemi için sıfır anlamına gelir.

Sağ tarafın genişletilmesi, atrous konvolüsyon olarak da adlandırılır. Daha fazla bilgi için tf.nn.atrous_conv2d başlıklı makaleyi inceleyin. Soldaki terimin genişletilmesi, transpoze convolve olarak da bilinir. 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ış örtüşmeler için kullanılabilir. feature_group_count, hem giriş hem de çıkış özellik boyutunun böleni olmalıdır. feature_group_count 1'den büyükse bu, giriş ve çıkış özellik boyutunun ve rhs çıkış özellik boyutunun, her biri art arda gelen bir özellik alt dizisinden oluşan birçok feature_group_count grubuna eşit olarak bölündüğü anlamına gelir. rhs giriş özelliği boyutunun, lhs giriş özelliği boyutunun feature_group_count'e bölünmesiyle elde edilen değere eşit olması gerekir (bu nedenle, giriş özelliği grubu boyutuna sahip olur). i. gruplar, birçok ayrı topoloji için feature_group_count hesaplamak üzere birlikte kullanılır. Bu karmaşık toplama işlemlerinin sonuçları, çıkış özellik boyutunda birleştirilir.

Derinlik boyutlu konvolusyon için feature_group_count bağımsız değişkeni giriş özellik boyutuna ayarlanır ve filtre [filter_height, filter_width, in_channels, channel_multiplier] yerine [filter_height, filter_width, 1, in_channels * channel_multiplier] olarak yeniden şekillendirilir. Daha fazla bilgi için tf.nn.depthwise_conv2d başlıklı makaleyi inceleyin.

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

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

• batch: Bu boyutun boyutu çarpı batch_group_count, sol taraftaki batch boyutunun boyutuna eşit olmalıdır.
• z: Çekirdekteki output-z ile aynı boyut (rhs).
• spatial_dims: Devrimsel pencerenin her geçerli yerleşimi için bir değer.

Yukarıdaki şekilde, batch_group_count alanının işleyiş şekli gösterilmektedir. Her bir sol taraf grubunu batch_group_count gruba böler ve çıkış özellikleri için de aynısını yaparız. Ardından, bu grupların her biri için ikili toplamalar yapar ve çıkışı çıkış özelliği boyutu boyunca birleştiririz. Diğer tüm boyutların (özellik ve mekansal) işlevsel semantikleri aynı kalır.

Devrimsel pencerenin geçerli yerleşimleri, adımlara ve dolgudan sonraki taban alanının boyutuna göre belirlenir.

Bir yığınlamanın ne yaptığını açıklamak için 2D yığınlamayı düşünün ve çıkışta sabit batch, z, y, x koordinatları seçin. Ardından (y,x), pencerenin bir köşesinin taban alanındaki konumudur (ör. uzamsal boyutları nasıl yorumladığınıza bağlı olarak sol üst köşe). Artık temel alandan alınan 2D bir penceremiz var. Bu pencerede her 2D nokta 1D bir vektörle ilişkilendirilir. Böylece 3D bir kutu elde ederiz. z çıkış koordinatını sabitlediğimiz için, convolutional çekirdeğinden 3D bir kutu da elde ederiz. İki kutunun boyutları aynı olduğundan, iki kutu arasındaki öğe bazında çarpımların toplamını (skaler çarpıma benzer şekilde) alabiliriz. Bu, çıkış değeridir.

output-z örneğin şu şekildeyse: 5 ise pencerenin her konumu, çıktının z boyutunda 5 değer oluşturur. Bu değerler, konvolüsyon çekirdeğin hangi kısmının kullanıldığına göre farklılık gösterir. Her output-z koordinatı için ayrı bir 3D değer kutusu vardır. Bu nedenle, her biri için farklı bir filtreye sahip 5 ayrı konvolüsyon olarak düşünebilirsiniz.

Aşağıda, dolgu ve adım boyutu içeren 2D bir konvolüsyon için sözde kod 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;
}

ConvertElementType

Ayrıca XlaBuilder::ConvertElementType sayfasını da inceleyin.

C++'daki öğe bazında static_cast işlevine benzer şekilde, bir veri şeklinden hedef şekle öğe bazında dönüşüm işlemi gerçekleştirir. Boyutlar eşleşmeli ve dönüşüm öğe bazında olmalıdır. Örneğin, s32 öğeleri bir s32-f32 dönüşüm rutini aracılığıyla f32 öğeleri haline gelir.

ConvertElementType(operand, new_element_type)

İşlenenin ve hedef şeklinin boyutları eşleşmelidir. Kaynak ve hedef öğe türleri tuple olmamalıdır.

T=s32 ile U=f32 arasında yapılan bir dönüşüm, en yakın çift sayıya yuvarlama gibi normalleştirici bir tam sayıdan kayan noktaya 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}

CrossReplicaSum

Toplama hesaplamasıyla AllReduce işlemini gerçekleştirir.

CustomCall

Ayrıca XlaBuilder::CustomCall sayfasını da inceleyin.

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

CustomCall(target_name, args..., shape)

args bağımsız değişkeninin türü veya sayısı ne olursa olsun işlev imzası aynıdır:

extern "C" void target_name(void* out, void** in);

Örneğin, ÖzelÇağrı aşağıdaki gibi kullanılıyorsa:

let x = f32[2] {1,2};
let y = f32[2x3] { {10, 20, 30}, {40, 50, 60} };

CustomCall("myfunc", {x, y}, f32[3x3])

myfunc uygulamasına örnek:

extern "C" void myfunc(void* out, void** in) {
  float (&x)[2] = *static_cast<float(*)[2]>(in[0]);
  float (&y)[2][3] = *static_cast<float(*)[2][3]>(in[1]);
  EXPECT_EQ(1, x[0]);
  EXPECT_EQ(2, x[1]);
  EXPECT_EQ(10, y[0][0]);
  EXPECT_EQ(20, y[0][1]);
  EXPECT_EQ(30, y[0][2]);
  EXPECT_EQ(40, y[1][0]);
  EXPECT_EQ(50, y[1][1]);
  EXPECT_EQ(60, y[1][2]);
  float (&z)[3][3] = *static_cast<float(*)[3][3]>(out);
  z[0][0] = x[1] + y[1][0];
  // ...
}

Kullanıcı tarafından sağlanan işlevin yan etkileri olmamalı ve yürütülmesi tekil olmalıdır.

Nokta

Ayrıca XlaBuilder::Dot sayfasını da inceleyin.

Dot(lhs, rhs)

Bu işlemin tam semantiği, operatörlerin sıralarına bağlıdır:

İşlem, lhs'ün ikinci boyutu (veya 1 boyutu varsa ilk boyutu) ve rhs'ün ilk boyutu üzerinde çarpım toplamını gerçekleştirir. Bunlar "daraltılmış" boyutlardır. lhs ve rhs'un sözleşmeli 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.

DotGeneral

Ayrıca XlaBuilder::DotGeneral sayfasını da inceleyin.

DotGeneral(lhs, rhs, dimension_numbers)

Noktaya benzer ancak hem lhs hem de rhs için sözleşmeli ve toplu boyut numaralarının belirtilmesine olanak tanır.

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

lhs ve rhs'teki ilişkili sözleşmeli boyut numaralarının aynı olması gerekmez ancak aynı boyut boyutlarına sahip olmalıdır.

Daralan boyut numaraları 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'daki ilişkili toplu boyut numaraları aynı boyut boyutlarına sahip olmalıdır.

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

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

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

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

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

Sonuç olarak, elde edilen boyut numarasının önce toplu boyut, ardından lhs sözleşme dışı/toplu olmayan boyut ve son olarak rhs sözleşme dışı/toplu olmayan boyut ile başladığı anlaşılır.

DynamicSlice

Ayrıca XlaBuilder::DynamicSlice sayfasını da inceleyin.

DynamicSlice, dinamik start_indices değerinde giriş dizisinden bir alt dizi ayırır. Her boyuttaki dilimin boyutu, her boyuttaki özel dilim aralıklarını belirten size_indices parametresine iletilir: [start, start + size). start_indices şekli 1 boyutlu olmalı ve boyut boyutu operand boyutlarının sayısına eşit olmalıdır.

DynamicSlice(operand, start_indices, size_indices)

Etkili dilim dizinleri, dilim oluşturmadan önce [1, N) içindeki her i dizine aşağıdaki dönüşüm uygulanarak hesaplanır:

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

Bu, ayıklanan dilimin operatör dizisine göre her zaman sınırlar içinde olmasını sağlar. Dönüşüm uygulanmadan önce dilim sınırları içindeyse dönüşümün hiçbir etkisi olmaz.

1 boyutlu örnek:

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

DynamicSlice(a, s, {2}) produces:
{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}) produces:
{ { 7.0,  8.0},
{10.0, 11.0} }

DynamicUpdateSlice

Ayrıca XlaBuilder::DynamicUpdateSlice sayfasını da inceleyin.

DynamicUpdateSlice, start_indices'de update dilimindeki verilerin üzerine yazıldığı operand giriş dizisinin değeri olan bir sonuç döndürür. update'ün şekli, güncellenen sonucun alt dizisinin şeklini belirler. start_indices'ün şekli 1 boyutlu olmalı ve boyut boyutu operand boyutlarının sayısına eşit olmalıdır.

DynamicUpdateSlice(operand, update, start_indices)

Etkili dilim dizinleri, dilim oluşturmadan önce [1, N) içindeki her i dizine 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 sayede, güncellenen dilimin operatör dizisine göre her zaman sınırlar içinde olduğundan emin olabilirsiniz. Dönüşüm uygulanmadan önce dilim sınırları içindeyse dönüşümün hiçbir etkisi olmaz.

1 boyutlu örnek:

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

DynamicUpdateSlice(a, u, s) produces:
{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) produces:
{ {0.0,  1.0,  2.0},
{3.0, 12.0, 13.0},
{6.0, 14.0, 15.0},
{9.0, 16.0, 17.0} }

Öğe bazında ikili aritmetik işlemler

Ayrıca XlaBuilder::Add sayfasını da inceleyin.

Öğe bazında bir dizi ikili aritmetik işlem desteklenir.

Op(lhs, rhs)

Burada Op, Add (toplama), Sub(çıkarma), Mul (çarpma), Div (bölme), Pow (üs), Rem (kalan), Max (maksimum), Min (minimum), And (mantıksal VE), Or (mantıksal VEYA), Xor (mantıksal ÇOKEĞER), ShiftLeft (sol kaydırma), ShiftRightArithmetic (arifmetik sağ kaydırma), ShiftRightLogical (mantıksal sağ kaydırma), Atan2 (2 bağımsız değişkenli arktanjant) veya Complex (gerçek ve sanal kısımları karmaşık bir sayıyla birleştirir) işlemlerinden biridir.

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

Op Rem olduğunda sonucun işareti paydan alınır ve sonucun mutlak değeri her zaman bölenin mutlak değerinden azdır.

Tam sayı bölme taşması (simgesiz/simgeli bölme/kalan sıfıra bölündüğünde veya INT_SMIN'ün -1 ile işaretli bölme/kalanı), uygulama tanımlı bir değer oluşturur.

Bu işlemler için farklı boyutlu yayın desteğine sahip alternatif bir varyant mevcuttur:

Op(lhs, rhs, broadcast_dimensions)

Burada Op, yukarıdaki gibidir. İşlemin bu varyantı, farklı rütbelerdeki diziler arasındaki aritmetik işlemler için (ör. bir matrisi bir vektöre ekleme) kullanılmalıdır.

Ek broadcast_dimensions işlevi, daha düşük boyutlu işlevin boyut sayısını daha yüksek boyutlu işlevin boyut sayısına kadar genişletmek için kullanılan bir tamsayı dilimidir. broadcast_dimensions, daha düşük boyutlu şeklin boyutlarını daha yüksek boyutlu şeklin boyutlarıyla eşleştirir. Genişletilmiş şeklin eşlenmemiş boyutları, boyutu bir olan boyutlarla doldurulur. Dejenere boyut yayını, her iki operandın şekillerini eşitlemek için şekilleri bu dejenere boyutlar boyunca yayınlar. Anlamlar yayınlama sayfasında ayrıntılı olarak açıklanmaktadır.

Öğe bazında karşılaştırma işlemleri

Ayrıca XlaBuilder::Eq sayfasını da inceleyin.

Standart öğe bazında ikili karşılaştırma işlemleri desteklenir. Kayan nokta türleri karşılaştırılırken standart IEEE 754 kayan nokta karşılaştırma semantiklerinin geçerli olduğunu unutmayın.

Op(lhs, rhs)

Burada Op, Eq (eşittir), Ne (eşit değildir), Ge (büyüktür veya eşittir), Gt (büyüktür), Le (küçüktür veya eşittir), Lt (küçüktür) seçeneklerinden biridir. EqTotalOrder, NeTotalOrder, GeTotalOrder, GtTotalOrder, LeTotalOrder ve LtTotalOrder adlı başka bir operatör grubu da aynı işlevleri sağlar. Bununla birlikte, bu operatörler -NaN < -Inf < -Finite < -0 < +0 < +Finite < +Inf < +NaN kuralını uygulayarak kayan noktalı sayılar üzerinde toplam siparişi de destekler.

Bağımsız değişkenlerin şekilleri benzer veya uyumlu olmalıdır. Şekillerin uyumlu olmasıyla ilgili yayınlama dokümanlarına bakın. Bir işlemin sonucu, iki giriş dizisinin PRED öğe türüyle yayınlanmasının sonucu olan bir şekle sahiptir. Bu varyantta, operatörlerden biri skaler olmadığı sürece farklı rütbelerdeki diziler arasındaki işlemler desteklenmez.

Bu işlemler için farklı boyutlu yayın desteğine sahip alternatif bir varyant mevcuttur:

Op(lhs, rhs, broadcast_dimensions)

Burada Op, yukarıdaki gibidir. İşlemin bu varyantı, farklı rütbelerdeki diziler arasındaki karşılaştırma işlemleri için kullanılmalıdır (ör. bir matrisi bir vektöre ekleme).

Ek broadcast_dimensions işleneni, işlenenleri yayınlamak için kullanılacak boyutları belirten bir tam sayı dilimidir. Anlamlar yayınlama sayfasında ayrıntılı olarak açıklanmıştır.

Öğe bazında tek değerli işlevler

XlaBuilder, aşağıdaki öğe bazında tek değerli işlevleri destekler:

Abs(operand) Öğe bazında mutlak değer x -> |x|.

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

Ceil(operand) Öğe bazında yuvarlama x -> ⌈x⌉.

Clz(operand) Başında sıfır olan sayıları öğe bazında sayar.

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

Erf(operand) Öğe bazında hata işlevi x -> erf(x).

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

Exp(operand) Öğe bazında doğal üstel x -> e^x.

Expm1(operand) Öğe bazında doğal üs, bir eksix -> e^x - 1.

Floor(operand) Öğe bazında taban x -> ⌊x⌋.

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

IsFinite(operand) operand öğelerinin her birinin sonlu olup olmadığını (ör. pozitif veya negatif sonsuzluk ve NaN olmadığı) test eder. Girdiyle aynı şekle sahip bir PRED değeri dizisi döndürür. Bu diziye karşılık gelen giriş öğesi sonluysa ve yalnızca bu durumda her öğe true olur.

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

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

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

Neg(operand) Öğe bazında olumsuzlama x -> -x.

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

PopulationCount(operand), operand öğesinin her birinde ayarlanan bit sayısını hesaplar.

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

Round(operand) Öğe bazında yuvarlama, sıfırdan uzaklaşan bağlar.

RoundNearestEven(operand) Öğe bazında yuvarlama, en yakın çift sayıya yuvarlanır.

Rsqrt(operand) Kare kök işleminin öğe bazında ters değerix -> 1.0 / sqrt(x).

Sign(operand) Öğe bazında işaret işlemi x -> sgn(x).

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

operand öğe türünün karşılaştırma operatörünü kullanarak.

Sin(operand) Öğe bazında sinüs x -> sin(x).

Sqrt(operand) Öğe bazında karekök işlemi x -> sqrt(x).

Tan(operand) Öğe bazında teğet x -> tan(x).

Tanh(operand) Öğe bazında hiperbolik tanjant x -> tanh(x).

İşlev, operand dizisindeki her öğeye uygulanır ve aynı şekle sahip bir dizi oluşturur. operand'ün skaler (0 boyutlu) olmasına izin verilir.

Fft

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

Ayrıca XlaBuilder::Fft sayfasını da inceleyin.

Çok boyutlu FFT

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

Uygulama ayrıntıları

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

Gather

XLA toplama işlemi, bir giriş dizisinin birkaç dilimini (her dilim olası farklı bir çalışma zamanı ofsetinde) bir araya getirir.

Genel Anlambilim

Ayrıca XlaBuilder::Gather sayfasını da inceleyin. Daha anlaşılır bir açıklama için aşağıdaki "Resmi Olmayan Açıklama" bölümüne bakın.

gather(operand, start_indices, offset_dims, collapsed_slice_dims, slice_sizes, start_index_map)

Kolaylık sağlamak amacıyla, çıkış dizisindeki boyutları offset_dims yerine batch_dims olarak etiketliyoruz.

Çıkış, batch_dims.size + offset_dims.size boyutu içeren bir dizidir.

operand.rank, offset_dims.size ile collapsed_slice_dims.size'nin 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'a eşitse start_indices'nin sonuna 1 boyutu eklenmiş olarak kabul edilir (yani start_indices, [6,7] şeklindeyse ve index_vector_dim, 2 ise start_indices'nin şekli [6,7,1] olarak kabul edilir).

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

1. i, batch_dims içinde mevcutsa (yani bazı k için batch_dims[k]'ye eşitse) index_vector_dim atlanarak start_indices.shape içinden ilgili boyut sınırlarını seçeriz (yani k < index_vector_dim ise start_indices.shape.dims[k] ve aksi takdirde start_indices.shape.dims[k+1] seçeriz).

2. i, offset_dims içindeyse (yani bazı k için offset_dims[k] ile eşittir) collapsed_slice_dims dikkate alındıktan sonra slice_sizes içinden ilgili sınırı seçeriz (yani adjusted_slice_sizes[k] seçeriz. Burada adjusted_slice_sizes, collapsed_slice_dims dizinlerindeki sınırlar kaldırılmış slice_sizes'tır).

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

1. G = { batch_dims içindeki k için Out[k] } olsun. S vektörünü G kullanarak dilimleyin. Bu durumda S[i] = start_indices[Combine(G, i)] olur. Burada Combine(A, b), b öğesini A'nın index_vector_dim konumuna ekler. G boş olsa bile bunun iyi tanımlandığını unutmayın: G boşsa S = start_indices olur.

2. start_index_map kullanarak S'ü dağıtarak Sin başlangıç dizini oluşturun.Soperand Daha açık belirtmek gerekirse:

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

   2. Aksi takdirde Sin[_] = 0.

3. Dizinleri Out'teki ofset boyutlarında collapsed_slice_dims kümesine göre dağıtarak operand içinde Oin dizini oluşturun. Daha açık belirtmek gerekirse:

   1. k < offset_dims.size ise Oin[remapped_offset_dims(k)] = Out[offset_dims[k]] (remapped_offset_dims aşağıda tanımlanmıştır).

   2. Aksi takdirde Oin[_] = 0.

4. In, Oin + Sin şeklindedir. Burada +, öğe bazında toplama işlemidir.

remapped_offset_dims, [0, offset_dims.size) aralığında ve [0, operand.rank) \ collapsed_slice_dims aralığında monoton bir işlevdir. Ö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'un kullanıcı tarafından sıralandığını (start_index_map'e göre değerlerini dağıttıktan sonra artan düzende) varsayabilir. Aksi takdirde semantik, uygulama tarafından tanımlanır.

Resmi Olmayan Açıklama ve Örnekler

Gayrı resmi olarak, çıkış dizisindeki her dizin Out, operant dizisindeki bir öğeye E karşılık gelir ve aşağıdaki şekilde hesaplanır:

• start_indices'daki bir başlangıç dizini aramak için Out'teki toplu boyutları kullanırız.

• Başlangıç dizini (operand.rank'tan daha küçük olabilir) operand içindeki "tam" bir başlangıç dizine eşlemek için start_index_map kullanırız.

• Tam başlangıç dizini kullanılarak slice_sizes boyutunda bir dilim dinamik olarak kesilir.

• collapsed_slice_dims boyutlarını daraltarak dilimi yeniden şekillendiririz. Tüm daraltılmış dilim boyutlarının 1 sınırına sahip olması gerektiğinden bu yeniden şekillendirme her zaman geçerlidir.

• Çıkış dizini Out'ye karşılık gelen giriş öğesini (E) almak için bu dilimde dizin oluşturmak üzere Out'teki ofset boyutlarını kullanırız.

Aşağıdaki örneklerin tümünde index_vector_dim, start_indices.rank - 1 olarak ayarlanmıştır. index_vector_dim için daha ilginç değerler, işlemi temelden değiştirmez ancak görsel temsili daha hantal hale getirir.

Yukarıdakilerin tümünün bir arada nasıl çalıştığı hakkında fikir edinmek için bir [16,11] dizisinden 5 adet [8,6] şeklinde dilim toplayan bir örneğe bakalım. [16,11] dizisindeki bir dilimin konumu, S64[2] şeklinde bir dizin vektörü olarak temsil edilebilir. Bu nedenle, 5 konumdan oluşan küme S64[5,2] dizisi olarak temsil edilebilir.

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

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

slice_sizes, O₀ ve O₁ aralığına karar veren [8,6]'tır. Bu da dilimin sınırlarını belirler.

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

Toplama dizinleri çok boyutlu olabilir. Örneğin, [4,5,2] şeklinde bir "toplama dizini" dizisi kullanan yukarıdaki örneğin daha genel bir versiyonunda dizinler şu şekilde çevrilir:

Yine de bu, toplu dinamik dilim G0 ve toplu boyutlar olarak G1 görevi görür. Dilim boyutu hâlâ [8,6].

XLA'daki toplama işlemi, yukarıda özetlenen gayrı resmi semantikleri aşağıdaki şekillerde genelleştirir:

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

2. Çıkış şeklinde açıkça bulunan çıkış ofset boyutlarının sayısı, giriş boyutu sayısından daha az olabilir. collapsed_slice_dims olarak açıkça listelenen bu "eksik" boyutların dilim boyutu 1 olmalıdır. 1 dilim boyutuna sahip olduklarından, bunlar için geçerli tek dizin 0'dur ve bunların atlanması belirsizlik oluşturmaz.

3. "Dizinleri Topla" dizisinden (son örnekteki (X, Y)) ayıklanan dilim, giriş dizisinin boyut sayısından daha az öğeye sahip olabilir ve dizin, girişle aynı boyut sayısına sahip olacak şekilde nasıl genişletileceğini açık bir eşlemeyle belirtir.

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

G0 ve G1, başlangıç dizininin yalnızca bir öğe (X) içermesi dışında her zamanki gibi toplanan dizinler dizisinden bir başlangıç dizini almak için kullanılır. Benzer şekilde, O0 değerine sahip yalnızca bir çıkış ofset dizini vardır. Ancak bunlar, giriş dizisindeki dizinler olarak kullanılmadan önce "Toplama Dizin Eşlemesi" (resmi açıklamada start_index_map) ve "Ofset Eşlemesi"ne (resmi açıklamada remapped_offset_dims) göre sırasıyla [X,0] ve [0,O0] olarak genişletilir ve [X,O0] değerini verir. Diğer bir deyişle, çıkış dizini [G0,G1,O0] giriş dizini [GatherIndices[G0,G1,0],O0] ile eşlenir. Bu da bize tf.gather_nd için anlam bilgisi verir.

Bu destek kaydının slice_sizes değeri [1,11]'dır. Bu, sezgisel olarak, toplayıcı dizinleri dizisindeki her dizin X'in bir satırın tamamını seçtiği ve sonucun tüm bu satırların birleştirilmesi olduğu anlamına gelir.

GetDimensionSize

Ayrıca XlaBuilder::GetDimensionSize sayfasını da inceleyin.

İşlenenin belirtilen boyutunun boyutunu döndürür. İşlenen dizi şeklinde olmalıdır.

GetDimensionSize(operand, dimension)

SetDimensionSize

Ayrıca XlaBuilder::SetDimensionSize sayfasını da inceleyin.

XlaOp'un belirli boyutunun dinamik boyutunu ayarlar. İşlenen dizi şeklinde olmalıdır.

SetDimensionSize(operand, size, dimension)

Dinamik boyut derleyici tarafından izlenirken, operandı sonuç olarak iletin.

Doldurulmuş değerler, yayın sonrası azaltma işlemleri tarafından yoksayılır.

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

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

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

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

GetTupleElement

Ayrıca XlaBuilder::GetTupleElement sayfasını da inceleyin.

Derleme zamanı sabit değeri olan bir tuple içinde dizine eklenir.

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

Bu, C++'daki 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 sayfasını da inceleyin.

Feed içi

Ayrıca XlaBuilder::Infeed sayfasını da inceleyin.

Infeed(shape)

Cihazın örtülü feed akış arayüzünden tek bir veri öğesini okur, verileri belirtilen şekil ve düzeni olarak yorumlar ve verilerin XlaOp değerini döndürür. Bir hesaplamada birden fazla feed işlemine izin verilir ancak feed işlemleri arasında toplam bir sipariş olmalıdır. Örneğin, aşağıdaki koddaki iki feed'in toplam siparişi vardır çünkü while döngüleri arasında 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ş tuple şekilleri desteklenmez. Boş bir tuple şekli için feed işlemi etkili bir şekilde işlem yapmaz ve cihazın feed'inden herhangi bir veri okumadan devam eder.

Iota

Ayrıca XlaBuilder::Iota sayfasını da inceleyin.

Iota(shape, iota_dimension)

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

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

Harita

Ayrıca XlaBuilder::Map sayfasını da inceleyin.

Map(operands..., computation)

Belirtilen operands dizileri üzerinde bir skaler işlevi uygular. Bu işlev, her bir öğenin giriş dizilerindeki ilgili öğelere uygulanan eşlenen işlevin sonucu olduğu, aynı boyutlara sahip bir dizi oluşturur.

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

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

OptimizationBarrier

Optimizasyon geçişlerinin hesaplamaları engellemesini engeller.

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

Ped

Ayrıca XlaBuilder::Pad sayfasını da inceleyin.

Pad(operand, padding_value, padding_config)

Belirtilen operand dizisini, dizi etrafında ve dizi öğeleri arasında belirtilen padding_value ile dolgu yaparak genişletir. padding_config, her boyut için kenar dolgusunun miktarını ve iç dolguyu belirtir.

PaddingConfig, her boyut için üç alan içeren PaddingConfigDimension'un yinelenen bir alanıdır: edge_padding_low, edge_padding_high ve interior_padding.

edge_padding_low ve edge_padding_high, sırasıyla her boyutun alt ucunda (0 dizininin yanında) ve üst ucunda (en yüksek dizinin yanında) eklenen dolgu miktarını belirtir. Kenar dolgusunun miktarı negatif olabilir. Negatif dolgunun mutlak değeri, belirtilen boyuttan kaldırılacak öğe sayısını gösterir.

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

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

Al

Ayrıca XlaBuilder::Recv sayfasını da inceleyin.

Recv(shape, channel_handle)

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

Recv işleminin istemci API'si senkronize iletişimi temsil eder. Ancak bu talimat, asenkron veri aktarımını etkinleştirmek için dahili olarak 2 HLO talimatına (Recv ve RecvDone) ayrılır. Ayrıca HloInstruction::CreateRecv ve HloInstruction::CreateRecvDone belgelerini inceleyin.

Recv(const Shape& shape, int64 channel_id)

Aynı channel_id değerine sahip bir Send talimatından veri almak için gereken kaynakları ayırır. Atanan kaynaklar için bir bağlam döndürür. Bu bağlam, veri aktarımının tamamlanmasını beklemek için aşağıdaki RecvDone talimatı tarafından kullanılır. Bağlam, {receive buffer (shape), request identifier (U32)} bir tuple'dir ve yalnızca bir RecvDone talimatı tarafından kullanılabilir.

RecvDone(HloInstruction context)

Recv talimatı tarafından 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 sayfasını da inceleyin.

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

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

Burada:

• N'nin 1 veya daha büyük olması gerekir.
• Hesaplama "yaklaşık olarak" ilişkili olmalıdır (aşağıya bakın).
• Tüm giriş dizileri aynı boyutlara sahip olmalıdır.
• Tüm ilk değerlerin computation altında bir kimlik oluşturması gerekir.
• N = 1 ise Collate(T) T.
• N > 1 ise Collate(T_0, ..., T_{N-1}), T türündeki N öğelerden oluşan bir tuple'dir.

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

Farklı arka uçların azaltma hesaplamasını yeniden ilişkilendirmesine izin verilir. Toplama gibi bazı azaltma işlevleri kayan noktalı sayılar için ilişkili olmadığından bu durum sayısal farklılıklara neden olabilir. Ancak verilerin aralığı sınırlıysa kayan noktalı toplama, çoğu pratik kullanım için ilişkilendirmeye yetecek kadar yakındır.

Örnekler

[10, 11, 12, 13] değerlerine sahip tek bir 1 boyutlu dizinde f azaltma işleviyle (computation) tek bir boyut boyunca azaltma işlemi yapıldığında bu işlem şu şekilde hesaplanabilir:

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

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

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

Aşağıda, başlangıç değeri 0 olan azaltma hesaplaması olarak toplama işleminin kullanıldığı azaltmanın 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, 2D dizisinin (matris) azaltılmasına ilişkin bir örnek verilmiştir. Şeklin 2 boyutu vardır: 2 boyutunda 0 boyutu ve 3 boyutunda 1 boyutu:

"Ekle" işleviyle 0 veya 1 boyutlarını azaltmanın sonuçları:

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

Daha karmaşık bir örnek olarak 3D diziyi burada bulabilirsiniz. Boyut sayısı 3'tür: 0. boyut 4 boyutlu, 1. boyut 2 boyutlu ve 2. boyut 3 boyutlu. Kolaylık sağlamak için 1 ile 6 arasındaki değerler 0 boyutunda çoğaltılır.

2D örneğine benzer şekilde, yalnızca bir boyutu azaltabiliriz. Örneğin, 0. boyutu azaltırsak 0. boyuttaki tüm değerlerin bir skaler içinde toplandığı 2 boyutlu bir dizi elde ederiz:

|  4   8  12 |
| 16  20  24 |

2. boyutu azaltırsak 2. boyuttaki tüm değerlerin skaler olarak toplandığı 2 boyutlu bir dizi de elde ederiz:

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

Girişteki kalan boyutlar arasındaki göreceli sıranın çıkışta korunduğunu ancak bazı boyutlara yeni numaralar atanabileceğini (boyut sayısı değiştiği için) unutmayın.

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

3D dizinin tüm boyutları boyunca azaltılması, skaler 84 değerini verir.

Varyant azaltma

N > 1 olduğunda, azaltma işlevi tüm girişlere aynı anda uygulandığı için uygulama işlemi biraz daha karmaşıktır. İşlemlere ait operandlar aşağıdaki sırayla sağlanır:

• İlk operatör için azaltılmış değeri çalıştırma
• ...
• N. operatör için azaltılmış değeri çalıştırma
• İlk operatör için giriş değeri
• ...
• N. operand 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 düşünün:

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 ilk değerler I_V = Float, I_K = Int için yalnızca giriş boyutunda azaltma işleminin 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şlemi, bir değer dizisine ve sıralı dizin dizisine (ör. iota) uygulandığında diziler üzerinde birlikte iterasyon yapılır ve maksimum değeri ve eşleşen dizinini içeren bir tuple döndürülür.

ReducePrecision

Ayrıca XlaBuilder::ReducePrecision sayfasını da inceleyin.

Kayan nokta değerlerini daha düşük hassasiyetli bir biçime (ör. IEEE-FP16) ve orijinal biçime dönüştürmenin etkisini modeller. Düşük hassasiyetli biçimdeki üs ve ondalık basamak bitlerinin sayısı isteğe bağlı olarak belirtilebilir ancak tüm bit boyutları tüm donanım uygulamalarında desteklenmeyebilir.

ReducePrecision(operand, mantissa_bits, exponent_bits)

Sonuç, T türündeki bir dizidir. Giriş değerleri, belirtilen sayıda mantissa bitiyle temsil edilebilen en yakın değere yuvarlanır ("çift sayıya yuvarlanır" semantiği kullanılır) ve üs bitlerinin sayısıyla belirtilen aralığı aşan tüm değerler pozitif veya negatif sonsuz olarak sınırlandırılır. NaN değerleri korunur ancak normal NaN değerlerine dönüştürülebilir.

Düşük hassasiyetli biçimin en az bir üstel biti (her ikisi de sıfır ondalık basamağı olduğundan sıfır değerini sonsuzdan ayırt etmek için) ve negatif olmayan bir ondalık basamağı biti olmalıdır. Üs veya ondalık basamak sayısı, T türüne karşılık gelen değeri aşabilir. Bu durumda, dönüşümün ilgili kısmı hiçbir işlem yapmaz.

ReduceScatter

Ayrıca XlaBuilder::ReduceScatter sayfasını da inceleyin.

ReduceScatter, AllReduce'i etkili bir şekilde gerçekleştiren ve ardından sonucu scatter_dimension boyunca shard_count bloğa bölerek dağıtan bir toplu işlemdir. Replika grubundaki i kopyası, ith bölümünü alır.

ReduceScatter(operand, computation, scatter_dim, shard_count, replica_group_ids, channel_id)

• operand bir dizi grubu olduğunda, azaltma-dağıtma işlemi grubun her bir öğesinde gerçekleştirilir.
• replica_groups, azaltmanın yapıldığı kopya gruplarının bir listesidir (mevcut 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ıyla aynı sayıda öğe içermelidir. Birden fazla replika grubu varsa bunların tümü 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 ardından sonucu dağıtır.
• shard_count, her kopya grubunun boyutudur. replica_groups değerlerinin boş olduğu durumlarda buna ihtiyacımız vardır. 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 değerine sahip reduce-scatter işlemleri birbirleriyle iletişim kurabilir.

Çıkış şekli, scatter_dimension değerinin shard_count kat küçültüldüğü giriş şeklidir. Örneğin, iki kopya varsa ve operatör 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şlemden elde edilen çıkış değeri, ilk kopya için [4.0] ve ikinci kopya için [7.5] olur.

ReduceWindow

Ayrıca XlaBuilder::ReduceWindow sayfasını da inceleyin.

N boyutlu dizi dizisinin her penceresindeki tüm öğelere bir azaltma işlevi uygular ve çıktı olarak tek bir N boyutlu dizi veya N boyutlu dizilerden oluşan bir tuple oluşturur. Her çıkış dizisinde, pencerenin geçerli konumlarının sayısı kadar öğe bulunur. Bir toplama katmanı ReduceWindow olarak ifade edilebilir. Reduce'a benzer şekilde, uygulanan computation her zaman sol taraftaki init_values'e iletilir.

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

Burada:

• N'nin 1 veya daha büyük olması gerekir.
• Tüm giriş dizileri aynı boyutlara sahip olmalıdır.
• N = 1 ise Collate(T) T.
• N > 1 ise Collate(T_0, ..., T_{N-1}), (T0,...T{N-1}) türündeki N öğelerden oluşan bir tuple'dir.

Aşağıdaki kod ve resimde ReduceWindow kullanımıyla ilgili bir örnek gösterilmektedir. 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);

Bir boyuttaki 1 adım, boyuttaki bir pencerenin konumunun, bitişik penceresinden 1 öğe uzakta olduğunu belirtir. Hiçbir pencerenin birbiriyle örtüşmediğini belirtmek için window_stride_dimensions, window_dimensions ile eşit olmalıdır. Aşağıdaki şekilde, iki farklı adım değeri kullanılmaktadır. Girişteki her boyuta dolgu uygulanır ve hesaplamalar, giriş dolgudan sonra sahip olduğu boyutlarla gelmiş gibi aynıdır.

Basit olmayan bir dolgu örneği için, [10000, 1000, 100, 10, 1] giriş dizisi üzerinde 3 boyutu ve 2 adımıyla azaltılmış pencere minimumunu (ilk değer MAX_FLOAT) hesaplamayı düşünün. kValid dolgu, [10000, 1000, 100] ve [100, 10, 1] olmak üzere iki geçerli pencerede minimumları hesaplar ve [100, 1] çıktısını verir. kSame dolgu işlevi, ilk olarak diziyi doldurur. Böylece, azaltma penceresinden sonraki şekil, her iki tarafa da ilk öğeleri ekleyerek birinci adımdaki girişle aynı olur ve [MAX_VALUE, 10000, 1000, 100, 10, 1, MAX_VALUE] elde edilir. Doldurulmuş dizi üzerinde reduce-window çalıştırıldığında üç pencerede ([MAX_VALUE, 10000, 1000], [1000, 100, 10], [10, 1, MAX_VALUE]) işlem yapılır ve [1000, 10, 1] döndürülür.

Azaltma işlevinin değerlendirme sırası keyfidir ve deterministik olmayabilir. Bu nedenle, azaltma işlevi yeniden ilişkilendirmeye karşı aşırı duyarlı olmamalıdır. Daha fazla bilgi için Reduce bağlamında ilişkilendirme hakkındaki tartışmaya bakın.

ReplicaId

Ayrıca XlaBuilder::ReplicaId sayfasını da inceleyin.

Kopyanın benzersiz kimliğini (U32 skaler) döndürür.

ReplicaId()

Her kopyanın benzersiz kimliği, N kopya sayısının [0, N) aralığındaki işaretsiz bir tam sayıdır. Tüm kopyalar aynı programı çalıştırdığından, programdaki bir ReplicaId() çağrısı her kopyada farklı bir değer döndürür.

Yeniden şekillendirme

Ayrıca XlaBuilder::Reshape ve Collapse işlemine de bakın.

Bir dizinin boyutlarını yeni bir yapılandırmada yeniden şekillendirir.

Reshape(operand, dimensions)

Kavramsal olarak yeniden şekillendirme işlevi, önce bir diziyi veri değerlerinin tek boyutlu bir vektörüne düzleştirir, ardından bu vektörü yeni bir şekle dönüştürür. Giriş bağımsız değişkenleri, T türü bir dizi, derleme zamanında sabit bir boyut dizini vektörü ve sonuç için derleme zamanında sabit bir boyut boyutu vektörüdür. dimensions vektörü, çıkış dizisinin boyutunu belirler. dimensions dizisinde 0. dizinde bulunan değer 0. boyutun boyutudur, 1. dizinde bulunan değer 1. boyutun boyutudur ve bu şekilde devam eder. dimensions boyutlarının çarpımı, operatörün boyut boyutlarının çarpımına eşit olmalıdır. Daraltılmış dizi dimensions tarafından tanımlanan çok boyutlu diziye dönüştürülürken dimensions'teki boyutlar en yavaş değişenden (en büyük) en hızlı değişene (en küçük) göre sıralanır.

Örneğin, v'nin 24 öğe içeren bir dizi olduğunu varsayalım:

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

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

let v012_83 = Reshape(v, {8,3});
then v012_83 == f32[8x3] { {10, 11, 12}, {15, 16, 17},
                          {20, 21, 22}, {25, 26, 27},
                          {30, 31, 32}, {35, 36, 37},
                          {40, 41, 42}, {45, 46, 47} };

Özel bir durum olarak, yeniden şekillendirme tek öğeli bir diziyi skaler olarak dönüştürebilir ve bunun tam tersini yapabilir. Örneğin,

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

Rev (geri)

Ayrıca XlaBuilder::Rev sayfasını da inceleyin.

Rev(operand, dimensions)

Belirtilen dimensions boyunca operand dizisindeki öğelerin sırasını tersine çevirerek aynı şekle sahip bir çıkış dizisi oluşturur. Çok boyutlu bir dizindeki operan dizisinin her öğesi, dönüştürülmüş bir dizinde çıkış dizisine depolanır. Çok boyutlu dizin, tersine çevrilecek her boyuttaki dizin tersine çevrilerek dönüştürülür (ör. N boyutunda bir boyut, tersine çevrilecek boyutlardan biriyse i dizini N - 1 - i olarak dönüştürülür).

Rev işleminin bir kullanım alanı, sinir ağlarındaki gradyan hesaplaması sırasında iki pencere boyutu boyunca toplama ağırlığı dizisini tersine çevirmektir.

RngNormal

Ayrıca XlaBuilder::RngNormal sayfasını da inceleyin.

$N(\mu, \sigma)$ Normal dağılımı takip eden rastgele sayılarla belirli bir şeklin çıkışını oluşturur. $\mu$ ve $\sigma$parametreleri ile çıkış şeklinin kayan nokta temel türüne sahip olması gerekir. Ayrıca parametrelerin skaler değerli olması gerekir.

RngNormal(mu, sigma, shape)

RngUniform

Ayrıca XlaBuilder::RngUniform sayfasını da inceleyin.

$[a,b)$aralığında eşit dağılımı izleyen rastgele sayılarla belirli bir şeklin çıkışını oluşturur. Parametreler ve çıkış öğesi türü, boole türü, tam sayı türü veya kayan nokta türlerinden biri olmalıdır ve türler tutarlı olmalıdır. CPU ve GPU arka uçları şu anda yalnızca F64, F32, F16, BF16, S64, U64, S32 ve U32'yi destekler. Ayrıca, parametrelerin skaler değerli olması gerekir. Sonuç uygulama tarafından tanımlanmışsa $b <= a$

RngUniform(a, b, shape)

RngBitGenerator

Belirtilen algoritmayı (veya arka uç varsayılanını) kullanarak tekdüze rastgele bitlerle doldurulmuş belirli bir şekle sahip bir çıkış oluşturur ve güncellenmiş bir durumu (ilk durumla aynı şekle sahip) ve oluşturulan rastgele verileri döndürür.

Başlangıç durumu, mevcut rastgele sayı oluşturma işleminin başlangıç durumudur. Bu parametre, gerekli şekil ve geçerli değerler kullanılan algoritmaya bağlıdır.

Çıktının, başlangıç durumunun deterministik bir işlevi olduğu garanti edilir ancak arka uçlar ve farklı derleyici sürümleri arasında deterministik olması garanti edilmez.

RngBitGenerator(algorithm, key, shape)

algorithm için kullanılabilen değerler:

• rng_default: Arka uca özgü şekil gereksinimleri olan arka uca özgü algoritma.

• rng_three_fry: ThreeFry sayıcı tabanlı PRNG algoritması. initial_state şekli, rastgele değerlere sahip u64[2] şeklindedir. Salmon ve diğerleri SC 2011. Paralel rastgele sayılar: 1, 2, 3 kadar kolay.

• rng_philox: Paralel olarak rastgele sayı oluşturmak için Philox algoritması. initial_state şekli, rastgele değerlere sahip u64[3] şeklindedir. Salmon ve diğerleri SC 2011. Paralel rastgele sayılar: 1, 2, 3 kadar kolay.

Dağılım

XLA dağılım işlemi, operands giriş dizisinin değerleri olan bir sonuç dizisi oluşturur. Bu dizi, update_computation kullanılarak updates'deki değer dizisiyle güncellenen çeşitli dilimlerden (scatter_indices tarafından belirtilen dizininde) oluşur.

Ayrıca XlaBuilder::Scatter sayfasını da inceleyin.

scatter(operands..., scatter_indices, updates..., update_computation, index_vector_dim, update_window_dims, inserted_window_dims, scatter_dims_to_operand_dims)

Burada:

• N'nin 1 veya daha büyük olması gerekir.
• operands[0], ..., operands[N-1] değerlerinin tümü aynı boyutlara sahip olmalıdır.
• updates[0], ..., updates[N-1] değerlerinin tümü aynı boyutlara sahip olmalıdır.
• N = 1 ise Collate(T) T.
• N > 1 ise Collate(T_0, ..., T_N), T türündeki N öğelerden oluşan bir tuple'dir.

index_vector_dim, scatter_indices.rank ile eşitse scatter_indices için son 1 boyutu olduğu varsayılır.

ArraySlice<int64> türündeki update_scatter_dims, update_window_dims içinde olmayan ve updates şeklindeki boyutların artan düzendeki kümesi olarak tanımlanır.

Dağılım bağımsız değişkenlerinin aşağıdaki kısıtlamalara uyması gerekir:

• Her updates dizisinin update_window_dims.size + scatter_indices.rank - 1 boyutu olmalıdır.

• Her updates dizisindeki i boyutunun sınırları aşağıdakilere uygun olmalıdır:

  • i, update_window_dims'da mevcutsa (yani bazı k için update_window_dims[k] değerine eşitse) updates'daki i boyutunun sınırı, inserted_window_dims dikkate alındıktan sonra operand'in karşılık gelen sınırını aşmamalıdır (yani adjusted_window_bounds[k], burada adjusted_window_bounds, inserted_window_dims dizinlerindeki sınırlar kaldırılmış şekilde operand'in sınırlarını içerir).
  • i, update_scatter_dims'te mevcutsa (yani bazı k için update_scatter_dims[k] değerine eşitse) updates'teki i boyutunun sınırı, index_vector_dim atlanarak scatter_indices boyutunun ilgili sınırına eşit olmalıdır (yani k < index_vector_dim ise scatter_indices.shape.dims[k] ve aksi takdirde scatter_indices.shape.dims[k+1]).

• update_window_dims artan düzende olmalı, yinelenen boyut numaraları içermemeli ve [0, updates.rank) aralığında olmalıdır.

• inserted_window_dims artan düzende olmalı, yinelenen boyut numaraları içermemeli ve [0, operand.rank) aralığında olmalıdır.

• operand.rank, update_window_dims.size ve inserted_window_dims.size'nin toplamına eşit olmalıdır.

• scatter_dims_to_operand_dims.size, scatter_indices.shape.dims[index_vector_dim] ile eşit olmalı ve değerleri [0, operand.rank) aralığında olmalıdır.

Her updates dizisindeki belirli bir dizin U için, bu güncellemenin uygulanması gereken ilgili operands dizisindeki karşılık gelen dizin I aşağıdaki gibi hesaplanır:

1. G = { update_scatter_dims içindeki k için U[k] } olsun. scatter_indices dizisinde S dizini vektörünü aramak için G'ü kullanın. Bu durumda S[i] = scatter_indices[Combine(G, i)] olur. Burada Combine(A, b), b değerini A'daki index_vector_dim konumlarına ekler.
2. scatter_dims_to_operand_dims haritasını kullanarak S'ü dağıtarak Sin dizinini operand içine oluşturun.S Daha resmi bir dille:
   1. k < scatter_dims_to_operand_dims.size ise Sin[scatter_dims_to_operand_dims[k]] = S[k].
   2. Aksi takdirde Sin[_] = 0.
3. Dizinleri inserted_window_dims'a göre U'deki update_window_dims'e dağıtarak her operands dizisine bir Win dizini oluşturun. Daha resmi bir dille:
   1. k update_window_dims içindeyse Win[window_dims_to_operand_dims(k)] = U[k], burada window_dims_to_operand_dims, [0, update_window_dims.size) alanında ve [0, operand.rank) \ inserted_window_dims aralığında monoton bir işlevdir. (Örneğin, update_window_dims.size 4, operand.rank 6 ve inserted_window_dims {0, 2} ise window_dims_to_operand_dims {0→1, 1→3, 2→4, 3→5} olur.)
   2. Aksi takdirde Win[_] = 0.
4. I, Win + Sin şeklindedir. Burada +, öğe bazında toplama işlemidir.

Özet olarak, dağılım işlemi aşağıdaki gibi tanımlanabilir.

• output değerini operands ile başlatın. Yani tüm J dizinleri için, operands[J] dizisindeki tüm O dizinleri için:
  output[J][O] = operands[J][O]
• updates[J] dizisindeki her U dizini ve operand[J] dizisindeki ilgili O dizini için (O, output için geçerli bir dizinse):
  (output[0][O], ..., output[N-1][O]) =update_computation(output[0][O], ..., ,output[N-1][O],updates[0][U], ...,updates[N-1][U])

Güncellemelerin uygulanma sırası kesin değildir. Bu nedenle, updates'teki birden fazla dizin operands'teki aynı dizindeyse output'deki ilgili değer kesin olmayan bir değer olur.

update_computation işlevine iletilen ilk parametrenin her zaman output dizisindeki mevcut değer, ikinci parametrenin ise her zaman updates dizisindeki değer olacağını unutmayın. Bu, özellikle update_computation'nin toplama işlemine göre değişmez olduğu durumlarda önemlidir.

indices_are_sorted doğru değerine ayarlanırsa XLA, scatter_indices öğelerinin kullanıcı tarafından sıralandığını (scatter_dims_to_operand_dims'e göre değerlerini dağıttıktan sonra artan düzende) varsayabilir. Aksi takdirde semantik, uygulama tarafından tanımlanır.

unique_indices doğru değerine ayarlanırsa XLA, dağıtılan tüm öğelerin benzersiz olduğunu varsayabilir. Böylece XLA, atomik olmayan işlemleri kullanabilir. unique_indices doğru olarak ayarlanırsa ve dağıtılan dizinler benzersiz değilse semantik, uygulama tarafından tanımlanır.

Düzensiz olarak, dağılım işlemi toplama işleminin tersi olarak görülebilir. Yani dağılım işlemi, girişteki ilgili toplama işlemi tarafından ayıklanan öğeleri günceller.

Ayrıntılı ve resmi olmayan bir açıklama ve örnekler için Gather altındaki "Resmi Olmayan Açıklama" bölümüne bakın.

Seç

Ayrıca XlaBuilder::Select sayfasını da inceleyin.

Bir önerme dizisinin değerlerine göre iki giriş dizisinin öğelerinden bir çıkış dizisi oluşturur.

Select(pred, on_true, on_false)

on_true ve on_false dizileri aynı şekle sahip olmalıdır. Bu, çıkış dizisinin şeklidir. pred dizisi, PRED öğe türüyle on_true ve on_false ile aynı boyuta sahip olmalıdır.

pred öğesinin her P öğesi için çıkış dizisinin ilgili öğesi, P değerinin true olması durumunda on_true'den, P değerinin false olması durumunda ise on_false'ten alınır. Yayınlama işleminin kısıtlanmış bir şekli olarak pred, PRED türüne sahip bir skaler olabilir. Bu durumda, çıkış dizisi pred true ise tamamen on_true'ten, pred false ise on_false'ten alınır.

Skaler olmayan pred içeren örnek:

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

Skaler pred içeren örnek:

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

İki küme arasında seçim yapılması desteklenir. Bu amaçla, tuple'ların skaler tür olduğu kabul edilir. on_true ve on_false tuplarsa (aynı şekle sahip olmalıdırlar) pred, PRED türüne sahip bir skaler olmalıdır.

SelectAndScatter

Ayrıca XlaBuilder::SelectAndScatter sayfasını da inceleyin.

Bu işlem, her pencereden bir öğe seçmek için önce operand dizisinde ReduceWindow işlevini hesaplayan ve ardından operand dizisiyle aynı şekle sahip bir çıkış dizisi oluşturmak için source dizisini seçili öğelerin dizinlerine dağıtan bir birleşik işlem olarak düşünülebilir. İkili select işlevi, her pencereye uygulayarak her pencereden bir öğe seçmek için kullanılır ve ilk parametrenin dizin vektörünün, ikinci parametrenin dizin vektöründen alfabetik olarak daha az olduğu özelliğiyle çağrılır. select işlevi, ilk parametre seçilirse true, ikinci parametre seçilirse false döndürür ve seçilen öğenin belirli bir pencerede taranan öğelerin sırasına bağlı olmaması için işlev geçişli olmalıdır (yani select(a, b) ve select(b, c) true ise select(a, c) de true olmalıdır).

scatter işlevi, çıkış dizisindeki her seçili dizinde uygulanır. İki skaler parametre alır:

1. Çıkış dizisindeki seçili dizinde geçerli değer
2. Seçilen dizin için geçerli olan source'teki dağılım değeri

İki parametreyi birleştirir ve çıkış dizisindeki seçili dizinde değeri güncellemek için kullanılan bir skaler değer döndürür. Başlangıçta çıkış dizisinin tüm dizinleri init_value olarak ayarlanır.

Çıkış dizisi, operand dizisiyle aynı şekle sahiptir ve source dizisi, operand dizisine bir ReduceWindow işleminin uygulanmasının sonucuyla aynı şekle sahip olmalıdır. SelectAndScatter, bir sinir ağındaki bir toplama katmanının gradyan değerlerini geri yaymak için kullanılabilir.

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

Aşağıdaki şekilde, select işlevinin parametreleri arasında en yüksek değeri hesapladığı SelectAndScatter işlevinin kullanım örnekleri gösterilmektedir. Pencereler aşağıdaki şekilde (2) gösterildiği gibi çakıştığında operand dizisinin bir dizininin farklı pencereler tarafından birden çok kez seçilebileceğini unutmayın. Şekilde, 9 değerine sahip öğe hem üst pencereler (mavi ve kırmızı) tarafından seçilir hem de ikili toplama scatter işlevi 8 değerine sahip (2 + 6) çıkış öğesini oluşturur.

scatter işlevinin değerlendirme sırası keyfidir ve belirlenemez olabilir. Bu nedenle, scatter işlevi yeniden ilişkilendirmeye karşı aşırı hassas olmamalıdır. Daha fazla bilgi için Reduce bağlamında ilişkilendirme hakkındaki tartışmaya bakın.

Gönder

Ayrıca XlaBuilder::Send sayfasını da inceleyin.

Send(operand, channel_handle)

Belirtilen operand verilerini, aynı kanal herkese açık kimliğini paylaşan başka bir hesaplamadaki Recv talimatına gönderir. Hiçbir veri döndürmez.

Recv işlemine benzer şekilde, Send işleminin istemci API'si senkron iletişimi temsil eder ve asenkron veri aktarımını etkinleştirmek için dahili olarak 2 HLO talimatına (Send ve SendDone) ayrılır. Ayrıca HloInstruction::CreateSend ve HloInstruction::CreateSendDone belgelerini inceleyin.

Send(HloInstruction operand, int64 channel_id)

Operanın, aynı kanal kimliğine sahip Recv talimatı tarafından ayrılan kaynaklara ayarsız aktarımını başlatır. Veri aktarımının tamamlanmasını beklemek için sonraki bir SendDone talimatı tarafından kullanılan bir bağlam döndürür. Bağlam, {operand (shape), request identifier (U32)} bir tuple'dir ve yalnızca bir SendDone talimatı tarafından kullanılabilir.

SendDone(HloInstruction context)

Send talimatı tarafından oluşturulan bir bağlamda, veri aktarımının tamamlanmasını bekler. Talimat hiçbir veri döndürmez.

Kanal talimatlarının planlanması

Her kanal için 4 talimatın (Recv, RecvDone, Send, SendDone) yürütme sırası aşağıda verilmiştir.

• Recv, Send tarihinden önce gerçekleşir
• Send, RecvDone tarihinden önce gerçekleşir
• Recv, RecvDone tarihinden önce gerçekleşir
• Send, SendDone tarihinden önce gerçekleşir

Arka uç derleyiciler, kanal talimatları aracılığıyla iletişim kuran her hesaplama için doğrusal bir program oluşturduğunda, hesaplamalar arasında döngü olmamalıdır. Örneğin, aşağıdaki planlar kilitlenmeye neden olur.

Talimatlardaki kısıtlamanın yalnızca çalışma zamanındaki TPU'lar için geçerli olduğunu unutmayın. GPU'da send ve recv, kaynak ile hedef cihazlar arasında bir el sıkışma işlemi gerçekleşene kadar gerçek verileri engeller ve göndermez.

Dilim

Ayrıca XlaBuilder::Slice sayfasını da inceleyin.

Dilimleme, giriş dizisinden bir alt dizi ayıklar. Alt dizi, girişle aynı sayıda boyuta sahiptir ve giriş dizisindeki bir sınır kutusu içindeki değerleri içerir. Bu sınır kutusunun boyutları ve dizinleri, dilimleme işlemine bağımsız değişken olarak verilir.

Slice(operand, start_indices, limit_indices, strides)

1 boyutlu örnek:

let a = {0.0, 1.0, 2.0, 3.0, 4.0}
Slice(a, {2}, {4}) produces:
  {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} }

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

Sırala

Ayrıca XlaBuilder::Sort sayfasını da inceleyin.

Sort(operands, comparator, dimension, is_stable)

Yalnızca bir operatör sağlanırsa:

• İşlenen 1 boyutlu bir tensörse (dizin) sonuç sıralanmış bir dizindir. Diziyi artan düzende sıralamak istiyorsanız karşılaştırıcı, küçüktür karşılaştırması yapmalıdır. Resmi olarak, dizi sıralandıysa i < j'nin comparator(value[i], value[j]) = comparator(value[j], value[i]) = false veya comparator(value[i], value[j]) = true olduğu tüm dizin konumları i, j için geçerlidir.

• İşlenenin boyut sayısı daha fazlaysa işlenen, sağlanan boyuta göre sıralanır. Örneğin, 2 boyutlu bir tensör (matris) için 0 boyut değeri her sütunu bağımsız olarak sıralar ve 1 boyut değeri her satırı bağımsız olarak sıralar. Boyut numarası sağlanmazsa varsayılan olarak son boyut seçilir. Sıralamada kullanılan boyut için 1 boyutlu durumdakiyle aynı sıralama düzeni geçerlidir.

n > 1 işleçleri sağlanırsa:

• Tüm n operatörleri aynı boyutlara sahip tenzorlar olmalıdır. Tensörlerin öğe türleri farklı olabilir.

• Tüm operatörler tek tek değil, birlikte sıralanır. İşlenenler kavramsal olarak bir tuple olarak kabul edilir. Dizin konumları i ve j'teki her bir operandın öğelerinin değiştirilmesi gerekip gerekmediği kontrol edilirken karşılaştırıcı, 2 * n skaler parametreleriyle çağrılır. Bu parametrelerde 2 * k, k-th operandının i konumundaki değere, 2 * k + 1 ise k-th operandının j konumundaki değere karşılık gelir. Bu nedenle, karşılaştırıcı genellikle 2 * k ve 2 * k + 1 parametrelerini birbiriyle karşılaştırır ve olası eşitlik durumunda diğer parametre çiftlerini kullanır.

• Sonuç, sıralı düzende (yukarıda belirtildiği gibi sağlanan boyutla birlikte) operatörlerden oluşan bir tuple olur. İkili grubun i-th işlevi, Sırala işlevinin i-th işlevine karşılık gelir.

Örneğin, operand0 = [3, 1], operand1 = [42, 50], operand2 = [-3.0, 1.1] olmak üzere üç operatör varsa ve karşılaştırıcı yalnızca operand0 değerlerini küçüktür operatörüyle karşılaştırırsa sıralamanın sonucu ([1, 3], [50, 42], [1.1, -3.0]) kümesi olur.

is_stable doğru olarak ayarlanırsa sıralamanın kararlı olacağı garanti edilir. Yani karşılaştırıcı tarafından eşit olarak kabul edilen öğeler varsa eşit değerlerin göreceli sırası korunur. İki öğe e1 ve e2 yalnızca comparator(e1, e2) = comparator(e2, e1) = false ise eşittir. is_stable varsayılan olarak false olarak ayarlanır.

TopK

Ayrıca XlaBuilder::TopK sayfasını da inceleyin.

TopK, belirtilen tensörün son boyutu için k en büyük veya en küçük öğenin değerlerini ve dizinlerini bulur.

TopK(operand, k, largest)

1 boyutlu bir giriş tensörü (dizi) için dizindeki k en büyük veya en küçük girişleri bulur ve iki diziden oluşan bir tuple döndürür (values, indices). Bu nedenle values[j], operand içinde j. en büyük/küçük giriştir ve dizini indices[j]'dır.

1'den fazla boyutu olan bir giriş tensörü için son boyut boyunca ilk k girişi hesaplar ve çıkıştaki diğer tüm boyutları (satırları) korur. Bu nedenle, Q >= k şeklindeki bir operatör için çıktı bir (values, indices) tuple'idir. Burada:[A, B, ..., P, Q]

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

Bir satırdaki iki öğe eşitse öncelikli olarak daha düşük endeksli öğe gösterilir.

Transpoze

tf.reshape işlemine de bakın.

Transpose(operand)

Operand boyutlarını belirtilen permütasyonla permüte eder. Böylece ∀ i . 0 ≤ i < number of dimensions ⇒ input_dimensions[permutation[i]] = output_dimensions[i] olur.

Bu, Reshape(operand, permutation, Permute(permutation, operand.shape.dimensions)) ile aynıdır.

TriangularSolve

Ayrıca XlaBuilder::TriangularSolve sayfasını da inceleyin.

Aşağı veya yukarı üçgen katsayı matrislerine sahip doğrusal denklem sistemlerini ileri veya geri değiştirme yöntemiyle çözer. Öne gelen boyutlar boyunca yayın yapan bu rutin, op(a)'nin op(a) = a, op(a) = Transpose(a) veya op(a) = Conj(Transpose(a)) olduğu durumlarda a ve b verildiğinde x değişkeni için op(a) * x = b veya x * op(a) = b matris sistemlerinden birini çözer.

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