Semantyka operacji

Poniżej opisujemy semantykę operacji zdefiniowanych w interfejsie XlaBuilder. Zazwyczaj te operacje są mapowane 1:1 na operacje zdefiniowane w interfejsie RPC w xla_data.proto.

Uwaga dotycząca nazewnictwa: uogólniony typ danych XLA to tablica N-wymiarowa zawierająca elementy tego samego typu (np. 32-bitowe liczby zmiennoprzecinkowe). W dokumentacji termin tablica oznacza tablicę o dowolnej liczbie wymiarów. Dla wygody w przypadku szczególnych przypadków używane są bardziej szczegółowe i znane nazwy. Na przykład wektor to tablica jednowymiarowa, a macierz to tablica dwuwymiarowa.

Dowiedz się więcej o strukturze operacji w sekcjach Kształty i układ oraz Układ kafelkowy.

Brzuch

Zobacz też XlaBuilder::Abs.

Wartość bezwzględna każdego elementu x -> |x|.

Abs(operand)

Informacje o StableHLO znajdziesz w artykule StableHLO – abs.

Dodaj

Zobacz też XlaBuilder::Add.

Wykonuje dodawanie elementów lhs i rhs.

Add(lhs, rhs)

Kształty argumentów muszą być podobne lub zgodne. Więcej informacji o tym, co oznacza zgodność kształtów, znajdziesz w dokumentacji dotyczącej rozgłaszania. Wynik operacji ma kształt, który jest wynikiem rozgłaszania dwóch tablic wejściowych. W tym wariancie operacje między tablicami o różnych rangach nie są obsługiwane, chyba że jeden z operandów jest skalarem.

Istnieje alternatywny wariant z obsługą transmisji w różnych wymiarach w przypadku dodatku:

Add(lhs,rhs, broadcast_dimensions)

Ten wariant operacji należy stosować w przypadku działań arytmetycznych na tablicach o różnych rangach (np. dodawania macierzy do wektora).

Dodatkowy operand broadcast_dimensions to wycinek liczb całkowitych określający wymiary, które mają być używane do rozgłaszania operandów. Semantyka jest szczegółowo opisana na stronie dotyczącej transmisji.

Więcej informacji o StableHLO znajdziesz w artykule StableHLO – dodawanie.

AddDependency

Zobacz też HloInstruction::AddDependency.

AddDependency może pojawiać się w zrzutach HLO, ale nie jest przeznaczony do ręcznego tworzenia przez użytkowników.

AfterAll

Zobacz też XlaBuilder::AfterAll.

Funkcja AfterAll przyjmuje zmienną liczbę tokenów i zwraca jeden token. Tokeny to typy pierwotne, które można przekazywać między operacjami wywołującymi efekty uboczne, aby wymusić kolejność. AfterAll może być używany jako łącznik tokenów do zamawiania operacji po wykonaniu zestawu operacji.

AfterAll(tokens)

Więcej informacji o StableHLO znajdziesz w artykule StableHLO - after_all.

AllGather

Zobacz też XlaBuilder::AllGather.

Wykonuje konkatenację między replikami.

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

• replica_groups to lista grup replik, między którymi wykonywana jest konkatenacja (identyfikator repliki dla bieżącej repliki można pobrać za pomocą funkcji ReplicaId). Kolejność replik w każdej grupie określa kolejność, w jakiej ich dane wejściowe znajdują się w wyniku. replica_groups musi być puste (w takim przypadku wszystkie repliki należą do jednej grupy, uporządkowanej od 0 do N - 1) lub zawierać tyle samo elementów co liczba replik. Na przykład replica_groups = {0, 2}, {1, 3} wykonuje konkatenację między replikami 0 i 2 oraz 1 i 3.
• shard_count to rozmiar każdej grupy replik. Jest to potrzebne w przypadku, gdy pole replica_groups jest puste.
• channel_id służy do komunikacji między modułami: tylko operacje all-gather z tym samym channel_id mogą się ze sobą komunikować.
• use_global_device_ids Zwraca wartość „prawda”, jeśli identyfikatory w konfiguracji ReplicaGroup reprezentują identyfikator globalny (replica_id * partition_count + partition_id) zamiast identyfikatora repliki. Umożliwia to bardziej elastyczne grupowanie urządzeń, jeśli ta operacja all-reduce jest wykonywana zarówno w różnych partycjach, jak i w różnych replikach.

Kształt wyjściowy to kształt wejściowy powiększony all_gather_dimensionshard_count razy. Jeśli na przykład są 2 repliki, a operand ma odpowiednio wartości [1.0, 2.5] i [3.0, 5.25] na tych 2 replikach, to wartość wyjściowa tego działania, w którym all_gather_dim to 0, będzie wynosić [1.0, 2.5, 3.0,5.25] na obu replikach.

Interfejs API funkcji AllGather jest wewnętrznie rozkładany na 2 instrukcje HLO (AllGatherStart i AllGatherDone).

Zobacz też HloInstruction::CreateAllGatherStart.

AllGatherStart, AllGatherDone służą jako elementy podstawowe w HLO. Te operacje mogą pojawiać się w zrzutach HLO, ale nie są przeznaczone do ręcznego tworzenia przez użytkowników.

Informacje o StableHLO znajdziesz w artykule StableHLO – all_gather.

AllReduce

Zobacz też XlaBuilder::AllReduce.

Wykonuje obliczenia niestandardowe na replikach.

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

• Gdy operand jest krotką tablic, operacja all-reduce jest wykonywana na każdym elemencie krotki.
• replica_groups to lista grup replik, między którymi przeprowadzane jest zmniejszanie (identyfikator repliki bieżącej można pobrać za pomocą ReplicaId). replica_groups musi być pusta (w takim przypadku wszystkie repliki należą do jednej grupy) lub zawierać tyle elementów, ile jest replik. Na przykład replica_groups = {0, 2}, {1, 3} przeprowadza zmniejszanie między replikami 0 i 2 oraz 1 i 3.
• channel_id służy do komunikacji między modułami: tylko operacje all-reduce z tym samym channel_id mogą się ze sobą komunikować.
• shape_with_layout: wymusza układ operacji AllReduce. Jest używany, aby zagwarantować ten sam układ w przypadku grupy operacji AllReduce skompilowanych oddzielnie.
• use_global_device_ids Zwraca wartość „prawda”, jeśli identyfikatory w konfiguracji ReplicaGroup reprezentują identyfikator globalny (replica_id * partition_count + partition_id) zamiast identyfikatora repliki. Umożliwia to bardziej elastyczne grupowanie urządzeń, jeśli ta operacja all-reduce jest wykonywana zarówno w różnych partycjach, jak i w różnych replikach.

Kształt danych wyjściowych jest taki sam jak kształt danych wejściowych. Jeśli na przykład są 2 repliki, a operand ma wartość [1.0, 2.5] i [3.0, 5.25] odpowiednio na 2 replikach, to wartość wyjściowa tej operacji i obliczenia sumy wyniesie [4.0, 7.75] na obu replikach. Jeśli dane wejściowe są krotką, dane wyjściowe też będą krotką.

Obliczenie wyniku AllReduce wymaga danych wejściowych z każdej repliki, więc jeśli jedna replika wykona węzeł AllReduce więcej razy niż inna, pierwsza replika będzie czekać w nieskończoność. Ponieważ repliki uruchamiają ten sam program, nie ma wielu sposobów na to, aby tak się stało, ale jest to możliwe, gdy warunek pętli while zależy od danych z infeed, a dane z infeed powodują, że pętla while wykonuje więcej iteracji na jednej replice niż na innej.

Interfejs API funkcji AllReduce jest wewnętrznie rozkładany na 2 instrukcje HLO (AllReduceStart i AllReduceDone).

Zobacz też HloInstruction::CreateAllReduceStart.

AllReduceStart i AllReduceDone to elementy podstawowe w HLO. Te operacje mogą pojawiać się w zrzutach HLO, ale nie są przeznaczone do ręcznego tworzenia przez użytkowników.

CrossReplicaSum

Zobacz też XlaBuilder::CrossReplicaSum.

Wykonuje AllReduce z obliczeniem sumy.

CrossReplicaSum(operand, replica_groups)

Zwraca sumę wartości operandu w każdej podgrupie replik. Wszystkie repliki dostarczają jeden element wejściowy do sumy, a wszystkie repliki otrzymują wynikową sumę dla każdej podgrupy.

AllToAll

Zobacz też XlaBuilder::AllToAll.

AllToAll to operacja zbiorowa, która wysyła dane ze wszystkich rdzeni do wszystkich rdzeni. Składa się z 2 faz:

1. Faza rozproszenia. Na każdym rdzeniu operand jest dzielony na split_count bloków wzdłuż osi split_dimensions, a bloki są rozpraszane na wszystkie rdzenie, np. i-ty blok jest wysyłany do i-tego rdzenia.
2. Faza zbierania. Każdy rdzeń łączy otrzymane bloki wzdłuż osiconcat_dimension.

Uczestniczące rdzenie można skonfigurować:

• replica_groups: każda grupa replik zawiera listę identyfikatorów replik uczestniczących w obliczeniach (identyfikator repliki dla bieżącej repliki można pobrać za pomocą funkcji ReplicaId). Funkcja AllToAll będzie stosowana w podgrupach w określonej kolejności. Na przykład replica_groups = { {1,2,3}, {4,5,0} } oznacza, że funkcja AllToAll będzie stosowana w replikach {1, 2, 3} w fazie zbierania, a otrzymane bloki będą łączone w tej samej kolejności, czyli 1, 2, 3. Następnie funkcja AllToAll będzie stosowana w replikach 4, 5, 0, a kolejność łączenia będzie również wynosić 4, 5, 0. Jeśli replica_groups jest pusta, wszystkie repliki należą do jednej grupy w kolejności łączenia odpowiadającej kolejności ich występowania.

Wymagania wstępne:

• Rozmiar wymiaru operandu w split_dimension jest podzielny przez split_count.
• Kształt operandu nie jest krotką.

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

Więcej informacji o kształtach i układach znajdziesz w xla::shapes.

Więcej informacji o StableHLO znajdziesz w artykule StableHLO – all_to_all.

AllToAll – przykład 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);

W przykładzie powyżej w operacji Alltoall uczestniczą 4 rdzenie. Na każdym rdzeniu operand jest dzielony na 4 części wzdłuż wymiaru 1, więc każda część ma kształt f32[4,4]. 4 części są rozproszone na wszystkie rdzenie. Następnie każdy rdzeń łączy otrzymane części wzdłuż wymiaru 0 w kolejności rdzeń 0–4. Dane wyjściowe na każdym rdzeniu mają kształt f32[16,4].

AllToAll - Example 2 - StableHLO

W przykładzie powyżej w operacji AllToAll uczestniczą 2 repliki. Na każdej replice operand ma kształt f32[2,4]. Operand jest dzielony na 2 części wzdłuż wymiaru 1, więc każda część ma kształt f32[2,2]. Następnie te 2 części są wymieniane między replikami zgodnie z ich pozycją w grupie replik. Każda replika pobiera odpowiednią część z obu operandów i łączy je wzdłuż wymiaru 0. W rezultacie dane wyjściowe na każdej replice mają kształt f32[4,2].

RaggedAllToAll

Zobacz też XlaBuilder::RaggedAllToAll.

RaggedAllToAll wykonuje zbiorową operację all-to-all, w której dane wejściowe i wyjściowe są tensorami poszarpanymi.

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

Poszarpane tensory są zdefiniowane przez zestaw 3 tensorów:

• data: tensor data jest „nierówny” wzdłuż najbardziej zewnętrznego wymiaru, wzdłuż którego każdy indeksowany element ma zmienny rozmiar.
• offsets: tensor offsets indeksuje najbardziej zewnętrzny wymiar tensora data i reprezentuje początkowe przesunięcie każdego nierównego elementu tensora data.
• sizes: tensor sizes reprezentuje rozmiar każdego nierównego elementu tensora data, przy czym rozmiar jest określony w jednostkach elementów podrzędnych. Podrzędny element jest zdefiniowany jako sufiks kształtu tensora „data” uzyskany przez usunięcie najbardziej zewnętrznego „nierównego” wymiaru.
• Tensory offsets i sizes muszą mieć ten sam rozmiar.

Przykładowy tensor poszarpany:

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 musi być podzielony w taki sposób, aby każda replika miała przesunięcia z perspektywy wyjściowej repliki docelowej.

W przypadku i-tego przesunięcia wyjściowego bieżąca replika wyśle aktualizację input[input_offsets[i]:input_offsets[i]+send_sizes[i]] do i-tej repliki, która zostanie zapisana w output_i[output_offsets[i]:output_offsets[i]+send_sizes[i]] w i-tej replice output.

Jeśli na przykład mamy 2 repliki:

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]

Funkcja ragged all-to-all HLO ma te argumenty:

• input: nierówny tensor danych wejściowych.
• output: tensor wyjściowy z nierównymi wymiarami.
• input_offsets: tensor przesunięć wejściowych o nieregularnym kształcie.
• send_sizes: tensor z nierównymi rozmiarami wysyłania.
• output_offsets: tablica nierównych przesunięć w danych wyjściowych repliki docelowej.
• recv_sizes: tensor z nierównymi rozmiarami odbioru.

Tensory *_offsets i *_sizes muszą mieć ten sam kształt.

W przypadku tensorów *_offsets i *_sizes obsługiwane są 2 kształty:

• [num_devices], gdzie ragged-all-to-all może wysłać co najwyżej 1 aktualizację do każdego urządzenia zdalnego w grupie replik. Na przykład:

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], gdzie ragged-all-to-all może wysyłać do num_updates aktualizacji tego samego urządzenia zdalnego (każda z innym przesunięciem) dla każdego urządzenia zdalnego w grupie replik.

Na przykład:

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

I

Zobacz też XlaBuilder::And.

Wykonuje operację AND na poszczególnych elementach 2 tensorów lhs i rhs.

And(lhs, rhs)

Kształty argumentów muszą być podobne lub zgodne. Więcej informacji o tym, co oznacza zgodność kształtów, znajdziesz w dokumentacji dotyczącej rozgłaszania. Wynik operacji ma kształt, który jest wynikiem rozgłaszania dwóch tablic wejściowych. W tym wariancie operacje między tablicami o różnych rangach nie są obsługiwane, chyba że jeden z operandów jest skalarem.

Istnieje alternatywna odmiana z obsługą transmisji w różnych wymiarach dla warunku:

And(lhs,rhs, broadcast_dimensions)

Ten wariant operacji należy stosować w przypadku działań arytmetycznych na tablicach o różnych rangach (np. dodawania macierzy do wektora).

Dodatkowy operand broadcast_dimensions to wycinek liczb całkowitych określający wymiary, które mają być używane do rozgłaszania operandów. Semantyka jest szczegółowo opisana na stronie dotyczącej transmisji.

Więcej informacji o StableHLO znajdziesz w artykule StableHLO – i.

Dane asynchroniczne

Zobacz też HloInstruction::CreateAsyncStart,HloInstruction::CreateAsyncUpdate,HloInstruction::CreateAsyncDone.

AsyncDone, AsyncStart i AsyncUpdate to wewnętrzne instrukcje HLO używane w operacjach asynchronicznych, które służą jako elementy podstawowe w HLO. Te operacje mogą pojawiać się w zrzutach HLO, ale nie są przeznaczone do ręcznego tworzenia przez użytkowników.

Atan2

Zobacz też XlaBuilder::Atan2.

Wykonuje operację atan2 na poszczególnych elementach tensorów lhs i rhs.

Atan2(lhs, rhs)

Kształty argumentów muszą być podobne lub zgodne. Więcej informacji o tym, co oznacza zgodność kształtów, znajdziesz w dokumentacji dotyczącej rozgłaszania. Wynik operacji ma kształt, który jest wynikiem rozgłaszania dwóch tablic wejściowych. W tym wariancie operacje między tablicami o różnych rangach nie są obsługiwane, chyba że jeden z operandów jest skalarem.

Istnieje alternatywny wariant funkcji Atan2, który obsługuje transmisję w różnych wymiarach:

Atan2(lhs,rhs, broadcast_dimensions)

Ten wariant operacji należy stosować w przypadku działań arytmetycznych na tablicach o różnych rangach (np. dodawania macierzy do wektora).

Dodatkowy operand broadcast_dimensions to wycinek liczb całkowitych określający wymiary, które mają być używane do rozgłaszania operandów. Semantyka jest szczegółowo opisana na stronie dotyczącej transmisji.

Więcej informacji o StableHLO znajdziesz w artykule StableHLO – atan2.

BatchNormGrad

Szczegółowy opis algorytmu znajdziesz też w XlaBuilder::BatchNormGrad i oryginalnym artykule na temat normalizacji wsadowej.

Oblicza gradienty normalizacji wsadowej.

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

W przypadku każdej cechy w wymiarze cech (feature_index to indeks wymiaru cech w operand) operacja oblicza gradienty względem operand, offset i scale we wszystkich pozostałych wymiarach. Parametr feature_index musi być prawidłowym indeksem wymiaru cechy w parametrze operand.

Trzy gradienty są zdefiniowane przez te wzory (przy założeniu, że tablica 4-wymiarowa to operand, indeks wymiaru cechy to l, rozmiar partii to m, a rozmiary przestrzenne to w i 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} \]

Dane wejściowe batch_mean i batch_var reprezentują wartości momentów w wymiarach partii i przestrzeni.

Typem wyjściowym jest krotka 3 uchwytów:

Więcej informacji o StableHLO znajdziesz w artykule StableHLO – batch_norm_grad.

BatchNormInference

Szczegółowy opis algorytmu znajdziesz też w XlaBuilder::BatchNormInference i oryginalnym artykule na temat normalizacji wsadowej.

Normalizuje tablicę w wymiarach partii i przestrzeni.

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

W przypadku każdej cechy w wymiarze cech (feature_index to indeks wymiaru cech w operand) operacja oblicza średnią i wariancję we wszystkich pozostałych wymiarach oraz używa średniej i wariancji do normalizacji każdego elementu w operand. Wartość feature_index musi być prawidłowym indeksem wymiaru cech w operand.

BatchNormInference jest odpowiednikiem wywołania funkcji BatchNormTraining bez obliczania wartości mean i variance dla każdej partii. Zamiast tego używa danych wejściowych mean i variance jako wartości szacunkowych. Celem tej operacji jest zmniejszenie opóźnienia w procesie wnioskowania, stąd nazwa BatchNormInference.

Wynikiem jest znormalizowana tablica n-wymiarowa o takim samym kształcie jak tablica wejściowaoperand.

Więcej informacji o StableHLO znajdziesz w artykule StableHLO – batch_norm_inference.

BatchNormTraining

Szczegółowy opis algorytmu znajdziesz też w sekcjach XlaBuilder::BatchNormTraining i the original batch normalization paper.

Normalizuje tablicę w wymiarach partii i przestrzeni.

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

W przypadku każdej cechy w wymiarze cech (feature_index to indeks wymiaru cech w operand) operacja oblicza średnią i wariancję we wszystkich pozostałych wymiarach oraz używa średniej i wariancji do normalizacji każdego elementu w operand. Wartość feature_index musi być prawidłowym indeksem wymiaru cech w operand.

Algorytm działa w ten sposób w przypadku każdej partii w operand \(x\) , która zawiera m elementy o rozmiarach wymiarów przestrzennych w i h (zakładając, że operand jest 4-wymiarową tablicą):

• Oblicza średnią wsadową \(\mu_l\) dla każdej cechy l w wymiarze cechy:\(\mu_l=\frac{1}{mwh}\sum_{i=1}^m\sum_{j=1}^w\sum_{k=1}^h x_{ijkl}\)

• Oblicza wariancję partii: \(\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$

• Normalizuje, skaluje i przesuwa:\(y_{ijkl}=\frac{\gamma_l(x_{ijkl}-\mu_l)}{\sqrt[2]{\sigma^2_l+\epsilon} }+\beta_l\)

Wartość epsilon, zwykle mała liczba, jest dodawana, aby uniknąć błędów dzielenia przez zero.

Typem wyjściowym jest krotka 3 obiektów XlaOp:

Wartości batch_mean i batch_var są momentami obliczanymi w wymiarach przestrzennych i wymiarach partii za pomocą powyższych wzorów.

Informacje o StableHLO znajdziesz w artykule StableHLO – batch_norm_training.

Bitcast

Zobacz też HloInstruction::CreateBitcast.

Bitcast mogą pojawiać się w zrzutach HLO, ale nie są przeznaczone do ręcznego tworzenia przez użytkowników.

BitcastConvertType

Zobacz też XlaBuilder::BitcastConvertType.

Podobnie jak tf.bitcast w TensorFlow wykonuje operację bitcast na poziomie elementów, przekształcając kształt danych w kształt docelowy. Rozmiar danych wejściowych i wyjściowych musi być taki sam, np. s32 elementów staje się f32 elementów w wyniku procedury bitcast, a jeden element s32 staje się czterema elementami s8. Operacja bitcast jest implementowana jako rzutowanie niskiego poziomu, więc maszyny z różnymi reprezentacjami zmiennoprzecinkowymi będą dawać różne wyniki.

BitcastConvertType(operand, new_element_type)

Wymiary operandu i kształtu docelowego muszą być zgodne, z wyjątkiem ostatniego wymiaru, który zmieni się o stosunek rozmiaru elementu przed i po konwersji.

Typy elementów źródłowych i docelowych nie mogą być krotkami.

Informacje o StableHLO znajdziesz w artykule StableHLO – bitcast_convert.

Konwersja bitcast na typ prosty o innej szerokości

BitcastConvert Instrukcja HLO obsługuje przypadek, w którym rozmiar typu elementu wyjściowego T' nie jest równy rozmiarowi elementu wejściowego T. Ponieważ cała operacja jest koncepcyjnie bitcastem i nie zmienia podstawowych bajtów, kształt elementu wyjściowego musi się zmienić. W przypadku B = sizeof(T), B' = sizeof(T') możliwe są 2 sytuacje.

Po pierwsze, gdy B > B', kształt wyjściowy otrzymuje nowy wymiar o najmniejszym znaczeniu o rozmiarze B/B'. Na przykład:

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

W przypadku efektywnych skalarów reguła pozostaje taka sama:

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

Alternatywnie w przypadku B' > B instrukcja wymaga, aby ostatni wymiar logiczny kształtu wejściowego był równy B'/B, a ten wymiar jest usuwany podczas konwersji:

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

Pamiętaj, że konwersje między różnymi szerokościami bitowymi nie są wykonywane na poszczególnych elementach.

Nadawanie

Zobacz też XlaBuilder::Broadcast.

Dodaje wymiary do tablicy, duplikując dane w tablicy.

Broadcast(operand, broadcast_sizes)

Nowe wymiary są wstawiane po lewej stronie, tzn. jeśli broadcast_sizes ma wartości {a0, ..., aN}, a kształt operandu ma wymiary {b0, ..., bM}, to kształt wyniku ma wymiary {a0, ..., aN, b0, ..., bM}.

Nowe wymiary są indeksowane w kopiach operandu, tzn.

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

Jeśli na przykład operand jest skalarem f32 o wartości 2.0f, a broadcast_sizes to {2, 3}, wynikiem będzie tablica o kształcie f32[2, 3], a wszystkie wartości w niej będą równe 2.0f.

Więcej informacji o StableHLO znajdziesz w artykule StableHLO – broadcast.

BroadcastInDim

Zobacz też XlaBuilder::BroadcastInDim.

Zwiększa rozmiar i liczbę wymiarów tablicy przez zduplikowanie danych w tablicy.

BroadcastInDim(operand, out_dim_size, broadcast_dimensions)

Podobne do funkcji Broadcast, ale umożliwia dodawanie wymiarów w dowolnym miejscu i rozszerzanie istniejących wymiarów o rozmiarze 1.

operand jest rozgłaszany do kształtu opisanego przez out_dim_size. broadcast_dimensions mapuje wymiary operand na wymiary kształtu docelowego, tzn. i-ty wymiar operandu jest mapowany na wymiar broadcast_dimension[i] kształtu wyjściowego. Wymiary operand muszą mieć rozmiar 1 lub taki sam jak wymiar w kształcie wyjściowym, na który są mapowane. Pozostałe wymiary są wypełniane wymiarami o rozmiarze 1. Rozgłaszanie wymiarów zdegenerowanych rozgłasza następnie wzdłuż tych wymiarów zdegenerowanych, aby osiągnąć kształt wyjściowy. Semantyka jest szczegółowo opisana na stronie rozgłaszania.

Połączenie

Zobacz też XlaBuilder::Call.

Wywołuje obliczenia z podanymi argumentami.

Call(computation, operands...)

Liczność i typy argumentów funkcji operands muszą być zgodne z parametrami funkcji computation. Można nie podawać wartości operands.

CompositeCall

Zobacz też XlaBuilder::CompositeCall.

Zawiera operację składającą się z innych operacji StableHLO, która przyjmuje dane wejściowe i atrybuty złożone oraz zwraca wyniki. Semantyka operacji jest implementowana przez atrybut dekompozycji. Operację złożoną można zastąpić jej dekompozycją bez zmiany semantyki programu. W przypadkach, gdy wstawienie dekompozycji nie zapewnia tej samej semantyki operacji, zalecamy użycie funkcji custom_call.

Pole wersji (domyślnie 0) służy do oznaczania, kiedy zmienia się semantyka typu złożonego.

Ta operacja jest implementowana jako kCall z atrybutem is_composite=true. Pole decomposition jest określone przez atrybut computation. Atrybuty interfejsu przechowują pozostałe atrybuty z prefiksem composite..

Przykładowe wywołanie 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)

Operacja decomposition nie jest polem, ale atrybutem to_apply, który wskazuje funkcję zawierającą implementację niższego poziomu, czyli to_apply=%funcname.

Więcej informacji o operacjach złożonych i dekompozycji znajdziesz w specyfikacji StableHLO.

Cbrt

Zobacz też XlaBuilder::Cbrt.

Operacja pierwiastka sześciennego na poszczególnych elementach x -> cbrt(x).

Cbrt(operand)

Funkcja cbrt obsługuje też opcjonalny argument result_accuracy:

Cbrt(operand, result_accuracy)

Więcej informacji o result_accuracy znajdziesz w sekcji Dokładność wyników.

Informacje o StableHLO znajdziesz w artykule StableHLO – cbrt.

ceil

Zobacz też XlaBuilder::Ceil.

Zaokrąglenie w górę poszczególnych elementów x -> ⌈x⌉.

Ceil(operand)

Więcej informacji o StableHLO znajdziesz w artykule StableHLO – ceil.

Cholesky

Zobacz też XlaBuilder::Cholesky.

Oblicza rozkład Cholesky’ego partii symetrycznych (hermitowskich) macierzy dodatnio określonych.

Cholesky(a, lower)

Jeśli lower to true, oblicza macierze dolnotrójkątne l takie, że $a = l . l^T$. Jeśli lower to false, oblicza górnotrójkątne macierze u takie, że\(a = u^T . u\).

Dane wejściowe są odczytywane tylko z dolnego lub górnego trójkąta macierzy a, w zależności od wartości lower. Wartości z drugiego trójkąta są ignorowane. Dane wyjściowe są zwracane w tym samym trójkącie. Wartości w drugim trójkącie są zdefiniowane przez implementację i mogą być dowolne.

Jeśli a ma więcej niż 2 wymiary, jest traktowany jako partia macierzy, w której wszystkie wymiary oprócz 2 mniejszych są wymiarami partii.a

Jeśli macierz a nie jest symetryczna (hermitowska) i dodatnio określona, wynik jest zdefiniowany przez implementację.

Informacje o StableHLO znajdziesz w artykule StableHLO – cholesky.

Ograniczanie zakresu

Zobacz też XlaBuilder::Clamp.

Ogranicza operand do zakresu między wartością minimalną a maksymalną.

Clamp(min, operand, max)

Na podstawie argumentu oraz wartości minimalnej i maksymalnej zwraca argument, jeśli mieści się on w zakresie między wartością minimalną a maksymalną. W przeciwnym razie zwraca wartość minimalną, jeśli argument jest mniejszy od tej wartości, lub wartość maksymalną, jeśli argument jest większy od tej wartości. Czyli clamp(a, x, b) = min(max(a, x), b).

Wszystkie 3 tablice muszą mieć ten sam kształt. Alternatywnie, jako ograniczona forma nadawania, min lub max może być skalarem typu T.

Przykład ze skalarami min i 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};

