Semantica dell'operazione

Di seguito vengono descritte le semantiche delle operazioni definite nell'interfaccia XlaBuilder. In genere, queste operazioni vengono mappate uno a uno alle operazioni definite nell'interfaccia RPC in xla_data.proto.

Una nota sulla nomenclatura: il tipo di dati generalizzato XLA gestisce un array N-dimensionale contenente elementi di un tipo uniforme (ad esempio float a 32 bit). In tutta la documentazione, array viene utilizzato per indicare un array di dimensioni arbitrarie. Per comodità, i casi speciali hanno nomi più specifici e familiari; ad esempio, un vettore è un array unidimensionale e una matrice è un array bidimensionale.

Scopri di più sulla struttura di un'app in Forme e layout e Layout a mosaico.

Addominali

Vedi anche XlaBuilder::Abs.

Element-wise abs x -> |x|.

Abs(operand)

Per informazioni su StableHLO, vedi StableHLO - abs.

Aggiungi

Vedi anche XlaBuilder::Add.

Esegue l'addizione elemento per elemento di lhs e rhs.

Add(lhs, rhs)

Le forme degli argomenti devono essere simili o compatibili. Consulta la documentazione sulla trasmissione per scoprire cosa significa che le forme sono compatibili. Il risultato di un'operazione ha una forma che è il risultato della trasmissione dei due array di input. In questa variante, le operazioni tra array di ranghi diversi non sono supportate, a meno che uno degli operandi non sia uno scalare.

Esiste una variante alternativa con supporto per la trasmissione in dimensioni diverse per Aggiungi:

Add(lhs,rhs, broadcast_dimensions)

Questa variante dell'operazione deve essere utilizzata per le operazioni aritmetiche tra array di ranghi diversi (ad esempio l'aggiunta di una matrice a un vettore).

L'operando broadcast_dimensions aggiuntivo è una sezione di numeri interi che specifica le dimensioni da utilizzare per la trasmissione degli operandi. La semantica è descritta in dettaglio nella pagina di trasmissione.

Per informazioni su StableHLO, vedi StableHLO - add.

AddDependency

Vedi anche HloInstruction::AddDependency.

AddDependency può essere visualizzato nei dump HLO, ma non è destinato a essere creato manualmente dagli utenti finali.

AfterAll

Vedi anche XlaBuilder::AfterAll.

AfterAll accetta un numero variabile di token e produce un singolo token. I token sono tipi primitivi che possono essere inseriti tra operazioni con effetti collaterali per imporre l'ordinamento. AfterAll può essere utilizzato come unione di token per ordinare un'operazione dopo una serie di operazioni.

AfterAll(tokens)

Per informazioni su StableHLO, vedi StableHLO - after_all.

AllGather

Vedi anche XlaBuilder::AllGather.

Esegue la concatenazione tra le repliche.

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

• replica_groups è un elenco di gruppi di repliche tra cui viene eseguita la concatenazione (l'ID replica per la replica corrente può essere recuperato utilizzando ReplicaId). L'ordine delle repliche in ogni gruppo determina l'ordine in cui si trovano i relativi input nel risultato. replica_groups deve essere vuoto (nel qual caso tutte le repliche appartengono a un unico gruppo, ordinato da 0 a N - 1) o contenere lo stesso numero di elementi del numero di repliche. Ad esempio, replica_groups = {0, 2}, {1, 3} esegue la concatenazione tra le repliche 0 e 2 e 1 e 3.
• shard_count è la dimensione di ogni gruppo di repliche. Ciò è necessario nei casi in cui replica_groups sono vuoti.
• channel_id viene utilizzato per la comunicazione tra moduli: solo le operazioni all-gather con lo stesso channel_id possono comunicare tra loro.
• use_global_device_ids Restituisce true se gli ID nella configurazione ReplicaGroup rappresentano un ID globale di (replica_id * partition_count + partition_id) anziché un ID replica. Ciò consente un raggruppamento più flessibile dei dispositivi se questa riduzione collettiva è sia cross-partition che cross-replica.

La forma di output è la forma di input con il all_gather_dimension reso shard_count volte più grande. Ad esempio, se ci sono due repliche e l'operando ha il valore [1.0, 2.5] e [3.0, 5.25] rispettivamente sulle due repliche, il valore di output di questa operazione in cui all_gather_dim è 0 sarà [1.0, 2.5, 3.0,5.25] su entrambe le repliche.

L'API di AllGather viene scomposta internamente in due istruzioni HLO (AllGatherStart e AllGatherDone).

Vedi anche HloInstruction::CreateAllGatherStart.

AllGatherStart, AllGatherDone fungono da primitive in HLO. Queste operazioni potrebbero essere visualizzate nei dump HLO, ma non sono destinate a essere create manualmente dagli utenti finali.

Per informazioni su StableHLO, vedi StableHLO - all_gather.

AllReduce

Vedi anche XlaBuilder::AllReduce.

Esegue un calcolo personalizzato tra le repliche.

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

• Quando operand è una tupla di array, la riduzione viene eseguita su ciascun elemento della tupla.
• replica_groups è un elenco di gruppi di repliche tra cui viene eseguita la riduzione (l'ID replica per la replica corrente può essere recuperato utilizzando ReplicaId). replica_groups deve essere vuoto (nel qual caso tutte le repliche appartengono a un unico gruppo) o contenere lo stesso numero di elementi del numero di repliche. Ad esempio, replica_groups = {0, 2}, {1, 3} esegue la riduzione tra le repliche 0 e 2 e 1 e 3.
• channel_id viene utilizzato per la comunicazione tra moduli: solo le operazioni all-reduce con lo stesso channel_id possono comunicare tra loro.
• shape_with_layout: forza il layout di AllReduce al layout specificato. Questo attributo viene utilizzato per garantire lo stesso layout per un gruppo di operazioni AllReduce compilate separatamente.
• use_global_device_ids Restituisce true se gli ID nella configurazione ReplicaGroup rappresentano un ID globale di (replica_id * partition_count + partition_id) anziché un ID replica. Ciò consente un raggruppamento più flessibile dei dispositivi se questa riduzione collettiva è sia cross-partition che cross-replica.

La forma dell'output è uguale a quella dell'input. Ad esempio, se ci sono due repliche e l'operando ha il valore [1.0, 2.5] e [3.0, 5.25] rispettivamente sulle due repliche, il valore di output di questa operazione e il calcolo della somma sarà [4.0, 7.75] su entrambe le repliche. Se l'input è una tupla, anche l'output è una tupla.

Il calcolo del risultato di AllReduce richiede un input da ogni replica, quindi se una replica esegue un nodo AllReduce più volte di un'altra, la prima replica attenderà per sempre. Poiché le repliche eseguono tutte lo stesso programma, non ci sono molti modi in cui ciò può accadere, ma è possibile quando la condizione di un ciclo while dipende dai dati di infeed e i dati di infeed fanno sì che il ciclo while venga iterato più volte su una replica rispetto a un'altra.

L'API di AllReduce viene scomposta internamente in due istruzioni HLO (AllReduceStart e AllReduceDone).

Vedi anche HloInstruction::CreateAllReduceStart.

AllReduceStart e AllReduceDone fungono da primitive in HLO. Queste operazioni potrebbero essere visualizzate nei dump HLO, ma non sono destinate a essere create manualmente dagli utenti finali.

CrossReplicaSum

Vedi anche XlaBuilder::CrossReplicaSum.

Esegue AllReduce con un calcolo di somma.

CrossReplicaSum(operand, replica_groups)

Restituisce la somma del valore dell'operando all'interno di ogni sottogruppo di repliche. Tutte le repliche forniscono un input alla somma e tutte le repliche ricevono la somma risultante per ogni sottogruppo.

AllToAll

Vedi anche XlaBuilder::AllToAll.

AllToAll è un'operazione collettiva che invia dati da tutti i core a tutti i core. È composta da due fasi:

1. La fase di dispersione. Su ogni core, l'operando viene suddiviso in split_count blocchi lungo split_dimensions e i blocchi vengono distribuiti a tutti i core, ad esempio l'i-esimo blocco viene inviato all'i-esimo core.
2. La fase di raccolta. Ogni core concatena i blocchi ricevuti lungo concat_dimension.

I core partecipanti possono essere configurati in base a:

• replica_groups: ogni ReplicaGroup contiene un elenco di ID replica che partecipano al calcolo (l'ID replica per la replica corrente può essere recuperato utilizzando ReplicaId). AllToAll verrà applicato all'interno dei sottogruppi nell'ordine specificato. Ad esempio, replica_groups = { {1,2,3}, {4,5,0} } significa che verrà applicato un AllToAll all'interno delle repliche {1, 2, 3} e nella fase di raccolta, e i blocchi ricevuti verranno concatenati nello stesso ordine di 1, 2, 3. Quindi, verrà applicato un altro AllToAll all'interno delle repliche 4, 5, 0 e l'ordine di concatenazione è anche 4, 5, 0. Se replica_groups è vuoto, tutte le repliche appartengono a un unico gruppo, nell'ordine di concatenazione della loro visualizzazione.

Prerequisiti:

• La dimensione della dimensione dell'operando su split_dimension è divisibile per split_count.
• La forma dell'operando non è una tupla.

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

Per saperne di più su forme e layout, consulta xla::shapes.

Per informazioni su StableHLO, vedi StableHLO - all_to_all.

AllToAll - Esempio 1.

XlaBuilder b("alltoall");
auto x = Parameter(&b, 0, ShapeUtil::MakeShape(F32, {4, 16}), "x");
AllToAll(
    x,
    /*split_dimension=*/ 1,
    /*concat_dimension=*/ 0,
    /*split_count=*/ 4);

Nell'esempio precedente, ci sono 4 core che partecipano all'operazione Alltoall. Su ogni core, l'operando viene suddiviso in 4 parti lungo la dimensione 1, quindi ogni parte ha forma f32[4,4]. Le 4 parti sono distribuite a tutti i core. Poi ogni core concatena le parti ricevute lungo la dimensione 0, nell'ordine dei core 0-4. Pertanto, l'output su ogni core ha forma f32[16,4].

AllToAll - Esempio 2 - StableHLO

Nell'esempio precedente, ci sono due repliche che partecipano all'operazione AllToAll. Su ogni replica, l'operando ha forma f32[2,4]. L'operando viene suddiviso in due parti lungo la dimensione 1, quindi ogni parte ha forma f32[2,2]. Le due parti vengono poi scambiate tra le repliche in base alla loro posizione nel gruppo di repliche. Ogni replica raccoglie la parte corrispondente da entrambi gli operandi e li concatena lungo la dimensione 0. Di conseguenza, l'output di ogni replica ha forma f32[4,2].

RaggedAllToAll

Vedi anche XlaBuilder::RaggedAllToAll.

RaggedAllToAll esegue un'operazione collettiva all-to-all, in cui l'input e l'output sono tensori irregolari.

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

I tensori irregolari sono definiti da un insieme di tre tensori:

• data: il tensore dataè "irregolare" lungo la sua dimensione più esterna, lungo la quale ogni elemento indicizzato ha dimensioni variabili.
• offsets: il tensore offsets indicizza la dimensione più esterna del tensore data e rappresenta l'offset iniziale di ogni elemento irregolare del tensore data.
• sizes: il tensore sizes rappresenta la dimensione di ogni elemento irregolare del tensore data, dove la dimensione è specificata in unità di elementi secondari. Un sottoelemento è definito come il suffisso della forma del tensore "data" ottenuto rimuovendo la dimensione "irregolare" più esterna.
• I tensori offsets e sizes devono avere le stesse dimensioni.

Esempio di tensore irregolare:

data: [8,3] =
{ {a,b,c},{d,e,f},{g,h,i},{j,k,l},{m,n,o},{p,q,r},{s,t,u},{v,w,x} }

offsets: [3] = {0, 1, 4}

sizes: [3] = {1, 3, 4}

// Index 'data' at 'offsets'[0], 'sizes'[0]' // {a,b,c}

// Index 'data' at 'offsets'[1], 'sizes'[1]' // {d,e,f},{g,h,i},{j,k,l}

// Index 'data' at 'offsets'[2], 'sizes'[2]' // {m,n,o},{p,q,r},{s,t,u},{v,w,x}

output_offsets deve essere partizionato in modo che ogni replica abbia offset nella prospettiva di output della replica di destinazione.

Per l'offset di output i-esimo, la replica corrente invierà l'aggiornamento input[input_offsets[i]:input_offsets[i]+input_sizes[i]] alla replica i-esima che verrà scritto in output_i[output_offsets[i]:output_offsets[i]+send_sizes[i]] nella replica output-esima.i

Ad esempio, se abbiamo due repliche:

replica 0:
input: [1, 2, 2]
output:[0, 0, 0, 0]
input_offsets: [0, 1]
send_sizes: [1, 2]
output_offsets: [0, 0]
recv_sizes: [1, 1]

replica 1:
input: [3, 4, 0]
output: [0, 0, 0, 0]
input_offsets: [0, 1]
send_sizes: [1, 1]
output_offsets: [1, 2]
recv_sizes: [2, 1]

// replica 0's result will be: [1, 3, 0, 0]
// replica 1's result will be: [2, 2, 4, 0]

L'HLO ragged all-to-all ha i seguenti argomenti:

• input: tensore dei dati di input irregolare.
• output: tensore di dati di output irregolare.
• input_offsets: tensore degli offset di input irregolari.
• send_sizes: tensore delle dimensioni di invio irregolari.
• output_offsets: array di offset irregolari nell'output della replica di destinazione.
• recv_sizes: tensore delle dimensioni di ricezione irregolari.

I tensori *_offsets e *_sizes devono avere tutti la stessa forma.

Per i tensori *_offsets e *_sizes sono supportate due forme:

• [num_devices] dove ragged-all-to-all può inviare al massimo un aggiornamento a ogni dispositivo remoto nel gruppo di repliche. Ad esempio:

for (remote_device_id : replica_group) {
     SEND input[input_offsets[remote_device_id]],
     output[output_offsets[remote_device_id]],
     send_sizes[remote_device_id] }

• [num_devices, num_updates] dove ragged-all-to-all può inviare fino a num_updates aggiornamenti allo stesso dispositivo remoto (ciascuno con offset diversi), per ogni dispositivo remoto nel gruppo di repliche.

Ad esempio:

for (remote_device_id : replica_group) {
    for (update_idx : num_updates) {
        SEND input[input_offsets[remote_device_id][update_idx]],
        output[output_offsets[remote_device_id][update_idx]]],
        send_sizes[remote_device_id][update_idx] } }

E

Vedi anche XlaBuilder::And.

Esegue l'operazione AND elemento per elemento di due tensori lhs e rhs.

And(lhs, rhs)

Le forme degli argomenti devono essere simili o compatibili. Consulta la documentazione sulla trasmissione per scoprire cosa significa che le forme sono compatibili. Il risultato di un'operazione ha una forma che è il risultato della trasmissione dei due array di input. In questa variante, le operazioni tra array di ranghi diversi non sono supportate, a meno che uno degli operandi non sia uno scalare.

Esiste una variante alternativa con supporto della trasmissione di dimensioni diverse per And:

And(lhs,rhs, broadcast_dimensions)

Questa variante dell'operazione deve essere utilizzata per le operazioni aritmetiche tra array di ranghi diversi (ad esempio l'aggiunta di una matrice a un vettore).

L'operando broadcast_dimensions aggiuntivo è una sezione di numeri interi che specifica le dimensioni da utilizzare per la trasmissione degli operandi. La semantica è descritta in dettaglio nella pagina di trasmissione.

Per informazioni su StableHLO, vedi StableHLO - and.

Asinc

Vedi anche HloInstruction::CreateAsyncStart, HloInstruction::CreateAsyncUpdate, HloInstruction::CreateAsyncDone.

AsyncDone, AsyncStart e AsyncUpdate sono istruzioni HLO interne utilizzate per le operazioni asincrone e fungono da primitive in HLO. Queste operazioni potrebbero essere visualizzate nei dump HLO, ma non sono destinate a essere create manualmente dagli utenti finali.

Atan2

Vedi anche XlaBuilder::Atan2.

Esegue l'operazione atan2 elemento per elemento su lhs e rhs.

Atan2(lhs, rhs)

Le forme degli argomenti devono essere simili o compatibili. Consulta la documentazione sulla trasmissione per scoprire cosa significa che le forme sono compatibili. Il risultato di un'operazione ha una forma che è il risultato della trasmissione dei due array di input. In questa variante, le operazioni tra array di ranghi diversi non sono supportate, a meno che uno degli operandi non sia uno scalare.

Esiste una variante alternativa con supporto della trasmissione multidimensionale per Atan2:

Atan2(lhs,rhs, broadcast_dimensions)

Questa variante dell'operazione deve essere utilizzata per le operazioni aritmetiche tra array di ranghi diversi (ad esempio l'aggiunta di una matrice a un vettore).

