İşlem anlamı

Aşağıda, XlaBuilder arayüzünde tanımlanan işlemlerin semantikleri açıklanmaktadır. Genellikle bu işlemler xla_data.proto bölgesindeki 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 bkz. XlaBuilder::AfterAll.

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 yaratan işlemler arasında iş parçacığı oluşturulabilen temel 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)

Bağımsız değişkenler	Tür	Anlam
operands	XlaOp	değişken sayıda jeton

AllGather

Ayrıca XlaBuilder::AllGather adresine de göz atın.

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

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

Bağımsız değişkenler	Tür	Anlam bilimi
operand	XlaOp	Kopyalar arasında birleştirilecek dizi
all_gather_dim	int64	Birleştirme boyutu
replica_groups	int64 vektörlerinin vektörü	Dize birleştirme işleminin yapıldığı gruplar
channel_id	isteğe bağlı int64	Modüller arası iletişim için isteğe bağlı kanal kimliği

• replica_groups, aralarında birleştirmenin 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, 2 ve 1 ile 3 replikaları arasında birleştirme yapar.
• 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 operanın iki kopyada sırasıyla [1.0, 2.5] ve [3.0, 5.25] değerleri varsa 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 bkz. XlaBuilder::AllReduce.

Replikalarda özel hesaplama yapar.

AllReduce(operand, computation, replica_group_ids, channel_id)

Bağımsız değişkenler	Tür	Anlam
operand	XlaOp	Replikalar genelinde azaltılacak dizi veya boş olmayan bir dizi
computation	XlaComputation	Azaltma hesaplaması
replica_groups	int64 vektörlerinin vektörü	Azaltmaların gerçekleştirildiği gruplar
channel_id	isteğe bağlı int64	Modüller arası iletişim için isteğe bağlı kanal kimliği

• operand bir dizi tuple olduğunda, tüm azaltma işlemi tuple'in 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). 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 öğesine sahip all-reduce işlemleri birbiriyle 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 kez iterasyonuna neden olduğunda bu durum mümkündür.

AllToAll

Ayrıca bkz. XlaBuilder::AllToAll.

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ılan çekirdekler şu kullanıcılar tarafından yapılandırılabilir:

• replica_groups: Her ReplicaGroup, hesaplamaya katılan kopya kimliklerinin 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} }, bir AllToAll komutunun {1, 2, 3} replikalarında ve toplama aşamasında uygulanacağı ve alınan blokların aynı sırayla 1, 2, 3'e göre birleştirileceği anlamına gelir. Ardından, 4, 5, 0 replikalarının içinde başka bir AllToAll uygulaması uygulanır ve birleştirme sırası da 4, 5, 0 olur. replica_groups boşsa tüm replikalar, görünüm 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)

Bağımsız değişkenler	Tür	Anlam bilimi
operand	XlaOp	n boyutlu giriş dizisi
split_dimension	int64	[0, n) aralığında, işlenenin bölündüğü boyutu belirten bir değer
concat_dimension	int64	Bölünmüş blokların birleştirildiği boyutu adlandıran [0, n) aralığındaki bir değer
split_count	int64	Bu işleme katılan çekirdek sayısı. replica_groups boşsa bu, kopya sayısını, aksi takdirde her gruptaki kopya sayısına eşit olmalıdır.
replica_groups	ReplicaGroup vektörü	Her grup, kopya kimliklerinin bir listesini içerir.

Aşağıda bir 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 bulunuyor. Her çekirdekte, operandor 0 boyutu boyunca 4 parçaya bölünür. Bu nedenle her parçanın şekli f32[4,4] olur. 4 parça tüm çekirdeklere dağıtılır. Daha sonra her çekirdek, alınan parçaları 1. boyut boyunca çekirdek 0'dan 4'e doğru sırayla birleştirir. Dolayısıyla her çekirdeğin çıkışı f32[16,4] şeklindedir.

BatchNormGrad

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

Toplu normalleştirmenin gradyanlarını hesaplar.

BatchNormGrad(operand, scale, mean, variance, grad_output, epsilon, feature_index)

Bağımsız değişkenler	Tür	Anlam bilimi
operand	XlaOp	Normalleştirilecek n boyutlu dizi (x)
scale	XlaOp	1 boyutlu dizi (\(\gamma\))
mean	XlaOp	1 boyutlu dizi (\(\mu\))
variance	XlaOp	1 boyutlu dizi (\(\sigma^2\))
grad_output	XlaOp	Gradyanlar BatchNormTraining (\(\nabla y\)) sürümüne geçirildi
epsilon	float	Epsilon değeri (\(\epsilon\))
feature_index	int64	operand'teki özellik boyutunun dizini

İş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'taki ö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:

Çıkışlar	Tür	Anlam bilimi
grad_operand	XlaOp	operand girişine göre gradyan ($\nabla x$)
grad_scale	XlaOp	scale girişine göre gradyan ($\nabla \gamma$)
grad_offset	XlaOp	offset girişine göre gradyan ($\nabla \beta$)

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 genelinde normalleştirir.

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

Bağımsız değişkenler	Tür	Anlam bilimi
operand	XlaOp	Normalleştirilecek n boyutlu dizi
scale	XlaOp	1 boyutlu dizi
offset	XlaOp	1 boyutlu dizi
mean	XlaOp	1 boyutlu dizi
variance	XlaOp	1 boyutlu dizi
epsilon	float	Epsilon değeri
feature_index	int64	operand içindeki özellik boyutu için dizin

İş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 de BatchNormInference adı verilmiştir.

Çıkış, operand girdisiyle 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 boyutlarda normalleştirir.

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

Bağımsız değişkenler	Tür	Anlam bilimi
operand	XlaOp	Normalleştirilecek n boyutlu dizi (x)
scale	XlaOp	1 boyutlu dizi (\(\gamma\))
offset	XlaOp	1 boyutlu dizi (\(\beta\))
epsilon	float	Epsilon değeri (\(\epsilon\))
feature_index	int64	operand'teki özellik boyutunun dizini

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

Algoritma, operand \(x\) öğesinde konumsal boyutların boyutu olarak w ve h bulunan m öğeleri içeren her grup için aşağıdaki gibidir (operand öğesinin 4 boyutlu bir dizi olduğu varsayılır):

• Ö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}\)

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

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

Çıkış türü üç XlaOp birleşiminden oluşur:

Çıkışlar	Tür	Anlam bilimi
output	XlaOp	Giriş ile aynı şekle sahip n boyutlu dizi operand (y)
batch_mean	XlaOp	1 boyutlu dizi (\(\mu\))
batch_var	XlaOp	1 boyutlu dizi (\(\sigma^2\))

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

BitcastConvertType

Ayrıca bkz. XlaBuilder::BitcastConvertType.

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 uygulanır. Bu nedenle, farklı kayan nokta gösterimlerine sahip makineler farklı sonuçlar verir.

BitcastConvertType(operand, new_element_type)

Bağımsız değişkenler	Tür	Anlam bilimi
operand	XlaOp	D boyutu olan T türü dizi
new_element_type	PrimitiveType	U türü

Dönüşümden önceki ve sonraki temel boyutun oranına göre değişecek olan son boyut dışında, işlem görenin boyutları ve hedef şekli 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''ün 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 tabanlı olmadığını unutmayın.

Yayın

Ayrıca bkz. XlaBuilder::Broadcast.

Dizideki verileri kopyalayarak bir diziye boyut ekler.

Broadcast(operand, broadcast_sizes)

Bağımsız değişkenler	Tür	Anlam bilimi
operand	XlaOp	Çoğaltılacak dizi
broadcast_sizes	ArraySlice<int64>	Yeni boyutların boyutları

Yeni boyutlar sola eklenir. Yani, broadcast_sizes değeri {a0, ..., aN} değerlerine sahipse ve işlenen şeklin boyutları {b0, ..., bM} ise çıktının şekli {a0, ..., aN, b0, ..., bM} boyutlarına sahip olur.

Yeni boyut dizini, işlenenin kopyalarına dönüştürülür; ör.

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 adresine de göz atın.

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