Więcej informacji o StableHLO znajdziesz w artykule StableHLO – clamp.

Zwiń

Zobacz też XlaBuilder::Collapse. oraz operację tf.reshape.

Spłaszcza wymiary tablicy do jednego wymiaru.

Collapse(operand, dimensions)

Operacja zwijania zastępuje podany podzbiór wymiarów operandu pojedynczym wymiarem. Argumentami wejściowymi są dowolna tablica typu T i wektor indeksów wymiarów stałych w czasie kompilacji. Indeksy wymiarów muszą być uporządkowanym (od najmniejszego do największego) i kolejnym podzbiorem wymiarów tensora T. Zatem {0, 1, 2}, {0, 1} i {1, 2} to prawidłowe zbiory wymiarów, ale {1, 0} i {0, 2} już nie. Zastępuje je jeden nowy wymiar w tym samym miejscu w sekwencji wymiarów co zastępowane wymiary. Rozmiar nowego wymiaru jest równy iloczynowi rozmiarów pierwotnych wymiarów. Najmniejszy numer wymiaru w dimensions to wymiar o najwolniejszych zmianach (najważniejszy) w zagnieżdżeniu pętli, które zwija te wymiary, a największy numer wymiaru to wymiar o najszybszych zmianach (najmniej ważny). Jeśli potrzebujesz bardziej ogólnego porządkowania zwijania, użyj operatora tf.reshape.

Niech na przykład v będzie tablicą 24 elementów:

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

Zobacz też XlaBuilder::Clz.

Zliczanie zer na początku każdego elementu.

Clz(operand)

CollectiveBroadcast

Zobacz też XlaBuilder::CollectiveBroadcast.

Rozsyła dane do replik. Dane są wysyłane z pierwszego identyfikatora repliki w każdej grupie do pozostałych identyfikatorów w tej samej grupie. Jeśli identyfikator repliki nie należy do żadnej grupy replik, dane wyjściowe na tej replice to tensor składający się z zer w shape.

CollectiveBroadcast(operand, replica_groups, channel_id)

Informacje o StableHLO znajdziesz w artykule StableHLO – collective_broadcast.

CollectivePermute

Zobacz też XlaBuilder::CollectivePermute.

CollectivePermute to operacja zbiorowa, która wysyła i odbiera dane między replikami.

CollectivePermute(operand, source_target_pairs, channel_id)

Pamiętaj, że w przypadku source_target_pairs obowiązują te ograniczenia:

• Żadne 2 pary nie powinny mieć tego samego identyfikatora repliki docelowej ani tego samego identyfikatora repliki źródłowej.
• Jeśli identyfikator repliki nie jest celem w żadnej parze, dane wyjściowe na tej replice to tensor składający się z zer o takim samym kształcie jak dane wejściowe.

Operacja API CollectivePermute jest wewnętrznie rozkładana na 2 instrukcje HLO (CollectivePermuteStart i CollectivePermuteDone).

Zobacz też HloInstruction::CreateCollectivePermuteStart.

CollectivePermuteStart i CollectivePermuteDone służą jako elementy podstawowe w HLO. Te operacje mogą pojawiać się w zrzutach HLO, ale nie są przeznaczone do ręcznego tworzenia przez użytkowników.

Więcej informacji o StableHLO znajdziesz w artykule StableHLO – collective_permute.

Porównaj

Zobacz też XlaBuilder::Compare.

Wykonuje porównanie elementów lhs i rhs w przypadku:

Eq

Zobacz też XlaBuilder::Eq.

Wykonuje porównanie równości elementów w lhs i rhs.

\(lhs = rhs\)

Eq(lhs, rhs)

Kształty argumentów muszą być podobne lub zgodne. Więcej informacji o tym, co oznacza zgodność kształtów, znajdziesz w dokumentacji dotyczącej rozgłaszania. Wynik operacji ma kształt, który jest wynikiem rozgłaszania dwóch tablic wejściowych. W tym wariancie operacje między tablicami o różnych rangach nie są obsługiwane, chyba że jeden z operandów jest skalarem.

Istnieje alternatywna wersja z obsługą transmisji w różnych wymiarach dla Eq:

Eq(lhs,rhs, broadcast_dimensions)

Ten wariant operacji należy stosować w przypadku działań arytmetycznych na tablicach o różnych rangach (np. dodawania macierzy do wektora).

Dodatkowy operand broadcast_dimensions to wycinek liczb całkowitych określający wymiary, które mają być używane do rozgłaszania operandów. Semantyka jest szczegółowo opisana na stronie dotyczącej transmisji.

Obsługa łącznej liczby zamówień w przypadku liczb zmiennoprzecinkowych istnieje w przypadku warunku Eq, przez wymuszenie:

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

EqTotalOrder(lhs,rhs, broadcast_dimensions)

Więcej informacji o StableHLO znajdziesz w artykule StableHLO – porównanie.

Ne

Zobacz też XlaBuilder::Ne.

Wykonuje porównanie elementów różnych od siebie w przypadku tensorów lhs i rhs.

\(lhs != rhs\)

Ne(lhs, rhs)

Kształty argumentów muszą być podobne lub zgodne. Więcej informacji o tym, co oznacza zgodność kształtów, znajdziesz w dokumentacji dotyczącej rozgłaszania. Wynik operacji ma kształt, który jest wynikiem rozgłaszania dwóch tablic wejściowych. W tym wariancie operacje między tablicami o różnych rangach nie są obsługiwane, chyba że jeden z operandów jest skalarem.

Istnieje alternatywna odmiana Ne z obsługą transmisji w różnych wymiarach:

Ne(lhs,rhs, broadcast_dimensions)

Ten wariant operacji należy stosować w przypadku działań arytmetycznych na tablicach o różnych rangach (np. dodawania macierzy do wektora).

Dodatkowy operand broadcast_dimensions to wycinek liczb całkowitych określający wymiary, które mają być używane do rozgłaszania operandów. Semantyka jest szczegółowo opisana na stronie dotyczącej transmisji.

Obsługa łącznej kwoty zamówienia w przypadku liczb zmiennoprzecinkowych jest dostępna w przypadku Ne, przez wymuszenie:

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

NeTotalOrder(lhs,rhs, broadcast_dimensions)

Więcej informacji o StableHLO znajdziesz w artykule StableHLO – porównanie.

Ge

Zobacz też XlaBuilder::Ge.

Wykonuje porównanie greater-or-equal-than elementów lhs i rhs.

\(lhs >= rhs\)

Ge(lhs, rhs)

Kształty argumentów muszą być podobne lub zgodne. Więcej informacji o tym, co oznacza zgodność kształtów, znajdziesz w dokumentacji dotyczącej rozgłaszania. Wynik operacji ma kształt, który jest wynikiem rozgłaszania dwóch tablic wejściowych. W tym wariancie operacje między tablicami o różnych rangach nie są obsługiwane, chyba że jeden z operandów jest skalarem.

Dla języka Ge istnieje alternatywny wariant z obsługą transmisji o różnych wymiarach:

Ge(lhs,rhs, broadcast_dimensions)

Ten wariant operacji należy stosować w przypadku działań arytmetycznych na tablicach o różnych rangach (np. dodawania macierzy do wektora).

Dodatkowy operand broadcast_dimensions to wycinek liczb całkowitych określający wymiary, które mają być używane do rozgłaszania operandów. Semantyka jest szczegółowo opisana na stronie dotyczącej transmisji.

Obsługa łącznej liczby zamówień przekraczającej liczby zmiennoprzecinkowe istnieje w przypadku wartości większych od zera, poprzez wymuszanie:

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

GtTotalOrder(lhs,rhs, broadcast_dimensions)

Więcej informacji o StableHLO znajdziesz w artykule StableHLO – porównanie.

Gt

Zobacz też XlaBuilder::Gt.

Wykonuje porównanie elementów większych niż w przypadku wartości lhs i rhs.

\(lhs > rhs\)

Gt(lhs, rhs)

Kształty argumentów muszą być podobne lub zgodne. Więcej informacji o tym, co oznacza zgodność kształtów, znajdziesz w dokumentacji dotyczącej rozgłaszania. Wynik operacji ma kształt, który jest wynikiem rozgłaszania dwóch tablic wejściowych. W tym wariancie operacje między tablicami o różnych rangach nie są obsługiwane, chyba że jeden z operandów jest skalarem.

Dla Gt istnieje alternatywny wariant z obsługą transmisji o różnych wymiarach:

Gt(lhs,rhs, broadcast_dimensions)

Ten wariant operacji należy stosować w przypadku działań arytmetycznych na tablicach o różnych rangach (np. dodawania macierzy do wektora).

Dodatkowy operand broadcast_dimensions to wycinek liczb całkowitych określający wymiary, które mają być używane do rozgłaszania operandów. Semantyka jest szczegółowo opisana na stronie dotyczącej transmisji.

Więcej informacji o StableHLO znajdziesz w artykule StableHLO – porównanie.

Le

Zobacz też XlaBuilder::Le.

Wykonuje porównanie less-or-equal-than elementów lhs i rhs.

\(lhs <= rhs\)

Le(lhs, rhs)

Kształty argumentów muszą być podobne lub zgodne. Więcej informacji o tym, co oznacza zgodność kształtów, znajdziesz w dokumentacji dotyczącej rozgłaszania. Wynik operacji ma kształt, który jest wynikiem rozgłaszania dwóch tablic wejściowych. W tym wariancie operacje między tablicami o różnych rangach nie są obsługiwane, chyba że jeden z operandów jest skalarem.

Dla Le istnieje alternatywny wariant z obsługą transmisji o różnych wymiarach:

Le(lhs,rhs, broadcast_dimensions)

Ten wariant operacji należy stosować w przypadku działań arytmetycznych na tablicach o różnych rangach (np. dodawania macierzy do wektora).

Dodatkowy operand broadcast_dimensions to wycinek liczb całkowitych określający wymiary, które mają być używane do rozgłaszania operandów. Semantyka jest szczegółowo opisana na stronie dotyczącej transmisji.

Obsługa całkowitego porządku liczb zmiennoprzecinkowych istnieje w przypadku relacji Le, poprzez wymuszenie:

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

LeTotalOrder(lhs,rhs, broadcast_dimensions)

Więcej informacji o StableHLO znajdziesz w artykule StableHLO – porównanie.

Lt

Zobacz też XlaBuilder::Lt.