L'operando broadcast_dimensions aggiuntivo è una sezione di numeri interi che specifica le dimensioni da utilizzare per la trasmissione degli operandi. La semantica è descritta in dettaglio nella pagina di trasmissione.

Per informazioni su StableHLO, vedi StableHLO - atan2.

BatchNormGrad

Per una descrizione dettagliata dell'algoritmo, consulta anche XlaBuilder::BatchNormGrad e l'articolo originale sulla normalizzazione batch.

Calcola i gradienti della normalizzazione batch.

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

Per ogni caratteristica nella dimensione delle caratteristiche (feature_index è l'indice della dimensione delle caratteristiche in operand), l'operazione calcola i gradienti rispetto a operand, offset e scale in tutte le altre dimensioni. feature_index deve essere un indice valido per la dimensione della funzionalità in operand.

I tre gradienti sono definiti dalle seguenti formule (supponendo un array quadridimensionale come operand e con indice di dimensione della funzionalità l, dimensione batch m e dimensioni spaziali w e h):

\[ \begin{split} c_l&= \frac{1}{mwh}\sum_{i=1}^m\sum_{j=1}^w\sum_{k=1}^h \left( \nabla y_{ijkl} \frac{x_{ijkl} - \mu_l}{\sigma^2_l+\epsilon} \right) \\\\ d_l&= \frac{1}{mwh}\sum_{i=1}^m\sum_{j=1}^w\sum_{k=1}^h \nabla y_{ijkl} \\\\ \nabla x_{ijkl} &= \frac{\gamma_{l} }{\sqrt{\sigma^2_{l}+\epsilon} } \left( \nabla y_{ijkl} - d_l - c_l (x_{ijkl} - \mu_{l}) \right) \\\\ \nabla \gamma_l &= \sum_{i=1}^m\sum_{j=1}^w\sum_{k=1}^h \left( \nabla y_{ijkl} \frac{x_{ijkl} - \mu_l}{\sqrt{\sigma^2_{l}+\epsilon} } \right) \\\\\ \nabla \beta_l &= \sum_{i=1}^m\sum_{j=1}^w\sum_{k=1}^h \nabla y_{ijkl} \end{split} \]

Gli input batch_mean e batch_var rappresentano i valori dei momenti nelle dimensioni batch e spaziali.

Il tipo di output è una tupla di tre handle:

Per informazioni su StableHLO, vedi StableHLO - batch_norm_grad.

BatchNormInference

Per una descrizione dettagliata dell'algoritmo, consulta anche XlaBuilder::BatchNormInference e l'articolo originale sulla normalizzazione batch.

Normalizza un array in base alle dimensioni batch e spaziali.

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

Per ogni caratteristica nella dimensione delle caratteristiche (feature_index è l'indice della dimensione delle caratteristiche in operand), l'operazione calcola la media e la varianza in tutte le altre dimensioni e utilizza la media e la varianza per normalizzare ogni elemento in operand. feature_index deve essere un indice valido per la dimensione della funzionalità in operand.

BatchNormInference è equivalente alla chiamata di BatchNormTraining senza calcolare mean e variance per ogni batch. Utilizza invece mean e variance come valori stimati. Lo scopo di questa operazione è ridurre la latenza nell'inferenza, da cui il nome BatchNormInference.

L'output è un array normalizzato n-dimensionale con la stessa forma dell'input operand.

Per informazioni su StableHLO, vedi StableHLO - batch_norm_inference.

BatchNormTraining

Vedi anche XlaBuilder::BatchNormTraining e the original batch normalization paper per una descrizione dettagliata dell'algoritmo.

Normalizza un array in base alle dimensioni batch e spaziali.

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

Per ogni caratteristica nella dimensione delle caratteristiche (feature_index è l'indice della dimensione delle caratteristiche in operand), l'operazione calcola la media e la varianza in tutte le altre dimensioni e utilizza la media e la varianza per normalizzare ogni elemento in operand. feature_index deve essere un indice valido per la dimensione della funzionalità in operand.

L'algoritmo funziona nel seguente modo per ogni batch in operand \(x\) che contiene m elementi con w e h come dimensioni spaziali (supponendo che operand sia un array quadridimensionale):

• Calcola la media del batch \(\mu_l\) per ogni caratteristica l nella dimensione della caratteristica: \(\mu_l=\frac{1}{mwh}\sum_{i=1}^m\sum_{j=1}^w\sum_{k=1}^h x_{ijkl}\)

• Calcola la varianza del batch \(\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$

• Normalizza, scala e sposta: \(y_{ijkl}=\frac{\gamma_l(x_{ijkl}-\mu_l)}{\sqrt[2]{\sigma^2_l+\epsilon} }+\beta_l\)

Il valore epsilon, in genere un numero piccolo, viene aggiunto per evitare errori di divisione per zero.

Il tipo di output è una tupla di tre XlaOp:

batch_mean e batch_var sono momenti calcolati in base alle dimensioni batch e spaziali utilizzando le formule riportate sopra.

Per informazioni su StableHLO, vedi StableHLO - batch_norm_training.

Bitcast

Vedi anche HloInstruction::CreateBitcast.

Bitcast può essere visualizzato nei dump HLO, ma non è destinato a essere costruito manualmente dagli utenti finali.

BitcastConvertType

Vedi anche XlaBuilder::BitcastConvertType.

Simile a un tf.bitcast in TensorFlow, esegue un'operazione bitcast element-wise da una forma di dati a una forma di destinazione. Le dimensioni dell'input e dell'output devono corrispondere: ad esempio, s32 elementi diventano f32 elementi tramite la routine bitcast e un elemento s32 diventerà quattro elementi s8. Bitcast viene implementato come trasmissione di basso livello, quindi le macchine con rappresentazioni in virgola mobile diverse daranno risultati diversi.

BitcastConvertType(operand, new_element_type)

Le dimensioni dell'operando e della forma di destinazione devono corrispondere, a parte l'ultima dimensione, che cambierà in base al rapporto tra le dimensioni primitive prima e dopo la conversione.

I tipi di elementi di origine e di destinazione non devono essere tuple.

Per informazioni su StableHLO, vedi StableHLO - bitcast_convert.

Bitcast: conversione in tipo primitivo di larghezza diversa

BitcastConvert L'istruzione HLO supporta il caso in cui la dimensione del tipo di elemento di output T' non è uguale alla dimensione dell'elemento di input T. Poiché l'intera operazione è concettualmente un bitcast e non modifica i byte sottostanti, la forma dell'elemento di output deve cambiare. Per B = sizeof(T), B' = sizeof(T'), esistono due possibili casi.

Innanzitutto, quando B > B', la forma di output acquisisce una nuova dimensione secondaria di dimensione B/B'. Ad esempio:

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

La regola rimane invariata per gli scalari effettivi:

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

In alternativa, per B' > B l'istruzione richiede che l'ultima dimensione logica della forma di input sia uguale a B'/B e questa dimensione viene eliminata durante la conversione:

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

Tieni presente che le conversioni tra diverse larghezze di bit non sono elementwise.

Trasmissione

Vedi anche XlaBuilder::Broadcast.

Aggiunge dimensioni a un array duplicando i dati nell'array.

Broadcast(operand, broadcast_sizes)

Le nuove dimensioni vengono inserite a sinistra, ovvero se broadcast_sizes ha valori {a0, ..., aN} e la forma dell'operando ha dimensioni {b0, ..., bM}, allora la forma dell'output ha dimensioni {a0, ..., aN, b0, ..., bM}.

I nuovi indici di dimensione nelle copie dell'operando, ovvero

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

Ad esempio, se operand è uno scalare f32 con valore 2.0f e broadcast_sizes è {2, 3}, il risultato sarà un array con forma f32[2, 3] e tutti i valori nel risultato saranno 2.0f.

Per informazioni su StableHLO, vedi StableHLO - broadcast.

BroadcastInDim

Vedi anche XlaBuilder::BroadcastInDim.

Aumenta le dimensioni e il numero di dimensioni di un array duplicando i dati nell'array.

BroadcastInDim(operand, out_dim_size, broadcast_dimensions)

Simile a Trasmissione, ma consente di aggiungere dimensioni ovunque ed espandere le dimensioni esistenti con dimensione 1.

operand viene trasmesso alla forma descritta da out_dim_size. broadcast_dimensions mappa le dimensioni di operand alle dimensioni della forma di destinazione, ovvero la i-esima dimensione dell'operando viene mappata alla i-esima dimensione di broadcast_dimension della forma di output. Le dimensioni di operand devono avere dimensione 1 o le stesse dimensioni della dimensione nella forma di output a cui sono mappate. Le dimensioni rimanenti vengono riempite con dimensioni di dimensione 1. La trasmissione delle dimensioni degenerate viene quindi eseguita lungo queste dimensioni degenerate per raggiungere la forma di output. La semantica è descritta in dettaglio nella pagina di trasmissione.

Chiama

Vedi anche XlaBuilder::Call.

Richiama un calcolo con gli argomenti specificati.

Call(computation, operands...)

L'arità e i tipi di operands devono corrispondere ai parametri di computation. È consentito non avere operands.

CompositeCall

Vedi anche XlaBuilder::CompositeCall.

Incapsula un'operazione composta da altre operazioni StableHLO, che accetta input e composite_attributes e produce risultati. La semantica dell'operazione viene implementata dall'attributo di decomposizione. L'operazione composita può essere sostituita dalla sua decomposizione senza modificare la semantica del programma. Nei casi in cui l'incorporamento della scomposizione non fornisce la stessa semantica dell'operazione, preferisci utilizzare custom_call.

Il campo della versione (il valore predefinito è 0) viene utilizzato per indicare quando la semantica di un composito cambia.

Questa operazione viene implementata come kCall con l'attributo is_composite=true. Il campo decomposition è specificato dall'attributo computation. Gli attributi frontend memorizzano gli attributi rimanenti con il prefisso composite..

Esempio di operazione CompositeCall:

f32[] call(f32[] %cst), to_apply=%computation, is_composite=true,
frontend_attributes = {
  composite.name="foo.bar",
  composite.attributes={n = 1 : i32, tensor = dense<1> : tensor<i32>},
  composite.version="1"
}

CompositeCall(computation, operands..., name, attributes, version)

L'operazione decomposition non è un campo chiamato, ma viene visualizzata come attributo to_apply che punta alla funzione che contiene l'implementazione di livello inferiore, ovvero to_apply=%funcname

Per ulteriori informazioni su composizione e scomposizione, consulta la specifica StableHLO.

Cbrt

Vedi anche XlaBuilder::Cbrt.

Operazione di radice cubica elemento per elemento x -> cbrt(x).

Cbrt(operand)

Cbrt supporta anche l'argomento facoltativo result_accuracy:

Cbrt(operand, result_accuracy)

Per ulteriori informazioni su result_accuracy, consulta Accuratezza dei risultati.

Per informazioni su StableHLO, vedi StableHLO - cbrt.

Ceil

Vedi anche XlaBuilder::Ceil.

Element-wise ceil x -> ⌈x⌉.

Ceil(operand)

Per informazioni su StableHLO, consulta StableHLO - ceil.

Cholesky

Vedi anche XlaBuilder::Cholesky.

Calcola la decomposizione di Cholesky di un batch di matrici definite positive simmetriche (hermitiane).

Cholesky(a, lower)

Se lower è true, calcola le matrici triangolari inferiori l in modo che $a = l . l^T$. Se lower è false, calcola le matrici triangolari superiori u in modo che \(a = u^T . u\).

I dati di input vengono letti solo dal triangolo inferiore/superiore di a, a seconda del valore di lower. I valori dell'altro triangolo vengono ignorati. I dati di output vengono restituiti nello stesso triangolo; i valori nell'altro triangolo sono definiti dall'implementazione e possono essere qualsiasi valore.

Se a ha più di 2 dimensioni, a viene trattato come un batch di matrici, in cui tutte le dimensioni, tranne le due minori, sono dimensioni batch.

Se a non è simmetrica (hermitiana) definita positiva, il risultato è definito dall'implementazione.

Per informazioni su StableHLO, vedi StableHLO - cholesky.

Clamp

Vedi anche XlaBuilder::Clamp.

Limita un operando all'intervallo compreso tra un valore minimo e uno massimo.

Clamp(min, operand, max)

Dato un operando e i valori minimo e massimo, restituisce l'operando se rientra nell'intervallo tra il minimo e il massimo, altrimenti restituisce il valore minimo se l'operando è inferiore a questo intervallo o il valore massimo se l'operando è superiore a questo intervallo. ovvero clamp(a, x, b) = min(max(a, x), b).

Tutti e tre gli array devono avere la stessa forma. In alternativa, in quanto forma limitata di trasmissione, min e/o max possono essere uno scalare di tipo T.

Esempio con scalari min e max:

let operand: s32[3] = {-1, 5, 9};
let min: s32 = 0;
let max: s32 = 6;
==>
Clamp(min, operand, max) = s32[3]{0, 5, 6};

Per informazioni su StableHLO, vedi StableHLO - clamp.

Comprimi

Vedi anche XlaBuilder::Collapse. e l'operazione tf.reshape.

Comprime le dimensioni di un array in una sola dimensione.

Collapse(operand, dimensions)

Collapse sostituisce il sottoinsieme specificato delle dimensioni dell'operando con una singola dimensione. Gli argomenti di input sono un array arbitrario di tipo T e un vettore costante in fase di compilazione di indici di dimensione. Gli indici delle dimensioni devono essere un sottoinsieme consecutivo e in ordine (numeri delle dimensioni dal più basso al più alto) delle dimensioni di T. Pertanto, {0, 1, 2}, {0, 1} o {1, 2} sono tutti set di dimensioni validi, ma {1, 0} o {0, 2} non lo sono. Vengono sostituite da una singola nuova dimensione, nella stessa posizione nella sequenza delle dimensioni di quelle che sostituiscono, con la nuova dimensione uguale al prodotto delle dimensioni originali. Il numero di dimensione più basso in dimensions è la dimensione con la variazione più lenta (la più importante) nel nido di cicli che comprime queste dimensioni, mentre il numero di dimensione più alto è la dimensione con la variazione più rapida (la meno importante). Consulta l'operatore tf.reshape se è necessario un ordinamento di compressione più generale.

Ad esempio, sia v un array di 24 elementi:

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

// Collapse to a single dimension, leaving one dimension.
let v012 = Collapse(v, {0,1,2});
then v012 == f32[24] {10, 11, 12, 15, 16, 17,
20, 21, 22, 25, 26, 27,
30, 31, 32, 35, 36, 37,
40, 41, 42, 45, 46, 47};

// Collapse the two lower dimensions, leaving two dimensions.
let v01 = Collapse(v, {0,1});
then v01 == f32[4x6] { {10, 11, 12, 15, 16, 17},
{20, 21, 22, 25, 26, 27},
{30, 31, 32, 35, 36, 37},
{40, 41, 42, 45, 46, 47} };

// Collapse the two higher dimensions, leaving two dimensions.
let v12 = Collapse(v, {1,2});
then v12 == f32[8x3] { {10, 11, 12},
{15, 16, 17},
{20, 21, 22},
{25, 26, 27},
{30, 31, 32},
{35, 36, 37},
{40, 41, 42},
{45, 46, 47} };

Clz

Vedi anche XlaBuilder::Clz.

Conteggio elemento per elemento degli zeri iniziali.

Clz(operand)

CollectiveBroadcast

Vedi anche XlaBuilder::CollectiveBroadcast.

Trasmette i dati tra le repliche. I dati vengono inviati dal primo ID replica di ogni gruppo agli altri ID dello stesso gruppo. Se un ID replica non si trova in alcun gruppo di repliche, l'output della replica è un tensore composto da 0 in shape.

CollectiveBroadcast(operand, replica_groups, channel_id)

Per informazioni su StableHLO, vedi StableHLO - collective_broadcast.

CollectivePermute

Vedi anche XlaBuilder::CollectivePermute.

CollectivePermute è un'operazione collettiva che invia e riceve dati tra le repliche.

CollectivePermute(operand, source_target_pairs, channel_id, inplace)

Tieni presente che esistono le seguenti limitazioni per source_target_pairs:

• Due coppie non devono avere lo stesso ID replica di destinazione e non devono avere lo stesso ID replica di origine.
• Se un ID replica non è una destinazione in nessuna coppia, l'output sulla replica è un tensore composto da 0 con la stessa forma dell'input.

L'API dell'operazione CollectivePermute viene scomposta internamente in due istruzioni HLO (CollectivePermuteStart e CollectivePermuteDone).

Vedi anche HloInstruction::CreateCollectivePermuteStart.

CollectivePermuteStart e CollectivePermuteDone fungono da primitive in HLO. Queste operazioni potrebbero essere visualizzate nei dump HLO, ma non sono destinate a essere create manualmente dagli utenti finali.

Per informazioni su StableHLO, vedi StableHLO - collective_permute.

Confronta

Vedi anche XlaBuilder::Compare.

Esegue il confronto elemento per elemento di lhs e rhs di quanto segue:

Eq

Vedi anche XlaBuilder::Eq.

Esegue il confronto uguale a elemento per elemento di lhs e rhs.

\(lhs = rhs\)

Eq(lhs, rhs)

Le forme degli argomenti devono essere simili o compatibili. Consulta la documentazione sulla trasmissione per scoprire cosa significa che le forme sono compatibili. Il risultato di un'operazione ha una forma che è il risultato della trasmissione dei due array di input. In questa variante, le operazioni tra array di ranghi diversi non sono supportate, a meno che uno degli operandi non sia uno scalare.

Esiste una variante alternativa con supporto di trasmissione di dimensioni diverse per Eq:

Eq(lhs,rhs, broadcast_dimensions)

Questa variante dell'operazione deve essere utilizzata per le operazioni aritmetiche tra array di ranghi diversi (ad esempio l'aggiunta di una matrice a un vettore).

L'operando broadcast_dimensions aggiuntivo è una sezione di numeri interi che specifica le dimensioni da utilizzare per la trasmissione degli operandi. La semantica è descritta in dettaglio nella pagina di trasmissione.

Supporta un ordine totale superiore ai numeri in virgola mobile per Eq, applicando:

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

EqTotalOrder(lhs,rhs, broadcast_dimensions)

Per informazioni su StableHLO, vedi StableHLO - confronta.

Ne

Vedi anche XlaBuilder::Ne.

Esegue il confronto diverso da elemento per elemento di lhs e rhs.

\(lhs != rhs\)

Ne(lhs, rhs)

Le forme degli argomenti devono essere simili o compatibili. Consulta la documentazione sulla trasmissione per scoprire cosa significa che le forme sono compatibili. Il risultato di un'operazione ha una forma che è il risultato della trasmissione dei due array di input. In questa variante, le operazioni tra array di ranghi diversi non sono supportate, a meno che uno degli operandi non sia uno scalare.

Esiste una variante alternativa con supporto della trasmissione in dimensioni diverse per Ne:

Ne(lhs,rhs, broadcast_dimensions)

Questa variante dell'operazione deve essere utilizzata per le operazioni aritmetiche tra array di ranghi diversi (ad esempio l'aggiunta di una matrice a un vettore).

L'operando broadcast_dimensions aggiuntivo è una sezione di numeri interi che specifica le dimensioni da utilizzare per la trasmissione degli operandi. La semantica è descritta in dettaglio nella pagina di trasmissione.

Supporta un ordine totale superiore ai numeri in virgola mobile per Ne, by imponendo:

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

NeTotalOrder(lhs,rhs, broadcast_dimensions)

Per informazioni su StableHLO, vedi StableHLO - confronta.

Ge

Vedi anche XlaBuilder::Ge.

Esegue il confronto greater-or-equal-than elemento per elemento di lhs e rhs.

\(lhs >= rhs\)

Ge(lhs, rhs)

Le forme degli argomenti devono essere simili o compatibili. Consulta la documentazione sulla trasmissione per scoprire cosa significa che le forme sono compatibili. Il risultato di un'operazione ha una forma che è il risultato della trasmissione dei due array di input. In questa variante, le operazioni tra array di ranghi diversi non sono supportate, a meno che uno degli operandi non sia uno scalare.

Esiste una variante alternativa con supporto di trasmissione di dimensioni diverse per Ge:

Ge(lhs,rhs, broadcast_dimensions)

Questa variante dell'operazione deve essere utilizzata per le operazioni aritmetiche tra array di ranghi diversi (ad esempio l'aggiunta di una matrice a un vettore).

L'operando broadcast_dimensions aggiuntivo è una sezione di numeri interi che specifica le dimensioni da utilizzare per la trasmissione degli operandi. La semantica è descritta in dettaglio nella pagina di trasmissione.

Supporta un ordine totale superiore ai numeri in virgola mobile per Gt, by imponendo:

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

GtTotalOrder(lhs,rhs, broadcast_dimensions)

Per informazioni su StableHLO, vedi StableHLO - confronta.

Gt

Vedi anche XlaBuilder::Gt.

Esegue il confronto maggiore di elemento per elemento di lhs e rhs.

\(lhs > rhs\)

Gt(lhs, rhs)

Le forme degli argomenti devono essere simili o compatibili. Consulta la documentazione sulla trasmissione per scoprire cosa significa che le forme sono compatibili. Il risultato di un'operazione ha una forma che è il risultato della trasmissione dei due array di input. In questa variante, le operazioni tra array di ranghi diversi non sono supportate, a meno che uno degli operandi non sia uno scalare.

Esiste una variante alternativa con supporto della trasmissione in dimensioni diverse per Gt:

Gt(lhs,rhs, broadcast_dimensions)

Questa variante dell'operazione deve essere utilizzata per le operazioni aritmetiche tra array di ranghi diversi (ad esempio l'aggiunta di una matrice a un vettore).

L'operando broadcast_dimensions aggiuntivo è una sezione di numeri interi che specifica le dimensioni da utilizzare per la trasmissione degli operandi. La semantica è descritta in dettaglio nella pagina di trasmissione.

Per informazioni su StableHLO, vedi StableHLO - confronta.

Le

Vedi anche XlaBuilder::Le.

Esegue il confronto less-or-equal-than elemento per elemento di lhs e rhs.

\(lhs <= rhs\)

Le(lhs, rhs)

Le forme degli argomenti devono essere simili o compatibili. Consulta la documentazione sulla trasmissione per scoprire cosa significa che le forme sono compatibili. Il risultato di un'operazione ha una forma che è il risultato della trasmissione dei due array di input. In questa variante, le operazioni tra array di ranghi diversi non sono supportate, a meno che uno degli operandi non sia uno scalare.

Esiste una variante alternativa con supporto di trasmissione di dimensioni diverse per Le:

Le(lhs,rhs, broadcast_dimensions)

Questa variante dell'operazione deve essere utilizzata per le operazioni aritmetiche tra array di ranghi diversi (ad esempio l'aggiunta di una matrice a un vettore).