BroadcastInDim(operand, out_dim_size, broadcast_dimensions)

Bağımsız değişkenler	Tür	Anlam bilimi
operand	XlaOp	Kopyalanacak dizi
out_dim_size	ArraySlice<int64>	Hedef şeklin boyutlarının boyutları
broadcast_dimensions	ArraySlice<int64>	İşlenen şeklin her boyutunun hedef şekildeki hangi boyuta karşılık geldiği

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 adresine de göz atın.

Verilen bağımsız değişkenlerle hesaplamaya çağrı yapar.

Call(computation, args...)

Bağımsız değişkenler	Tür	Anlam
computation	XlaComputation	N adet rastgele türde parametre içeren T_0, T_1, ..., T_{N-1} -> S türündeki hesaplama
args	N tane XlaOp dizisi	İsteğe bağlı türde N bağımsız değişken

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

Cholesky

Ayrıca bkz. XlaBuilder::Cholesky.

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

Cholesky(a, lower)

Bağımsız değişkenler	Tür	Anlam bilimi
a	XlaOp	Karmaşık veya kayan nokta türündeki 2'den büyük bir sıra dizisi.
lower	bool	a üst veya alt üçgeninin kullanılıp kullanılmayacağını belirtir.

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 değerinin sırası 2'den büyükse a, küçük 2 boyut hariç tümü paket boyutu olan bir matris grubu olarak değerlendirilir.

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

Kıskaç

Ayrıca XlaBuilder::Clamp adresine de göz atın.

Bir işleneni, minimum ve maksimum değer arasındaki aralık içinde olacak şekilde tutturur.

Clamp(min, operand, max)

Bağımsız değişkenler	Tür	Anlam
min	XlaOp	T türü dizi
operand	XlaOp	T türü dizi
max	XlaOp	T türü dizi

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

XlaBuilder::Collapse ve tf.reshape işlemini de inceleyin.

Dizinin boyutlarını tek bir boyut olarak daraltır.

Collapse(operand, dimensions)

Bağımsız değişkenler	Tür	Anlam
operand	XlaOp	T türü dizi
dimensions	int64 vektörü	T boyutlarının sıralı, art arda gelen alt kümesi.

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ünde rastgele bir dizi ve boyut dizinlerinin derleme süresi sabit 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. Bu boyutların yerini, boyut sıralamasında değiştirildikleriyle aynı konumda bulunan ve orijinal boyut boyutlarının çarpımına eşit olan tek bir yeni boyut alır. dimensions içindeki en düşük boyut numarası, bu boyutları daraltan döngü yuvası içinde 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 daralma sıralaması 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} };

CollectivePermute

Ayrıca XlaBuilder::CollectivePermute adresine de göz atın.

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

CollectivePermute(operand, source_target_pairs)

Bağımsız değişkenler	Tür	Anlam bilimi
operand	XlaOp	n boyutlu giriş dizisi
source_target_pairs	<int64, int64> vektörü	(source_replica_id, target_replica_id) çiftlerinin bir listesi. Her çift için işlenen, kaynak replikadan hedef replikaya gönderilir.

source_target_pair için aşağıdaki kısıtlamaların olduğunu unutmayın:

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

Birleştirme

Ayrıca bkz. XlaBuilder::ConcatInDim.

Birleştir, birden fazla dizi operandından bir dizi oluşturur. Dizi, giriş dizisi operatörlerinin her biri ile aynı rütbeye sahiptir (operatörler de birbirleriyle aynı rütbeye sahip olmalıdır) ve bağımsız değişkenleri belirtildikleri sırayla içerir.

Concatenate(operands..., dimension)

Bağımsız değişkenler	Tür	Anlam bilimi
operands	N XlaOp dizisi	[L0, L1, ...] boyutlarına sahip T türü N dizi. N >= 1 olmalıdır.
dimension	int64	operands arasında birleştirilecek boyutu belirleyen [0, N) aralığında bir değer.

dimension hariç tüm boyutlar aynı olmalıdır. Bunun nedeni, XLA'nın "düzensiz" dizileri desteklememesidir. Ayrıca, 0. sıralı 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 bkz. XlaBuilder::Conditional.

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

Bağımsız değişkenler	Tür	Anlam
pred	XlaOp	PRED türündeki skaler
true_operand	XlaOp	\(T_0\)türündeki bağımsız değişken
true_computation	XlaComputation	\(T_0 \to S\)türündeki XlaComputation
false_operand	XlaOp	\(T_1\)türündeki bağımsız değişken
false_computation	XlaComputation	\(T_1 \to S\)türünün XlaHesaplaması

pred true ise true_computation öğesini, pred false ise false_computation işlemini 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 özelliklerinden yalnızca birinin yürütüleceğini unutmayın.

Conditional(branch_index, branch_computations, branch_operands)

Bağımsız değişkenler	Tür	Anlam bilimi
branch_index	XlaOp	S32 türünde skaler
branch_computations	N XlaComputation dizisi	\(T_0 \to S , T_1 \to S , ..., T_{N-1} \to S\)türündeki XlaComputations
branch_operands	N XlaOp dizisi	\(T_0 , T_1 , ..., T_{N-1}\)türündeki bağımsız değişkenler

branch_computations[branch_index] öğesini 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ünde tek bir bağımsız değişken almalıdır. 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 değerlerinden yalnızca birinin yürütüleceğini unutmayın.

Conv (konvolüsyon)

Ayrıca XlaBuilder::Conv adresine de göz atın.

ConvWithGeneralPadding olarak değişir, ancak dolgu kısa bir şekilde SAME veya GEÇERLİ olarak 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 bkz. XlaBuilder::ConvWithGeneralPadding.

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

Bağımsız değişkenler	Tür	Anlam
lhs	XlaOp	n+2 giriş dizisi sıralaması
rhs	XlaOp	n+2 sıralı çekirdek ağırlıkları dizisi
window_strides	ArraySlice<int64>	Çekirdek adımlarının n boyutlu dizisi
padding	ArraySlice< pair<int64,int64>>	n-d dizisi (düşük, yüksek) dolgu
lhs_dilation	ArraySlice<int64>	n boyutlu sol taraf genişleme faktörü dizisi
rhs_dilation	ArraySlice<int64>	n-d rhs genişletme faktörü dizisi
feature_group_count	int64	özellik gruplarının sayısı
batch_group_count	int64	toplu grupların sayısı

n, uzamsal boyutların sayısı olsun. lhs bağımsız değişkeni, taban alanını tanımlayan n+2 kademeli bir dizidir. Buna giriş denir. Sağ taraf da giriştir. Bir 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: Taban alanındaki her (y,x) konumu, kendisiyle ilişkilendirilmiş ve bu boyuta giden bir vektöre sahiptir.
• spatial_dims: Pencerenin taşındığı temel alanı tanımlayan n boyutsal boyutlarını tanımlar.

rhs bağımsız değişkeni, ardışık filtreyi/çekirdeği/pencereyi açıklayan n+2 kademeli bir dizidir. Boyutlar şu sırayladır:

• output-z: Çıktının z boyutu.
• input-z: Bu boyutun feature_group_count çarpı boyutu, lh'deki 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 mekansal boyuttaki adım 3 ise pencere yalnızca ilk uzamsal dizinin 3'e bölündüğü 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 çiftin ilk öğe olarak düşük dolgusu ve ikinci öğe olarak yüksek dolgusu vardır. 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] değeri (2,3) ise ikinci mekansal boyutta sol tarafta 2 sıfır ve sağ tarafta 3 sıfır dolgu olacaktır. Dolgu kullanımı, konvolüsyondan ö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 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 dizi boyutu artar. Delikler "işlemsiz" değeriyle doldurulur, bu da konvolüsyon 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 değerine bölünmesiyle elde edilen değere eşit olması gerekir (yani zaten bir giriş özellikleri grubunun boyutuna sahiptir). i. gruplar, birçok ayrı topoloji için feature_group_count hesaplamak üzere birlikte kullanılır. Bu evrişimlerin sonuçları, çıkış özelliği boyutunda birleştirilir.