Wykonuje porównanie mniejsze niż elementów lhs i rhs.

\(lhs < rhs\)

Lt(lhs, rhs)

Kształty argumentów muszą być podobne lub zgodne. Więcej informacji o tym, co oznacza zgodność kształtów, znajdziesz w dokumentacji dotyczącej rozgłaszania. Wynik operacji ma kształt, który jest wynikiem rozgłaszania dwóch tablic wejściowych. W tym wariancie operacje między tablicami o różnych rangach nie są obsługiwane, chyba że jeden z operandów jest skalarem.

Dla Lt istnieje alternatywny wariant z obsługą transmisji o różnych wymiarach:

Lt(lhs,rhs, broadcast_dimensions)

Ten wariant operacji należy stosować w przypadku działań arytmetycznych na tablicach o różnych rangach (np. dodawania macierzy do wektora).

Dodatkowy operand broadcast_dimensions to wycinek liczb całkowitych określający wymiary, które mają być używane do rozgłaszania operandów. Semantyka jest szczegółowo opisana na stronie dotyczącej transmisji.

Obsługa całkowitego porządku liczb zmiennoprzecinkowych istnieje w przypadku relacji Lt, poprzez wymuszenie:

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

LtTotalOrder(lhs,rhs, broadcast_dimensions)

Więcej informacji o StableHLO znajdziesz w artykule StableHLO – porównanie.

Złożony

Zobacz też XlaBuilder::Complex.

Wykonuje konwersję poszczególnych elementów na wartość zespoloną z pary wartości rzeczywistych i urojonych, lhs i rhs.

Complex(lhs, rhs)

Kształty argumentów muszą być podobne lub zgodne. Więcej informacji o tym, co oznacza zgodność kształtów, znajdziesz w dokumentacji dotyczącej rozgłaszania. Wynik operacji ma kształt, który jest wynikiem rozgłaszania dwóch tablic wejściowych. W tym wariancie operacje między tablicami o różnych rangach nie są obsługiwane, chyba że jeden z operandów jest skalarem.

Istnieje alternatywna odmiana z obsługą rozgłaszania o różnych wymiarach dla liczb zespolonych:

Complex(lhs,rhs, broadcast_dimensions)

Ten wariant operacji należy stosować w przypadku działań arytmetycznych na tablicach o różnych rangach (np. dodawania macierzy do wektora).

Dodatkowy operand broadcast_dimensions to wycinek liczb całkowitych określający wymiary, które mają być używane do rozgłaszania operandów. Semantyka jest szczegółowo opisana na stronie dotyczącej transmisji.

Więcej informacji o StableHLO znajdziesz w artykule StableHLO – złożone.

ConcatInDim (Concatenate)

Zobacz też XlaBuilder::ConcatInDim.

Funkcja ZŁĄCZ tworzy tablicę z wielu argumentów tablicowych. Tablica ma tyle samo wymiarów co każdy z argumentów tablicy wejściowej (które muszą mieć taką samą liczbę wymiarów) i zawiera argumenty w kolejności, w jakiej zostały podane.

Concatenate(operands..., dimension)

Z wyjątkiem dimension wszystkie wymiary muszą być takie same. Dzieje się tak, ponieważ XLA nie obsługuje „nierównych” tablic. Pamiętaj też, że wartości 0-wymiarowe nie mogą być łączone (ponieważ nie można nazwać wymiaru, wzdłuż którego następuje łączenie).

Przykład 1-wymiarowy:

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

Przykład 2-wymiarowy:

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

Diagram:

Więcej informacji o StableHLO znajdziesz w artykule StableHLO – concatenate.

Warunkowy

Zobacz też XlaBuilder::Conditional.

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

Wykonuje true_computation, jeśli predicate ma wartość true, wykonuje false_computation, jeśli predicate ma wartość false, i zwraca wynik.

Funkcja true_computation musi przyjmować jeden argument typu \(T_0\) i będzie wywoływana z argumentem true_operand, który musi być tego samego typu. Funkcja false_computation musi przyjmować pojedynczy argument typu \(T_1\) i będzie wywoływana z argumentem false_operand, który musi być tego samego typu. Typ zwracanej wartości true_computation i false_computation musi być taki sam.

Pamiętaj, że w zależności od wartości predicate wykonana zostanie tylko jedna z funkcji true_computation i false_computation.

Conditional(branch_index, branch_computations, branch_operands)

Wykonuje branch_computations[branch_index] i zwraca wynik. Jeśli branch_index jest liczbą S32, która jest < 0 lub >= N, to branch_computations[N-1] jest wykonywane jako gałąź domyślna.

Każda funkcja branch_computations[b] musi przyjmować pojedynczy argument typu \(T_b\) i będzie wywoływana z argumentem branch_operands[b], który musi być tego samego typu. Typ zwracanej wartości każdej funkcji branch_computations[b] musi być taki sam.

Pamiętaj, że w zależności od wartości branch_index zostanie wykonana tylko jedna z funkcji branch_computations.

Informacje o StableHLO znajdziesz w sekcji StableHLO – if.

Stała

Zobacz też XlaBuilder::ConstantLiteral.

Tworzy output ze stałej literal.

Constant(literal)

Więcej informacji o StableHLO znajdziesz w artykule StableHLO – stała.

ConvertElementType

Zobacz też XlaBuilder::ConvertElementType.

Podobnie jak funkcja static_cast w C++, funkcja ConvertElementType wykonuje operację konwersji poszczególnych elementów z kształtu danych na kształt docelowy. Wymiary muszą być zgodne, a konwersja jest wykonywana na poziomie poszczególnych elementów, np. s32elementy stają się f32elementami w ramach procedury konwersji z s32 na f32.

ConvertElementType(operand, new_element_type)

Wymiary operandu i kształtu docelowego muszą być zgodne. Typy elementów źródłowego i docelowego nie mogą być krotkami.

Konwersja, np. T=s32 na U=f32, spowoduje wykonanie procedury normalizującej konwersję liczby całkowitej na liczbę zmiennoprzecinkową, np. zaokrąglanie do najbliższej parzystej liczby.

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

Więcej informacji o StableHLO znajdziesz w artykule StableHLO – convert.

Conv (splot)

Zobacz też XlaBuilder::Conv.

Oblicza splot typu używanego w sieciach neuronowych. Splot można tu traktować jako n-wymiarowe okno przesuwające się po n-wymiarowym obszarze bazowym. Obliczenia są wykonywane dla każdej możliwej pozycji okna.

Conv Umieszcza w kolejce instrukcję splotu, która używa domyślnych numerów wymiarów splotu bez rozszerzenia.

Wypełnienie jest określane w skrócony sposób jako SAME lub VALID. Wypełnienie SAME uzupełnia dane wejściowe (lhs) zerami, tak aby dane wyjściowe miały taki sam kształt jak dane wejściowe, jeśli nie uwzględnia się kroku. Wypełnienie VALID oznacza po prostu brak wypełnienia.

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

W przypadku Conv dostępne są różne poziomy kontroli:

• ConvWithGeneralPadding
• ConvWithGeneralDimensions
• ConvGeneral
• ConvGeneralDilated

Niech n będzie liczbą wymiarów przestrzennych. Argument lhs to tablica (n+2)-wymiarowa opisująca obszar podstawowy. Nazywamy to wejściem, chociaż oczywiście prawa strona też jest wejściem. W sieci neuronowej są to aktywacje wejściowe. Wymiary n+2 są w tej kolejności:

• batch: Każda współrzędna w tym wymiarze reprezentuje niezależne dane wejściowe, dla których przeprowadzana jest konwolucja.
• z/depth/features: Każda pozycja (y,x) w obszarze podstawowym ma powiązany wektor, który wchodzi w skład tego wymiaru.
• spatial_dims: opisuje n wymiary przestrzenne, które określają obszar bazowy, po którym przesuwa się okno.

Argument rhs to tablica (n+2)-wymiarowa opisująca filtr/jądro/okno splotu. Wymiary są podane w tej kolejności:

• output-z: wymiar z danych wyjściowych.
• input-z: rozmiar tego wymiaru pomnożony przez feature_group_count powinien być równy rozmiarowi wymiaru z po lewej stronie.
• spatial_dims: opisuje n wymiary przestrzenne, które definiują n-wymiarowe okno przesuwające się po obszarze bazowym.

Argument window_strides określa krok okna splotu w wymiarach przestrzennych. Jeśli na przykład krok w pierwszym wymiarze przestrzennym wynosi 3, okno można umieścić tylko we współrzędnych, w których pierwszy indeks przestrzenny jest podzielny przez 3.

Argument padding określa ilość dopełnienia zerami, które ma zostać zastosowane do obszaru podstawowego. Wartość dopełnienia może być ujemna – wartość bezwzględna ujemnego dopełnienia wskazuje liczbę elementów do usunięcia z określonego wymiaru przed wykonaniem splotu. padding[0] określa dopełnienie wymiaru y, a padding[1] określa dopełnienie wymiaru x. W każdej parze pierwszy element to dolny margines wewnętrzny, a drugi to górny margines wewnętrzny. Dopełnienie o niskiej wartości jest stosowane w kierunku niższych indeksów, a dopełnienie o wysokiej wartości – w kierunku wyższych indeksów. Jeśli np. padding[1] to (2,3), w drugim wymiarze przestrzennym po lewej stronie zostaną dodane 2 zera, a po prawej – 3 zera. Użycie dopełnienia jest równoważne wstawieniu tych samych wartości zerowych do danych wejściowych (lhs) przed wykonaniem splotu.

Argumenty lhs_dilation i rhs_dilation określają współczynnik rozszerzenia, który ma być zastosowany odpowiednio do lewej i prawej strony w każdym wymiarze przestrzennym. Jeśli współczynnik rozszerzenia w wymiarze przestrzennym wynosi d, między poszczególnymi elementami w tym wymiarze umieszcza się d-1 otworów, co zwiększa rozmiar tablicy. Luki są wypełniane wartością bez operacji, która w przypadku splotu oznacza zera.

Rozszerzenie prawej strony równania jest też nazywane konwolucją z dziurami. Więcej informacji znajdziesz w artykule tf.nn.atrous_conv2d. Rozszerzenie lewej strony równania jest też nazywane konwolucją transponowaną. Więcej informacji znajdziesz w artykule tf.nn.conv2d_transpose.

Argument feature_group_count (wartość domyślna to 1) może być używany w przypadku konwolucji grupowej. feature_group_count musi być dzielnikiem zarówno wymiaru cechy wejściowej, jak i wyjściowej. Jeśli feature_group_count jest większe niż 1, oznacza to, że wymiar cechy wejściowej i wyjściowej oraz wymiar cechy wyjściowej rhs są koncepcyjnie dzielone równomiernie na wiele grup feature_group_count, z których każda składa się z kolejnych podciągów cech. Wymiar cechy wejściowej rhs musi być równy wymiarowi cechy wejściowej lhs podzielonemu przez feature_group_count (czyli musi mieć rozmiar grupy cech wejściowych). i-te grupy są używane razem do obliczania feature_group_count w przypadku wielu oddzielnych operacji splotu. Wyniki tych operacji splotu są łączone w wymiarze cechy wyjściowej.

W przypadku konwolucji przestrzennej argument feature_group_count zostanie ustawiony na wymiar cechy wejściowej, a filtr zostanie przekształcony z [filter_height, filter_width, in_channels, channel_multiplier] na [filter_height, filter_width, 1, in_channels * channel_multiplier]. Więcej informacji znajdziesz w sekcji tf.nn.depthwise_conv2d.

Argument batch_group_count (wartość domyślna 1) może być używany w przypadku zgrupowanych filtrów podczas propagacji wstecznej. batch_group_count musi być dzielnikiem rozmiaru wymiaru wsadu lhs (danych wejściowych). Jeśli batch_group_count jest większe niż 1, oznacza to, że wymiar wsadu wyjściowego powinien mieć rozmiar input batch / batch_group_count. Wartość batch_group_count musi być dzielnikiem rozmiaru cechy wyjściowej.

Kształt danych wyjściowych ma te wymiary w tej kolejności:

• batch: rozmiar tego wymiaru pomnożony przez batch_group_count powinien być równy rozmiarowi wymiaru batch po lewej stronie.
• z: taki sam rozmiar jak output-z w jądrze (rhs).
• spatial_dims: jedna wartość dla każdego prawidłowego umieszczenia okna konwolucyjnego.

Ilustracja powyżej pokazuje, jak działa pole batch_group_count. Każdą partię po lewej stronie dzielimy na batch_group_count grup, a to samo robimy z cechami wyjściowymi. Następnie w przypadku każdej z tych grup wykonujemy sploty parami i łączymy wyniki wzdłuż wymiaru cechy wyjściowej. Semantyka operacyjna wszystkich pozostałych wymiarów (funkcji i przestrzennych) pozostaje bez zmian.

Prawidłowe miejsca docelowe okna konwolucyjnego są określane przez krok i rozmiar obszaru bazowego po dopełnieniu.