L'operando broadcast_dimensions aggiuntivo è una sezione di numeri interi che specifica le dimensioni da utilizzare per la trasmissione degli operandi. La semantica è descritta in dettaglio nella pagina di trasmissione.

Supporta un ordine totale superiore ai numeri con rappresentazione in virgola mobile esistenti per Le, by enforcing:

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

LeTotalOrder(lhs,rhs, broadcast_dimensions)

Per informazioni su StableHLO, vedi StableHLO - confronta.

Lt

Vedi anche XlaBuilder::Lt.

Esegue il confronto minore di elemento per elemento di lhs e rhs.

\(lhs < rhs\)

Lt(lhs, rhs)

Le forme degli argomenti devono essere simili o compatibili. Consulta la documentazione sulla trasmissione per scoprire cosa significa che le forme sono compatibili. Il risultato di un'operazione ha una forma che è il risultato della trasmissione dei due array di input. In questa variante, le operazioni tra array di ranghi diversi non sono supportate, a meno che uno degli operandi non sia uno scalare.

Esiste una variante alternativa con supporto di trasmissione di dimensioni diverse per Lt:

Lt(lhs,rhs, broadcast_dimensions)

Questa variante dell'operazione deve essere utilizzata per le operazioni aritmetiche tra array di ranghi diversi (ad esempio l'aggiunta di una matrice a un vettore).