Derinlemesine dönüşüm 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] iken [filter_height, filter_width, 1, in_channels * channel_multiplier] olarak yeniden biçimlendirilir. 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: Kıvrımlı 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. Etkin bir şekilde, her bir lh grubunu batch_group_count gruba ayırıyoruz ve aynı işlemi çıktı özellikleri için de yapıyoruz. Daha sonra bu grupların her biri için ikili kıvrımlar yapar ve sonucu çıktı özelliği boyutuyla 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. Bu durumda (y,x), pencerenin bir köşesinin taban alanı (ör. konumsal boyutları nasıl yorumladığınıza bağlı olarak sol üst köşe) içindeki konumudur. 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 kutu aynı boyutlara sahiptir. Bu yüzden, iki kutu arasındaki öğe tabanlı ürünlerin toplamını alabiliriz (noktalı çarpıma benzer). Bu, çıkış değeridir.

output-z örneğin şu şekildeyse: 5 değerini ayarlarsanız pencerenin her konumu, çıktının z boyutuna çıkışta 5 değer üretir. 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, bunu her biri için farklı bir filtreye sahip 5 ayrı topolojik dönüşüm 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 bkz. XlaBuilder::ConvertElementType.

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)

Bağımsız değişkenler	Tür	Anlam bilimi
operand	XlaOp	D boyutu olan T türü dizi
new_element_type	PrimitiveType	U türü

İşlem görenin boyutları ve hedef şeklinin eşleşmesi gerekir. Kaynak ve hedef öğe türleri demetler 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üştürme 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 adresine de göz atın.

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

CustomCall(target_name, args..., shape)

Bağımsız değişkenler	Tür	Anlam bilimi
target_name	string	İşlevin adı. Bu simge adını hedefleyen bir arama talimatı gönderilir.
args	N XlaOp dizisi	İşleve iletilecek, rastgele türde N bağımsız değişken.
shape	Shape	İşlevin çıkış şekli

args bağımsız değişkeninin türü veya sayısına bakılmaksızın işlev imzası aynıdır:

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

Örneğin, CustomCall aşağıdaki gibi kullanılırsa:

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

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

Aşağıda, myfunc uygulamasına bir örnek verilmiştir:

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 bulunmamalı ve yürütülmesi gerektiğinde kullanılabilir olmalıdır.

Nokta

Ayrıca XlaBuilder::Dot adresine de göz atın.

Dot(lhs, rhs)

Bağımsız değişkenler	Tür	Anlam
lhs	XlaOp	T türü dizi
rhs	XlaOp	T türü dizi

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

Giriş	Çıkış	Anlam
vektör [n] dot vektör [n]	skaler	vektör nokta çarpımı
matris [m x k] dot vektör [k]	vektör [m]	matris-vektor çarpımı
matris [m x k] dot matris [k x n]	matris [m x n]	matris çarpımı

İşlem, lhs'ün ikinci boyutu (veya 1. sıradaysa ilk boyutu) ve rhs'ün ilk boyutu üzerinde çarpım toplamı gerçekleştirir. Bunlar "daraltılmış" boyutlardır. lhs ve rhs'nin 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 adresine de göz atın.

DotGeneral(lhs, rhs, dimension_numbers)

Bağımsız değişkenler	Tür	Anlam
lhs	XlaOp	T türü dizi
rhs	XlaOp	T türü dizi
dimension_numbers	DotDimensionNumbers	sözleşmeli ve toplu boyut numaraları

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

DotDimensionNumbers Alanları	Tür	Anlam bilimi
lhs_contracting_dimensions	Tekrarlanan int64	lhs daraltma boyutu sayıları
rhs_contracting_dimensions	Tekrarlanan int64	rhs daraltılmış boyut sayıları
lhs_batch_dimensions	Tekrarlanan int64	lhs grup boyutu sayıları
rhs_batch_dimensions	Tekrarlanan int64	rhs toplu boyut numarası

DotGeneral, dimension_numbers içinde belirtilen sözleşme boyutlarının üzerinde ürünlerin toplamını yapar.

lhs ve rhs'deki 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 kaynaklı ilişkili grup boyutu sayıları 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} } }

Giriş	Çıkış	Anlam bilimi
[b0, m, k] dot [b0, k, n]	[b0, m, n]	toplu matmul
[b0, b1, m, k] dot [b0, b1, k, n]	[b0, b1, m, n]	toplu matmul

Sonuçta ortaya çıkan boyut numarasının grup boyutu, ardından lhs sözleşmeli/toplu olmayan boyut ve son olarak da rhs sözleşmeli/toplu olmayan boyutla başladığına dikkat edin.

DynamicSlice

Ayrıca XlaBuilder::DynamicSlice adresine de göz atın.

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

DynamicSlice(operand, start_indices, size_indices)

Bağımsız değişkenler	Tür	Anlam
operand	XlaOp	T türünde N boyutlu dizi
start_indices	N XlaOp dizisi	Her boyut için dilimin başlangıç dizinlerini içeren N skaler tam sayı listesi. Değer sıfırdan büyük veya sıfıra eşit olmalıdır.
size_indices	ArraySlice<int64>	Her boyut için dilim boyutunu içeren N tam sayıdan oluşan liste. Her değer kesinlikle sıfırdan büyük olmalıdır ve boyut modülüne sarmalanmamak için start + size, boyutun boyutundan küçük veya boyuta eşit olmalıdır.

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 bkz. XlaBuilder::DynamicUpdateSlice.

DynamicUpdateSlice, start_indices sırasında update diliminin üzerine yazılan operand giriş dizisinin değeri olan bir sonuç oluşturur. update'ün şekli, güncellenen sonucun alt dizisinin şeklini belirler. start_indices'ün şekli, rank == 1 olmalı ve boyut boyutu operand'ün sırasına eşit olmalıdır.

DynamicUpdateSlice(operand, update, start_indices)

Bağımsız değişkenler	Tür	Anlam
operand	XlaOp	T türünde N boyutlu dizi
update	XlaOp	Dilim güncellemesini içeren T türü N boyutlu dizi. Güncelleme şeklinin her boyutu kesinlikle sıfırdan büyük olmalıdır ve sınırların dışında güncelleme dizinleri oluşturulmasını önlemek için başlangıç + güncelleme, her boyutun operand boyutundan küçük veya ona eşit olmalıdır.
start_indices	N XlaOp dizisi	Her boyut için dilimin başlangıç dizinlerini içeren N skaler tam sayı listesi. Değer sıfırdan büyük veya sıfıra eşit olmalıdır.

Etkili dilim dizinleri, dilim oluşturmadan önce [1, N) içindeki her i dizini 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 işlenen diziye göre her zaman sınırların içinde olmasını sağlar. Dilim, dönüştürme uygulanmadan önce sınırlar içindeyse dönüşümün herhangi bir etkisi olmaz.

1 boyutlu örnek:

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

DynamicUpdateSlice(a, u, s) 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} }

Element tabanlı ikili aritmetik işlemler

Ayrıca XlaBuilder::Add adresine de göz atın.

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

Op(lhs, rhs)