Aby opisać, co robi konwolucja, rozważmy konwolucję 2D i wybierzmy stałe współrzędne batch, z, y, x w danych wyjściowych. Wtedy (y,x) to pozycja rogu okna w obszarze podstawowym (np. lewy górny róg, w zależności od interpretacji wymiarów przestrzennych). Mamy teraz okno 2D, które pochodzi z obszaru podstawowego, gdzie każdy punkt 2D jest powiązany z wektorem 1D, więc otrzymujemy pole 3D. Z konwolucyjnego jądra, ponieważ ustaliliśmy współrzędną wyjściową z, mamy też trójwymiarowe pole. Oba pola mają te same wymiary, więc możemy obliczyć sumę iloczynów elementów między nimi (podobnie jak w przypadku iloczynu skalarnego). Jest to wartość wyjściowa.

Jeśli np. output-z wynosi 5, to każda pozycja okna generuje 5 wartości w danych wyjściowych w wymiarze z. Wartości te różnią się tym, która część jądra konwolucyjnego jest używana – dla każdego współrzędnego output-z używane jest osobne trójwymiarowe pole wartości. Można to sobie wyobrazić jako 5 oddzielnych operacji splotu z różnymi filtrami.

Oto pseudokod dla konwolucji 2D z wypełnieniem i krokiem:

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 służy do określania konfiguracji precyzji. Poziom określa, czy sprzęt powinien próbować generować więcej instrukcji kodu maszynowego, aby w razie potrzeby zapewnić dokładniejszą emulację typu danych (np. emulację typu f32 na jednostce TPU, która obsługuje tylko mnożenie macierzy typu bf16). Wartości mogą być równe DEFAULT, HIGH lub HIGHEST. Dodatkowe informacje w sekcjach MXU.

preferred_element_type to element skalarny o wyższej lub niższej precyzji, który jest używany do akumulacji. preferred_element_type zaleca typ akumulacyjny w przypadku danej operacji, ale nie jest to gwarantowane. Dzięki temu niektóre platformy sprzętowe mogą gromadzić dane w innym typie i przekształcać je w preferowany typ wyjściowy.

Więcej informacji o StableHLO znajdziesz w artykule StableHLO – konwolucja.

ConvWithGeneralPadding

Zobacz też XlaBuilder::ConvWithGeneralPadding.

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

Tak samo jak Conv, gdzie konfiguracja dopełnienia jest jawna.

ConvWithGeneralDimensions

Zobacz też XlaBuilder::ConvWithGeneralDimensions.

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

Tak samo jak w przypadku Conv, gdzie numery wymiarów są podane wprost.

ConvGeneral

Zobacz też XlaBuilder::ConvGeneral.

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

Tak samo jak w przypadku Conv, gdzie numery wymiarów i konfiguracja dopełnienia są określone wprost.

ConvGeneralDilated

Zobacz też 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)

Podobnie jak w przypadku Conv, gdzie konfiguracja dopełnienia, współczynniki rozszerzenia i numery wymiarów są podane wprost.

Kopiuj

Zobacz też HloInstruction::CreateCopyStart.

Copy jest wewnętrznie rozkładana na 2 instrukcje HLO: CopyStart i CopyDone. Copy wraz z CopyStart i CopyDone służą jako elementy podstawowe w HLO. Te operacje mogą pojawiać się w zrzutach HLO, ale nie są przeznaczone do ręcznego tworzenia przez użytkowników.

Cos

Zobacz teżXlaBuilder::Cos.

Podobieństwo kosinusowe elementów x -> cos(x).

Cos(operand)

Funkcja Cos obsługuje też opcjonalny argument result_accuracy:

Cos(operand, result_accuracy)

Więcej informacji o result_accuracy znajdziesz w sekcji Dokładność wyników.

Więcej informacji o StableHLO znajdziesz w artykule StableHLO – cosine.

Cosh

Zobacz też XlaBuilder::Cosh.

Cosinus hiperboliczny każdego elementu x -> cosh(x).

Cosh(operand)

Funkcja cosh obsługuje też opcjonalny argument result_accuracy:

Cosh(operand, result_accuracy)

Więcej informacji o result_accuracy znajdziesz w sekcji Dokładność wyników.

CustomCall

Zobacz też XlaBuilder::CustomCall.

Wywoływanie funkcji przekazanej przez użytkownika w obliczeniach.

Dokumentacja CustomCall jest dostępna w sekcji Szczegóły dla deweloperów – niestandardowe wywołania XLA.

Informacje o StableHLO znajdziesz w artykule StableHLO – custom_call.

Dyw

Zobacz też XlaBuilder::Div.

Wykonuje dzielenie elementów dywidendy lhs przez dzielnik rhs.

Div(lhs, rhs)

Przepełnienie dzielenia całkowitego (dzielenie/reszta ze znakiem lub bez znaku przez zero albo dzielenie/reszta ze znakiem liczby INT_SMIN przez -1) daje wartość zdefiniowaną przez implementację.

Kształty argumentów muszą być podobne lub zgodne. Więcej informacji o tym, co oznacza zgodność kształtów, znajdziesz w dokumentacji dotyczącej rozgłaszania. Wynik operacji ma kształt, który jest wynikiem rozgłaszania dwóch tablic wejściowych. W tym wariancie operacje między tablicami o różnych rangach nie są obsługiwane, chyba że jeden z operandów jest skalarem.

W przypadku elementu Div istnieje alternatywna odmiana z obsługą transmisji w różnych wymiarach:

Div(lhs,rhs, broadcast_dimensions)

Ten wariant operacji należy stosować w przypadku działań arytmetycznych na tablicach o różnych rangach (np. dodawania macierzy do wektora).

Dodatkowy operand broadcast_dimensions to wycinek liczb całkowitych określający wymiary, które mają być używane do rozgłaszania operandów. Semantyka jest szczegółowo opisana na stronie dotyczącej transmisji.

Więcej informacji o StableHLO znajdziesz w artykule StableHLO – dzielenie.

Domena

Zobacz też HloInstruction::CreateDomain.

Domain może pojawiać się w zrzutach HLO, ale nie jest przeznaczony do ręcznego tworzenia przez użytkowników.

Kropka

Zobacz też XlaBuilder::Dot.

Dot(lhs, rhs, precision_config, preferred_element_type)

Dokładna semantyka tej operacji zależy od rangi operandów:

Operacja wykonuje sumę iloczynów wzdłuż drugiego wymiaru tensora lhs (lub pierwszego, jeśli ma 1 wymiar) i pierwszego wymiaru tensora rhs. Są to wymiary „umowne”. Skrócone wymiary lhs i rhs muszą być tego samego rozmiaru. W praktyce można go używać do obliczania iloczynów skalarnych wektorów, mnożenia wektorów przez macierze lub mnożenia macierzy przez macierze.

precision_config służy do określania konfiguracji precyzji. Poziom określa, czy sprzęt powinien próbować generować więcej instrukcji kodu maszynowego, aby w razie potrzeby zapewnić dokładniejszą emulację typu danych (np. emulację typu f32 na jednostce TPU, która obsługuje tylko mnożenie macierzy typu bf16). Wartości mogą być równe DEFAULT, HIGH lub HIGHEST. Dodatkowe informacje w sekcjach MXU.

preferred_element_type to element skalarny o wyższej lub niższej precyzji, który jest używany do akumulacji. preferred_element_type zaleca typ akumulacyjny w przypadku danej operacji, ale nie jest to gwarantowane. Dzięki temu niektóre platformy sprzętowe mogą gromadzić dane w innym typie i przekształcać je w preferowany typ wyjściowy.

Informacje o StableHLO znajdziesz w artykule StableHLO – dot.

DotGeneral

Zobacz też XlaBuilder::DotGeneral.

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

Podobny do Dot, ale umożliwia określenie numerów wymiarów kurczenia i partii zarówno dla lhs, jak i rhs.

Funkcja DotGeneral wykonuje sumę produktów w przypadku wymiarów kurczenia określonych w dimension_numbers.

Powiązane numery wymiarów umowy z lhs i rhs nie muszą być takie same, ale muszą mieć te same rozmiary.

Przykład z numerami wymiarów kurczliwych:

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

Powiązane numery wymiarów wsadu z lhs i rhs muszą mieć te same rozmiary wymiarów.

Przykład z numerami wymiarów wsadowych (wielkość wsadu 2, macierze 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} } }

Wynikowy numer wymiaru zaczyna się od wymiaru wsadowego, następnie od wymiaru lhs niepodlegającego kontrakcji/niebędącego wymiarem wsadowym, a na końcu od wymiaru rhs niepodlegającego kontrakcji/niebędącego wymiarem wsadowym.

precision_config służy do określania konfiguracji precyzji. Poziom określa, czy sprzęt powinien próbować generować więcej instrukcji kodu maszynowego, aby w razie potrzeby zapewnić dokładniejszą emulację typu danych (np. emulację typu f32 na jednostce TPU, która obsługuje tylko mnożenie macierzy typu bf16). Wartości mogą być równe DEFAULT, HIGH lub HIGHEST. Więcej informacji znajdziesz w sekcjach dotyczących MXU.

preferred_element_type to element skalarny o wyższej lub niższej precyzji, który jest używany do akumulacji. preferred_element_type zaleca typ akumulacyjny w przypadku danej operacji, ale nie jest to gwarantowane. Dzięki temu niektóre platformy sprzętowe mogą gromadzić dane w innym typie i przekształcać je w preferowany typ wyjściowy.

Więcej informacji o StableHLO znajdziesz w artykule StableHLO – dot_general.

ScaledDot

Zobacz też XlaBuilder::ScaledDot.

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

Podobne do DotGeneral.

Tworzy operację skalowanego iloczynu skalarnego z operandami „lhs”, „lhs_scale”, „rhs” i „rhs_scale” oraz wymiarami kurczącymi i wsadowymi określonymi w parametrze „dimension_numbers”.

RaggedDot

Zobacz też XlaBuilder::RaggedDot.

Szczegółowe informacje o obliczeniach RaggedDot znajdziesz w artykule StableHLO - chlo.ragged_dot.

DynamicReshape

Zobacz też XlaBuilder::DynamicReshape.

Ta operacja jest funkcjonalnie identyczna z operacją reshape, ale kształt wyniku jest określany dynamicznie za pomocą argumentu output_shape.

DynamicReshape(operand, dim_sizes, new_size_bounds, dims_are_dynamic)

Informacje o StableHLO znajdziesz w artykule StableHLO – dynamic_reshape.

DynamicSlice

Zobacz też XlaBuilder::DynamicSlice.

DynamicSlice wyodrębnia podtablicę z tablicy wejściowej w dynamicznym indeksie start_indices. Rozmiar wycinka w każdym wymiarze jest przekazywany w size_indices, które określają punkt końcowy wyłącznych przedziałów wycinka w każdym wymiarze: [start, start + size). Kształt start_indices musi być 1-wymiarowy, a rozmiar wymiaru musi być równy liczbie wymiarów operand.

DynamicSlice(operand, start_indices, slice_sizes)

Efektywne indeksy wycinków są obliczane przez zastosowanie tej transformacji do każdego indeksu i w [1, N) przed wykonaniem wycinka:

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

Dzięki temu wyodrębniony wycinek zawsze będzie mieścił się w granicach tablicy operandów. Jeśli wycinek znajduje się w zakresie przed zastosowaniem przekształcenia, nie ma ono żadnego wpływu.

Przykład 1-wymiarowy:

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

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

Przykład 2-wymiarowy:

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

Informacje o StableHLO znajdziesz w artykule StableHLO – dynamic_slice.

DynamicUpdateSlice

Zobacz też XlaBuilder::DynamicUpdateSlice.

Funkcja DynamicUpdateSlice generuje wynik, który jest wartością tablicy wejściowej operand, z nadpisanym wycinkiem update w miejscu start_indices. Kształt update określa kształt podtablicy wyniku, która jest aktualizowana. Kształt start_indices musi być jednowymiarowy, a rozmiar wymiaru musi być równy liczbie wymiarów operand.

DynamicUpdateSlice(operand, update, start_indices)

Efektywne indeksy wycinków są obliczane przez zastosowanie tej transformacji do każdego indeksu i w [1, N) przed wykonaniem wycinka:

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

Dzięki temu zaktualizowany wycinek zawsze będzie mieścił się w zakresie tablicy operandów. Jeśli wycinek znajduje się w zakresie przed zastosowaniem przekształcenia, nie ma ono żadnego wpływu.

Przykład 1-wymiarowy:

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}

Przykład 2-wymiarowy:

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

Informacje o StableHLO znajdziesz w artykule StableHLO – dynamic_update_slice.

Erf

Zobacz też XlaBuilder::Erf.

Funkcja błędu x -> erf(x) dla poszczególnych elementów, gdzie:

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

Erf(operand)

Funkcja Erf obsługuje też opcjonalny argument result_accuracy:

Erf(operand, result_accuracy)

Więcej informacji o result_accuracy znajdziesz w sekcji Dokładność wyników.

Wykł.

Zobacz też XlaBuilder::Exp.