L'operando broadcast_dimensions aggiuntivo è una sezione di numeri interi che specifica le dimensioni da utilizzare per la trasmissione degli operandi. La semantica è descritta in dettaglio nella pagina di trasmissione.

Supporta un ordine totale superiore ai numeri in virgola mobile per Lt, by imponendo:

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

LtTotalOrder(lhs,rhs, broadcast_dimensions)

Per informazioni su StableHLO, vedi StableHLO - confronta.

Complesso

Vedi anche XlaBuilder::Complex.

Esegue la conversione elemento per elemento in un valore complesso da una coppia di valori reali e immaginari, lhs e rhs.

Complex(lhs, rhs)

Le forme degli argomenti devono essere simili o compatibili. Consulta la documentazione sulla trasmissione per scoprire cosa significa che le forme sono compatibili. Il risultato di un'operazione ha una forma che è il risultato della trasmissione dei due array di input. In questa variante, le operazioni tra array di ranghi diversi non sono supportate, a meno che uno degli operandi non sia uno scalare.

Esiste una variante alternativa con supporto della trasmissione multidimensionale per Complex:

Complex(lhs,rhs, broadcast_dimensions)

Questa variante dell'operazione deve essere utilizzata per le operazioni aritmetiche tra array di ranghi diversi (ad esempio l'aggiunta di una matrice a un vettore).

L'operando broadcast_dimensions aggiuntivo è una sezione di numeri interi che specifica le dimensioni da utilizzare per la trasmissione degli operandi. La semantica è descritta in dettaglio nella pagina di trasmissione.

Per informazioni su StableHLO, vedi StableHLO - complex.

ConcatInDim (Concatenate)

Vedi anche XlaBuilder::ConcatInDim.

Concatenate crea un array da più operandi array. L'array ha lo stesso numero di dimensioni di ciascuno degli operandi dell'array di input (che devono avere lo stesso numero di dimensioni tra loro) e contiene gli argomenti nell'ordine in cui sono stati specificati.

Concatenate(operands..., dimension)

Ad eccezione di dimension, tutte le dimensioni devono essere uguali. Questo perché XLA non supporta gli array "irregolari". Tieni presente inoltre che i valori a zero dimensioni non possono essere concatenati (in quanto è impossibile denominare la dimensione lungo la quale avviene la concatenazione).

Esempio unidimensionale:

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

Esempio bidimensionale:

let a = { {1, 2},
         {3, 4},
         {5, 6} };

let b = { {7, 8} };

Concat({a, b}, 0)

//Output:  { {1, 2},
//          {3, 4},
//          {5, 6},
//          {7, 8} }

Diagramma:

Per informazioni su StableHLO, vedi StableHLO - concatenate.

Condizionale

Vedi anche XlaBuilder::Conditional.

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

Esegue true_computation se predicate è true, false_computation se predicate è false e restituisce il risultato.

true_computation deve accettare un singolo argomento di tipo \(T_0\) e verrà richiamato con true_operand, che deve essere dello stesso tipo. false_computation deve accettare un singolo argomento di tipo \(T_1\) e verrà richiamato con false_operand, che deve essere dello stesso tipo. Il tipo di valore restituito di true_computation e false_computation deve essere lo stesso.

Tieni presente che verrà eseguito solo uno dei due valori true_computation e false_computation a seconda del valore di predicate.

Conditional(branch_index, branch_computations, branch_operands)

Esegue branch_computations[branch_index] e restituisce il risultato. Se branch_index è un S32 che è < 0 o >= N, allora branch_computations[N-1] viene eseguito come ramo predefinito.

Ogni branch_computations[b] deve accettare un singolo argomento di tipo \(T_b\) e verrà richiamato con branch_operands[b], che deve essere dello stesso tipo. Il tipo di valore restituito di ogni branch_computations[b] deve essere lo stesso.

Tieni presente che verrà eseguito solo uno dei branch_computations a seconda del valore di branch_index.

Per informazioni su StableHLO, vedi StableHLO - if.

Costante

Vedi anche XlaBuilder::ConstantLiteral.

Produce un output da una costante literal.

Constant(literal)

Per informazioni su StableHLO, vedi StableHLO - constant.

ConvertElementType

Vedi anche XlaBuilder::ConvertElementType.

Simile a un'operazione static_cast elemento per elemento in C++, ConvertElementType esegue una conversione elemento per elemento da una forma dei dati a una forma di destinazione. Le dimensioni devono corrispondere e la conversione è elemento per elemento; ad esempio, gli elementi s32 diventano elementi f32 tramite una routine di conversione da s32 a f32.

ConvertElementType(operand, new_element_type)

Le dimensioni dell'operando e della forma di destinazione devono corrispondere. I tipi di elementi di origine e destinazione non devono essere tuple.

Una conversione come T=s32 in U=f32 eseguirà una routine di conversione int-to-float di normalizzazione, ad esempio round-to-nearest-even.

let a: s32[3] = {0, 1, 2};
let b: f32[3] = convert(a, f32);
then b == f32[3]{0.0, 1.0, 2.0}

Per informazioni su StableHLO, vedi StableHLO - convert.

Conv (convoluzione)

Vedi anche XlaBuilder::Conv.

Calcola una convoluzione del tipo utilizzato nelle reti neurali. In questo caso, una convoluzione può essere considerata una finestra n-dimensionale che si sposta su un'area di base n-dimensionale e viene eseguito un calcolo per ogni posizione possibile della finestra.

Conv Inserisce un'istruzione di convoluzione nel calcolo, che utilizza i numeri di dimensione di convoluzione predefiniti senza dilatazione.

Il padding viene specificato in modo abbreviato come SAME o VALID. SAME il padding riempie l'input (lhs) con zeri in modo che l'output abbia la stessa forma dell'input quando non si tiene conto dello striding. Il riempimento VALID significa semplicemente nessun riempimento.

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

Per Conv sono disponibili livelli di controllo crescenti:

• ConvWithGeneralPadding
• ConvWithGeneralDimensions
• ConvGeneral
• ConvGeneralDilated

Sia n il numero di dimensioni spaziali. L'argomento lhs è un array (n+2)-dimensionale che descrive l'area di base. Questo è chiamato input, anche se ovviamente anche il lato destro è un input. In una rete neurale, queste sono le attivazioni di input. Le dimensioni n+2 sono, in questo ordine:

• batch: ogni coordinata in questa dimensione rappresenta un input indipendente per il quale viene eseguita la convoluzione.
• z/depth/features: a ogni posizione (y,x) nell'area di base è associato un vettore che rientra in questa dimensione.
• spatial_dims: descrive le dimensioni spaziali n che definiscono l'area di base in cui si sposta la finestra.

L'argomento rhs è un array (n+2) dimensionale che descrive il filtro/kernel/finestra convoluzionale. Le dimensioni sono, in questo ordine:

• output-z: la dimensione z dell'output.
• input-z: le dimensioni di questa dimensione moltiplicate per feature_group_count devono essere uguali alle dimensioni della dimensione z nella parte sinistra.
• spatial_dims: descrive le dimensioni spaziali n che definiscono la finestra n-dimensionale che si sposta nell'area di base.

L'argomento window_strides specifica lo stride della finestra convoluzionale nelle dimensioni spaziali. Ad esempio, se lo stride nella prima dimensione spaziale è 3, la finestra può essere posizionata solo in corrispondenza di coordinate in cui il primo indice spaziale è divisibile per 3.

L'argomento padding specifica la quantità di padding zero da applicare all'area di base. La quantità di padding può essere negativa. Il valore assoluto del padding negativo indica il numero di elementi da rimuovere dalla dimensione specificata prima di eseguire la convoluzione. padding[0] specifica il padding per la dimensione y e padding[1] specifica il padding per la dimensione x. Ogni coppia ha il padding basso come primo elemento e il padding alto come secondo elemento. Il riempimento basso viene applicato nella direzione degli indici più bassi, mentre il riempimento alto viene applicato nella direzione degli indici più alti. Ad esempio, se padding[1] è (2,3), nella seconda dimensione spaziale verrà aggiunto un riempimento di due zeri a sinistra e di tre zeri a destra. L'utilizzo del padding equivale a inserire gli stessi valori zero nell'input (lhs) prima di eseguire la convoluzione.

Gli argomenti lhs_dilation e rhs_dilation specificano il fattore di dilatazione da applicare rispettivamente al lato sinistro e destro in ogni dimensione spaziale. Se il fattore di dilatazione in una dimensione spaziale è d, vengono inseriti implicitamente d-1 fori tra ogni voce di quella dimensione, aumentando le dimensioni dell' array. I fori vengono riempiti con un valore no-op, che per la convoluzione significa zeri.

La dilatazione del lato destro è anche chiamata convoluzione atrous. Per maggiori dettagli, vedi tf.nn.atrous_conv2d. L'espansione del lato sinistro è anche chiamata convoluzione trasposta. Per maggiori dettagli, vedi tf.nn.conv2d_transpose.

L'argomento feature_group_count (valore predefinito 1) può essere utilizzato per le convoluzioni raggruppate. feature_group_count deve essere un divisore sia della dimensione della funzionalità di input sia di quella di output. Se feature_group_count è maggiore di 1, significa che concettualmente la dimensione della funzionalità di input e output e la dimensione della funzionalità di output rhs sono suddivise equamente in molti gruppi feature_group_count, ciascuno costituito da una sottosequenza consecutiva di funzionalità. La dimensione della funzionalità di input di rhs deve essere uguale alla dimensione della funzionalità di input lhs divisa per feature_group_count (quindi ha già le dimensioni di un gruppo di funzionalità di input). Gli i-esimi gruppi vengono utilizzati insieme per calcolare feature_group_count per molte convoluzioni separate. I risultati di queste convoluzioni vengono concatenati nella dimensione della funzionalità di output.