Op şunlardan biridir: Add (toplama), Sub(çıkarma), Mul (çarpma), Div (bölme), Pow (güç), Rem (kalan), Max (maksimum), Min (minimum), And (mantıksal VE), Or (mantıksal VEYA), Xor (mantıksal XOR), ShiftLeft (Sola Kaydırma), ShiftRightArithmetic (mantıksal-1) ve ShiftRightLogical (mantıksal1), ShiftRightLogical Karmaşık veya Sağa Bölme), ShiftRightLogical Karmaşık veya Sağa Bölme), {14Atan2Complex

Bağımsız değişkenler	Tür	Anlam bilimi
lhs	XlaOp	sol taraftaki işlenen: T türü dizi
rhs	XlaOp	sağ taraftaki operant: T türü dizi

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, işlem görenlerden biri skaler olmadığı sürece farklı sıralardaki 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/sıfıra kalan veya INT_SMIN'ün -1 ile işaretli bölme/kalan), uygulama tanımlı bir değer oluşturur.

Aşağıdaki işlemler için farklı sıralı 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 operanı, düşük rütbeli operanın rütbesini daha yüksek rütbeli operanın rütbesine kadar genişletmek için kullanılan bir tamsayı dilimidir. broadcast_dimensions, alt düzeydeki şeklin boyutlarını üst düzeydeki şeklin boyutlarıyla eşler. Genişletilmiş şeklin eşlenmemiş boyutları, boyutu bir olan boyutlarla doldurulur. Dejenere boyut yayını, her iki operatörün şekillerini eşitlemek için şekilleri bu dejenere boyutlar boyunca yayınlar. Anlamsal özellikler, yayınlama sayfasında ayrıntılı olarak açıklanmıştır.

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

Ayrıca XlaBuilder::Eq adresine de göz atın.

Standart öğe tabanlı ikili karşılaştırma işlemleri grubu desteklenir. Kayan nokta türlerini karşılaştırırken standart IEEE 754 kayan nokta karşılaştırma semantiğinin 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. Bir başka operatör grubu olan EqTotalOrders, NeTotal Order, GeTotalOrders, GtTotal Order, LeTotalOrders ve LtTotalOrders, aynı işlevleri sunar. Ancak bu operatörler, -NaN < -Inf < -Finite < -0 < -Finite < -0 <a <+N.

Bağımsız değişkenler	Tür	Anlam bilimi
lhs	XlaOp	sol taraftaki işlenen: T türü dizi
rhs	XlaOp	sağ taraftaki operant: T türü dizi

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, PRED öğe türüne sahip 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.

Aşağıdaki işlemler için farklı düzeylerde 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. Anlamsal özellikler, yayınlama sayfasında ayrıntılı olarak açıklanmıştır.

Öğe tabanlı tekli 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 tabanlı kübik kök işlemi x -> cbrt(x).

Ceil(operand) Öğe bazında ceil 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) nerede?

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

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

Expm1(operand) Öğe bazında doğal üs, eksi bir x -> 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). Operand kayan nokta türü ise 0 döndürülür.

IsFinite(operand) operand öğesinin her bir öğesinin sonlu olup olmadığını, yani pozitif veya negatif sonsuz olup olmadığını ve NaN olmadığını test eder. Girdi ile 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) x -> !(x) değil, öğe açısından mantıksal.

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). Operand kayan nokta türüyse aynı değeri döndürür.

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

RoundNearestEven(operand) Öğe bazında yuvarlama, en yakın eşit değerine eşittir.

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

Sign(operand) Öğe tabanlı işaret işlemi x -> sgn(x) nerede?

\[\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ü kullanılır.

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

Bağımsız değişkenler	Tür	Anlam bilimi
operand	XlaOp	İşlevin işleneni

İşlev, operand dizisindeki her öğeye uygulanır ve aynı şekle sahip bir dizi oluşturur. operand değerinin skaler (sıralama 0) 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 bkz. XlaBuilder::Fft.

Bağımsız değişkenler	Tür	Anlam bilimi
operand	XlaOp	Fourier dönüşümü yaptığımız dizi.
fft_type	FftType	Aşağıdaki tabloya bakın.
fft_length	ArraySlice<int64>	Dönüştürülen eksenlerin zaman alanı uzunlukları. RFFT(fft_length=[16]), RFFT(fft_length=[17]) ile aynı çıkış şekline sahip olduğundan bu, özellikle IRFFT'nin en iç ekseni doğru boyuta ayarlamasını sağlamak için gereklidir.

FftType	Anlam bilimi
FFT	Karmaşıktan karmaşığa ileri FFT. Şekil değiştirilmedi.
IFFT	Karmaşıktan karmaşığa ters FFT. Şekilde değişiklik yapılmaz.
RFFT	Gerçekten karmaşık FFT'ye yönlendirme. fft_length[-1] sıfır olmayan bir değerse en içteki eksenin şekli, dönüştürülen sinyalin Nyquist frekansının ötesindeki ters eşlenik kısmı atlanarak fft_length[-1] // 2 + 1 değerine indirilir.
IRFFT	Ters gerçeğe dönüşen FFT (ör. karmaşık alır, gerçek sonucu döndürür). En içteki eksenin şekli, fft_length[-1] sıfır olmayan bir değerse fft_length[-1] olarak genişletilir. Bu durumda, dönüştürülmüş sinyalin Nyquist frekansının ötesindeki kısmı, 1 girişlerinin ters birleşiminden fft_length[-1] // 2 + 1 girişlerine kadar tahmin edilir.

Çok boyutlu FFT

1'den fazla fft_length sağlandığında bu, en içteki eksenin her birine bir dizi FFT işlemi 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 TensorFFT ile desteklenir. GPU FFT, cuFFT 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 bkz. XlaBuilder::Gather. 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)

Bağımsız değişkenler	Tür	Anlam bilimi
operand	XlaOp	Verileri toparladığımız dizi.
start_indices	XlaOp	Topladığımız dilimlerin başlangıç dizinlerini içeren dizi.
index_vector_dim	int64	start_indices içindeki, başlangıç dizinlerini "içeren" boyut. Ayrıntılı açıklama için aşağıya bakın.
offset_dims	ArraySlice<int64>	Çıkış şeklindeki, işlenen öğeden dilimlenmiş bir diziye kaydıran boyutlar grubu.
slice_sizes	ArraySlice<int64>	slice_sizes[i], i boyutundaki dilimin sınırlarıdır.
collapsed_slice_dims	ArraySlice<int64>	Her bir dilimde daraltılan boyut grubu. Bu boyutlar 1 boyutunda olmalıdır.
start_index_map	ArraySlice<int64>	start_indices içindeki dizinlerin, işlev öğesindeki geçerli dizinlerle nasıl eşleneceğini açıklayan bir harita.
indices_are_sorted	bool	Dizinlerin çağrıya göre sıralanacağının garanti edilip edilmediği.

Kolaylık sağlaması açısından, çıkış dizisindeki offset_dims değerindeki boyutları batch_dims olarak etiketleriz.

Çıkış, batch_dims.size + offset_dims.size sıralamasından oluşan 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. batch_dims içinde i varsa (ör. bazı k için batch_dims[k] değerine eşitse) start_indices.shape dışında ilgili boyut sınırlarını seçeriz ve index_vector_dim atlanır (yani k < index_vector_dim ve aksi halde start_indices.shape.dims[k+1] için start_indices.shape.dims[k] değerini seçin).

2. offset_dims içinde i mevcutsa (ör. bazı k için offset_dims[k] değerine eşit) collapsed_slice_dims hesaba katıldıktan sonra slice_sizes üzerinden karşılık gelen sınırı seçeriz (yani adjusted_slice_sizes, collapsed_slice_dims dizinlerindeki sınırlar kaldırılmış şekilde adjusted_slice_sizes[k] değerini seçeriz).slice_sizes

Resmi olarak, belirli bir çıkış dizinine (Out) karşılık gelen In işlem dizini şu şekilde hesaplanır:

1. batch_dims } içinde k için G = { Out[k] olsun. S[i] = start_indices[Birleştir(G, i)] olacak şekilde S vektörünü dilimlemek için G kullanın.index_vector_dim 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. 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 collapsed_slice_dims grubuna göre Out ofset boyutlarında dağıtarak operand konumunda 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. Oin[_] = 0 diğer durumlarda.

4. In, Oin + Sin şeklindedir. Burada +, öğe tabanlı toplamadır.

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 (doğru) olarak ayarlanırsa XLA, start_indices öğelerinin 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ıç dizinini kullanarak slice_sizes boyutunda bir dilimi dinamik olarak dilimden ayırırız.

• collapsed_slice_dims boyutlarını daraltarak dilimi yeniden şekillendiririz. Tüm daraltılmış dilim boyutlarının sınırı 1 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 temel olarak değiştirmez ancak görsel temsili daha hantal hale getirir.

Yukarıdakilerin hepsinin birbirine nasıl uyum sağladığını anlamak için bir [16,11] dizisinden 5 şekil ([8,6]) 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:

İlk önce G kullanarak dizin toplama dizisinden bir (X,Y) vektörü seçeriz. Bu durumda, [G,O0,O1] dizinindeki çıkış dizisindeki öğe, [X+O0,Y+O1] dizinindeki giriş dizisindeki öğ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 işlevi 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. Çıktı şeklindeki hangi boyutların ofset boyutları (son örnekte O0, O1 içeren boyutlar) olacağını yapılandırabiliriz. Çı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ş sıralamasından daha az olabilir. Açıkça collapsed_slice_dims olarak 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. "Dizin Toplama" dizisinden (son örnekteki X, Y) çıkarılan dilim, giriş dizisi sıralamasından daha az öğeye sahip olabilir. Açık bir eşleme, dizinin girişle aynı sıralamaya sahip olması için nasıl genişletilmesi gerektiğini belirtir.

Son bir örnek olarak, tf.gather_nd'i uygulamak için (2) ve (3)'ü kullanıyoruz:

G0 ve G1, başlangıç dizininin yalnızca bir öğe (X) içermesi dışında, toplanan dizinler dizisinden bir başlangıç dizini dilimlemek için her zamanki gibi 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"ne (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 semantiği verir.

Bu destek kaydı için slice_sizes, [1,11]. Sezgisel olarak bu, dizin toplama dizisindeki her X dizininin bir satırı seçtiği ve sonuçta tüm bu satırların birleştirilmesi anlamına gelir.

GetDimensionSize

Ayrıca bkz. XlaBuilder::GetDimensionSize.

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

GetDimensionSize(operand, dimension)

Bağımsız değişkenler	Tür	Anlam bilimi
operand	XlaOp	n boyutlu giriş dizisi
dimension	int64	Boyutu belirten [0, n) aralığındaki bir değer

SetDimensionSize

Ayrıca bkz. XlaBuilder::SetDimensionSize.

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

SetDimensionSize(operand, size, dimension)

Bağımsız değişkenler	Tür	Anlam bilimi
operand	XlaOp	n boyutlu giriş dizisi.
size	XlaOp	Çalışma zamanındaki dinamik boyutu temsil eden int32.
dimension	int64	Boyutu belirten [0, n) aralığındaki bir değer.

Sonuç olarak işleneni, derleyici tarafından izlenen dinamik boyutla geçin.

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 bkz. XlaBuilder::GetTupleElement.

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

Değerin, derleme zamanı sabiti olması gerekir. Böylece şekil çıkarımı, sonuç olarak elde edilecek değerin türünü belirleyebilir.

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 adresini de inceleyin.

Feed içi

Ayrıca XlaBuilder::Infeed adresine de göz atın.

Infeed(shape)

Argüman	Tür	Anlam
shape	Shape	Feed içi arayüzünden okunan verilerin şekli. Şeklin düzen alanı, cihaza gönderilen verilerin düzeniyle eşleşecek şekilde ayarlanmalıdır. Aksi takdirde, davranışı tanımlanmaz.

Cihazın örtülü feed akış arayüzünden tek bir veri öğesini okur, verileri belirli bir şekil ve düzen 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ş demet şekilleri desteklenmiyor. Boş bir tuple şekli için feed işlemi etkin bir şekilde işlem yapmaz ve cihazın feed'inden herhangi bir veri okumadan devam eder.

Iota

Ayrıca XlaBuilder::Iota adresine de göz atın.

Iota(shape, iota_dimension)

Potansiyel olarak 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ürlerinde üretilen dizi, Iota değerinin integral türünde olduğu ve dönüşümün kayan nokta türüne olduğu ConvertElementType(Iota(...)) işlevine eş değerdir.

Bağımsız değişkenler	Tür	Anlam bilimi
shape	Shape	Iota() tarafından oluşturulan dizinin şekli
iota_dimension	int64	Birlikte artacak boyut.

Ö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 adresine de göz atın.

Map(operands..., computation)

Bağımsız değişkenler	Tür	Anlam bilimi
operands	N tane XlaOp dizisi	T0..T{N-1} türünde N dizi
computation	XlaComputation	rastgele türde T ve M türünde N parametreyle T_0, T_1, .., T_{N + M -1} -> S türü hesaplaması
dimensions	int64 dizisi	harita boyutları dizisi

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.

Haritalanmış işlev, T skaler türüne sahip N girişi ve S türüne sahip tek bir çıkışı olan bir kısıtlamaya sahip rastgele bir hesaplamadır. Çıkış, işlem görenlerle aynı boyutlara sahiptir. Tek fark, T öğe türünün S ile değiştirilmesidir.

Ö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) ile eşleme yapar.