Wykładnik naturalny dla każdego elementu x -> e^x.

Exp(operand)

Funkcja Exp obsługuje też opcjonalny argument result_accuracy:

Exp(operand, result_accuracy)

Więcej informacji o result_accuracy znajdziesz w sekcji Dokładność wyników.

Informacje o StableHLO znajdziesz w artykule StableHLO – wykładnicze.

Expm1

Zobacz też XlaBuilder::Expm1.

Wartość funkcji wykładniczej o podstawie e pomniejszona o 1 x -> e^x - 1.

Expm1(operand)

Funkcja expm1 obsługuje też opcjonalny argument result_accuracy:

Expm1(operand, result_accuracy)

Więcej informacji o result_accuracy znajdziesz w sekcji Dokładność wyników.

Informacje o StableHLO znajdziesz w artykule StableHLO – exponential_minus_one.

FFT

Zobacz też XlaBuilder::Fft.

Operacja XLA FFT implementuje transformaty Fouriera w przód i w tył dla danych wejściowych i wyjściowych w postaci liczb rzeczywistych i zespolonych. Obsługiwane są wielowymiarowe FFT na maksymalnie 3 osiach.

Fft(operand, ftt_type, fft_length)

Informacje o StableHLO znajdziesz w artykule StableHLO – fft.

Wielowymiarowa szybka transformata Fouriera

Jeśli podasz więcej niż 1 wartość fft_length, będzie to równoznaczne z zastosowaniem kaskady operacji FFT do każdej z najbardziej wewnętrznych osi. Zauważ, że w przypadku przekształceń rzeczywiste → zespolone i zespolone → rzeczywiste najpierw (skutecznie) wykonywane jest przekształcenie osi wewnętrznej (RFFT; ostatnie w przypadku IRFFT), dlatego to oś wewnętrzna zmienia rozmiar. Inne przekształcenia osi będą wtedy złożone -> złożone.

Szczegóły implementacji

Szybka transformata Fouriera na procesorze jest obsługiwana przez TensorFFT z biblioteki Eigen. GPU FFT korzysta z cuFFT.

Piętro

Zobacz też XlaBuilder::Floor.

Funkcja podłogi dla poszczególnych elementów x -> ⌊x⌋.

Floor(operand)

Więcej informacji o StableHLO znajdziesz w artykule StableHLO – floor.

Fusion

Zobacz też HloInstruction::CreateFusion.

Operacja Fusion reprezentuje instrukcje HLO i służy jako element podstawowy w HLO. Ta operacja może pojawiać się w zrzutach HLO, ale nie jest przeznaczona do ręcznego tworzenia przez użytkowników.

Zbieranie

Operacja zbierania XLA łączy kilka wycinków (każdy z potencjalnie innym przesunięciem czasu wykonania) tablicy wejściowej.

Więcej informacji o StableHLO znajdziesz w artykule StableHLO – zbieranie.

Semantyka ogólna

Zobacz też XlaBuilder::Gather. Bardziej intuicyjny opis znajdziesz w sekcji „Nieformalny opis” poniżej.

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

Dla wygody wymiary w tablicy wyjściowej, które nie są oznaczone jako offset_dims, oznaczamy jako batch_dims.

Wynikiem jest tablica o wymiarach batch_dims.size + offset_dims.size.

Wartość operand.rank musi być równa sumie wartości offset_dims.size i collapsed_slice_dims.size. Poza tym wartość slice_sizes.size musi być równa operand.rank.

Jeśli index_vector_dim jest równe start_indices.rank, domyślnie przyjmujemy, że start_indices ma wymiar końcowy 1 (czyli jeśli start_indices ma kształt [6,7], a index_vector_dim to 2, domyślnie przyjmujemy, że kształt start_indices to [6,7,1]).

Granice tablicy wyjściowej wzdłuż wymiaru i są obliczane w ten sposób:

1. Jeśli i występuje w batch_dims (tzn. jest równe batch_dims[k] dla pewnego k), wybieramy odpowiednie granice wymiaru z start_indices.shape, pomijając index_vector_dim (tzn. wybieramy start_indices.shape.dims[k], jeśli k < index_vector_dim, a w przeciwnym razie start_indices.shape.dims[k+1]).

2. Jeśli wartość i występuje w offset_dims (czyli jest równa offset_dims[k] dla pewnego k), wybieramy odpowiednią wartość graniczną z slice_sizes po uwzględnieniu collapsed_slice_dims (czyli wybieramy adjusted_slice_sizes[k], gdzie adjusted_slice_sizes to slice_sizes z usuniętymi wartościami granicznymi na indeksach collapsed_slice_dims).

Formalnie indeks operandu In odpowiadający danemu indeksowi wyjściowemu Out jest obliczany w ten sposób:

1. Niech G = { Out[k] for k in batch_dims }. Użyj G, aby wyciąć wektor S taki, że S[i] = start_indices[Combine(G, i)], gdzie Combine(A, b) wstawia b na pozycję index_vector_dim w A. Pamiętaj, że jest to dobrze zdefiniowane nawet wtedy, gdy G jest puste: jeśli G jest puste, to S = start_indices.

2. Utwórz indeks początkowy Sin w operand za pomocą S, rozpraszając S za pomocą start_index_map. Dokładniej:

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

   2. Sin[_] = 0 w innym przypadku.

3. Utwórz indeks Oin w operand, rozpraszając indeksy w wymiarach przesunięcia w Out zgodnie z ustawieniem collapsed_slice_dims. Dokładniej:

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

   2. Oin[_] = 0 w innym przypadku.

4. In to Oin + Sin, gdzie + oznacza dodawanie elementów.

remapped_offset_dims to funkcja monotoniczna o dziedzinie [0, offset_dims.size) i zbiorze wartości [0, operand.rank) \ collapsed_slice_dims. Jeśli np. offset_dims.size to 4, operand.rank to 6, a collapsed_slice_dims to {0, 2}, to remapped_offset_dims to {0→1, 1→3, 2→4, 3→5}.

Jeśli zasada indices_are_sorted ma wartość Prawda, XLA może założyć, że użytkownik posortował wartości start_indices (w kolejności rosnącej, po rozproszeniu ich zgodnie z zasadą start_index_map). W przeciwnym razie semantyka jest zdefiniowana przez implementację.

Nieformalny opis i przykłady

Nieformalnie każdy indeks Out w tablicy wyjściowej odpowiada elementowi E w tablicy operandów, obliczonemu w ten sposób:

• Wymiarów pakietu używamy w Out, aby wyszukać indeks początkowy w start_indices.

• Używamy start_index_map, aby zmapować indeks początkowy (którego rozmiar może być mniejszy niż operand.rank) na „pełny” indeks początkowy w operand.

• Dynamicznie wycinamy wycinek o rozmiarze slice_sizes, używając pełnego indeksu początkowego.

• Zmieniamy kształt wycinka, zwijając wymiary collapsed_slice_dims. Ponieważ wszystkie wymiary zwiniętego wycinka muszą mieć wartość 1, ta zmiana kształtu jest zawsze prawidłowa.

• Używamy wymiarów przesunięcia w Out, aby indeksować ten wycinek i uzyskać element wejściowy E odpowiadający indeksowi wyjściowemu Out.

index_vector_dim ma wartość start_indices.rank–1 we wszystkich poniższych przykładach. Bardziej interesujące wartości index_vector_dim nie zmieniają zasadniczo działania, ale utrudniają wizualizację.

Aby zrozumieć, jak to wszystko działa, przyjrzyjmy się przykładowi, w którym z tablicy [16,11] pobieranych jest 5 wycinków o kształcie [8,6]. Położenie wycinka w tablicy [16,11] można przedstawić jako wektor indeksu o kształcie S64[2], więc zbiór 5 pozycji można przedstawić jako tablicę S64[5,2].

Działanie operacji zbierania można przedstawić jako transformację indeksu,która przyjmuje [G,O0,O1], indeks w kształcie wyjściowym i mapuje go na element w tablicy wejściowej w ten sposób:

Najpierw wybieramy wektor (X,Y) z tablicy indeksów zbierania za pomocą funkcji G. Element w tablicy wyjściowej o indeksie [G,O0,O1] jest elementem w tablicy wejściowej o indeksie [X+O0,Y+O1].

slice_sizes to [8,6], co decyduje o zakresie O₀ i O₁, a to z kolei decyduje o granicach wycinka.

Ta operacja zbierania działa jak dynamiczny wycinek wsadowy z G jako wymiarem wsadowym.

Indeksy zbierania mogą być wielowymiarowe. Na przykład bardziej ogólna wersja powyższego przykładu, która używa tablicy „gather indices” o kształcie [4,5,2], przetłumaczy indeksy w ten sposób:

Ponownie jest to dynamiczny wycinek zbiorczy G0, a G1 to wymiary zbiorcze. Rozmiar wycinka to nadal [8,6].

Operacja gather w XLA uogólnia nieformalną semantykę opisaną powyżej w następujący sposób:

1. Możemy skonfigurować, które wymiary w kształcie wyjściowym są wymiarami przesunięcia (wymiary zawierające O0, O1 w ostatnim przykładzie). Wymiary wsadu wyjściowego (wymiary zawierające G0, G1 w ostatnim przykładzie) są zdefiniowane jako wymiary wyjściowe, które nie są wymiarami przesunięcia.

2. Liczba wymiarów przesunięcia wyjściowego jawnie występujących w kształcie wyjściowym może być mniejsza niż liczba wymiarów wejściowych. Wymiary „brakujące”, które są wyraźnie wymienione jako collapsed_slice_dims, muszą mieć rozmiar wycinka 1. Ponieważ mają rozmiar wycinka 1, jedynym prawidłowym indeksem jest 0, a ich pominięcie nie wprowadza niejednoznaczności.

3. Wyodrębniony z tablicy „Zbierz indeksy” wycinek ((X, Y) w ostatnim przykładzie) może mieć mniej elementów niż liczba wymiarów tablicy wejściowej, a jawne mapowanie określa, jak indeks powinien zostać rozwinięty, aby mieć taką samą liczbę wymiarów jak dane wejściowe.

Na koniec używamy (2) i (3) do implementacji tf.gather_nd:

G0 i G1 służą do wyodrębniania indeksu początkowego z tablicy indeksów zbierania w zwykły sposób, z tym wyjątkiem, że indeks początkowy ma tylko 1 element, X. Podobnie istnieje tylko jeden indeks przesunięcia danych wyjściowych o wartości O0. Zanim jednak zostaną użyte jako indeksy w tablicy wejściowej, są rozwijane zgodnie z „Mapowaniem indeksu zbierania” (start_index_map w formalnym opisie) i „Mapowaniem przesunięcia” (remapped_offset_dims w formalnym opisie) do [X,0] i [0,O0], co daje w sumie [X,O0]. Innymi słowy,indeks wyjściowy [G0, G1,O0] jest mapowany na indeks wejściowy [GatherIndices[G0,G1,0],O0],co daje nam semantykę tf.gather_nd.

slice_sizes w tym przypadku wynosi [1,11]. Intuicyjnie oznacza to, że każdy indeks X w tablicy indeksów zbierania wybiera cały wiersz, a wynikiem jest połączenie wszystkich tych wierszy.

GetDimensionSize

Zobacz też XlaBuilder::GetDimensionSize.

Zwraca rozmiar danego wymiaru argumentu. Operand musi mieć kształt tablicy.

GetDimensionSize(operand, dimension)

Informacje o StableHLO znajdziesz w artykule StableHLO – get_dimension_size.

GetTupleElement

Zobacz też XlaBuilder::GetTupleElement.

Indeksuje krotkę za pomocą wartości stałej w czasie kompilacji.

Wartość musi być stałą w czasie kompilacji, aby wnioskowanie o kształcie mogło określić typ wynikowej wartości.

Jest to analogiczne do std::get<int N>(t) w C++. Koncepcyjnie:

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.

Zobacz też tf.tuple.

GetTupleElement(tuple_data, index)

Informacje o StableHLO znajdziesz w artykule StableHLO – get_tuple_element.

Imag

Zobacz też XlaBuilder::Imag.

Część urojona elementu kształtu zespolonego (lub rzeczywistego). x -> imag(x). Jeśli operand jest typu zmiennoprzecinkowego, zwraca 0.

Imag(operand)

Informacje o StableHLO znajdziesz w artykule StableHLO – imag.

Infeed

Zobacz też XlaBuilder::Infeed.

Infeed(shape, config)

Odczytuje pojedynczy element danych z niejawnego interfejsu przesyłania strumieniowego Infeed urządzenia, interpretując dane jako podany kształt i jego układ, i zwraca XlaOp danych. W obliczeniach dozwolonych jest wiele operacji Infeed, ale musi między nimi istnieć porządek całkowity. Na przykład dwie instrukcje Infeed w poniższym kodzie mają całkowitą kolejność, ponieważ istnieje zależność między pętlami while.

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

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

Zagnieżdżone kształty krotek nie są obsługiwane. W przypadku pustego kształtu krotki operacja Infeed jest w zasadzie operacją bezczynną i przebiega bez odczytywania danych z kanału Infeed urządzenia.