Per la convoluzione depthwise, l'argomento feature_group_count verrà impostato sulla dimensione della funzionalità di input e il filtro verrà rimodellato da [filter_height, filter_width, in_channels, channel_multiplier] a [filter_height, filter_width, 1, in_channels * channel_multiplier]. Per maggiori dettagli, vedi tf.nn.depthwise_conv2d.

L'argomento batch_group_count (valore predefinito 1) può essere utilizzato per i filtri raggruppati durante la retropropagazione. batch_group_count deve essere un divisore della dimensione del batch lhs (input). Se batch_group_count è maggiore di 1, significa che la dimensione del batch di output deve essere input batch / batch_group_count. batch_group_count deve essere un divisore della dimensione della funzionalità di output.

La forma di output ha queste dimensioni, in questo ordine:

• batch: le dimensioni di questa dimensione moltiplicate per batch_group_count devono essere uguali alle dimensioni della dimensione batch nel lato sinistro.
• z: Le stesse dimensioni di output-z sul kernel (rhs).
• spatial_dims: Un valore per ogni posizionamento valido della finestra convoluzionale.

La figura sopra mostra come funziona il campo batch_group_count. In pratica, dividiamo ogni batch lhs in batch_group_count gruppi e facciamo lo stesso per le funzionalità di output. Quindi, per ciascuno di questi gruppi eseguiamo convoluzioni a coppie e concateniamo l'output lungo la dimensione della funzionalità di output. La semantica operativa di tutte le altre dimensioni (funzionalità e spaziali) rimane invariata.

I posizionamenti validi della finestra convoluzionale sono determinati dagli stride e dalle dimensioni dell'area di base dopo il padding.

Per descrivere cosa fa una convoluzione, considera una convoluzione 2D e scegli alcune coordinate batch, z, y, x fisse nell'output. (y,x) è una posizione di un angolo della finestra all'interno dell'area di base (ad es. l'angolo in alto a sinistra, a seconda di come interpreti le dimensioni spaziali). Ora abbiamo una finestra 2D, presa dall'area di base, in cui ogni punto 2D è associato a un vettore 1D, quindi otteniamo una scatola 3D. Dal kernel convoluzionale, poiché abbiamo corretto la coordinata di output z, abbiamo anche una casella 3D. Le due caselle hanno le stesse dimensioni, quindi possiamo calcolare la somma dei prodotti elemento per elemento tra le due caselle (in modo simile a un prodotto scalare). Questo è il valore di output.

Tieni presente che se output-z è, ad esempio, 5, quindi ogni posizione della finestra produce 5 valori nell'output nella dimensione z dell'output. Questi valori differiscono nella parte del kernel convoluzionale utilizzata: esiste una casella 3D separata di valori utilizzati per ogni coordinata output-z. Puoi quindi considerarlo come 5 convoluzioni separate con un filtro diverso per ciascuna.

Ecco il pseudocodice per una convoluzione 2D con padding e striding:

for (b, oz, oy, ox) { // output coordinates
  value = 0;
  for (iz, ky, kx) { // kernel coordinates and input z
    iy = oy*stride_y + ky - pad_low_y;
    ix = ox*stride_x + kx - pad_low_x;
    if ((iy, ix) inside the base area considered without padding) {
      value += input(b, iz, iy, ix) * kernel(oz, iz, ky, kx);
    }
  }
  output(b, oz, oy, ox) = value;
}

precision_config viene utilizzato per indicare la configurazione della precisione. Il livello determina se l'hardware deve tentare di generare più istruzioni di codice macchina per fornire un'emulazione del tipo di dati più accurata quando necessario (ad es. emulazione di f32 su una TPU che supporta solo matmul bf16). I valori possono essere DEFAULT, HIGH, HIGHEST. Ulteriori dettagli nelle sezioni MXU.

preferred_element_type è un elemento scalare di tipi di output con precisione maggiore/minore utilizzati per l'accumulo. preferred_element_type consiglia il tipo di accumulo per l'operazione specificata, ma non è garantito. Ciò consente ad alcuni backend hardware di accumularsi in un tipo diverso e di essere convertiti nel tipo di output preferito.

Per informazioni su StableHLO, vedi StableHLO - convoluzione.

ConvWithGeneralPadding

Vedi anche XlaBuilder::ConvWithGeneralPadding.

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

Come Conv, dove la configurazione del padding è esplicita.

ConvWithGeneralDimensions

Vedi anche XlaBuilder::ConvWithGeneralDimensions.

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

Uguale a Conv, dove i numeri delle dimensioni sono espliciti.

ConvGeneral

Vedi anche XlaBuilder::ConvGeneral.

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

Come Conv, dove i numeri delle dimensioni e la configurazione del padding sono espliciti

ConvGeneralDilated

Vedi anche XlaBuilder::ConvGeneralDilated.

ConvGeneralDilated(lhs, rhs, window_strides, padding, lhs_dilation, rhs_dilation, dimension_numbers, feature_group_count, batch_group_count, precision_config, preferred_element_type, window_reversal)

Uguale a Conv in cui la configurazione del padding, i fattori di dilatazione e i numeri delle dimensioni sono espliciti.

Copia

Vedi anche HloInstruction::CreateCopyStart.

Copy viene scomposto internamente in due istruzioni HLO CopyStart e CopyDone. Copy insieme a CopyStart e CopyDone fungono da primitive in HLO. Queste operazioni potrebbero essere visualizzate nei dump HLO, ma non sono destinate a essere create manualmente dagli utenti finali.

Cos

Vedi ancheXlaBuilder::Cos.

Coseno elemento per elemento x -> cos(x).

Cos(operand)

Cos supporta anche l'argomento facoltativo result_accuracy:

Cos(operand, result_accuracy)

Per ulteriori informazioni su result_accuracy, consulta Accuratezza dei risultati.

Per informazioni su StableHLO, vedi StableHLO - cosine.

Cosh

Vedi anche XlaBuilder::Cosh.

Coseno iperbolico elemento per elemento x -> cosh(x).

Cosh(operand)

Cosh supporta anche l'argomento facoltativo result_accuracy:

Cosh(operand, result_accuracy)

Per ulteriori informazioni su result_accuracy, consulta Accuratezza dei risultati.

CustomCall

Vedi anche XlaBuilder::CustomCall.

Chiama una funzione fornita dall'utente all'interno di un calcolo.

La documentazione di CustomCall è fornita in Dettagli per gli sviluppatori - CustomCall XLA

Per informazioni su StableHLO, vedi StableHLO - custom_call.

Div

Vedi anche XlaBuilder::Div.

Esegue la divisione elemento per elemento del dividendo lhs e del divisore rhs.

Div(lhs, rhs)

L'overflow della divisione intera (divisione/resto con o senza segno per zero o divisione/resto con segno di INT_SMIN con -1) produce un valore definito dall'implementazione.

Le forme degli argomenti devono essere simili o compatibili. Consulta la documentazione sulla trasmissione per scoprire cosa significa che le forme sono compatibili. Il risultato di un'operazione ha una forma che è il risultato della trasmissione dei due array di input. In questa variante, le operazioni tra array di ranghi diversi non sono supportate, a meno che uno degli operandi non sia uno scalare.

Esiste una variante alternativa con supporto della trasmissione di dimensioni diverse per Div:

Div(lhs,rhs, broadcast_dimensions)

Questa variante dell'operazione deve essere utilizzata per le operazioni aritmetiche tra array di ranghi diversi (ad esempio l'aggiunta di una matrice a un vettore).

L'operando broadcast_dimensions aggiuntivo è una sezione di numeri interi che specifica le dimensioni da utilizzare per la trasmissione degli operandi. La semantica è descritta in dettaglio nella pagina di trasmissione.

Per informazioni su StableHLO, vedi StableHLO - divide.

Dominio

Vedi anche HloInstruction::CreateDomain.

Domain può essere visualizzato nei dump HLO, ma non è destinato a essere creato manualmente dagli utenti finali.

Punto

Vedi anche XlaBuilder::Dot.

Dot(lhs, rhs, precision_config, preferred_element_type)

La semantica esatta di questa operazione dipende dai ranghi degli operandi:

L'operazione esegue la somma dei prodotti sulla seconda dimensione di lhs (o la prima se ha una dimensione) e sulla prima dimensione di rhs. Queste sono le dimensioni "contratte". Le dimensioni contratte di lhs e rhs devono essere le stesse. In pratica, può essere utilizzato per eseguire prodotti scalari tra vettori, moltiplicazioni vettore/matrice o moltiplicazioni matrice/matrice.

precision_config viene utilizzato per indicare la configurazione della precisione. Il livello determina se l'hardware deve tentare di generare più istruzioni di codice macchina per fornire un'emulazione del tipo di dati più accurata quando necessario (ad es. emulazione di f32 su una TPU che supporta solo matmul bf16). I valori possono essere DEFAULT, HIGH, HIGHEST. Ulteriori dettagli nelle sezioni MXU.

preferred_element_type è un elemento scalare di tipi di output con precisione maggiore/minore utilizzati per l'accumulo. preferred_element_type consiglia il tipo di accumulo per l'operazione specificata, ma non è garantito. Ciò consente ad alcuni backend hardware di accumularsi in un tipo diverso e di essere convertiti nel tipo di output preferito.

Per informazioni su StableHLO, vedi StableHLO - dot.

DotGeneral

Vedi anche XlaBuilder::DotGeneral.

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

Simile a Punto, ma consente di specificare i numeri di dimensione di contrazione e batch sia per lhs che per rhs.

DotGeneral esegue la somma dei prodotti nelle dimensioni di contrazione specificate in dimension_numbers.

I numeri delle dimensioni di contratto associate di lhs e rhs non devono essere uguali, ma devono avere le stesse dimensioni.

Esempio con numeri di dimensioni che si riducono:

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

I numeri delle dimensioni del batch associati di lhs e rhs devono avere le stesse dimensioni.

Esempio con numeri di dimensioni batch (dimensione batch 2, matrici 2x2):

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

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

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

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

Di conseguenza, il numero della dimensione risultante inizia con la dimensione batch, poi con la dimensione lhs non contrattuale/non batch e infine con la dimensione rhs non contrattuale/non batch.

precision_config viene utilizzato per indicare la configurazione della precisione. Il livello determina se l'hardware deve tentare di generare più istruzioni di codice macchina per fornire un'emulazione del tipo di dati più accurata quando necessario (ad es. emulazione di f32 su una TPU che supporta solo matmul bf16). I valori possono essere DEFAULT, HIGH, HIGHEST. Ulteriori dettagli sono disponibili nelle sezioni relative alle unità MXU.

preferred_element_type è un elemento scalare di tipi di output con precisione maggiore/minore utilizzati per l'accumulo. preferred_element_type consiglia il tipo di accumulo per l'operazione specificata, ma non è garantito. Ciò consente ad alcuni backend hardware di accumularsi in un tipo diverso e di essere convertiti nel tipo di output preferito.

Per informazioni su StableHLO, vedi StableHLO - dot_general.

ScaledDot

Vedi anche XlaBuilder::ScaledDot.

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

Simile a DotGeneral.

Crea un'operazione di prodotto scalare con gli operandi "lhs", "lhs_scale", "rhs" e "rhs_scale", con le dimensioni di contrazione e batch specificate in "dimension_numbers".

RaggedDot

Vedi anche XlaBuilder::RaggedDot.

Per un'analisi dettagliata del calcolo di RaggedDot, vedi StableHLO - chlo.ragged_dot

DynamicReshape

Vedi anche XlaBuilder::DynamicReshape.

Questa operazione è funzionalmente identica a reshape, ma la forma del risultato viene specificata dinamicamente tramite output_shape.

DynamicReshape(operand, dim_sizes, new_size_bounds, dims_are_dynamic)

Per informazioni su StableHLO, vedi StableHLO - dynamic_reshape.

DynamicSlice

Vedi anche XlaBuilder::DynamicSlice.

DynamicSlice estrae un sottoarray dall'array di input in dynamic start_indices. La dimensione della sezione in ogni dimensione viene passata in size_indices, che specifica il punto finale degli intervalli di sezioni esclusivi in ogni dimensione: [start, start + size). La forma di start_indices deve essere unidimensionale, con dimensioni pari al numero di dimensioni di operand.

DynamicSlice(operand, start_indices, slice_sizes)

Gli indici delle sezioni effettivi vengono calcolati applicando la seguente trasformazione per ogni indice i in [1, N) prima di eseguire la sezione:

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

In questo modo, la sezione estratta è sempre nei limiti rispetto all'array dell'operando. Se la sezione è all'interno dei limiti prima dell'applicazione della trasformazione, la trasformazione non ha alcun effetto.

Esempio unidimensionale:

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

DynamicSlice(a, s, {2});
// Result: {2.0, 3.0}

Esempio bidimensionale:

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

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

Per informazioni su StableHLO, vedi StableHLO - dynamic_slice.

DynamicUpdateSlice