OptimizationBarrier

Optimizasyon geçişlerinin, hesaplamaları bariyer boyunca taşımasını engeller.

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

Ped

Ayrıca XlaBuilder::Pad adresine de göz atın.

Pad(operand, padding_value, padding_config)

Bağımsız değişkenler	Tür	Anlam bilimi
operand	XlaOp	T türü dizi
padding_value	XlaOp	eklenen dolguyu doldurmak için T türünde skaler
padding_config	PaddingConfig	her iki kenardaki (düşük, yüksek) ve her boyutun öğeleri arasındaki dolgu miktarı

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 dolgusu ve iç dolgu miktarını belirtir.

PaddingConfig, her boyut için üç alan içeren yinelenen bir PaddingConfigDimension 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 dolgusu negatif olabilir. Negatif dolgunun mutlak değeri, belirtilen boyuttan kaldırılacak öğe sayısını gösterir.

interior_padding, her bir boyuttaki herhangi iki öğe arasına eklenen dolgu miktarını belirtir; 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ğerleriyle ilgili örnekler gösterilmektedir.

Recv

Ayrıca XlaBuilder::Recv adresine de göz atın.

Recv(shape, channel_handle)

Bağımsız değişkenler	Tür	Anlam bilimi
shape	Shape	verilerin şeklini değiştirebilirsiniz
channel_handle	ChannelHandle	her gönderme/alma çiftinin benzersiz tanımlayıcısı

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, eşzamansız veri aktarımları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. Ayrılan kaynaklar için bağlam döndürür. Bu bağlam, veri aktarımının tamamlanmasını beklemek için aşağıdaki bir 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 bkz. XlaBuilder::Reduce.

Paralel olarak bir veya daha fazla diziye indirgeme işlevi uygular.

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

Bağımsız değişkenler	Tür	Anlam bilimi
operands	N XlaOp dizisi	T_0, ..., T_{N-1} türünde N dizi.
init_values	N XlaOp dizisi	T_0, ..., T_{N-1} türünde N skaler.
computation	XlaComputation	T_0, ..., T_{N-1}, T_0, ..., T_{N-1} -> Collate(T_0, ..., T_{N-1}) türündeki hesaplama.
dimensions	int64 dizisi	sıralanmamış boyut dizisi.

Burada:

• N'nin 1'e eşit 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 başlangıç değerleri, computation altında bir özdeşlik oluşturmalıdır.
• N = 1 ise Collate(T) değeri T olur.
• N > 1 ise Collate(T_0, ..., T_{N-1}), T türünde 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 dizinin sıralaması rank(operand) - len(dimensions). İşlemin çıkışı Collate(Q_0, ..., Q_N)'tür. 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 daha birçok olasılık 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 rank 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]

2D dizisinin (matris) azaltılmasına ilişkin bir örnek aşağıda verilmiştir. Şeklin boyutu 2, boyut 2, boyut 0 ve boyut 3'tür:

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

Her iki azaltma sonucunun da 1 boyutlu diziler olduğunu unutmayın. Görsel kolaylık olması açısından, diyagramda biri sütun, diğeri ise satır olarak gösterilmiştir.

Daha karmaşık bir örnek için burada bir 3D dizi verilmiştir. Sıralaması 3, boyut 0, boyut 4, boyut 1, boyut 2 ve boyutu 2'dir. 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. sıralı bir dizi elde ederiz:

|  4   8  12 |
| 16  20  24 |