Informacje o StableHLO znajdziesz w artykule StableHLO – infeed.

Iota

Zobacz też XlaBuilder::Iota.

Iota(shape, iota_dimension)

Tworzy stały literał na urządzeniu zamiast potencjalnie dużego transferu hosta. Tworzy tablicę o określonym kształcie, która zawiera wartości zaczynające się od zera i zwiększające się o jeden wzdłuż określonego wymiaru. W przypadku typów reprezentacji zmiennoprzecinkowej wygenerowana tablica jest równoważna ConvertElementType(Iota(...)), gdzie Iota jest typu całkowitego, a konwersja jest do typu reprezentacji zmiennoprzecinkowej.

Na przykład Iota(s32[4, 8], 0) zwraca

[[0, 0, 0, 0, 0, 0, 0, 0 ],
 [1, 1, 1, 1, 1, 1, 1, 1 ],
 [2, 2, 2, 2, 2, 2, 2, 2 ],
 [3, 3, 3, 3, 3, 3, 3, 3 ]]

Iota(s32[4, 8], 1) za możliwość zwrotu

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

Więcej informacji o StableHLO znajdziesz w artykule StableHLO – iota.

IsFinite

Zobacz też XlaBuilder::IsFinite.

Sprawdza, czy każdy element operand jest skończony, tzn. nie jest dodatnią ani ujemną nieskończonością i nie jest wartością NaN. Zwraca tablicę wartości PRED o takim samym kształcie jak dane wejściowe, gdzie każdy element ma wartość true tylko wtedy, gdy odpowiedni element wejściowy jest skończony.

IsFinite(operand)

Informacje o StableHLO znajdziesz w artykule StableHLO – is_finite.

Log

Zobacz też XlaBuilder::Log.

Logarytm naturalny każdego elementu x -> ln(x).

Log(operand)

Funkcja LOG obsługuje też opcjonalny argument result_accuracy:

Log(operand, result_accuracy)

Więcej informacji o result_accuracy znajdziesz w sekcji Dokładność wyników.

Więcej informacji o StableHLO znajdziesz w artykule StableHLO – log.

Log1p

Zobacz też XlaBuilder::Log1p.

Przesunięty logarytm naturalny x -> ln(1+x).

Log1p(operand)

Funkcja log1p obsługuje też opcjonalny argument result_accuracy:

Log1p(operand, result_accuracy)

Więcej informacji o result_accuracy znajdziesz w sekcji Dokładność wyników.

Więcej informacji o StableHLO znajdziesz w artykule StableHLO – log_plus_one.

Logistyczna

Zobacz też XlaBuilder::Logistic.

Obliczenie funkcji logistycznej dla poszczególnych elementów x -> logistic(x).

Logistic(operand)

Funkcja logistyczna obsługuje też opcjonalny argument result_accuracy:

Logistic(operand, result_accuracy)

Więcej informacji o result_accuracy znajdziesz w sekcji Dokładność wyników.

Informacje o StableHLO znajdziesz w artykule StableHLO – logistyka.

Mapa

Zobacz też XlaBuilder::Map.

Map(operands..., computation, dimensions)

Stosuje funkcję skalarną do podanych tablic operands, tworząc tablicę o tych samych wymiarach, w której każdy element jest wynikiem zastosowania funkcji mapowania do odpowiednich elementów w tablicach wejściowych.

Zmapowana funkcja to dowolne obliczenie z ograniczeniem, że ma N wejść typu skalarnego T i jedno wyjście typu S. Wyjście ma te same wymiary co operandy, z tym wyjątkiem, że typ elementu T jest zastępowany typem S.

Przykład: Map(op1, op2, op3, computation, par1) mapuje elem_out <- computation(elem1, elem2, elem3, par1) w każdym (wielowymiarowym) indeksie w tablicach wejściowych, aby utworzyć tablicę wyjściową.

Informacje o StableHLO znajdziesz na mapie StableHLO.

Maks.

Zobacz też XlaBuilder::Max.

Wykonuje operację max na poszczególnych elementach tensorów lhs i rhs.

Max(lhs, rhs)

Kształty argumentów muszą być podobne lub zgodne. Więcej informacji o tym, co oznacza zgodność kształtów, znajdziesz w dokumentacji dotyczącej rozgłaszania. Wynik operacji ma kształt, który jest wynikiem rozgłaszania dwóch tablic wejściowych. W tym wariancie operacje między tablicami o różnych rangach nie są obsługiwane, chyba że jeden z operandów jest skalarem.

Istnieje alternatywny wariant Maxa z obsługą transmisji w różnych wymiarach:

Max(lhs,rhs, broadcast_dimensions)

Ten wariant operacji należy stosować w przypadku działań arytmetycznych na tablicach o różnych rangach (np. dodawania macierzy do wektora).

Dodatkowy operand broadcast_dimensions to wycinek liczb całkowitych określający wymiary, które mają być używane do rozgłaszania operandów. Semantyka jest szczegółowo opisana na stronie dotyczącej transmisji.

Informacje o StableHLO znajdziesz w artykule StableHLO – maksimum.

Minimum

Zobacz też XlaBuilder::Min.

Wykonuje operację minimum na poszczególnych elementach tensorów lhs i rhs.

Min(lhs, rhs)

Kształty argumentów muszą być podobne lub zgodne. Więcej informacji o tym, co oznacza zgodność kształtów, znajdziesz w dokumentacji dotyczącej rozgłaszania. Wynik operacji ma kształt, który jest wynikiem rozgłaszania dwóch tablic wejściowych. W tym wariancie operacje między tablicami o różnych rangach nie są obsługiwane, chyba że jeden z operandów jest skalarem.

Istnieje alternatywna wersja z obsługą transmisji o różnych wymiarach dla funkcji Min:

Min(lhs,rhs, broadcast_dimensions)

Ten wariant operacji należy stosować w przypadku działań arytmetycznych na tablicach o różnych rangach (np. dodawania macierzy do wektora).

Dodatkowy operand broadcast_dimensions to wycinek liczb całkowitych określający wymiary, które mają być używane do rozgłaszania operandów. Semantyka jest szczegółowo opisana na stronie dotyczącej transmisji.

Informacje o StableHLO znajdziesz w sekcji StableHLO – minimum.

Mul

Zobacz też XlaBuilder::Mul.

Wykonuje iloczyn elementów lhs i rhs.

Mul(lhs, rhs)

Kształty argumentów muszą być podobne lub zgodne. Więcej informacji o tym, co oznacza zgodność kształtów, znajdziesz w dokumentacji dotyczącej rozgłaszania. Wynik operacji ma kształt, który jest wynikiem rozgłaszania dwóch tablic wejściowych. W tym wariancie operacje między tablicami o różnych rangach nie są obsługiwane, chyba że jeden z operandów jest skalarem.

Istnieje alternatywna wersja funkcji Mul, która obsługuje nadawanie o różnych wymiarach:

Mul(lhs,rhs, broadcast_dimensions)

Ten wariant operacji należy stosować w przypadku działań arytmetycznych na tablicach o różnych rangach (np. dodawania macierzy do wektora).

Dodatkowy operand broadcast_dimensions to wycinek liczb całkowitych określający wymiary, które mają być używane do rozgłaszania operandów. Semantyka jest szczegółowo opisana na stronie dotyczącej transmisji.

Więcej informacji o StableHLO znajdziesz w artykule StableHLO – mnożenie.

Neg

Zobacz też XlaBuilder::Neg.

Negacja elementu x -> -x.

Neg(operand)

Więcej informacji o StableHLO znajdziesz w artykule StableHLO – negate.

Nie

Zobacz też XlaBuilder::Not.

Logiczne zaprzeczenie elementu x -> !(x).

Not(operand)

Informacje o StableHLO znajdziesz w sekcji StableHLO – nie.

OptimizationBarrier

Zobacz też XlaBuilder::OptimizationBarrier.

Blokuje przenoszenie obliczeń przez barierę w przypadku dowolnego etapu optymalizacji.

OptimizationBarrier(operand)

Gwarantuje, że wszystkie dane wejściowe zostaną ocenione przed operatorami, którzy zależą od wyników bariery.

Informacje o StableHLO znajdziesz w sekcji StableHLO – optimization_barrier.

Lub

Zobacz też XlaBuilder::Or.

Wykonuje operację OR na poszczególnych elementach lhs i rhs .

Or(lhs, rhs)

Kształty argumentów muszą być podobne lub zgodne. Więcej informacji o tym, co oznacza zgodność kształtów, znajdziesz w dokumentacji dotyczącej rozgłaszania. Wynik operacji ma kształt, który jest wynikiem rozgłaszania dwóch tablic wejściowych. W tym wariancie operacje między tablicami o różnych rangach nie są obsługiwane, chyba że jeden z operandów jest skalarem.

Istnieje wariant alternatywny z obsługą transmisji w różnych wymiarach dla:

Or(lhs,rhs, broadcast_dimensions)

Ten wariant operacji należy stosować w przypadku działań arytmetycznych na tablicach o różnych rangach (np. dodawania macierzy do wektora).

Dodatkowy operand broadcast_dimensions to wycinek liczb całkowitych określający wymiary, które mają być używane do rozgłaszania operandów. Semantyka jest szczegółowo opisana na stronie dotyczącej transmisji.

Więcej informacji o StableHLO znajdziesz w artykule StableHLO – lub.

Wyjście

Zobacz też XlaBuilder::Outfeed.

Zapisuje dane wejściowe w pliku wyjściowym.

Outfeed(operand, shape_with_layout, outfeed_config)

shape_with_layout określa ułożony kształt, który chcemy wyeksportować.

Więcej informacji o StableHLO znajdziesz w artykule StableHLO – outfeed.

Podkładka

Zobacz też XlaBuilder::Pad.

Pad(operand, padding_value, padding_config)

Rozszerza podaną tablicę operand, dodając do niej dopełnienie wokół niej oraz między jej elementami za pomocą podanego znaku padding_value. padding_config określa ilość dopełnienia krawędzi i dopełnienia wewnętrznego dla każdego wymiaru.

PaddingConfig to pole powtarzane w PaddingConfigDimension, które zawiera 3 pola dla każdego wymiaru: edge_padding_low, edge_padding_high i interior_padding.

edge_padding_low i edge_padding_high określają ilość dopełnienia dodanego odpowiednio na początku (obok indeksu 0) i na końcu (obok najwyższego indeksu) każdego wymiaru. Ilość dopełnienia krawędziowego może być ujemna – wartość bezwzględna ujemnego dopełnienia wskazuje liczbę elementów do usunięcia z określonego wymiaru.

interior_padding określa ilość dopełnienia dodawanego między dowolnymi dwoma elementami w każdym wymiarze. Nie może być ujemna. Dopełnienie wewnętrzne występuje logicznie przed dopełnieniem krawędzi, więc w przypadku ujemnego dopełnienia krawędzi elementy są usuwane z operandu z dopełnieniem wewnętrznym.

Ta operacja nie ma wpływu na wynik, jeśli wszystkie pary dopełnienia krawędzi to (0, 0), a wartości dopełnienia wewnętrznego to 0. Na rysunku poniżej przedstawiono przykłady różnych wartości edge_padding i interior_padding w przypadku tablicy dwuwymiarowej.

Więcej informacji o StableHLO znajdziesz w artykule StableHLO – pad.

Parametr

Zobacz też XlaBuilder::Parameter.

Parameter reprezentuje argument wejściowy do obliczeń.

PartitionID

Zobacz też XlaBuilder::BuildPartitionId.

Generuje partition_id bieżącego procesu.

PartitionID(shape)

Zapis PartitionID może się pojawiać w zrzutach HLO, ale nie jest przeznaczony do ręcznego tworzenia przez użytkowników.

Informacje o StableHLO znajdziesz w artykule StableHLO – partition_id.

PopulationCount

Zobacz też XlaBuilder::PopulationCount.

Oblicza liczbę bitów ustawionych w każdym elemencie operand.

PopulationCount(operand)

Więcej informacji o StableHLO znajdziesz w artykule StableHLO – popcnt.

Pow

Zobacz też XlaBuilder::Pow.

Wykonuje potęgowanie elementów lhs przez rhs.

Pow(lhs, rhs)

Kształty argumentów muszą być podobne lub zgodne. Więcej informacji o tym, co oznacza zgodność kształtów, znajdziesz w dokumentacji dotyczącej rozgłaszania. Wynik operacji ma kształt, który jest wynikiem rozgłaszania dwóch tablic wejściowych. W tym wariancie operacje między tablicami o różnych rangach nie są obsługiwane, chyba że jeden z operandów jest skalarem.

Istnieje alternatywny wariant z obsługą transmisji w różnych wymiarach dla Pow:

Pow(lhs,rhs, broadcast_dimensions)

Ten wariant operacji należy stosować w przypadku działań arytmetycznych na tablicach o różnych rangach (np. dodawania macierzy do wektora).