Vedi anche XlaBuilder::DynamicUpdateSlice.

DynamicUpdateSlice genera un risultato che è il valore dell'array di input operand, con una sezione update sovrascritta in start_indices. La forma di update determina la forma della matrice secondaria del risultato che viene aggiornata. La forma di start_indices deve essere unidimensionale, con dimensioni pari al numero di dimensioni di operand.

DynamicUpdateSlice(operand, update, start_indices)

Gli indici delle sezioni effettivi vengono calcolati applicando la seguente trasformazione per ogni indice i in [1, N) prima di eseguire la sezione:

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

In questo modo, la sezione aggiornata è sempre nei limiti rispetto all'array di operandi. Se la sezione è all'interno dei limiti prima dell'applicazione della trasformazione, la trasformazione non ha alcun effetto.

Esempio unidimensionale:

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

DynamicUpdateSlice(a, u, s)
// Result: {0.0, 1.0, 5.0, 6.0, 4.0}

Esempio bidimensionale:

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

let s = {1, 1}

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

Per informazioni su StableHLO, consulta StableHLO - dynamic_update_slice.

Erf

Vedi anche XlaBuilder::Erf.

Funzione di errore elemento per elemento x -> erf(x), dove:

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

Erf(operand)

Erf supporta anche l'argomento facoltativo result_accuracy:

Erf(operand, result_accuracy)

Per ulteriori informazioni su result_accuracy, consulta Accuratezza dei risultati.

Exp

Vedi anche XlaBuilder::Exp.

Esponenziale naturale elemento per elemento x -> e^x.

Exp(operand)

Exp supporta anche l'argomento facoltativo result_accuracy:

Exp(operand, result_accuracy)

Per ulteriori informazioni su result_accuracy, consulta Accuratezza dei risultati.

Per informazioni su StableHLO, vedi StableHLO - exponential.

Expm1

Vedi anche XlaBuilder::Expm1.

Esponenziale naturale meno uno elemento per elemento x -> e^x - 1.

Expm1(operand)

Expm1 supporta anche l'argomento facoltativo result_accuracy:

Expm1(operand, result_accuracy)

Per ulteriori informazioni su result_accuracy, consulta Accuratezza dei risultati.

Per informazioni su StableHLO, vedi StableHLO - exponential_minus_one.

Fft

Vedi anche XlaBuilder::Fft.

L'operazione XLA FFT implementa le trasformate di Fourier diretta e inversa per input/output reali e complessi. Sono supportate le FFT multidimensionali su un massimo di tre assi.

Fft(operand, ftt_type, fft_length)

Per informazioni su StableHLO, vedi StableHLO - fft.

FFT multidimensionale

Se viene fornito più di un fft_length, ciò equivale ad applicare una cascata di operazioni FFT a ciascuno degli assi più interni. Tieni presente che per i casi reale->complesso e complesso->reale, la trasformazione dell'asse più interno viene eseguita (in modo efficace) per prima (RFFT; per ultima per IRFFT), motivo per cui l'asse più interno è quello che cambia dimensione. Le altre trasformazioni degli assi saranno da complesso a complesso.

Dettagli di implementazione

La FFT della CPU è supportata da TensorFFT di Eigen. La FFT della GPU utilizza cuFFT.

Piano

Vedi anche XlaBuilder::Floor.

Element-wise floor x -> ⌊x⌋.

Floor(operand)

Per informazioni su StableHLO, vedi StableHLO - floor.

Fusione

Vedi anche HloInstruction::CreateFusion.

L'operazione Fusion rappresenta le istruzioni HLO e funge da primitiva in HLO. Questa operazione potrebbe essere visualizzata nei dump HLO, ma non è pensata per essere creata manualmente dagli utenti finali.

Raccogli

L'operazione di raccolta XLA unisce diverse sezioni (ciascuna con un offset di runtime potenzialmente diverso) di un array di input.

Per informazioni su StableHLO, vedi StableHLO - gather.

Semantica generale

Vedi anche XlaBuilder::Gather. Per una descrizione più intuitiva, consulta la sezione "Descrizione informale" di seguito.

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

Per comodità, etichettiamo le dimensioni nell'array di output non in offset_dims come batch_dims.

L'output è un array con batch_dims.size + offset_dims.size dimensioni.

operand.rank deve essere uguale alla somma di offset_dims.size e collapsed_slice_dims.size. Inoltre, slice_sizes.size deve essere uguale a operand.rank.

Se index_vector_dim è uguale a start_indices.rank, consideriamo implicitamente che start_indices abbia una dimensione finale 1 (ovvero, se start_indices aveva forma [6,7] e index_vector_dim è 2, consideriamo implicitamente la forma di start_indices come [6,7,1]).

I limiti per l'array di output lungo la dimensione i vengono calcolati come segue:

1. Se i è presente in batch_dims (ovvero è uguale a batch_dims[k] per alcuni k), scegliamo i limiti della dimensione corrispondente da start_indices.shape, saltando index_vector_dim (ovvero scegliamo start_indices.shape.dims[k] se k < index_vector_dim e start_indices.shape.dims[k+1] altrimenti).

2. Se i è presente in offset_dims (ovvero è uguale a offset_dims[k] per alcuni k), scegliamo il limite corrispondente da slice_sizes dopo aver tenuto conto di collapsed_slice_dims (ovvero scegliamo adjusted_slice_sizes[k], dove adjusted_slice_sizes è slice_sizes con i limiti agli indici collapsed_slice_dims rimossi).

Formalmente, l'indice dell'operando In corrispondente a un determinato indice di output Out viene calcolato come segue:

1. Sia G = { Out[k] per k in batch_dims }. Utilizza G per estrarre un vettore S in modo che S[i] = start_indices[Combine(G, i)] dove Combine(A, b) inserisce b nella posizione index_vector_dim di A. Tieni presente che questa operazione è ben definita anche se G è vuoto: se G è vuoto, S = start_indices.

2. Crea un indice iniziale, Sin, in operand utilizzando S spargendo S utilizzando start_index_map. Più precisamente:

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

   2. Sin[_] = 0 altrimenti.

3. Crea un indice Oin in operand distribuendo gli indici nelle dimensioni di offset in Out in base al set collapsed_slice_dims. Più precisamente:

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

   2. Oin[_] = 0 altrimenti.

4. In è Oin + Sin, dove + è l'addizione elemento per elemento.

remapped_offset_dims è una funzione monotona con dominio [0, offset_dims.size) e intervallo [0, operand.rank) \ collapsed_slice_dims. Quindi, se, ad esempio, offset_dims.size è 4, operand.rank è 6 e collapsed_slice_dims è {0, 2}, allora remapped_offset_dims è {0→1, 1→3, 2→4, 3→5}.

Se indices_are_sorted è impostato su true, XLA può presupporre che start_indices siano ordinati (in ordine crescente, dopo aver distribuito i valori in base a start_index_map) dall'utente. In caso contrario, la semantica è definita dall'implementazione.

Descrizione informale ed esempi

Informalmente, ogni indice Out nell'array di output corrisponde a un elemento E nell'array operando, calcolato come segue:

• Utilizziamo le dimensioni batch in Out per cercare un indice iniziale da start_indices.

• Utilizziamo start_index_map per mappare l'indice iniziale (la cui dimensione potrebbe essere inferiore a operand.rank) a un indice iniziale "completo" in operand.

• Estraiamo dinamicamente una sezione di dimensioni slice_sizes utilizzando l'indice iniziale completo.

• Rimodelliamo la sezione comprimendo le dimensioni collapsed_slice_dims. Poiché tutte le dimensioni della sezione compressa devono avere un limite di 1, questo rimodellamento è sempre legale.

• Utilizziamo le dimensioni dell'offset in Out per indicizzare questa sezione e ottenere l'elemento di input, E, corrispondente all'indice di output Out.

index_vector_dim è impostato su start_indices.rank - 1 in tutti gli esempi che seguono. Valori più interessanti per index_vector_dim non modificano l'operazione in modo sostanziale, ma rendono la rappresentazione visiva più complessa.

Per capire come si combinano tutti gli elementi precedenti, esaminiamo un esempio che raccoglie 5 sezioni della forma [8,6] da un array [16,11]. La posizione di una sezione nell'array [16,11] può essere rappresentata come un vettore di indici di forma S64[2], quindi l'insieme di 5 posizioni può essere rappresentato come un array S64[5,2].

Il comportamento dell'operazione di raccolta può quindi essere rappresentato come una trasformazione dell'indice che prende [G,O0,O1], un indice nella forma di output e lo mappa a un elemento nell'array di input nel seguente modo:

Innanzitutto, selezioniamo un vettore (X,Y) dall'array di indici di raccolta utilizzando G. L'elemento nell'array di output all'indice [G,O0,O1] è quindi l'elemento nell'array di input all'indice [X+O0,Y+O1].

slice_sizes è [8,6], che determina l'intervallo di O₀ e O₁, che a sua volta determina i limiti della sezione.

Questa operazione di raccolta funge da slice dinamica batch con G come dimensione batch.

Gli indici di raccolta possono essere multidimensionali. Ad esempio, una versione più generale dell'esempio precedente che utilizza un array "gather indices" di forma [4,5,2] tradurrebbe gli indici in questo modo:

Anche in questo caso, funge da slice dinamico batch G0 e G1 come dimensioni batch. La dimensione della sezione è ancora [8,6].

L'operazione di raccolta in XLA generalizza la semantica informale descritta sopra nei seguenti modi:

1. Possiamo configurare quali dimensioni nella forma di output sono le dimensioni di offset (dimensioni contenenti O0, O1 nell'ultimo esempio). Le dimensioni del batch di output (dimensioni contenenti G0, G1 nell'ultimo esempio) sono definite come le dimensioni di output che non sono dimensioni di offset.

2. Il numero di dimensioni di offset di output presenti esplicitamente nella forma di output potrebbe essere inferiore al numero di dimensioni di input. Queste dimensioni "mancanti", elencate esplicitamente come collapsed_slice_dims, devono avere una dimensione della sezione di 1. Poiché hanno una dimensione della sezione di 1, l'unico indice valido è 0 e la loro eliminazione non introduce ambiguità.

3. La sezione estratta dall'array "Gather Indices" ((X, Y) nell'ultimo esempio) potrebbe avere meno elementi del numero di dimensioni dell'array di input e una mappatura esplicita determina in che modo l'indice deve essere espanso per avere lo stesso numero di dimensioni dell'input.

Come ultimo esempio, utilizziamo (2) e (3) per implementare tf.gather_nd:

G0 e G1 vengono utilizzati per estrarre un indice iniziale dall'array di indici di raccolta come di consueto, tranne per il fatto che l'indice iniziale ha un solo elemento, X. Analogamente, esiste un solo indice di offset di output con il valore O0. Tuttavia, prima di essere utilizzati come indici nell'array di input, questi vengono espansi in base a "Gather Index Mapping" (start_index_map nella descrizione formale) e "Offset Mapping" (remapped_offset_dims nella descrizione formale) in [X,0] e [0,O0] rispettivamente, sommando fino a [X,O0]. In altre parole, l'indice di output [G0,G1,O0] viene mappato all'indice di input [GatherIndices[G0,G1,0],O0] che ci fornisce la semantica per tf.gather_nd.

slice_sizes per questa richiesta è [1,11]. Intuitivamente, ciò significa che ogni indice X nell'array di indici di raccolta seleziona un'intera riga e il risultato è la concatenazione di tutte queste righe.

GetDimensionSize

Vedi anche XlaBuilder::GetDimensionSize.

Restituisce la dimensione della dimensione specificata dell'operando. L'operando deve avere la forma di un array.

GetDimensionSize(operand, dimension)

Per informazioni su StableHLO, vedi StableHLO - get_dimension_size.

GetTupleElement

Vedi anche XlaBuilder::GetTupleElement.

Indici in una tupla con un valore costante in fase di compilazione.

Il valore deve essere una costante in fase di compilazione in modo che l'inferenza della forma possa determinare il tipo del valore risultante.

È analogo a std::get<int N>(t) in C++. Concettualmente:

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.

Vedi anche tf.tuple.

GetTupleElement(tuple_data, index)

Per informazioni su StableHLO, vedi StableHLO - get_tuple_element.

Imag

Vedi anche XlaBuilder::Imag.

Parte immaginaria elemento per elemento di una forma complessa (o reale). x -> imag(x). Se l'operando è un tipo a virgola mobile, restituisce 0.

Imag(operand)

Per informazioni su StableHLO, consulta StableHLO - imag.

Infeed

Vedi anche XlaBuilder::Infeed.

Infeed(shape, config)