2. boyutu azaltırsak, 2. boyut genelindeki tüm değerlerin skaler halinde katlandığı bir sıra-2 dizisi 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 sayılar atanabileceğini (sıralama değiştiğinden) 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ında azaltılması skaler 84 sonucunu verir.

Varyant azaltma

N > 1 olduğunda küçültme işlevi uygulaması, tüm girişlere eş zamanlı olarak uygulandığı için biraz daha karmaşıktır. İşlemlere ait operandlar aşağıdaki sırayla sağlanır:

• İlk işlenen için düşük değer çalıştırılıyor
• ...
• N. operatör için azaltılmış değeri çalıştırma
• İlk operand 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))

Bir değer dizisine ve bir sıralı dizin dizisine (ör. iota) bu indirgeme uygulandığında, diziler yinelenir ve maksimum değer ile eşleşen dizini içeren bir unsur döndürülür.

ReducePrecision

Ayrıca XlaBuilder::ReducePrecision adresine de göz atın.

Kayan nokta değerlerini daha düşük hassasiyetli bir biçime (IEEE-FP16 gibi) ve orijinal biçime geri 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)

Bağımsız değişkenler	Tür	Anlam bilimi
operand	XlaOp	T kayan nokta türü dizisi.
exponent_bits	int32	düşük hassasiyetli biçimde üs bit sayısı
mantissa_bits	int32	düşük hassasiyetli biçimdeki mantissa bit sayısı

Sonuç, T türündeki bir dizidir. Giriş değerleri, belirtilen mantissa bit sayısı ile temsil edilebilen en yakın değere yuvarlanır ("çift değer ile eşittir" semantiği kullanılarak) ve üs bit sayısının belirttiği aralığı aşan değerler pozitif veya negatif sonsuza sabitlenir. NaN değerleri korunur ancak normal NaN değerlerine dönüştürülebilir.

Düşük hassasiyetli biçimde en az bir üs bit olmalıdır (sıfır değerini sonsuzdan ayırt etmek için, her ikisi de sıfır ondalık basamağı olduğundan) ve sıfır olmayan sayıda 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 adresine de göz atın.

ReduceScatter, bir AllReduce işlemini etkili bir şekilde yapan, ardından sonucu scatter_dimension boyunca shard_count bloklarına ayırarak sonucu dağıtan toplu bir işlemdir. Kopya grubundaki i replikası, ith kırığını alır.

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

Bağımsız değişkenler	Tür	Anlam
operand	XlaOp	Replikalar genelinde azaltılacak dizi veya boş olmayan bir dizi deliği.
computation	XlaComputation	Azaltma hesaplaması
scatter_dimension	int64	Dağılacak boyut.
shard_count	int64	Bölünecek blok sayısı scatter_dimension
replica_groups	int64 vektörlerinin vektörü	İndirimlerin yapıldığı gruplar
channel_id	isteğe bağlı int64	Modüller arası iletişim için isteğe bağlı kanal kimliği

• operand bir dizi kümesi olduğunda, azaltma yayılımı, tuple öğesinin 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 ya boş olmalı (bu durumda tüm replikalar tek bir gruba aittir) ya da replika sayısıyla aynı sayıda öğeyi 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], ikinci kopya için ise [7.5] olur.

ReduceWindow

Ayrıca bkz. XlaBuilder::ReduceWindow.

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 havuz katmanı, ReduceWindow ile 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)

Bağımsız değişkenler	Tür	Anlam bilimi
operands	N XlaOps	Her biri pencerenin yerleştirildiği taban alanı temsil eden N adet T_0,..., T_{N-1} türü çok boyutlu dizi dizisi.
init_values	N XlaOps	Azaltma işlemi için N başlangıç değeri (N operatörün her biri için bir tane). Ayrıntılar için Azalt bölümüne bakın.
computation	XlaComputation	Tüm giriş işlenenlerinin her bir penceresindeki öğelere uygulanacak T_0, ..., T_{N-1}, T_0, ..., T_{N-1} -> Collate(T_0, ..., T_{N-1}) türündeki azaltma işlevi.
window_dimensions	ArraySlice<int64>	pencere boyutu değerleri için tamsayı dizisi
window_strides	ArraySlice<int64>	Pencere adımı değerleri için tamsayı dizisi
base_dilations	ArraySlice<int64>	taban genişleme değerleri için tam sayı dizisi
window_dilations	ArraySlice<int64>	Pencere genişletme değerleri için tamsayı dizisi
padding	Padding	pencere için dolgu türü (Dolgu::kAynı, adım 1 ise girişle aynı çıkış şekle sahip olacak şekilde dolgular veya dolgu::kValid, dolgu kullanmayan ve artık sığmadığında pencereyi "durduran" Dolgu::kValid)

Burada:

• N'nin 1'e eşit veya daha büyük olması gerekir.
• Tüm giriş dizileri aynı boyutlara sahip olmalıdır.
• N = 1 ise Collate(T) değeri T olur.
• N > 1 ise Collate(T_0, ..., T_{N-1}), (T0,...T{N-1}) türünde 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.

İndirgenme işlevinin değerlendirme sırası rastgeledir 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 adresine de göz atın.

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

ReplicaId()

Her replikanın benzersiz kimliği, [0, N) aralığında imzalanmamış bir tam sayıdır. Burada N, replikaların sayısı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 şekillendir

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

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

Reshape(operand, new_sizes) Reshape(operand, dimensions, new_sizes)

Bağımsız değişkenler	Tür	Anlam
operand	XlaOp	T türü dizi
dimensions	int64 vektörü	boyutların daraltıldığı sıra
new_sizes	int64 vektörü	yeni boyutların boyut vektörü

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. dimension vektöründeki değerler, verilmişse tüm T boyutlarının permütasyonu olmalıdır; belirtilmezse varsayılan olarak {0, ..., rank - 1} değeri kullanılır. dimensions boyutlarının sırası, giriş dizisini tek bir boyuta toplayan döngü iç içe yerleştirilmesinde en yavaş değişen boyuttan (en büyük) en hızlı değişen boyuta (en küçük) doğrudur. new_sizes vektörü, çıkış dizisinin boyutunu belirler. new_sizes dizisinde 0. dizinde bulunan değer 0. boyutun boyutudur, 1. dizinde bulunan değer 1. boyutun boyutudur ve bu böyle devam eder. new_size boyutlarının çarpımı, operatörün boyut boyutlarının çarpımına eşit olmalıdır. Daraltılmış dizi new_sizes tarafından tanımlanan çok boyutlu diziye dönüştürülürken new_sizes'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, 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} } };