Dodatkowy operand broadcast_dimensions to wycinek liczb całkowitych określający wymiary, które mają być używane do rozgłaszania operandów. Semantyka jest szczegółowo opisana na stronie dotyczącej transmisji.

Więcej informacji o StableHLO znajdziesz w artykule StableHLO – zasilanie.

Real

Zobacz też XlaBuilder::Real.

Część rzeczywista elementu złożonego (lub rzeczywistego). x -> real(x). Jeśli operand jest liczbą zmiennoprzecinkową, funkcja Real zwraca tę samą wartość.

Real(operand)

Informacje o StableHLO znajdziesz w artykule StableHLO – rzeczywiste.

Recv

Zobacz też XlaBuilder::Recv.

Recv, RecvWithTokens i RecvToHost to operacje, które służą jako podstawowe elementy komunikacji w HLO. Te operacje zwykle pojawiają się w zrzutach HLO jako część operacji wejścia/wyjścia niskiego poziomu lub przesyłania na innym urządzeniu, ale nie są przeznaczone do ręcznego tworzenia przez użytkowników.

Recv(shape, handle)

Otrzymuje dane o podanym kształcie z instrukcji Send w innym obliczeniu, które korzysta z tego samego uchwytu kanału. Zwraca XlaOp dla otrzymanych danych.

Więcej informacji o StableHLO znajdziesz w artykule StableHLO – recv.

RecvDone

Zobacz też HloInstruction::CreateRecv i HloInstruction::CreateRecvDone.

Podobnie jak w przypadku operacji Send, interfejs API klienta operacji Recv reprezentuje komunikację synchroniczną. Instrukcja jest jednak wewnętrznie rozkładana na 2 instrukcje HLO (Recv i RecvDone), aby umożliwić asynchroniczne przesyłanie danych.

Recv(const Shape& shape, int64 channel_id)

Przydziela zasoby wymagane do odbierania danych z instrukcji Send z tym samym identyfikatorem channel_id. Zwraca kontekst przydzielonych zasobów, który jest używany przez następną instrukcję RecvDone do oczekiwania na zakończenie przesyłania danych. Kontekst jest krotką {bufor odbiorczy (kształt), identyfikator żądania (U32)} i może być używany tylko przez instrukcję RecvDone.

W kontekście utworzonym przez instrukcję Recv czeka na zakończenie przesyłania danych i zwraca otrzymane dane.

Ograniczamy

Zobacz też XlaBuilder::Reduce.

Równolegle stosuje funkcję redukcji do co najmniej 1 tablicy.

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

Gdzie:

• Wartość N musi być większa lub równa 1.
• Obliczenia muszą być „w przybliżeniu” łączne (patrz poniżej).
• Wszystkie tablice wejściowe muszą mieć te same wymiary.
• Wszystkie wartości początkowe muszą tworzyć tożsamość w ramach computation.
• Jeśli N = 1, Collate(T) to T.
• Jeśli N > 1, Collate(T_0, ..., T_{N-1}) jest krotką elementów N typu T.

Ta operacja zmniejsza co najmniej 1 wymiar każdej tablicy wejściowej do wartości skalarnej. Liczba wymiarów każdej zwróconej tablicy to number_of_dimensions(operand) - len(dimensions). Wynikiem działania tego operatora jest Collate(Q_0, ..., Q_N), gdzie Q_i to tablica typu T_i, której wymiary opisano poniżej.

Różne back-endy mogą ponownie powiązać obliczenia redukcji. Może to prowadzić do różnic liczbowych, ponieważ niektóre funkcje redukcji, takie jak dodawanie, nie są łączne w przypadku liczb zmiennoprzecinkowych. Jeśli jednak zakres danych jest ograniczony, dodawanie liczb zmiennoprzecinkowych jest wystarczająco bliskie łączności w większości praktycznych zastosowań.

Informacje o StableHLO znajdziesz w artykule StableHLO – reduce.

Przykłady

Gdy redukujesz w jednym wymiarze w pojedynczej tablicy 1D z wartościami [10, 11, 12, 13] za pomocą funkcji redukcji f (czyli computation), możesz to obliczyć w ten sposób:

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

ale istnieje też wiele innych możliwości, np.

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

Poniżej znajdziesz przykładowy pseudokod, który pokazuje, jak można zaimplementować redukcję, używając sumowania jako obliczenia redukcji z wartością początkową 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]

Oto przykład zmniejszania tablicy 2D (macierzy). Kształt ma 2 wymiary: wymiar 0 o rozmiarze 2 i wymiar 1 o rozmiarze 3:

Wyniki redukcji wymiarów 0 lub 1 za pomocą funkcji „dodawanie”:

Zwróć uwagę, że oba wyniki redukcji to tablice 1D. Na diagramie jeden z nich jest przedstawiony jako kolumna, a drugi jako wiersz, aby ułatwić wizualizację.

Oto bardziej złożony przykład tablicy 3D. Liczba wymiarów wynosi 3, wymiar 0 ma rozmiar 4, wymiar 1 ma rozmiar 2, a wymiar 2 ma rozmiar 3. Dla uproszczenia wartości od 1 do 6 są powielane w wymiarze 0.

Podobnie jak w przypadku przykładu 2D możemy zmniejszyć tylko jeden wymiar. Jeśli np. zmniejszymy wymiar 0, otrzymamy tablicę dwuwymiarową, w której wszystkie wartości w wymiarze 0 zostały przekształcone w wartość skalarną:

|  4   8  12 |
| 16  20  24 |

Jeśli zmniejszymy wymiar 2, otrzymamy też tablicę dwuwymiarową, w której wszystkie wartości w wymiarze 2 zostały zwinięte do skalaru:

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

Pamiętaj, że względna kolejność pozostałych wymiarów w danych wejściowych jest zachowywana w danych wyjściowych, ale niektóre wymiary mogą otrzymać nowe numery (ponieważ zmienia się liczba wymiarów).

Możemy też zmniejszyć liczbę wymiarów. Dodanie wymiarów redukujących 0 i 1 daje 1-wymiarową tablicę [20, 28, 36].

Zmniejszenie tablicy 3D we wszystkich jej wymiarach daje skalar 84.

Variadic Reduce

W przypadku funkcji N > 1 zastosowanie funkcji reduce jest nieco bardziej złożone, ponieważ jest ona stosowana jednocześnie do wszystkich danych wejściowych. Operandy są dostarczane do obliczeń w następującej kolejności:

• Uruchomienie zmniejszonej wartości pierwszego argumentu
• …
• Uruchomienie zmniejszonej wartości dla N-tego operandu
• Wartość wejściowa pierwszego argumentu
• …
• Wartość wejściowa N-tego operandu

Rozważmy na przykład tę funkcję redukcji, której można użyć do równoległego obliczania wartości maksymalnej i argumentu wartości maksymalnej w tablicy 1D:

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

W przypadku jednowymiarowych tablic wejściowych V = Float[N], K = Int[N] i wartości początkowych I_V = Float, I_K = Int wynik f_(N-1) redukcji w jedynym wymiarze wejściowym jest równoważny z tym rekurencyjnym zastosowaniem:

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

Zastosowanie tej redukcji do tablicy wartości i tablicy kolejnych indeksów (np. iota) spowoduje iterację po tablicach i zwrócenie krotki zawierającej maksymalną wartość i odpowiadający jej indeks.

ReducePrecision

Zobacz też XlaBuilder::ReducePrecision.

Modeluje efekt konwersji wartości zmiennoprzecinkowych na format o mniejszej precyzji (np. IEEE-FP16) i z powrotem na format pierwotny. Liczbę bitów wykładnika i mantysy w formacie o niższej precyzji można określić dowolnie, chociaż nie wszystkie rozmiary bitów mogą być obsługiwane we wszystkich implementacjach sprzętowych.

ReducePrecision(operand, exponent_bits, mantissa_bits)

Wynikiem jest tablica typu T. Wartości wejściowe są zaokrąglane do najbliższej wartości, którą można przedstawić za pomocą podanej liczby bitów mantysy (przy użyciu semantyki „zaokrąglanie do najbliższej parzystej”), a wszystkie wartości przekraczające zakres określony przez liczbę bitów wykładnika są przycinane do dodatniej lub ujemnej nieskończoności. Wartości NaN są zachowywane, chociaż mogą być przekształcane w kanoniczne wartości NaN.

Format o mniejszej precyzji musi mieć co najmniej 1 bit wykładnika (aby odróżnić wartość zero od nieskończoności, ponieważ obie mają mantysę równą zero) i nieujemną liczbę bitów mantysy. Liczba bitów wykładnika lub mantysy może przekraczać odpowiednią wartość dla typu T; odpowiednia część konwersji jest wtedy po prostu operacją bez efektu.

Informacje o StableHLO znajdziesz w sekcji StableHLO – reduce_precision.

ReduceScatter

Zobacz też XlaBuilder::ReduceScatter.

ReduceScatter to operacja zbiorowa, która skutecznie wykonuje AllReduce, a następnie rozprasza wynik, dzieląc go na shard_count bloków wzdłuż wymiaru scatter_dimension. Replika i w grupie replik otrzymuje fragment ith.

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

• Gdy operand jest krotką tablic, operacja reduce-scatter jest wykonywana na każdym elemencie krotki.
• replica_groups to lista grup replik, między którymi przeprowadzane jest zmniejszanie (identyfikator repliki dla bieżącej repliki można pobrać za pomocą ReplicaId). Kolejność replik w każdej grupie określa kolejność, w jakiej wynik operacji all-reduce zostanie rozproszony. replica_groups musi być pusta (w takim przypadku wszystkie repliki należą do jednej grupy) lub zawierać tyle samo elementów co liczba replik. Jeśli jest więcej niż jedna grupa replik, wszystkie muszą mieć ten sam rozmiar. Na przykład replica_groups = {0, 2}, {1, 3} przeprowadza zmniejszanie między replikami 0 i 2 oraz 1 i 3, a następnie rozprasza wynik.
• shard_count to rozmiar każdej grupy replik. Jest to potrzebne w przypadku, gdy pole replica_groups jest puste. Jeśli pole replica_groups nie jest puste, wartość shard_count musi być równa rozmiarowi każdej grupy replik.
• channel_id jest używany do komunikacji między modułami: tylko operacje reduce-scatter z tym samym channel_id mogą się ze sobą komunikować.
• layout Więcej informacji o układach znajdziesz w sekcji xla::shapes.
• use_global_device_ids to flaga określona przez użytkownika. Gdy false(domyślnie) liczby w replica_groups są ReplicaId, a gdy true liczby w replica_groups reprezentują globalny identyfikator (ReplicaID*partition_count + partition_id). Przykład:
  • W przypadku 2 replik i 4 partycji
  • 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)
  • gdzie każda para to (replica_id, partition_id).

Kształt wyjściowy jest kształtem wejściowym zmniejszonym scatter_dimension razy.shard_count Jeśli na przykład są 2 repliki, a operand ma wartość [1.0, 2.25] i [3.0, 5.25] odpowiednio na 2 replikach, to wartość wyjściowa tego działania, w którym scatter_dim to 0, będzie wynosić [4.0] na pierwszej replice i [7.5] na drugiej replice.

Informacje o StableHLO znajdziesz w artykule StableHLO – reduce_scatter.

ReduceScatter - Example 1 - StableHLO

W przykładzie powyżej w operacji ReduceScatter uczestniczą 2 repliki. W każdej replice operand ma kształt f32[2,4]. Na replikach jest wykonywana operacja all-reduce (suma), która daje zredukowaną wartość o kształcie f32[2,4] na każdej replice. Ta zredukowana wartość jest następnie dzielona na 2 części wzdłuż wymiaru 1, więc każda część ma kształt f32[2,2]. Każda replika w grupie procesów otrzymuje część odpowiadającą jej pozycji w grupie. W rezultacie dane wyjściowe na każdej replice mają kształt f32[2,2].

ReduceWindow

Zobacz też XlaBuilder::ReduceWindow.

Stosuje funkcję redukcji do wszystkich elementów w każdym oknie sekwencji N tablic wielowymiarowych, tworząc jako dane wyjściowe pojedynczą tablicę wielowymiarową lub krotkę N tablic wielowymiarowych. Każda tablica wyjściowa ma tyle samo elementów, ile jest prawidłowych pozycji okna. Warstwę puli można wyrazić jako ReduceWindow. Podobnie jak w przypadku Reduce, zastosowany computation jest zawsze przekazywany do init_values po lewej stronie.

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

Gdzie:

• Wartość N musi być większa lub równa 1.
• Wszystkie tablice wejściowe muszą mieć te same wymiary.
• Jeśli N = 1, Collate(T) to T.
• Jeśli N > 1, Collate(T_0, ..., T_{N-1}) jest krotką elementów N typu (T0,...T{N-1}).

Informacje o StableHLO znajdziesz w artykule StableHLO – reduce_window.

ReduceWindow – przykład 1

Dane wejściowe to macierz o rozmiarze [4x6], a zarówno window_dimensions, jak i window_stride_dimensions mają rozmiar [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);