Legge un singolo elemento di dati dall'interfaccia di streaming infeed implicita del dispositivo, interpretando i dati come la forma e il layout specificati e restituisce un XlaOp dei dati. Sono consentite più operazioni Infeed in un calcolo, ma deve esistere un ordine totale tra le operazioni Infeed. Ad esempio, due Infeed nel codice riportato di seguito hanno un ordine totale perché esiste una dipendenza tra i cicli while.

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

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

Le forme di tuple nidificate non sono supportate. Per una forma di tupla vuota, l'operazione Infeed è effettivamente un'operazione no-op e procede senza leggere alcun dato dall'Infeed del dispositivo.

Per informazioni su StableHLO, vedi StableHLO - infeed.

Iota

Vedi anche XlaBuilder::Iota.

Iota(shape, iota_dimension)

Crea una costante letterale sul dispositivo anziché un trasferimento host potenzialmente di grandi dimensioni. Crea un array con la forma specificata e contiene valori che iniziano da zero e aumentano di uno lungo la dimensione specificata. Per i tipi in virgola mobile, l'array prodotto è equivalente a ConvertElementType(Iota(...)) dove Iota è di tipo integrale e la conversione è al tipo in virgola mobile.

Ad esempio, Iota(s32[4, 8], 0) restituisce

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

Resi a Iota(s32[4, 8], 1)

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

Per informazioni su StableHLO, consulta StableHLO - iota.

IsFinite

Vedi anche XlaBuilder::IsFinite.

Verifica se ogni elemento di operand è finito, ovvero non è infinito positivo o negativo e non è NaN. Restituisce un array di valori PRED con la stessa forma dell'input, dove ogni elemento è true se e solo se l'elemento di input corrispondente è finito.

IsFinite(operand)

Per informazioni su StableHLO, vedi StableHLO - is_finite.

Log

Vedi anche XlaBuilder::Log.

Logaritmo naturale elemento per elemento x -> ln(x).

Log(operand)

Il log supporta anche l'argomento facoltativo result_accuracy:

Log(operand, result_accuracy)

Per ulteriori informazioni su result_accuracy, consulta Accuratezza dei risultati.

Per informazioni su StableHLO, vedi StableHLO - log.

Log1p

Vedi anche XlaBuilder::Log1p.

Logaritmo naturale traslato elemento per elemento x -> ln(1+x).

Log1p(operand)

Log1p supporta anche l'argomento facoltativo result_accuracy:

Log1p(operand, result_accuracy)

Per ulteriori informazioni su result_accuracy, consulta Accuratezza dei risultati.

Per informazioni su StableHLO, vedi StableHLO - log_plus_one.

Logistica

Vedi anche XlaBuilder::Logistic.

Calcolo della funzione logistica elemento per elemento x -> logistic(x).

Logistic(operand)

La logistica supporta anche l'argomento facoltativo result_accuracy:

Logistic(operand, result_accuracy)

Per ulteriori informazioni su result_accuracy, consulta Accuratezza dei risultati.

Per informazioni su StableHLO, vedi StableHLO - logistic.

Mappa

Vedi anche XlaBuilder::Map.

Map(operands..., computation, dimensions)

Applica una funzione scalare agli array operands specificati, producendo un array delle stesse dimensioni in cui ogni elemento è il risultato della funzione mappata applicata agli elementi corrispondenti negli array di input.

La funzione mappata è un calcolo arbitrario con la limitazione di avere N input di tipo scalare T e un singolo output di tipo S. L'output ha le stesse dimensioni degli operandi, tranne per il fatto che il tipo di elemento T viene sostituito con S.

Ad esempio, Map(op1, op2, op3, computation, par1) mappa elem_out <- computation(elem1, elem2, elem3, par1) in ogni indice (multidimensionale) degli array di input per produrre l'array di output.

Per informazioni su StableHLO, vedi StableHLO - map.

Max

Vedi anche XlaBuilder::Max.

Esegue l'operazione max elemento per elemento sui tensori lhs e rhs.

Max(lhs, rhs)

Le forme degli argomenti devono essere simili o compatibili. Consulta la documentazione sulla trasmissione per scoprire cosa significa che le forme sono compatibili. Il risultato di un'operazione ha una forma che è il risultato della trasmissione dei due array di input. In questa variante, le operazioni tra array di ranghi diversi non sono supportate, a meno che uno degli operandi non sia uno scalare.

Esiste una variante alternativa con supporto di trasmissione in dimensioni diverse per Max:

Max(lhs,rhs, broadcast_dimensions)

Questa variante dell'operazione deve essere utilizzata per le operazioni aritmetiche tra array di ranghi diversi (ad esempio l'aggiunta di una matrice a un vettore).

L'operando broadcast_dimensions aggiuntivo è una sezione di numeri interi che specifica le dimensioni da utilizzare per la trasmissione degli operandi. La semantica è descritta in dettaglio nella pagina di trasmissione.

Per informazioni su StableHLO, consulta StableHLO - massimo.

Min

Vedi anche XlaBuilder::Min.

Esegue l'operazione min elemento per elemento su lhs e rhs.

Min(lhs, rhs)

Le forme degli argomenti devono essere simili o compatibili. Consulta la documentazione sulla trasmissione per scoprire cosa significa che le forme sono compatibili. Il risultato di un'operazione ha una forma che è il risultato della trasmissione dei due array di input. In questa variante, le operazioni tra array di ranghi diversi non sono supportate, a meno che uno degli operandi non sia uno scalare.

Esiste una variante alternativa con supporto della trasmissione multidimensionale per Min:

Min(lhs,rhs, broadcast_dimensions)

Questa variante dell'operazione deve essere utilizzata per le operazioni aritmetiche tra array di ranghi diversi (ad esempio l'aggiunta di una matrice a un vettore).

L'operando broadcast_dimensions aggiuntivo è una sezione di numeri interi che specifica le dimensioni da utilizzare per la trasmissione degli operandi. La semantica è descritta in dettaglio nella pagina di trasmissione.

Per informazioni su StableHLO, vedi StableHLO - minimo.

Mul

Vedi anche XlaBuilder::Mul.

Esegue il prodotto elemento per elemento di lhs e rhs.

Mul(lhs, rhs)

Le forme degli argomenti devono essere simili o compatibili. Consulta la documentazione sulla trasmissione per scoprire cosa significa che le forme sono compatibili. Il risultato di un'operazione ha una forma che è il risultato della trasmissione dei due array di input. In questa variante, le operazioni tra array di ranghi diversi non sono supportate, a meno che uno degli operandi non sia uno scalare.

Esiste una variante alternativa con supporto per la trasmissione multidimensionale per Mul:

Mul(lhs,rhs, broadcast_dimensions)

Questa variante dell'operazione deve essere utilizzata per le operazioni aritmetiche tra array di ranghi diversi (ad esempio l'aggiunta di una matrice a un vettore).

L'operando broadcast_dimensions aggiuntivo è una sezione di numeri interi che specifica le dimensioni da utilizzare per la trasmissione degli operandi. La semantica è descritta in dettaglio nella pagina di trasmissione.

Per informazioni su StableHLO, vedi StableHLO - multiply.

Neg

Vedi anche XlaBuilder::Neg.

Negazione elemento per elemento x -> -x.

Neg(operand)

Per informazioni su StableHLO, vedi StableHLO - negate

No

Vedi anche XlaBuilder::Not.

Negazione logica elemento per elemento x -> !(x).

Not(operand)

Per informazioni su StableHLO, vedi StableHLO - not.

OptimizationBarrier

Vedi anche XlaBuilder::OptimizationBarrier.

Impedisce a qualsiasi passaggio di ottimizzazione di spostare i calcoli oltre la barriera.

OptimizationBarrier(operand)

Garantisce che tutti gli input vengano valutati prima di qualsiasi operatore che dipende dagli output della barriera.

Per informazioni su StableHLO, vedi StableHLO - optimization_barrier.

Oppure

Vedi anche XlaBuilder::Or.

Esegue l'operazione OR elemento per elemento di lhs e rhs .

Or(lhs, rhs)

Le forme degli argomenti devono essere simili o compatibili. Consulta la documentazione sulla trasmissione per scoprire cosa significa che le forme sono compatibili. Il risultato di un'operazione ha una forma che è il risultato della trasmissione dei due array di input. In questa variante, le operazioni tra array di ranghi diversi non sono supportate, a meno che uno degli operandi non sia uno scalare.

Esiste una variante alternativa con supporto per la trasmissione in diverse dimensioni per Or:

Or(lhs,rhs, broadcast_dimensions)

Questa variante dell'operazione deve essere utilizzata per le operazioni aritmetiche tra array di ranghi diversi (ad esempio l'aggiunta di una matrice a un vettore).

L'operando broadcast_dimensions aggiuntivo è una sezione di numeri interi che specifica le dimensioni da utilizzare per la trasmissione degli operandi. La semantica è descritta in dettaglio nella pagina di trasmissione.

Per informazioni su StableHLO, vedi StableHLO - or.

Uscita

Vedi anche XlaBuilder::Outfeed.

Scrive gli input nel feed di output.

Outfeed(operand, shape_with_layout, outfeed_config)

shape_with_layout comunica la forma disposta che vogliamo estrarre.

Per informazioni su StableHLO, consulta StableHLO - outfeed.

Pad

Vedi anche XlaBuilder::Pad.

Pad(operand, padding_value, padding_config)

Espande l'array operand specificato aggiungendo un riempimento intorno all'array e tra gli elementi dell'array con il valore padding_value specificato. padding_config specifica la quantità di spaziatura interna del bordo e la spaziatura interna per ogni dimensione.

PaddingConfig è un campo ripetuto di PaddingConfigDimension, che contiene tre campi per ogni dimensione: edge_padding_low, edge_padding_high e interior_padding.

edge_padding_low e edge_padding_high specificano la quantità di spaziatura interna aggiunta all'estremità inferiore (accanto all'indice 0) e all'estremità superiore (accanto all'indice più alto) di ogni dimensione rispettivamente. L'importo del padding del bordo può essere negativo. Il valore assoluto del padding negativo indica il numero di elementi da rimuovere dalla dimensione specificata.

interior_padding specifica la quantità di spaziatura interna aggiunta tra due elementi in ogni dimensione; non può essere negativa. Il padding interno viene applicato logicamente prima del padding dei bordi, quindi in caso di padding dei bordi negativo, gli elementi vengono rimossi dall'operando con padding interno.

Questa operazione è un'operazione no-op se tutte le coppie di padding dei bordi sono (0, 0) e tutti i valori di padding interni sono 0. La figura seguente mostra esempi di diversi valori di edge_padding e interior_padding per un array bidimensionale.

Per informazioni su StableHLO, vedi StableHLO - pad.

Parametro

Vedi anche XlaBuilder::Parameter.

Parameter rappresenta un input di argomento per un calcolo.

PartitionID

Vedi anche XlaBuilder::BuildPartitionId.

Produce partition_id del processo corrente.

PartitionID(shape)

PartitionID può essere visualizzato nei dump HLO, ma non è destinato a essere creato manualmente dagli utenti finali.

Per informazioni su StableHLO, vedi StableHLO - partition_id.

PopulationCount

Vedi anche XlaBuilder::PopulationCount.

Calcola il numero di bit impostati in ogni elemento di operand.

PopulationCount(operand)

Per informazioni su StableHLO, vedi StableHLO - popcnt.

Pow

Vedi anche XlaBuilder::Pow.

Esegue l'elevamento a potenza elemento per elemento di lhs per rhs.

Pow(lhs, rhs)

Le forme degli argomenti devono essere simili o compatibili. Consulta la documentazione sulla trasmissione per scoprire cosa significa che le forme sono compatibili. Il risultato di un'operazione ha una forma che è il risultato della trasmissione dei due array di input. In questa variante, le operazioni tra array di ranghi diversi non sono supportate, a meno che uno degli operandi non sia uno scalare.

Esiste una variante alternativa con supporto di trasmissione di dimensioni diverse per Pow:

Pow(lhs,rhs, broadcast_dimensions)

Questa variante dell'operazione deve essere utilizzata per le operazioni aritmetiche tra array di ranghi diversi (ad esempio l'aggiunta di una matrice a un vettore).

L'operando broadcast_dimensions aggiuntivo è una sezione di numeri interi che specifica le dimensioni da utilizzare per la trasmissione degli operandi. La semantica è descritta in dettaglio nella pagina di trasmissione.

Per informazioni su StableHLO, vedi StableHLO - power.

Reale

Vedi anche XlaBuilder::Real.

Parte reale elemento per elemento di una forma complessa (o reale). x -> real(x). Se l'operando è un tipo con virgola mobile, Real restituisce lo stesso valore.

Real(operand)

Per informazioni su StableHLO, vedi StableHLO - real.

Ricevuto

Vedi anche XlaBuilder::Recv.

Recv, RecvWithTokens e RecvToHost sono operazioni che fungono da primitive di comunicazione in HLO. Queste operazioni in genere vengono visualizzate nei dump HLO come parte di input/output di basso livello o trasferimento tra dispositivi, ma non sono destinate a essere create manualmente dagli utenti finali.