In-order collapse:
let v012_24 = Reshape(v, {0,1,2}, {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, {0,1,2}, {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} };

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

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


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

Özel bir durum olarak, yeniden şekillendirme tek öğeli bir diziyi skaler diziye (veya tam tersi) dönüştürebilir. Örneğin,

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

Geri (ters)

Ayrıca XlaBuilder::Rev adresine de göz atın.

Rev(operand, dimensions)

Bağımsız değişkenler	Tür	Anlam
operand	XlaOp	T türü dizi
dimensions	ArraySlice<int64>	tersine çevirecek boyutlar

Belirtilen dimensions boyunca operand dizisindeki öğelerin sırasını tersine çevirerek aynı şekle sahip bir çıkış dizisi oluşturur. Çok boyutlu bir dizindeki operatör dizisinin her öğesi, dönüştürülmüş bir dizinde çıkış dizisine depolanır. Boyutlar arası 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 bkz. XlaBuilder::RngNormal.

\(N(\mu, \sigma)\) Normal dağılımı takip eden rastgele sayılarla belirli bir şeklin çıktısını oluşturur. Parametreler \(\mu\) ve \(\sigma\)ve çıkış şeklinin kayan nokta öğesi türünde olması gerekir. Ayrıca parametrelerin skaler değerli olması gerekir.

RngNormal(mu, sigma, shape)

Bağımsız değişkenler	Tür	Anlam bilimi
mu	XlaOp	Oluşturulan sayıların ortalamasını belirten T türü skaler
sigma	XlaOp	Oluşturulan değerin standart sapmasını belirten T türü skaler
shape	Shape	T türü çıkış şekli

RngUniform

Ayrıca bkz. XlaBuilder::RngUniform.

\([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ü, integral veya kayan nokta türünde olmalı ve türlerin tutarlı olması gerekir. CPU ve GPU arka uçları şu anda yalnızca F64, F32, F16, BF16, S64, U64, S32 ve U32'yi desteklemektedir. Ayrıca, parametrelerin skaler değerinde olması gerekir. Eğer \(b <= a\) sonuç, uygulama tanımlanmışsa.

RngUniform(a, b, shape)

Bağımsız değişkenler	Tür	Anlam bilimi
a	XlaOp	Alt aralık sınırını belirten T türündeki skaler
b	XlaOp	Aralığın üst sınırını belirten T türü skaler
shape	Shape	T türü çıkış şekli

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.

İlk durum, mevcut rastgele sayı oluşturma işleminin ilk 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)

Bağımsız değişkenler	Tür	Anlam bilimi
algorithm	RandomAlgorithm	Kullanılacak PRNG algoritması.
initial_state	XlaOp	PRNG algoritmasının başlangıç durumu.
shape	Shape	Oluşturulan verilerin çıkış şekli.

algorithm için kullanılabilen değerler:

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

• rng_three_fry: ThreeFry sayaç 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ılar 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 bkz. XlaBuilder::Scatter.

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

Bağımsız değişkenler	Tür	Anlam bilimi
operands	N XlaOp dizisi	Dağılacak T_0, ..., T_N türünde N dizi.
scatter_indices	XlaOp	Dağılımı olması gereken dilimlerin başlangıç dizinlerini içeren dizi.
updates	N XlaOp dizisi	T_0, ..., T_N türünde N dizi. updates[i], operands[i] dağıtımını gerçekleştirmek için kullanılması gereken değerleri içeriyor.
update_computation	XlaComputation	Giriş dizisindeki mevcut değerleri ve dağılım sırasındaki güncellemeleri birleştirmek için kullanılacak hesaplama. Bu hesaplama T_0, ..., T_N, T_0, ..., T_N -> Collate(T_0, ..., T_N) türü olmalıdır.
index_vector_dim	int64	scatter_indices dosyasında başlangıç dizinlerini içeren boyut.
update_window_dims	ArraySlice<int64>	updates şeklindeki ve pencere boyutları olan boyut grubu.
inserted_window_dims	ArraySlice<int64>	updates şekline yerleştirilmesi gereken pencere boyutları grubu.
scatter_dims_to_operand_dims	ArraySlice<int64>	Dağılım dizinlerinden operant dizini alanına bir boyutlar haritası. Bu dizi, i ile scatter_dims_to_operand_dims[i] eşlenecek şekilde yorumlanır. Bire bir ve toplam olmalıdır.
indices_are_sorted	bool	Dizinlerin arayan tarafından sıralandığından emin olun.
unique_indices	bool	Dizinlerin arayan tarafından benzersiz olacağının garanti edilip edilmediği.

Burada:

• N'nin 1'e eşit 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] 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 değerine eşitse dolaylı olarak scatter_indices değerinin sonunda 1 boyutu olduğunu kabul ederiz.

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ın bağımsız değişkenleri şu kısıtlamalara uymalıdır:

• Her updates dizisi update_window_dims.size + scatter_indices.rank - 1 rütbesinde olmalıdır.

• Her bir updates dizisindeki i boyut 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ış operand 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 sırada olmalı, yinelenen boyut sayıları içermemelidir ve [0, operand.rank) aralığında olmalıdır.

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

• scatter_dims_to_operand_dims.size, scatter_indices.shape.dims[index_vector_dim] değerine eşit 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 ilgili dizin I aşağıdaki şekilde hesaplanır:

1. update_scatter_dims } içinde k için G = { U[k] değerini kullanın. scatter_indices dizisinde S dizin vektörünü aramak için G kullanın. Bu şekilde S[i] = scatter_indices[Birleştir(G, i)]; burada Birleştir(A, b), index_vector_dim konumlarında b'yi A konumuna ekler.
2. scatter_dims_to_operand_dims haritasını kullanarak S'ü dağıtarak Sin dizin oluşturmak için operand'i kullanın. Daha resmi dilde:
   1. k < scatter_dims_to_operand_dims.size ise Sin[scatter_dims_to_operand_dims[k]] = S[k].
   2. Sin[_] = 0 diğer durumlarda.
3. Dizinleri inserted_window_dims'a göre U'deki update_window_dims'e dağıtarak her operands dizisinde bir Win dizini oluşturun. Daha resmi dilde:
   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.

Özetle, serpme işlemi aşağıdaki gibi tanımlanabilir.

• output'ü 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 ve operand[J] dizisindeki karşılık gelen dizin O 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. Dolayısıyla, updates içindeki birden fazla dizin operands bölgesinde aynı dizine başvuruda bulunduğunda output içindeki karşılık gelen değer deterministik olmaz.

update_computation işlevine iletilen ilk parametrenin her zaman output dizisindeki geçerli değer, ikinci parametrenin ise her zaman updates dizisindeki değer olacağını unutmayın. Bu, özellikle update_computation öğesinin değişmediği durumlar için önemlidir.

indices_are_sorted true (doğru) olarak 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 halde anlamlar uygulamaya tanımlanır.

unique_indices doğru değerine ayarlanırsa XLA, dağılımdaki tüm öğelerin benzersiz olduğunu varsayabilir. Bu nedenle 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.

Gayri resmî olarak, dağılım işlemi toplama işleminin tersi olarak görülebilir. Yani dağılım işlemi, karşılık gelen toplama işlemi tarafından çıkarılan girişteki öğ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 adresine de göz atın.

Bir yüklem dizisinin değerlerini temel alarak iki giriş dizisinin öğelerinden bir çıkış dizisi oluşturur.

Select(pred, on_true, on_false)

Bağımsız değişkenler	Tür	Anlam
pred	XlaOp	PRED türündeki dizi
on_true	XlaOp	T türü dizi
on_false	XlaOp	T türü dizi

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.

Her pred öğesi için (P) P değeri true ise çıkış dizisinin karşılık gelen öğesi on_true değerinden, P değeri false ise on_false değerinden 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 tamamen on_false'ten alınır.

Skaler olmayan pred örneği:

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

Tuple'lar arasında seçimler 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 bkz. XlaBuilder::SelectAndScatter.

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, bir öğeyi her bir pencereye uygulayarak her bir pencereden öğe seçmek için kullanılır ve ilk parametrenin dizin vektörünün sözlük açısından ikinci parametrenin dizin vektöründen küçük olması ö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. source parametresinde seçili dizin için geçerli olan 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)

Bağımsız değişkenler	Tür	Anlam bilimi
operand	XlaOp	Pencerelerin kaydığı T türü dizi
select	XlaComputation	her bir penceredeki tüm öğelere uygulanacak T, T -> PRED türündeki ikili hesaplama; ilk parametre seçilirse true değerini ve ikinci parametre seçilirse false değerini döndürür
window_dimensions	ArraySlice<int64>	pencere boyut değerleri için tam sayı dizisi
window_strides	ArraySlice<int64>	Pencere adımı değerleri için tamsayı dizisi
padding	Padding	Pencere için dolgu türü (Padding::kSame veya Padding::kValid)
source	XlaOp	Dağılacak değerleri içeren T türü dizi
init_value	XlaOp	Çıkış dizisinin ilk değeri için T türü skaler değer
scatter	XlaComputation	her dağılım kaynak öğesini hedef öğesiyle uygulamak için T, T -> T türünde ikili hesaplama

Aşağıdaki şekilde, select işlevinin parametreleri arasında en yüksek değeri hesapladığı SelectAndScatter işlevinin kullanım örnekleri gösterilmektedir. Aşağıdaki şekilde (2) gösterildiği gibi pencereler ç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, her iki üst pencere tarafından (mavi ve kırmızı) seçilir ve ikili toplama scatter işlevi, 8 (2 + 6) değerindeki çıkış öğesini üretir.