Recv(shape, handle)

Riceve i dati della forma specificata da un'istruzione Send in un altro calcolo che condivide lo stesso handle del canale. Restituisce un XlaOp per i dati ricevuti.

Per informazioni su StableHLO, vedi StableHLO - recv.

RecvDone

Vedi anche HloInstruction::CreateRecv e HloInstruction::CreateRecvDone.

Analogamente a Send, l'API client dell'operazione Recv rappresenta la comunicazione sincrona. Tuttavia, l'istruzione viene scomposta internamente in due istruzioni HLO (Recv e RecvDone) per consentire i trasferimenti di dati asincroni.

Recv(const Shape& shape, int64 channel_id)

Alloca le risorse necessarie per ricevere i dati da un'istruzione Send con lo stesso channel_id. Restituisce un contesto per le risorse allocate, che viene utilizzato da un'istruzione RecvDone successiva per attendere il completamento del trasferimento dei dati. Il contesto è una tupla di {buffer di ricezione (forma), identificatore della richiesta (U32)} e può essere utilizzato solo da un'istruzione RecvDone.

Dato un contesto creato da un'istruzione Recv, attende il completamento del trasferimento dei dati e restituisce i dati ricevuti.

Riduci

Vedi anche XlaBuilder::Reduce.

Applica una funzione di riduzione a uno o più array in parallelo.

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

Dove:

• N deve essere maggiore o uguale a 1.
• Il calcolo deve essere "approssimativamente" associativo (vedi sotto).
• Tutti gli array di input devono avere le stesse dimensioni.
• Tutti i valori iniziali devono formare un'identità in computation.
• Se N = 1, Collate(T) è T.
• Se N > 1, Collate(T_0, ..., T_{N-1}) è una tupla di N elementi di tipo T.

Questa operazione riduce una o più dimensioni di ogni array di input in scalari. Il numero di dimensioni di ogni matrice restituita è number_of_dimensions(operand) - len(dimensions). L'output dell'operazione è Collate(Q_0, ..., Q_N), dove Q_i è un array di tipo T_i, le cui dimensioni sono descritte di seguito.

A diversi backend è consentito riassociare il calcolo della riduzione. Ciò può portare a differenze numeriche, poiché alcune funzioni di riduzione come l'addizione non sono associative per i numeri in virgola mobile. Tuttavia, se l'intervallo dei dati è limitato, l'addizione in virgola mobile è sufficientemente associativa per la maggior parte degli usi pratici.

Per informazioni su StableHLO, vedi StableHLO - reduce.

Esempi

Quando si riduce una dimensione in un singolo array 1D con valori [10, 11, 12, 13], con la funzione di riduzione f (ovvero computation), il risultato può essere calcolato come

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

ma ci sono anche molte altre possibilità, ad esempio:

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

Di seguito è riportato un esempio di pseudo-codice approssimativo di come potrebbe essere implementata la riduzione, utilizzando la somma come calcolo della riduzione con un valore iniziale di 0.

result_shape <- remove all dims in dimensions from operand_shape

# Iterate over all elements in result_shape. The number of r's here is equal
# to the number of dimensions of the result.
for r0 in range(result_shape[0]), r1 in range(result_shape[1]), ...:
  # Initialize this result element
  result[r0, r1...] <- 0

  # Iterate over all the reduction dimensions
  for d0 in range(dimensions[0]), d1 in range(dimensions[1]), ...:
    # Increment the result element with the value of the operand's element.
    # The index of the operand's element is constructed from all ri's and di's
    # in the right order (by construction ri's and di's together index over the
    # whole operand shape).
    result[r0, r1...] += operand[ri... di]

Ecco un esempio di riduzione di un array bidimensionale (matrice). La forma ha 2 dimensioni, la dimensione 0 di dimensione 2 e la dimensione 1 di dimensione 3:

Risultati della riduzione delle dimensioni 0 o 1 con una funzione "add":

Tieni presente che entrambi i risultati della riduzione sono array 1D. Il diagramma mostra una come colonna e l'altra come riga solo per comodità visiva.

Per un esempio più complesso, ecco un array 3D. Il numero di dimensioni è 3, la dimensione 0 è di 4, la dimensione 1 è di 2 e la dimensione 2 è di 3. Per semplicità, i valori da 1 a 6 vengono replicati nella dimensione 0.

Analogamente all'esempio 2D, possiamo ridurre una sola dimensione. Se riduciamo la dimensione 0, ad esempio, otteniamo un array bidimensionale in cui tutti i valori della dimensione 0 sono stati ripiegati in uno scalare:

|  4   8  12 |
| 16  20  24 |

Se riduciamo la dimensione 2, otteniamo anche un array bidimensionale in cui tutti i valori della dimensione 2 sono stati ripiegati in uno scalare:

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

Tieni presente che l'ordine relativo tra le dimensioni rimanenti nell'input viene mantenuto nell'output, ma ad alcune dimensioni potrebbero essere assegnati nuovi numeri (poiché il numero di dimensioni cambia).

Possiamo anche ridurre più dimensioni. L'aggiunta delle dimensioni 0 e 1 produce l'array 1D [20, 28, 36].

La riduzione dell'array 3D in tutte le sue dimensioni produce lo scalare 84.

Variadic Reduce

Quando N > 1, la riduzione dell'applicazione della funzione è leggermente più complessa, in quanto viene applicata contemporaneamente a tutti gli input. Gli operandi vengono forniti al calcolo nel seguente ordine:

• Esecuzione del valore ridotto per il primo operando
• …
• Esecuzione del valore ridotto per l'ennesimo operando
• Valore di input per il primo operando
• …
• Valore di input per l'ennesimo operando

Ad esempio, considera la seguente funzione di riduzione, che può essere utilizzata per calcolare il massimo e l'argmax di un array 1D in parallelo:

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

Per gli array di input 1D V = Float[N], K = Int[N] e i valori iniziali I_V = Float, I_K = Int, il risultato f_(N-1) della riduzione nell'unica dimensione di input è equivalente alla seguente applicazione ricorsiva:

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

Se applichi questa riduzione a un array di valori e a un array di indici sequenziali (ad es. iota), gli array verranno iterati congiuntamente e verrà restituita una tupla contenente il valore massimo e l'indice corrispondente.

ReducePrecision

Vedi anche XlaBuilder::ReducePrecision.

Modella l'effetto della conversione dei valori in virgola mobile in un formato a precisione inferiore (ad esempio IEEE-FP16) e di nuovo nel formato originale. Il numero di bit di esponente e mantissa nel formato a precisione inferiore può essere specificato arbitrariamente, anche se tutte le dimensioni dei bit potrebbero non essere supportate in tutte le implementazioni hardware.

ReducePrecision(operand, exponent_bits, mantissa_bits)

Il risultato è un array di tipo T. I valori di input vengono arrotondati al valore rappresentabile più vicino con il numero specificato di bit della mantissa (utilizzando la semantica "ties to even"), e tutti i valori che superano l'intervallo specificato dal numero di bit dell'esponente vengono bloccati su infinito positivo o negativo. NaN vengono conservati, anche se potrebbero essere convertiti in valori NaN canonici.

Il formato a precisione inferiore deve avere almeno un bit esponente (per distinguere un valore zero da un valore infinito, poiché entrambi hanno una mantissa zero) e deve avere un numero non negativo di bit mantissa. Il numero di bit dell'esponente o della mantissa potrebbe superare il valore corrispondente per il tipo T; la parte corrispondente della conversione è quindi semplicemente un'operazione no-op.

Per informazioni su StableHLO, vedi StableHLO - reduce_precision.

ReduceScatter

Vedi anche XlaBuilder::ReduceScatter.

ReduceScatter è un'operazione collettiva che esegue in modo efficace un'operazione AllReduce e poi distribuisce il risultato dividendolo in shard_count blocchi lungo scatter_dimension e la replica i nel gruppo di repliche riceve lo shard ith.

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

• Quando operand è una tupla di array, la riduzione e la dispersione vengono eseguite su ciascun elemento della tupla.
• replica_groups è un elenco di gruppi di repliche tra cui viene eseguita la riduzione (l'ID replica per la replica corrente può essere recuperato utilizzando ReplicaId). L'ordine delle repliche in ogni gruppo determina l'ordine in cui verrà distribuito il risultato di all-reduce. replica_groups deve essere vuoto (nel qual caso tutte le repliche appartengono a un unico gruppo) o contenere lo stesso numero di elementi del numero di repliche. Quando sono presenti più gruppi di repliche, devono avere tutti le stesse dimensioni. Ad esempio, replica_groups = {0, 2}, {1, 3} esegue la riduzione tra le repliche 0 e 2 e 1 e 3, quindi distribuisce il risultato.
• shard_count è la dimensione di ogni gruppo di repliche. Ciò è necessario nei casi in cui replica_groups sono vuoti. Se replica_groups non è vuoto, shard_count deve essere uguale alla dimensione di ogni gruppo di repliche.
• channel_id viene utilizzato per la comunicazione tra moduli: solo le operazioni reduce-scatter con lo stesso channel_id possono comunicare tra loro.
• layout Per saperne di più sui layout, consulta xla::shapes.
• use_global_device_ids è un flag specificato dall'utente. Quando false(impostazione predefinita) i numeri in replica_groups sono ReplicaId quando true replica_groups rappresentano un ID globale di (ReplicaID*partition_count + partition_id). Ad esempio:
  • Con 2 repliche e 4 partizioni,
  • replica_groups={ {0,1,4,5},{2,3,6,7} } and use_global_device_ids=true
  • group[0] = (0,0), (0,1), (1,0), (1,1)
  • group[1] = (0,2), (0,3), (1,2), (1,3)
  • dove ogni coppia è (replica_id, partition_id).

La forma di output è la forma di input con il scatter_dimension reso shard_count volte più piccolo. Ad esempio, se ci sono due repliche e l'operando ha rispettivamente i valori [1.0, 2.25] e [3.0, 5.25] nelle due repliche, il valore di output di questa operazione in cui scatter_dim è 0 sarà [4.0] per la prima replica e [7.5] per la seconda replica.

Per informazioni su StableHLO, vedi StableHLO - reduce_scatter.

ReduceScatter - Example 1 - StableHLO

Nell'esempio precedente, ci sono due repliche che partecipano a ReduceScatter. Su ogni replica, l'operando ha forma f32[2,4]. Viene eseguita una riduzione totale (somma) tra le repliche, producendo un valore ridotto di forma f32[2,4] su ogni replica. Questo valore ridotto viene poi suddiviso in due parti lungo la dimensione 1, quindi ogni parte ha forma f32[2,2]. Ogni replica all'interno del gruppo di processi riceve la parte corrispondente alla sua posizione nel gruppo. Di conseguenza, l'output di ogni replica ha forma f32[2,2].

ReduceWindow

Vedi anche XlaBuilder::ReduceWindow.

Applica una funzione di riduzione a tutti gli elementi di ogni finestra di una sequenza di array multidimensionali N, producendo come output un singolo array multidimensionale o una tupla di array multidimensionali N. Ogni array di output ha lo stesso numero di elementi del numero di posizioni valide della finestra. Un livello di pooling può essere espresso come ReduceWindow. Analogamente a Reduce, l'computation applicato viene sempre passato all'init_values sul lato sinistro.

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

Dove:

• N deve essere maggiore o uguale a 1.
• Tutti gli array di input devono avere le stesse dimensioni.
• Se N = 1, Collate(T) è T.
• Se N > 1, Collate(T_0, ..., T_{N-1}) è una tupla di N elementi di tipo (T0,...T{N-1}).

Per informazioni su StableHLO, vedi StableHLO - reduce_window.

ReduceWindow - Example 1

L'input è una matrice di dimensioni [4x6] e sia window_dimensions che window_stride_dimensions sono [2x3].

// Create a computation for the reduction (maximum).
XlaComputation max;
{
  XlaBuilder builder(client_, "max");
  auto y = builder.Parameter(0, ShapeUtil::MakeShape(F32, {}), "y");
  auto x = builder.Parameter(1, ShapeUtil::MakeShape(F32, {}), "x");
  builder.Max(y, x);
  max = builder.Build().value();
}

// Create a ReduceWindow computation with the max reduction computation.
XlaBuilder builder(client_, "reduce_window_2x3");
auto shape = ShapeUtil::MakeShape(F32, {4, 6});
auto input = builder.Parameter(0, shape, "input");
builder.ReduceWindow(
    input,
    /*init_val=*/builder.ConstantLiteral(LiteralUtil::MinValue(F32)),
    *max,
    /*window_dimensions=*/{2, 3},
    /*window_stride_dimensions=*/{2, 3},
    Padding::kValid);