scatter işlevinin değerlendirme sırası rastgeledir ve deterministik olmayabilir. Bu nedenle, scatter işlevi yeniden ilişkilendirmeye aşırı duyarlı olmamalıdır. Daha fazla bilgi için ilişkilendirme hakkındaki tartışmaya Reduce bağlamında göz atın.

Gönder

Ayrıca XlaBuilder::Send adresine de göz atın.

Send(operand, channel_handle)

Bağımsız değişkenler	Tür	Anlam bilimi
operand	XlaOp	Gönderilecek veriler (T türü dizi)
channel_handle	ChannelHandle	her gönderme/alma çiftinin benzersiz tanımlayıcısı

Belirtilen işlenen verileri, aynı kanal herkese açık kullanıcı adını 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 bkz. HloInstruction::CreateSend ve HloInstruction::CreateSendDone.

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 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ç derleyicileri kanal talimatları aracılığıyla iletişim kuran her hesaplama için doğrusal bir program oluşturduğunda, hesaplamalar arasında döngüler olmamalıdır. Örneğin, aşağıdaki planlar kilitlenmeye neden olur.

Dilim

Ayrıca XlaBuilder::Slice adresine de göz atın.

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

Slice(operand, start_indices, limit_indices, strides)

Bağımsız değişkenler	Tür	Anlam
operand	XlaOp	T türündeki N boyutlu dizi
start_indices	ArraySlice<int64>	Her boyut için dilimin başlangıç dizinlerini içeren N tam sayı listesi. Değerler sıfırdan büyük veya sıfıra eşit olmalıdır.
limit_indices	ArraySlice<int64>	Her boyuta ait dilimin bitiş dizinlerini (hariç) içeren N tam sayı listesi. Her değer, boyutun ilgili start_indices değerinden büyük veya bu değere eşit, boyutun boyutundan küçük veya bu boyuta eşit olmalıdır.
strides	ArraySlice<int64>	Dilimin giriş adımına karar veren N tam sayının listesi. Dilim, d boyutundaki her strides[d] öğesini seçer.

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 adresine de göz atın.

Sort(operands, comparator, dimension, is_stable)

Bağımsız değişkenler	Tür	Anlam bilimi
operands	ArraySlice<XlaOp>	Sıralanacak işlenenler.
comparator	XlaComputation	Kullanılacak karşılaştırıcı hesaplaması.
dimension	int64	Sıralama ölçütü.
is_stable	bool	Sabit sıralamanın kullanılıp kullanılmayacağı.

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

• İşlenen 1. sıralı 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 şeklinde bir karşılaştırma yapmalıdır. Resmi olarak, dizi sıralandıysa i < j değerinin 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.

• İşlem gören daha yüksek bir sıralamaya sahipse işlenen, sağlanan boyuta göre sıralanır. Örneğin, 2. dereceden 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. sıra durumundaki sıralama sırası geçerlidir.

n > 1 operatörleri sağlanırsa:

• Tüm n işlenenleri, aynı boyutlara sahip tensörler 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ç, işlem görenlerden (yukarıda belirtildiği gibi sağlanan boyutla birlikte) sıralı düzende oluşan bir unsur olur. Tuple'ın i-th işleneni, Sort'un i-th işlenenine karşılık gelir.

Örneğin, operand0 = [3, 1], operand1 = [42, 50], operand2 = [-3.0, 1.1] olmak üzere üç işlenen varsa ve karşılaştırma aracı yalnızca operand0 değerlerini küçüktür değerleriyle karşılaştırıyorsa sıralamanın sonucu ([1, 3], [50, 42], [1.1, -3.0]) demeti olur.

is_stable doğru olarak ayarlanırsa sıralamanın kararlı olduğu 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 yanlış olarak ayarlanır.

Ters çevir

tf.reshape işlemini de inceleyin.

Transpose(operand)

Bağımsız değişkenler	Tür	Anlam bilimi
operand	XlaOp	Ters ibraz yapılacak işlem gören.
permutation	ArraySlice<int64>	Boyutların permütasyonu.

Verilen permütasyon ile işlem gören boyutlarının permütasyonunu yapar; dolayısıyla ∀ i . 0 ≤ i < rank ⇒ input_dimensions[permutation[i]] = output_dimensions[i].

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

TriangularSolve

Ayrıca XlaBuilder::TriangularSolve adresine de göz atın.

Aşağı veya yukarı üçgen katsayı matrislerine sahip doğrusal denklem sistemlerini ileri veya geri değiştirme yöntemiyle çözer. Ön 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)

Bağımsız değişkenler	Tür	Anlam bilimi
a	XlaOp	[..., M, M] şeklinde karmaşık veya kayan nokta türündeki 2'den büyük bir dizi.
b	XlaOp	left_side doğruysa [..., M, K], aksi takdirde [..., K, M] şeklindeki aynı türden bir sıra > 2 dizisi.
left_side	bool	op(a) * x = b (true) veya x * op(a) = b (false) biçimindeki bir sistemin çözüleceğini gösterir.
lower	bool	a üst veya alt üçgeninin kullanılıp kullanılmayacağını belirtir.
unit_diagonal	bool	true ise a'un köşegen öğelerinin 1 olduğu ve bunlara erişilmediği varsayılır.
transpose_a	Transpose	a olduğu gibi kullanılıp kullanılmayacağını, ters çevrilecek şekilde mi yoksa eşlenik ters çevrilecek şekilde mi kullanılacağını belirleyin.

Giriş verileri, lower değerine bağlı olarak a öğesinin alt/üst üçgeninden okunur. Diğer üçgendeki değerler yoksayılır. Çıkış verileri aynı üçgen içinde döndürülür. Diğer üçgendeki değerler uygulama tanımlıdır ve herhangi bir şey olabilir.

a ve b sıralaması 2'den büyükse bunlar, matris grupları olarak ele alınır. Küçük 2 boyut hariç bunların hepsi toplu boyutlardır. a ve b aynı toplu boyutlara sahip olmalıdır.

Delikli

Ayrıca XlaBuilder::Tuple adresine de göz atın.

Her biri kendi şekline sahip, değişken sayıda veri işleyicisi içeren bir demet.

Bu, C++'daki std::tuple 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);

İkili gruplar, GetTupleElement işlemi aracılığıyla deconstructed (erişilebilir) olabilir.

While

Ayrıca XlaBuilder::While adresine de göz atın.

While(condition, body, init)

Bağımsız değişkenler	Tür	Anlam bilimi
condition	XlaComputation	theloop'un sonlandırma koşulunu tanımlayan T -> PRED türünde XlaComputation.
body	XlaComputation	Döngünün gövdesini tanımlayan T -> T türündeki XlaComputation.
init	T	condition ve body parametresinin başlangıç değeri.

condition başarısız olana kadar body işlemini sırayla yürütür. Bu, aşağıda listelenen farklılıklar ve kısıtlamalar dışında diğer birçok dilde bulunan tipik bir while döngüsüne benzer.

• While düğümü, body işlevinin son çalıştırmasının sonucu olan T türündeki bir değer döndürür.
• T türünün şekli statik olarak belirlenir ve tüm iterasyonlarda aynı olmalıdır.

Hesaplamaların T parametreleri ilk iterasyonda init değeriyle başlatılır ve sonraki her iterasyonda body'ten gelen yeni sonuçla otomatik olarak güncellenir.

While düğümünün ana kullanım alanlarından biri, sinir ağlarında eğitimin tekrarlı olarak yürütülmesini sağlamaktır. Aşağıda, hesaplamayı temsil eden bir grafikle birlikte basitleştirilmiş sözde kod gösterilmektedir. Kodu while_test.cc adresinde bulabilirsiniz. Bu örnekteki T türü, iterasyon sayısı için bir int32 ve toplayıcı için bir vector[10] içeren bir Tuple türüdür. Döngü, 1.000 iterasyon boyunca toplayıcıya sabit bir vektör eklemeye devam eder.

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