작업 시맨틱스

컬렉션을 사용해 정리하기 내 환경설정을 기준으로 콘텐츠를 저장하고 분류하세요.

다음은 XlaBuilder 인터페이스에 정의된 작업의 시맨틱스를 설명합니다. 일반적으로 이러한 작업은 xla_data.proto의 RPC 인터페이스에 정의된 작업에 일대일로 매핑됩니다.

명명법에 관한 참고사항: XLA에서 다루는 일반화된 데이터 유형은 32비트 부동 소수점 수와 같은 일부 균일한 유형의 요소를 보유한 N차원 배열입니다. 문서 전체에서 배열은 임의 크기 배열을 나타내는 데 사용됩니다. 편의를 위해 특수 사례에는 더 구체적이고 친숙한 이름이 있습니다. 예를 들어 벡터는 1차원 배열이고 행렬은 2차원 배열입니다.

AfterAll

XlaBuilder::AfterAll도 참고하세요.

AfterAll은 가변 개수의 토큰을 사용하고 단일 토큰을 생성합니다. 토큰은 순서를 적용하기 위해 부작용이 있는 작업 간에 스레드할 수 있는 원시 유형입니다. AfterAll는 집합 연산 후 작업 순서를 지정하기 위한 토큰 조인으로 사용할 수 있습니다.

AfterAll(operands)

AllGather

XlaBuilder::AllGather도 참고하세요.

복제본 간에 연결을 실행합니다.

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

• replica_groups는 연결이 실행되는 복제본 그룹의 목록입니다. 현재 복제본의 복제본 ID는 ReplicaId를 사용하여 검색할 수 있습니다. 각 그룹의 복제본 순서에 따라 입력이 결과에 배치되는 순서가 결정됩니다. replica_groups는 비어 있거나 (이 경우 모든 복제본이 0에서 N - 1로 순서가 지정된 단일 그룹에 속함) 복제본 수와 동일한 수의 요소를 포함해야 합니다. 예를 들어 replica_groups = {0, 2}, {1, 3}는 복제본 0와 2, 1와 3 간에 연결을 실행합니다.
• shard_count은 각 복제본 그룹의 크기입니다. replica_groups가 비어 있는 경우에 필요합니다.
• channel_id는 교차 모듈 통신에 사용됩니다. 동일한 channel_id를 사용하는 all-gather 작업만 서로 통신할 수 있습니다.

출력 도형은 all_gather_dim가 shard_count배 커진 입력 도형입니다. 예를 들어 복제본이 두 개 있고 피연산자가 두 복제본에서 각각 [1.0, 2.5] 및 [3.0, 5.25] 값을 갖는 경우 all_gather_dim이 0인 이 연산의 출력 값은 두 복제본 모두에서 [1.0, 2.5, 3.0, 5.25]입니다.

AllReduce

XlaBuilder::AllReduce도 참고하세요.

여러 복제본에서 맞춤 계산을 실행합니다.

AllReduce(operand, computation, replica_group_ids, channel_id)

• operand가 배열의 튜플인 경우 튜플의 각 요소에 대해 all-reduce가 실행됩니다.
• replica_groups는 감소가 실행되는 복제본 그룹의 목록입니다 (현재 복제본의 복제본 ID는 ReplicaId를 사용하여 검색할 수 있음). replica_groups는 비어 있거나 (이 경우 모든 복제본이 단일 그룹에 속함) 복제본 수와 동일한 수의 요소를 포함해야 합니다. 예를 들어 replica_groups = {0, 2}, {1, 3}는 0 및 2 복제본과 1 및 3 복제본 간에 감소를 실행합니다.
• channel_id는 교차 모듈 통신에 사용됩니다. 동일한 channel_id를 사용하는 all-reduce 작업만 서로 통신할 수 있습니다.

출력 모양은 입력 모양과 동일합니다. 예를 들어 두 개의 복제본이 있고 피연산자가 두 복제본에서 각각 [1.0, 2.5] 및 [3.0, 5.25] 값을 갖는 경우 이 연산 및 합산 계산의 출력 값은 두 복제본 모두에서 [4.0, 7.75]입니다. 입력이 튜플인 경우 출력도 튜플입니다.

AllReduce의 결과를 계산하려면 각 복제본에서 하나의 입력이 필요하므로 한 복제본이 다른 복제본보다 AllReduce 노드를 더 많이 실행하면 이전 복제본은 영원히 대기합니다. 복제본은 모두 동일한 프로그램을 실행하므로 이러한 상황이 발생할 방법은 많지 않지만, while 루프의 조건이 인피드의 데이터에 종속되고 인피드된 데이터로 인해 while 루프가 한 복제본에서 다른 복제본보다 더 자주 반복되는 경우는 가능합니다.

AllToAll

XlaBuilder::AllToAll도 참고하세요.

AllToAll은 모든 코어에서 모든 코어로 데이터를 전송하는 집합 연산입니다. 두 단계로 구성됩니다.

1. 산포 단계 각 코어에서 피연산자는 split_dimensions을 따라 split_count개의 블록으로 분할되고 블록은 모든 코어에 흩어집니다. 예를 들어, i번째 블록은 i번째 코어로 전송됩니다.
2. 수집 단계 각 코어는 concat_dimension를 따라 수신된 블록을 연결합니다.

참여 코어는 다음과 같이 구성할 수 있습니다.

• replica_groups: 각 ReplicaGroup에는 계산에 참여하는 복제본 ID 목록이 포함됩니다. 현재 복제본의 복제본 ID는 ReplicaId를 사용하여 검색할 수 있습니다. AllToAll은 지정된 순서대로 하위 그룹 내에 적용됩니다. 예를 들어 replica_groups = { {1,2,3}, {4,5,0} }은 AllToAll이 복제본 {1, 2, 3} 내에서 수집 단계에 적용되며 수신된 블록이 1, 2, 3과 동일한 순서로 연결됨을 의미합니다. 그런 다음 4, 5, 0 복제본 내에 다른 AllToAll이 적용되고 연결 순서도 4, 5, 0입니다. replica_groups가 비어 있으면 모든 복제본이 표시 순서대로 하나의 그룹에 속합니다.

기본 요건:

• split_dimension의 피연산자의 크기는 split_count로 나눌 수 있습니다.
• 피연산자의 모양이 튜플이 아닙니다.

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

아래는 Alltoall의 예입니다.

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

이 예시에서는 Alltoall에 참여하는 코어가 4개 있습니다. 각 코어에서 피연산자는 1차원 1을 따라 4개 부분으로 분할되므로 각 부분의 모양은 f32[4,4]입니다. 4개의 부분이 모든 코어에 흩어져 있습니다. 그런 다음 각 코어는 0~4번 코어의 순서대로 차원 0을 따라 수신된 부분을 연결합니다. 따라서 각 코어의 출력은 f32[16,4] 형식입니다.

BatchNormGrad

알고리즘에 관한 자세한 설명은 XlaBuilder::BatchNormGrad 및 원래 배치 정규화 자료를 참고하세요.

배치 표준화의 기울기를 계산합니다.

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

이 연산은 특성 측정기준의 각 특성 (feature_index는 operand의 특성 측정기준 색인)에 대해 다른 모든 측정기준에서 operand, offset, scale에 관한 기울기를 계산합니다. feature_index은 operand의 지형지물 측정기준에 대한 유효한 색인이어야 합니다.

세 가지 기울기는 다음 수식으로 정의됩니다 (4차원 배열을 operand로 가정하고 특성 측정기준 색인이 l, 일괄 크기가 m, 공간 크기가 w 및 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} \]

입력 mean 및 variance는 일괄 처리 및 공간 측정기준의 순간 값을 나타냅니다.

출력 유형은 세 개의 핸들로 구성된 튜플입니다.

BatchNormInference

알고리즘에 관한 자세한 설명은 XlaBuilder::BatchNormInference 및 원래 배치 정규화 자료를 참고하세요.

배치 및 공간 차원에서 배열을 정규화합니다.

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

이 연산은 특성 측정기준의 각 특성 (feature_index는 operand의 특성 측정기준 지수)에 대해 다른 모든 측정기준의 평균과 분산을 계산하고 이 평균과 분산을 사용하여 operand의 각 요소를 정규화합니다. feature_index는 operand의 지형지물 측정기준에 대한 유효한 색인이어야 합니다.

BatchNormInference은 각 배치에 대해 mean 및 variance를 계산하지 않고 BatchNormTraining를 호출하는 것과 같습니다. 대신 입력된 mean 및 variance를 예상 값으로 사용합니다. 이 연산의 목적은 추론의 지연 시간을 줄이는 것이므로 이름이 BatchNormInference입니다.

출력은 입력 operand와 동일한 모양의 n차원 정규화 배열입니다.

BatchNormTraining

알고리즘에 관한 자세한 설명은 XlaBuilder::BatchNormTraining 및 the original batch normalization paper를 참고하세요.

배치 및 공간 차원에서 배열을 정규화합니다.

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

이 연산은 특성 측정기준의 각 특성 (feature_index는 operand의 특성 측정기준 지수)에 대해 다른 모든 측정기준의 평균과 분산을 계산하고 이 평균과 분산을 사용하여 operand의 각 요소를 정규화합니다. feature_index는 operand의 지형지물 측정기준에 대한 유효한 색인이어야 합니다.

이 알고리즘은 w 및 h를 공간적 크기로 사용하는 m 요소가 포함된 operand \(x\) 의 각 배치에 대해 다음과 같이 진행됩니다 (operand가 4차원 배열이라고 가정).

• 특성 측정기준의 각 특성 l에 대한 일괄 평균 \(\mu_l\) 을 계산합니다. \(\mu_l=\frac{1}{mwh}\sum_{i=1}^m\sum_{j=1}^w\sum_{k=1}^h x_{ijkl}\)

• 일괄 분산을 계산합니다. \(\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$

• 정규화, 크기 조정, 이동합니다. \(y_{ijkl}=\frac{\gamma_l(x_{ijkl}-\mu_l)}{\sqrt[2]{\sigma^2_l+\epsilon} }+\beta_l\)

엡실론 값(일반적으로 작은 수)은 0으로 나눗셈 오류를 방지하기 위해 추가됩니다.

출력 유형은 세 개의 XlaOp의 튜플입니다.

batch_mean 및 batch_var는 위의 수식을 사용하여 일괄 처리 및 공간 측정기준에서 계산된 순간입니다.

BitcastConvertType

XlaBuilder::BitcastConvertType도 참고하세요.

TensorFlow의 tf.bitcast와 마찬가지로 데이터 모양에서 타겟 모양으로의 요소별 비트 전송 작업을 실행합니다. 입력 크기와 출력 크기가 일치해야 합니다. 예를 들어 s32 요소는 비트캐스트 루틴을 통해 f32 요소가 되고 하나의 s32 요소는 4개의 s8 요소가 됩니다. 비트 전송은 하위 수준 전송으로 구현되므로 부동 소수점 표현이 다른 머신은 서로 다른 결과를 제공합니다.

BitcastConvertType(operand, new_element_type)

피연산자와 타겟 도형의 크기는 변환 전후에 원시 크기의 비율에 따라 변경되는 마지막 크기를 제외하고 일치해야 합니다.

소스 및 대상 요소 유형은 튜플이 아니어야 합니다.

다른 너비의 기본 유형으로 비트캐스트 변환

BitcastConvert HLO 명령어는 출력 요소 유형 T'의 크기가 입력 요소 T의 크기와 같지 않은 경우를 지원합니다. 전체 작업은 개념적으로 비트 전송이며 기본 바이트를 변경하지 않으므로 출력 요소의 모양이 변경되어야 합니다. B = sizeof(T), B' = sizeof(T')의 경우 두 가지 경우가 가능합니다.

첫째, B > B'인 경우 출력 도형은 크기가 B/B'인 새로운 최소 차원을 갖습니다. 예를 들면 다음과 같습니다.

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

유효 스칼라의 경우 규칙은 동일하게 유지됩니다.

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

또는 B' > B의 경우 입력 도형의 마지막 논리적 차원이 B'/B와 같아야 하며 이 차원은 변환 중에 삭제됩니다.

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

다른 비트 너비 간의 변환은 요소별이 아닙니다.

방송

XlaBuilder::Broadcast도 참고하세요.

배열의 데이터를 복제하여 배열에 측정기준을 추가합니다.

Broadcast(operand, broadcast_sizes)

새 크기가 왼쪽에 삽입됩니다. 즉, broadcast_sizes의 값이 {a0, ..., aN}이고 피연산자 도형의 크기가 {b0, ..., bM}이면 출력 도형의 크기는 {a0, ..., aN, b0, ..., bM}입니다.

새 측정기준은 피연산자의 사본에 색인을 생성합니다. 즉,

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

예를 들어 operand이 값이 2.0f인 스칼라 f32이고 broadcast_sizes이 {2, 3}이면 결과는 모양이 f32[2, 3]인 배열이 되고 결과의 모든 값은 2.0f입니다.

BroadcastInDim

XlaBuilder::BroadcastInDim도 참고하세요.

배열의 데이터를 복제하여 배열의 크기와 크기 수를 확장합니다.

BroadcastInDim(operand, out_dim_size, broadcast_dimensions)

Broadcast와 유사하지만 어디서나 측정기준을 추가하고 크기 1로 기존 측정기준을 확장할 수 있습니다.

operand은 out_dim_size로 설명된 도형에 브로드캐스트됩니다. broadcast_dimensions는 operand의 차원을 타겟 도형의 차원에 매핑합니다. 즉, 피연산자의 i번째 차원은 출력 도형의 broadcast_dimension[i]번째 차원에 매핑됩니다. operand의 크기는 1이거나 매핑되는 출력 도형의 크기와 동일해야 합니다. 나머지 크기는 크기 1의 크기로 채워집니다. 그런 다음 무효 차원 브로드캐스트는 이러한 무효 차원을 따라 브로드캐스트하여 출력 도형에 도달합니다. 시맨틱스는 브로드캐스트 페이지에서 자세히 설명합니다.

통화

XlaBuilder::Call도 참고하세요.

지정된 인수로 계산을 호출합니다.

Call(computation, args...)

args의 아리티와 유형은 computation의 매개변수와 일치해야 합니다. args가 없어도 됩니다.

CompositeCall

XlaBuilder::CompositeCall도 참고하세요.

입력과 composite_attributes를 사용하여 결과를 생성하는 다른 StableHLO 작업으로 구성된 작업을 캡슐화합니다. 연산의 시맨틱은 분해 속성으로 구현됩니다. 복합 연산은 프로그램 시맨틱을 변경하지 않고도 분해로 대체할 수 있습니다. 분해를 인라인 처리해도 동일한 연산 의미론이 제공되지 않는 경우에는 custom_call을 사용하는 것이 좋습니다.

버전 필드 (기본값: 0)는 합성의 시맨틱이 변경될 때를 나타내는 데 사용됩니다.

이 연산자는 is_composite=true 속성이 있는 kCall로 구현됩니다. decomposition 필드는 computation 속성으로 지정됩니다. 프런트엔드 속성은 나머지 속성을 composite. 접두사로 저장합니다.

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

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

Cholesky

XlaBuilder::Cholesky도 참고하세요.

대칭 (허미티안) 양의 정규 행렬 일괄의 콜레스키 분해를 계산합니다.

Cholesky(a, lower)

lower이 true인 경우 $a = l이 되도록 아래쪽 대각 행렬 l를 계산합니다 . l^T$. lower가 false인 경우\(a = u^T . u\)와 같은 상위 삼각형 행렬 u를 계산합니다.

입력 데이터는 lower 값에 따라 a의 하위/상위 삼각형에서만 읽습니다. 다른 삼각형의 값은 무시됩니다. 출력 데이터는 동일한 삼각형으로 반환됩니다. 다른 삼각형의 값은 구현에 의해 정의되며 무엇이든 될 수 있습니다.

a의 차원이 2보다 크면 a는 배치 행렬로 취급되며, 여기서 보조 2차원 외의 모든 차원이 배치 차원입니다.

a가 대칭 (허미티안) 양수 정규식이 아닌 경우 결과는 구현에 의해 정의됩니다.

고정

XlaBuilder::Clamp도 참고하세요.

최솟값과 최댓값 사이의 범위 내에 연산자를 고정합니다.

Clamp(min, operand, max)

피연산자와 최솟값 및 최댓값을 주면 피연산자가 최솟값과 최댓값 사이의 범위에 있으면 피연산자를 반환하고, 그렇지 않으면 피연산자가 이 범위보다 낮으면 최솟값을 반환하고, 피연산자가 이 범위보다 높으면 최대값을 반환합니다. 즉, clamp(a, x, b) = min(max(a, x), b)입니다.

세 배열의 모양이 모두 같아야 합니다. 또는 제한된 형태의 브로드캐스트로 min 또는 max가 T 유형의 스칼라일 수 있습니다.

스칼라 min 및 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};

접기

XlaBuilder::Collapse 및 tf.reshape 작업도 참고하세요.

배열의 차원을 하나의 차원으로 축소합니다.

Collapse(operand, dimensions)

Collapse는 피연산자의 측정기준 중 지정된 하위 집합을 단일 측정기준으로 대체합니다. 입력 인수는 T 유형의 임의 배열과 크기 색인의 컴파일 시간 상수 벡터입니다. 측정기준 색인은 T의 측정기준의 연속된 하위 집합으로, 순서가 지정되어야 합니다 (측정기준 번호가 낮음에서 높음). 따라서 {0, 1, 2}, {0, 1}, {1, 2}는 모두 유효한 측정기준 집합이지만 {1, 0} 또는 {0, 2}는 유효하지 않습니다. 대체되는 측정기준과 동일한 위치에 있는 단일 새 측정기준으로 대체되며, 새 측정기준 크기는 원래 측정기준 크기의 곱과 같습니다. dimensions의 가장 낮은 크기 숫자는 이러한 크기를 접는 루프 중첩에서 가장 느리게 변하는 크기 (가장 큰 크기)이고 가장 높은 크기 숫자는 가장 빠르게 변하는 크기 (가장 작은 크기)입니다. 더 일반적인 접기 순서가 필요한 경우 tf.reshape 연산자를 참고하세요.

예를 들어 v가 24개 요소의 배열이라고 가정해 보겠습니다.

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

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

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

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

CollectivePermute

XlaBuilder::CollectivePermute도 참고하세요.

CollectivePermute는 복제본 간에 데이터를 전송하고 수신하는 집합 연산입니다.

CollectivePermute(operand, source_target_pairs)

source_target_pair에는 다음과 같은 제한사항이 있습니다.

• 두 쌍의 대상 복제본 ID가 같아서는 안 되며 소스 복제본 ID도 같아서는 안 됩니다.
• 복제본 ID가 어떤 쌍에서도 타겟이 아닌 경우 해당 복제본의 출력은 입력과 동일한 모양의 0으로 구성된 텐서입니다.

Concatenate

XlaBuilder::ConcatInDim도 참고하세요.

연결 연산자는 여러 배열 피연산자로 배열을 구성합니다. 배열은 각 입력 배열 피연산자 (서로 동일한 수의 차원을 가져야 함)와 동일한 수의 차원을 가지며 지정된 순서대로 인수를 포함합니다.

Concatenate(operands..., dimension)

dimension를 제외한 모든 측정기준은 동일해야 합니다. 이는 XLA가 '누락된' 배열을 지원하지 않기 때문입니다. 또한 0차원 값은 연결할 수 없습니다 (연결이 발생하는 차원의 이름을 지정할 수 없기 때문).

1차원 예:

Concat({ {2, 3}, {4, 5}, {6, 7} }, 0)
>>> {2, 3, 4, 5, 6, 7}

2차원 예:

let a = {
{1, 2},
{3, 4},
{5, 6},
};
let b = {
{7, 8},
};
Concat({a, b}, 0)
>>> {
{1, 2},
{3, 4},
{5, 6},
{7, 8},
}

다이어그램:

조건부

XlaBuilder::Conditional도 참고하세요.

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

pred가 true이면 true_computation를, pred가 false이면 false_computation를 실행하고 결과를 반환합니다.

true_computation는 \(T_0\) 유형의 단일 인수를 사용해야 하며 동일한 유형의 true_operand로 호출됩니다. false_computation는 \(T_1\) 유형의 단일 인수를 사용해야 하며 동일한 유형의 false_operand로 호출됩니다. true_computation 및 false_computation의 반환 값 유형은 동일해야 합니다.

pred 값에 따라 true_computation와 false_computation 중 하나만 실행됩니다.

Conditional(branch_index, branch_computations, branch_operands)

branch_computations[branch_index]를 실행하고 결과를 반환합니다. branch_index가 0보다 작거나 N보다 큰 S32이면 branch_computations[N-1]가 기본 브랜치로 실행됩니다.

각 branch_computations[b]는 \(T_b\) 유형의 단일 인수를 사용해야 하며 동일한 유형의 branch_operands[b]로 호출됩니다. 각 branch_computations[b]의 반환 값 유형은 동일해야 합니다.

branch_index의 값에 따라 branch_computations 중 하나만 실행됩니다.

Conv (컨볼루션)

XlaBuilder::Conv도 참고하세요.

ConvWithGeneralPadding과 같지만 패딩은 SAME 또는 VALID로 간단하게 지정됩니다. SAME 패딩은 입력 (lhs)을 0으로 채우므로, 스트라이딩을 고려하지 않을 때 출력의 모양이 입력과 동일합니다. VALID 패딩은 패딩이 없다는 뜻입니다.

ConvWithGeneralPadding (컨볼루션)

XlaBuilder::ConvWithGeneralPadding도 참고하세요.

신경망에 사용되는 종류의 컨볼루션을 계산합니다. 여기서 컨볼루션은 n차원 기본 영역을 가로질러 이동하는 n차원 창으로 생각할 수 있으며, 가능한 각 창 위치에 대해 계산이 실행됩니다.

n은 공간 차원의 수입니다. lhs 인수는 기본 영역을 설명하는 (n+2)차원 배열입니다. 물론 rhs도 입력이지만 이를 입력이라고 합니다. 신경망에서 이는 입력 활성화입니다. n+2 차원은 다음과 같은 순서로 표시됩니다.

• batch: 이 측정기준의 각 좌표는 컨볼루션이 실행되는 독립적인 입력을 나타냅니다.
• z/depth/features: 기본 영역의 각 (y,x) 위치에는 이 측정기준으로 이동하는 연결된 벡터가 있습니다.
• spatial_dims: 창이 이동하는 기본 영역을 정의하는 n 공간 측정기준을 설명합니다.

rhs 인수는 컨볼루션 필터/커널/창을 나타내는 (n+2)차원 배열입니다. 측정기준은 다음과 같은 순서로 표시됩니다.

• output-z: 출력의 z 차원입니다.
• input-z: 이 차원의 크기에 feature_group_count를 곱한 값이 왼쪽 항의 z 차원 크기와 같아야 합니다.
• spatial_dims: 기본 영역을 가로질러 이동하는 n차원 창을 정의하는 n 공간적 측정기준을 설명합니다.

window_strides 인수는 공간적 측정기준에서 컨볼루션 창의 스트라이드를 지정합니다. 예를 들어 첫 번째 공간 측정기준의 스트라이드가 3이면 첫 번째 공간 색인이 3으로 나누어 떨어지는 좌표에만 창을 배치할 수 있습니다.

padding 인수는 기본 영역에 적용할 0 패딩의 양을 지정합니다. 패딩의 양은 음수일 수 있습니다. 음수 패딩의 절대값은 컨볼루션을 실행하기 전에 지정된 크기에서 삭제할 요소 수를 나타냅니다. padding[0]는 측정기준 y의 패딩을 지정하고 padding[1]는 측정기준 x의 패딩을 지정합니다. 각 쌍은 낮은 패딩을 첫 번째 요소로, 높은 패딩을 두 번째 요소로 갖습니다. 낮은 패딩은 낮은 색인 방향으로 적용되고 높은 패딩은 높은 색인 방향으로 적용됩니다. 예를 들어 padding[1]이 (2,3)이면 두 번째 공간 측정기준에서 왼쪽에 0 2개, 오른쪽에 0 3개가 패딩됩니다. 패딩을 사용하면 컨볼루션을 실행하기 전에 동일한 0 값을 입력 (lhs)에 삽입하는 것과 같습니다.

lhs_dilation 및 rhs_dilation 인수는 각 공간 측정기준에서 각각 lhs 및 rhs에 적용할 확장 계수를 지정합니다. 공간 측정기준의 확장 계수가 d이면 해당 측정기준의 각 항목 사이에 d-1개의 구멍이 암시적으로 배치되어 배열 크기가 증가합니다. 구멍은 무작위 값으로 채워지며, 컨볼루션의 경우 0을 의미합니다.

우변의 확장을 아트러스 컨볼루션이라고도 합니다. 자세한 내용은 tf.nn.atrous_conv2d를 참고하세요. 좌변의 확장은 전치 컨볼루션이라고도 합니다. 자세한 내용은 tf.nn.conv2d_transpose를 참고하세요.

feature_group_count 인수 (기본값 1)는 그룹화된 컨볼루션에 사용할 수 있습니다. feature_group_count는 입력 및 출력 피처 측정기준의 공배수여야 합니다. feature_group_count가 1보다 크면 개념적으로 입력 및 출력 특성 차원과 rhs 출력 특성 차원이 여러 feature_group_count 그룹으로 균등하게 분할되며 각 그룹은 특성의 연속 하위 시퀀스로 구성됩니다. rhs의 입력 특성 차원은 lhs 입력 특성 차원을 feature_group_count로 나눈 값과 같아야 합니다. 따라서 이미 입력 특성 그룹의 크기를 갖습니다. i번째 그룹은 여러 개의 개별 컨볼루션에 대해 feature_group_count를 계산하는 데 함께 사용됩니다. 이러한 컨볼루션의 결과는 출력 피처 측정기준에서 함께 연결됩니다.

깊이 방향 컨볼루션의 경우 feature_group_count 인수가 입력 특성 차원으로 설정되고 필터가 [filter_height, filter_width, in_channels, channel_multiplier]에서 [filter_height, filter_width, 1, in_channels * channel_multiplier]로 다시 형성됩니다. 자세한 내용은 tf.nn.depthwise_conv2d를 참고하세요.

batch_group_count (기본값 1) 인수는 역전파 중에 그룹화된 필터에 사용할 수 있습니다. batch_group_count는 lhs (입력) 배치 크기의 제수여야 합니다. batch_group_count가 1보다 크면 출력 배치 크기가 input batch / batch_group_count이어야 함을 의미합니다. batch_group_count는 출력 지형지물 크기의 제수여야 합니다.

출력 도형의 크기는 다음과 같은 순서로 지정됩니다.

• batch: 이 차원의 크기에 batch_group_count를 곱한 값은 왼쪽 항의 batch 차원 크기와 같아야 합니다.
• z: 커널의 output-z (rhs)와 동일한 크기입니다.
• spatial_dims: 컨볼루션 창의 유효한 각 배치에 대해 하나의 값입니다.

위 그림은 batch_group_count 필드의 작동 방식을 보여줍니다. 실제로 각 lhs 일괄 처리를 batch_group_count 그룹으로 자르고 출력 기능에 대해서도 동일하게 실행합니다. 그런 다음 이러한 각 그룹에 대해 쌍별 컨볼루션을 실행하고 출력 특성 차원을 따라 출력을 연결합니다. 다른 모든 측정기준 (지형지물 및 공간)의 운영 시맨틱은 동일하게 유지됩니다.

컨볼루션 창의 유효한 배치는 스트라이드와 패딩 후 베이스 영역의 크기에 따라 결정됩니다.

컨볼루션의 작동 방식을 설명하려면 2D 컨볼루션을 고려하고 출력에서 고정된 batch, z, y, x 좌표를 선택합니다. 그러면 (y,x)는 기본 영역 내 창 모서리의 위치입니다 (예: 공간적 크기를 해석하는 방식에 따라 왼쪽 상단 모서리). 이제 각 2D 포인트가 1D 벡터와 연결된 기본 영역에서 가져온 2D 창이 있으므로 3D 상자가 생성됩니다. 컨볼루션 커널에서 출력 좌표 z를 고정했으므로 3D 상자도 있습니다. 두 상자의 크기가 같으므로 두 상자 간의 요소별 곱셈의 합계를 취할 수 있습니다 (내적과 유사). 이것이 출력 값입니다.

output-z이 예를 들어 5이면 기간의 각 위치는 출력의 z 측정기준에 5개의 값을 출력합니다. 이러한 값은 컨볼루션 커널의 어느 부분이 사용되는지에 따라 다릅니다. 각 output-z 좌표에 사용되는 별도의 3D 값 상자가 있습니다. 따라서 이를 각각 다른 필터가 적용된 5개의 별도 컨볼루션으로 생각할 수 있습니다.

다음은 패딩 및 스트라이딩이 있는 2D 컨볼루션의 의사 코드입니다.

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

ConvertElementType

XlaBuilder::ConvertElementType도 참고하세요.

C++의 요소별 static_cast와 마찬가지로 데이터 모양에서 대상 모양으로 요소별 변환 작업을 실행합니다. 측정기준은 일치해야 하며 변환은 요소별로 이루어집니다. 예를 들어 s32 요소는 s32-f32 변환 루틴을 통해 f32 요소가 됩니다.

ConvertElementType(operand, new_element_type)

피연산자와 타겟 도형의 크기가 일치해야 합니다. 소스 및 대상 요소 유형은 튜플이 아니어야 합니다.

T=s32에서 U=f32로의 변환과 같은 변환은 가장 가까운 짝수로 반올림과 같은 정규화 int-to-float 변환 루틴을 실행합니다.

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

CrossReplicaSum

합산 계산을 사용하여 AllReduce를 실행합니다.

CustomCall

XlaBuilder::CustomCall도 참고하세요.

계산 내에서 사용자 제공 함수를 호출합니다.

CustomCall(target_name, args..., shape)

함수 서명은 인수의 개수나 유형과 관계없이 동일합니다.

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

예를 들어 CustomCall이 다음과 같이 사용되는 경우

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

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

다음은 myfunc 구현의 예입니다.

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

사용자 제공 함수에는 부작용이 없어야 하며 실행은 항상 동일한 결과를 반환해야 합니다.

Dot

XlaBuilder::Dot도 참고하세요.

Dot(lhs, rhs)

이 연산의 정확한 시맨틱스는 피연산자의 순위에 따라 다릅니다.

이 연산은 lhs의 두 번째 측정기준 (또는 측정기준이 1개인 경우 첫 번째 측정기준)과 rhs의 첫 번째 측정기준에 대해 곱셈의 합계를 실행합니다. 이러한 측정기준을 '축소된' 측정기준이라고 합니다. lhs와 rhs의 축소된 크기는 동일해야 합니다. 실제로는 벡터 간의 내적, 벡터/행렬 곱셈 또는 행렬/행렬 곱셈을 실행하는 데 사용할 수 있습니다.

DotGeneral

XlaBuilder::DotGeneral도 참고하세요.

DotGeneral(lhs, rhs, dimension_numbers)

Dot과 유사하지만 lhs 및 rhs 모두에 계약 및 일괄 측정기준 숫자를 지정할 수 있습니다.

DotGeneral은 dimension_numbers에 지정된 축소 측정기준에 대해 곱의 합계를 실행합니다.

lhs 및 rhs의 연결된 계약 차원 번호는 동일할 필요는 없지만 크기가 동일해야 합니다.

축소된 측정기준 번호의 예:

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

rhs = { {1.0, 1.0, 1.0},
{2.0, 2.0, 2.0} }

DotDimensionNumbers dnums;
dnums.add_lhs_contracting_dimensions(1);
dnums.add_rhs_contracting_dimensions(1);

DotGeneral(lhs, rhs, dnums) -> { {6.0, 12.0},
{15.0, 30.0} }

lhs 및 rhs의 연결된 배치 측정기준 번호는 측정기준 크기가 동일해야 합니다.

배치 크기가 2이고 행렬이 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} } }

따라서 결과 측정기준 번호는 배치 측정기준으로 시작하고, lhs 비계약/비배치 측정기준으로 시작하고, 마지막으로 rhs 비계약/비배치 측정기준으로 시작합니다.

DynamicSlice

XlaBuilder::DynamicSlice도 참고하세요.

DynamicSlice는 동적 start_indices의 입력 배열에서 하위 배열을 추출합니다. 각 측정기준의 슬라이스의 크기는 size_indices에 전달되며, 이는 각 측정기준의 제외 슬라이스 간격의 종료 지점([start, start + size))을 지정합니다. start_indices의 도형은 1차원이며 크기는 operand의 차원 수와 같습니다.

DynamicSlice(operand, start_indices, size_indices)

유효 슬라이스 색인은 슬라이스를 실행하기 전에 [1, N)의 각 색인 i에 다음 변환을 적용하여 계산됩니다.

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

이렇게 하면 추출된 슬라이스가 항상 피연산자 배열을 기준으로 범위 내에 있게 됩니다. 변환이 적용되기 전에 슬라이스가 범위 내에 있으면 변환이 적용되지 않습니다.

1차원 예:

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

DynamicSlice(a, s, {2}) produces:
{2.0, 3.0}

2차원 예:

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

DynamicSlice(b, s, {2, 2}) produces:
{ { 7.0,  8.0},
{10.0, 11.0} }

DynamicUpdateSlice

XlaBuilder::DynamicUpdateSlice도 참고하세요.

DynamicUpdateSlice는 입력 배열 operand의 값인 결과를 생성하며, 이때 start_indices에서 update 조각이 덮어씁니다. update의 모양에 따라 업데이트되는 결과의 하위 배열 모양이 결정됩니다. start_indices의 모양은 1차원이며 크기는 operand의 크기와 같습니다.

DynamicUpdateSlice(operand, update, start_indices)

유효 슬라이스 색인은 슬라이스를 실행하기 전에 [1, N)의 각 색인 i에 다음 변환을 적용하여 계산됩니다.

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

이렇게 하면 업데이트된 슬라이스가 항상 피연산자 배열을 기준으로 범위 내에 있게 됩니다. 변환이 적용되기 전에 슬라이스가 범위 내에 있으면 변환이 적용되지 않습니다.

1차원 예:

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

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

2차원 예:

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

let s = {1, 1}

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

요소별 바이너리 산술 연산

XlaBuilder::Add도 참고하세요.

일련의 요소별 바이너리 산술 연산이 지원됩니다.

Op(lhs, rhs)

여기서 Op는 Add (덧셈), Sub(뺄셈), Mul(곱셈), Div (나눗셈), Pow (제곱), Rem (나머지), Max(최대값), Min (최솟값), And (논리 AND), Or (논리 OR), Xor (논리 XOR), ShiftLeft (왼쪽 시프트), ShiftRightArithmetic (산술 오른쪽 시프트), ShiftRightLogical (논리 오른쪽 시프트), Atan2 (2개 인수 아르키탄젠트), Complex (실수와 허수 부분을 복소수로 결합) 중 하나입니다.

인수의 도형은 유사하거나 호환되어야 합니다. 도형이 호환된다는 의미에 관한 자세한 내용은 브로드캐스트 문서를 참고하세요. 작업의 결과는 두 입력 배열을 브로드캐스트한 결과인 모양을 갖습니다. 이 변형에서는 피연산자 중 하나가 스칼라가 아닌 한 다른 순위의 배열 간의 작업은 지원되지 않습니다.

Op가 Rem이면 결과의 부호는 피제곱수에서 가져오고 결과의 절대값은 항상 피제수의 절대값보다 작습니다.

정수 나눗셈 오버플로 (0으로 나눗셈/나머지 또는 -1로 INT_SMIN 나눗셈/나머지)는 구현 정의 값을 생성합니다.

이러한 연산에는 다른 차원 브로드캐스트 지원이 포함된 대체 변형이 있습니다.

Op(lhs, rhs, broadcast_dimensions)

여기서 Op은 위와 동일합니다. 이 연산 변형은 행렬을 벡터에 더하는 것과 같이 다양한 등급의 배열 간의 산술 연산에 사용해야 합니다.

추가 broadcast_dimensions 피연산자는 하위 차원 피연산자의 차원 수를 상위 차원 피연산자의 차원 수까지 확장하는 데 사용되는 정수 슬라이스입니다. broadcast_dimensions는 낮은 차원 도형의 크기를 더 높은 차원 도형의 크기에 매핑합니다. 확장된 도형의 매핑되지 않은 크기는 크기가 1인 크기로 채워집니다. 그런 다음 무효 차원 브로드캐스트는 이러한 무효 차원별로 도형을 브로드캐스트하여 두 피연산자의 도형을 동일하게 만듭니다. 시맨틱스는 브로드캐스트 페이지에서 자세히 설명합니다.

요소별 비교 연산

XlaBuilder::Eq도 참고하세요.

일련의 표준 요소별 바이너리 비교 연산이 지원됩니다. 부동 소수점 유형을 비교할 때는 표준 IEEE 754 부동 소수점 비교 시맨틱스가 적용됩니다.

Op(lhs, rhs)

여기서 Op은 Eq (같음), Ne (같지 않음), Ge(크거나 같음), Gt (보다 큼), Le (작거나 같음), Lt(보다 작음) 중 하나입니다. 다른 연산자 집합인 EqTotalOrder, NeTotalOrder, GeTotalOrder, GtTotalOrder, LeTotalOrder, LtTotalOrder는 동일한 기능을 제공하지만, -NaN < -Inf < -Finite < -0 < +0 < +Finite < +Inf < +NaN을 적용하여 부동 소수점 수에 대한 총 순서를 추가로 지원한다는 점이 다릅니다.

인수의 도형은 유사하거나 호환되어야 합니다. 도형이 호환된다는 의미에 관한 자세한 내용은 브로드캐스트 문서를 참고하세요. 연산의 결과는 요소 유형이 PRED인 두 입력 배열을 브로드캐스트한 결과인 모양을 갖습니다. 이 변형에서는 피연산자 중 하나가 스칼라가 아닌 한 다른 순위의 배열 간의 연산이 지원되지 않습니다.

이러한 연산에는 다른 차원 브로드캐스트 지원이 포함된 대체 변형이 있습니다.

Op(lhs, rhs, broadcast_dimensions)

여기서 Op은 위와 동일합니다. 이 연산 변형은 행렬을 벡터에 더하는 것과 같이 다양한 순위의 배열 간의 비교 연산에 사용해야 합니다.

추가 broadcast_dimensions 피연산자는 피연산자 브로드캐스트에 사용할 크기를 지정하는 정수 슬라이스입니다. 시맨틱스는 브로드캐스트 페이지에 자세히 설명되어 있습니다.

요소별 단항 함수

XlaBuilder는 다음과 같은 요소별 단항 함수를 지원합니다.

Abs(operand) 요소별 절대값 x -> |x|.

Cbrt(operand) 요소별 세제곱근 연산 x -> cbrt(x)

Ceil(operand) 요소별 올림 x -> ⌈x⌉.

Clz(operand) 요소별 선행 0 개수를 셉니다.

Cos(operand) 요소별 코사인 x -> cos(x).

Erf(operand) 요소별 오류 함수 x -> erf(x)는 다음과 같습니다.

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

Exp(operand) 요소별 자연 지수 x -> e^x.

Expm1(operand) 요소별 자연 지수에서 1을 뺀 값x -> e^x - 1입니다.

Floor(operand) 요소별 하한선 x -> ⌊x⌋.

Imag(operand) 복소 도형 (또는 실수 도형)의 요소별 허수부입니다. x -> imag(x). 피연산자가 부동 소수점 유형이면 0을 반환합니다.

IsFinite(operand) operand의 각 요소가 유한한지, 즉 양의 무한대 또는 음의 무한대가 아니며 NaN가 아닌지 테스트합니다. 입력과 동일한 모양의 PRED 값 배열을 반환합니다. 여기서 각 요소는 해당 입력 요소가 유한한 경우에만 true입니다.

Log(operand) 요소별 자연 로그 x -> ln(x)입니다.

Log1p(operand) 요소별로 이동된 자연 로그 x -> ln(1+x)입니다.

Logistic(operand) 요소별 로지스틱 함수 계산 x -> logistic(x)

Neg(operand) 요소별 부정 x -> -x.

Not(operand) 요소별 논리 부정 x -> !(x)입니다.

PopulationCount(operand) operand의 각 요소에 설정된 비트 수를 계산합니다.

Real(operand) 복소 도형 (또는 실수 도형)의 요소별 실수부입니다. x -> real(x). 피연산자가 부동 소수점 유형인 경우 동일한 값을 반환합니다.

Round(operand) 요소별 반올림, 동점인 경우 0에서 멀어지는 방향으로 반올림합니다.

RoundNearestEven(operand) 요소별 반올림, 가장 가까운 짝수로 연결

Rsqrt(operand) 제곱근 연산 x -> 1.0 / sqrt(x)의 요소별 역수입니다.

Sign(operand) 요소별 부호 연산 x -> sgn(x)은 다음과 같습니다.

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

operand 요소 유형의 비교 연산자를 사용합니다.

Sin(operand) 요소별 사인 x -> sin(x).

Sqrt(operand) 요소별 제곱근 연산 x -> sqrt(x).

Tan(operand) 요소별 접선 x -> tan(x).

Tanh(operand) 요소별 쌍곡탄젠트 x -> tanh(x).

이 함수는 operand 배열의 각 요소에 적용되어 동일한 모양의 배열이 생성됩니다. operand가 스칼라(0차원)일 수 있습니다.

Fft

XLA FFT 작업은 실수 및 복소수 입력/출력에 대한 전방 및 역 푸리에 변환을 구현합니다. 최대 3축의 다차원 FFT가 지원됩니다.

XlaBuilder::Fft도 참고하세요.

다차원 FFT

fft_length가 2개 이상 제공되면 이는 가장 안쪽 축에 FFT 작업의 캐스케이드를 적용하는 것과 같습니다. 실수->복소수 및 복소수->실수 사례의 경우 가장 안쪽 축 변환이 (효과적으로) 먼저 실행됩니다 (RFFT, IRFFT의 경우 마지막). 따라서 가장 안쪽 축이 크기를 변경합니다. 그러면 다른 축 변환은 복잡->복잡이 됩니다.

구현 세부정보

CPU FFT는 Eigen의 TensorFFT를 기반으로 합니다. GPU FFT는 cuFFT를 사용합니다.

Gather

XLA 수집 작업은 입력 배열의 여러 슬라이스 (각 슬라이스의 런타임 오프셋이 다를 수 있음)를 함께 연결합니다.

일반 시맨틱스

XlaBuilder::Gather도 참고하세요. 더 직관적인 설명은 아래의 '비공식 설명' 섹션을 참고하세요.

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

편의를 위해 offset_dims가 아닌 출력 배열의 측정기준에 batch_dims 라벨을 지정합니다.

출력은 batch_dims.size + offset_dims.size 차원이 있는 배열입니다.

operand.rank는 offset_dims.size와 collapsed_slice_dims.size의 합계와 같아야 합니다. 또한 slice_sizes.size는 operand.rank와 같아야 합니다.

index_vector_dim가 start_indices.rank과 같으면 start_indices에 후행 1 크기가 있다고 암시적으로 간주됩니다. 즉, start_indices의 모양이 [6,7]이고 index_vector_dim가 2인 경우 start_indices의 모양이 [6,7,1]이라고 암시적으로 간주됩니다.

i 측정기준을 따라 출력 배열의 경계는 다음과 같이 계산됩니다.

1. i가 batch_dims에 있는 경우 (즉, 일부 k의 경우 batch_dims[k]과 같음) index_vector_dim를 건너뛰면서 start_indices.shape에서 상응하는 측정기준 경계를 선택합니다 (즉, k < index_vector_dim인 경우 start_indices.shape.dims[k] 를 선택하고 그렇지 않은 경우 start_indices.shape.dims[k+1] 를 선택).

2. i가 offset_dims에 있는 경우 (즉, 일부 k의 경우 offset_dims[k] 와 같음) collapsed_slice_dims를 고려한 후 slice_sizes에서 상응하는 경계를 선택합니다 (즉, adjusted_slice_sizes[k] 를 선택하며 여기서 adjusted_slice_sizes는 색인 collapsed_slice_dims의 경계가 삭제된 slice_sizes입니다).

공식적으로 지정된 출력 색인 Out에 해당하는 피연산자 색인 In는 다음과 같이 계산됩니다.

1. G = { Out[k] for k in batch_dims }라고 하자. G를 사용하여 S[i] = start_indices[Combine(G, i)] 가 되도록 S 벡터를 슬라이스합니다. 여기서 Combine(A, b)는 index_vector_dim 위치에 b를 A에 삽입합니다. G가 비어 있는 경우에도 잘 정의됩니다. G가 비어 있으면 S = start_indices입니다.

2. start_index_map를 사용하여 S를 흩뿌려 S를 사용하여 operand에 시작 색인 Sin를 만듭니다. 더 구체적으로 설명하자면 다음과 같습니다.

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

   2. S그렇지 않으면 _in[_] = 0입니다.

3. collapsed_slice_dims 세트에 따라 Out의 오프셋 측정기준에 색인을 흩뿌려 operand에 색인 Oin를 만듭니다. 더 구체적으로 설명하자면 다음과 같습니다.

   1. Ok < offset_dims.size인 경우 _in[remapped_offset_dims(k)] = Out[offset_dims[k]] 입니다(remapped_offset_dims는 아래에 정의됨).

   2. O그렇지 않으면 _in[_] = 0입니다.

4. In는 Oin + Sin입니다. 여기서 +는 요소별 덧셈입니다.

remapped_offset_dims는 도메인이 [0, offset_dims.size)이고 범위가 [0, operand.rank) \ collapsed_slice_dims인 단조 함수입니다. 예를 들어 offset_dims.size가 4이고 operand.rank가 6이고 collapsed_slice_dims가 {0, 2}이면 remapped_offset_dims는 {0→1, 1→3, 2→4, 3→5}입니다.

indices_are_sorted가 true로 설정된 경우 XLA는 start_indices가 사용자가 정렬했다고 가정할 수 있습니다 (start_index_map에 따라 값을 흩뿌린 후 오름차순으로 정렬됨). 그렇지 않으면 시맨틱은 구현에서 정의됩니다.

비공식 설명 및 예시

비공식적으로 출력 배열의 모든 색인 Out는 다음과 같이 계산된 피연산자 배열의 요소 E에 해당합니다.

• Out의 일괄 측정기준을 사용하여 start_indices에서 시작 색인을 조회합니다.

• start_index_map를 사용하여 시작 색인 (크기가 operand.rank보다 작을 수 있음)을 operand의 '전체' 시작 색인에 매핑합니다.

• 전체 시작 색인을 사용하여 크기가 slice_sizes인 슬라이스를 동적으로 자릅니다.

• collapsed_slice_dims 측정기준을 접어서 슬라이스의 모양을 변경합니다. 모든 접힌 슬라이스 측정기준의 경계는 1이어야 하므로 이 리셰이프는 항상 유효합니다.

• Out의 오프셋 크기를 사용하여 이 슬라이스에 색인을 생성하여 출력 색인 Out에 해당하는 입력 요소 E를 가져옵니다.

다음의 모든 예시에서 index_vector_dim는 start_indices.rank - 1로 설정됩니다. 더 흥미로운 index_vector_dim 값은 작업을 근본적으로 변경하지는 않지만 시각적 표현을 더 번거롭게 만듭니다.

위의 모든 요소가 어떻게 작동하는지 직관적으로 이해하려면 [16,11] 배열에서 [8,6] 도형의 슬라이스 5개를 수집하는 예를 살펴보겠습니다. [16,11] 배열의 슬라이스의 위치는 S64[2] 형식의 색인 벡터로 표시할 수 있으므로 5개의 위치 집합은 S64[5,2] 배열로 표시할 수 있습니다.

그러면 수집 작업의 동작은 [G,O0,O1]를 사용하여 출력 도형의 색인을 다음과 같이 입력 배열의 요소에 매핑하는 색인 변환으로 나타낼 수 있습니다.

먼저 G를 사용하여 수집 색인 배열에서 (X,Y) 벡터를 선택합니다. 그러면 출력 배열의 색인 [G,O0,O1] 에 있는 요소는 입력 배열의 색인 [X+O0,Y+O1]에 있는 요소입니다.

slice_sizes는 O₀ 및 O₁의 범위를 결정하는 [8,6]이며, 이는 슬라이스의 경계를 결정합니다.

이 수집 작업은 G를 일괄 크기로 사용하는 일괄 동적 슬라이스 역할을 합니다.

수집 색인은 다차원일 수 있습니다. 예를 들어 모양이 [4,5,2]인 'gather indices' 배열을 사용하는 위 예시의 더 일반적인 버전은 다음과 같이 색인을 변환합니다.

다시 말해, 이는 배치 동적 슬라이스 G0 및 G1가 배치 측정기준으로 작동합니다. 슬라이스 크기는 여전히 [8,6]입니다.

XLA의 수집 연산은 위에 설명된 비공식 시맨틱스를 다음과 같은 방식으로 일반화합니다.

1. 출력 도형에서 어떤 측정기준이 오프셋 측정기준인지 (마지막 예에서 O0, O1를 포함하는 측정기준) 구성할 수 있습니다. 출력 일괄 차원 (마지막 예에서 G0, G1을 포함하는 차원)은 오프셋 차원이 아닌 출력 차원으로 정의됩니다.

2. 출력 도형에 명시적으로 표시되는 출력 오프셋 측정기준 수는 입력 측정기준 수보다 적을 수 있습니다. collapsed_slice_dims로 명시적으로 표시된 이러한 '누락된' 크기는 슬라이스 크기가 1여야 합니다. 슬라이스 크기가 1이므로 유효한 색인은 0뿐이며 생략해도 모호하지 않습니다.

3. 'Gather Indices' 배열(마지막 예에서는 (X, Y))에서 추출된 슬라이스의 요소 수가 입력 배열의 측정기준 수보다 적을 수 있으며, 명시적 매핑은 입력과 동일한 측정기준 수를 갖도록 색인을 확장하는 방법을 지정합니다.

마지막 예로 (2) 및 (3)을 사용하여 tf.gather_nd를 구현해 보겠습니다.

G0 및 G1는 평소와 같이 수집 색인 배열에서 시작 색인을 자르는 데 사용됩니다. 단, 시작 색인에는 요소가 하나(X)만 있습니다. 마찬가지로 값이 O0인 출력 오프셋 색인은 하나뿐입니다. _{그러나 입력 배열의 색인으로 사용되기 전에 '색인 수집 매핑' (공식 설명의 start_index_map) 및 '오프셋 매핑' (공식 설명의 remapped_offset_dims)에 따라 각각 [X,0] 및 [0,O0]로 확장되어 [X,O0]이 됩니다. 이 색인은 입력 색인 [GatherIndices[G0,G1,0],O0]에 매핑되어 tf.gather_nd의 시맨틱을 제공합니다.}00OGG1

이 케이스의 slice_sizes는 [1,11]입니다. 직관적으로 이는 수집 색인 배열의 모든 색인 X가 전체 행을 선택하고 결과는 이러한 모든 행의 연결입니다.

GetDimensionSize

XlaBuilder::GetDimensionSize도 참고하세요.

피연산자의 지정된 크기의 크기를 반환합니다. 피연산자는 배열 형식이어야 합니다.

GetDimensionSize(operand, dimension)

SetDimensionSize

XlaBuilder::SetDimensionSize도 참고하세요.

XlaOp의 지정된 측정기준의 동적 크기를 설정합니다. 피연산자는 배열 형식이어야 합니다.

SetDimensionSize(operand, size, dimension)

컴파일러에서 추적하는 동적 측정기준을 사용하여 피연산자를 결과로 전달합니다.

패딩된 값은 다운스트림 감소 연산에서 무시됩니다.

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

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

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

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

GetTupleElement

XlaBuilder::GetTupleElement도 참고하세요.

컴파일 시간 상수 값으로 튜플에 색인을 생성합니다.

모양 추론이 결과 값의 유형을 결정할 수 있도록 값은 컴파일 시간 상수여야 합니다.

이는 C++의 std::get<int N>(t)와 유사합니다. 개념적으로 다음과 같습니다.

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.

tf.tuple도 참고하세요.

인피드

XlaBuilder::Infeed도 참고하세요.

Infeed(shape)

기기의 암시적 인피드 스트리밍 인터페이스에서 단일 데이터 항목을 읽고 데이터를 지정된 도형 및 레이아웃으로 해석한 후 데이터의 XlaOp를 반환합니다. 계산에서 여러 인피드 작업이 허용되지만 인피드 작업 간에 총 순서가 있어야 합니다. 예를 들어 아래 코드의 두 인피드에는 전체 순서가 있습니다. while 루프 간에 종속 항목이 있기 때문입니다.

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

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

중첩된 튜플 도형은 지원되지 않습니다. 빈 튜플 도형의 경우 인피드 작업은 사실상 무작위 작업이며 기기의 인피드에서 데이터를 읽지 않고 진행됩니다.

Iota

XlaBuilder::Iota도 참고하세요.

Iota(shape, iota_dimension)

잠재적으로 큰 호스트 전송이 아닌 기기에서 상수 리터럴을 빌드합니다. 지정된 도형을 갖고 0에서 시작하여 지정된 크기를 따라 1씩 증가하는 값을 보유하는 배열을 만듭니다. 부동 소수점 유형의 경우 생성된 배열은 Iota가 정수 유형이고 변환이 부동 소수점 유형으로 이루어지는 경우 ConvertElementType(Iota(...))와 같습니다.

예를 들어 Iota(s32[4, 8], 0)는 다음을 반환합니다.

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

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

지도

XlaBuilder::Map도 참고하세요.

Map(operands..., computation)

지정된 operands 배열에 스칼라 함수를 적용하여 동일한 크기의 배열을 생성합니다. 여기서 각 요소는 입력 배열의 해당 요소에 적용된 매핑된 함수의 결과입니다.

매핑된 함수는 스칼라 유형 T의 입력이 N개 있고 유형이 S인 단일 출력이 있다는 제한이 있는 임의의 계산입니다. 출력은 요소 유형 T가 S로 대체되는 점을 제외하고 피연산자와 동일한 크기를 갖습니다.

예를 들어 Map(op1, op2, op3, computation, par1)는 입력 배열의 각 (다차원) 색인에서 elem_out <- computation(elem1, elem2, elem3, par1)를 매핑하여 출력 배열을 생성합니다.

OptimizationBarrier

최적화 패스가 장벽을 넘어 계산을 이동하지 못하도록 차단합니다.

장벽의 출력에 종속된 연산자보다 먼저 모든 입력이 평가되도록 합니다.

Pad

XlaBuilder::Pad도 참고하세요.

Pad(operand, padding_value, padding_config)

지정된 padding_value를 사용하여 배열 주변과 배열 요소 간에 패딩을 추가하여 지정된 operand 배열을 확장합니다. padding_config는 각 크기의 가장자리 패딩과 내부 패딩의 양을 지정합니다.

PaddingConfig는 각 측정기준에 관한 세 필드(edge_padding_low, edge_padding_high, interior_padding)를 포함하는 반복되는 PaddingConfigDimension 필드입니다.

edge_padding_low 및 edge_padding_high는 각 측정기준의 하단 (색인 0 옆) 및 상단 (최대 색인 옆)에 추가되는 패딩의 양을 각각 지정합니다. 가장자리 패딩의 양은 음수일 수 있습니다. 음수 패딩의 절대값은 지정된 크기에서 삭제할 요소 수를 나타냅니다.

interior_padding는 각 측정기준의 두 요소 사이에 추가되는 패딩의 양을 지정합니다. 음수일 수 없습니다. 내부 패딩은 논리적으로 가장자리 패딩 전에 발생하므로 음수 가장자리 패딩의 경우 내부 패딩된 피연산자에서 요소가 삭제됩니다.

가장자리 패딩 쌍이 모두 (0, 0)이고 내부 패딩 값이 모두 0인 경우 이 작업은 무작위 작업입니다. 아래 그림은 2차원 배열의 다양한 edge_padding 및 interior_padding 값의 예를 보여줍니다.

Recv

XlaBuilder::Recv도 참고하세요.

Recv(shape, channel_handle)

동일한 채널 핸들을 공유하는 다른 계산의 Send 명령어에서 지정된 도형의 데이터를 수신합니다. 수신된 데이터의 XlaOp를 반환합니다.

Recv 작업의 클라이언트 API는 동기 통신을 나타냅니다. 그러나 이 명령어는 비동기 데이터 전송을 사용 설정하기 위해 내부적으로 2개의 HLO 명령어(Recv 및 RecvDone)로 분해됩니다. HloInstruction::CreateRecv 및 HloInstruction::CreateRecvDone도 참고하세요.

Recv(const Shape& shape, int64 channel_id)

동일한 channel_id를 가진 Send 명령어에서 데이터를 수신하는 데 필요한 리소스를 할당합니다. 할당된 리소스의 컨텍스트를 반환합니다. 이 컨텍스트는 다음 RecvDone 명령어에서 데이터 전송 완료를 기다리는 데 사용됩니다. 컨텍스트는 {수신 버퍼 (형상), 요청 식별자(U32)}의 튜플이며 RecvDone 명령어에서만 사용할 수 있습니다.

RecvDone(HloInstruction context)

Recv 명령어로 생성된 컨텍스트를 사용하여 데이터 전송이 완료될 때까지 기다렸다가 수신된 데이터를 반환합니다.

방지(Reduce)

XlaBuilder::Reduce도 참고하세요.

하나 이상의 배열에 축소 함수를 동시에 적용합니다.

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

각 항목의 의미는 다음과 같습니다.

• N은 1 이상이어야 합니다.
• 계산은 '대략적으로' 결합되어야 합니다 (아래 참고).
• 모든 입력 배열의 크기가 같아야 합니다.
• 모든 초기 값은 computation 아래에서 ID를 형성해야 합니다.
• N = 1이면 Collate(T)은 T입니다.
• N > 1인 경우 Collate(T_0, ..., T_{N-1})는 T 유형의 N 요소 튜플입니다.

이 연산은 각 입력 배열의 하나 이상의 측정기준을 스칼라로 줄입니다. 반환된 각 배열의 크기는 number_of_dimensions(operand) - len(dimensions)입니다. 연산자의 출력은 Collate(Q_0, ..., Q_N)입니다. 여기서 Q_i은 T_i 유형의 배열이며 크기는 아래에 설명되어 있습니다.

다른 백엔드에서 감소 계산을 다시 연결할 수 있습니다. 덧셈과 같은 일부 감소 함수는 부동 소수점에 연결되지 않으므로 수치 차이가 발생할 수 있습니다. 그러나 데이터 범위가 제한된 경우 부동 소수점 덧셈은 대부분의 실제 사용 사례에서 결합에 거의 근접합니다.

예

값이 [10, 11, 12, 13]인 단일 1D 배열에서 하나의 측정기준을 축소할 때 축소 함수 f (computation)를 사용하면 다음과 같이 계산할 수 있습니다.

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

하지만 다른 방법도 많습니다.

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

다음은 초깃값이 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]

다음은 2D 배열 (행렬)을 줄이는 예입니다. 도형에는 2개의 차원이 있습니다. 크기가 2인 0차원과 크기가 3인 1차원입니다.

'add' 함수를 사용하여 차원 0 또는 1을 줄인 결과:

두 감소 결과 모두 1차원 배열입니다. 이 다이어그램에서는 시각적 편의를 위해 하나를 열로, 다른 하나를 행으로 표시합니다.

다음은 더 복잡한 예로 3D 배열입니다. 차원 수는 3개이며, 크기 4의 차원 0, 크기 2의 차원 1, 크기 3의 차원 2입니다. 편의상 1~6의 값이 측정기준 0에 걸쳐 복제됩니다.

2D 예와 마찬가지로 한 차원만 줄일 수 있습니다. 예를 들어 크기 0을 줄이면 크기 0의 모든 값이 스칼라로 접힌 2차원 배열이 됩니다.

|  4   8  12 |
| 16  20  24 |

2차원 크기를 줄이면 2차원 배열도 얻을 수 있으며, 이 배열에서는 2차원 크기의 모든 값이 스칼라로 접힙니다.

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

입력의 나머지 측정기준 간의 상대 순서는 출력에서 보존되지만 측정기준 수가 변경되므로 일부 측정기준에는 새 번호가 할당될 수 있습니다.

여러 측정기준을 줄일 수도 있습니다. 추가 감소 측정기준 0과 1을 사용하면 1차원 배열 [20, 28, 36]이 생성됩니다.

모든 차원에서 3D 배열을 줄이면 스칼라 84가 생성됩니다.

가변 인수 Reduce

N > 1인 경우 reduce 함수 적용은 모든 입력에 동시에 적용되므로 약간 더 복잡합니다. 피연산자는 다음 순서로 계산에 제공됩니다.

• 첫 번째 피연산자의 감소된 값 실행
• ...
• N번째 피연산자의 감소된 값 실행
• 첫 번째 피연산자의 입력 값
• ...
• N번째 피연산자의 입력 값

예를 들어 다음과 같은 감소 함수를 고려해 보세요. 이 함수는 1차원 배열의 최대값과 최대값 인덱스를 동시에 계산하는 데 사용할 수 있습니다.

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

1차원 입력 배열 V = Float[N], K = Int[N] 및 초기화 값 I_V = Float, I_K = Int의 경우 유일한 입력 측정기준에서 감소한 결과 f_(N-1)는 다음 재귀 적용과 같습니다.

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

이 감소 연산을 값 배열과 순차 색인 배열 (즉, iota)에 적용하면 배열을 함께 반복하고 최대 값과 일치하는 색인이 포함된 튜플을 반환합니다.

ReducePrecision

XlaBuilder::ReducePrecision도 참고하세요.

부동 소수점 값을 더 낮은 정밀도 형식 (예: IEEE-FP16)으로 변환한 다음 원래 형식으로 다시 변환하는 효과를 모델링합니다. 모든 하드웨어 구현에서 모든 비트 크기가 지원되지는 않지만, 정밀도가 낮은 형식의 지수 및 소수 자릿수 비트 수는 임의로 지정할 수 있습니다.

ReducePrecision(operand, mantissa_bits, exponent_bits)

결과는 T 유형의 배열입니다. 입력 값은 '짝수로 맞춤' 시맨틱스를 사용하여 지정된 소수점 자릿수 개수로 표현할 수 있는 가장 가까운 값으로 반올림되며, 지수 비트 개수로 지정된 범위를 초과하는 값은 양의 무한대 또는 음의 무한대로 제한됩니다. NaN 값은 표준 NaN 값으로 변환될 수 있지만 유지됩니다.

정밀도가 낮은 형식은 지수 비트가 하나 이상 있어야 합니다 (둘 다 가수가 0이므로 0 값을 무한대와 구별하기 위해). 또한 가수 비트 수가 0이 아닌 값이어야 합니다. 지수 또는 소수 자릿수 비트 수가 T 유형의 해당 값을 초과할 수 있습니다. 그러면 변환의 해당 부분은 아무 작업도 하지 않습니다.

ReduceScatter

XlaBuilder::ReduceScatter도 참고하세요.

ReduceScatter는 AllReduce를 효과적으로 실행한 후 결과를 scatter_dimension을 따라 shard_count 블록으로 분할하여 흩어내는 집합 연산이며, 복제 그룹의 복제본 i은 ith 샤드를 수신합니다.

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

• operand이 배열의 튜플인 경우 튜플의 각 요소에 reduce-scatter가 실행됩니다.
• replica_groups는 축소가 실행되는 복제본 그룹의 목록입니다. 현재 복제본의 복제본 ID는 ReplicaId를 사용하여 검색할 수 있습니다. 각 그룹의 복제본 순서에 따라 전체 감소 결과가 흩어지는 순서가 결정됩니다. replica_groups는 비어 있거나 (이 경우 모든 복제본이 단일 그룹에 속함) 복제본 수와 동일한 수의 요소를 포함해야 합니다. 복제 그룹이 두 개 이상인 경우 모두 동일한 크기여야 합니다. 예를 들어 replica_groups = {0, 2}, {1, 3}는 복제본 0와 2, 1와 3 간에 감소를 실행한 다음 결과를 흩뿌립니다.
• shard_count은 각 복제본 그룹의 크기입니다. replica_groups가 비어 있는 경우에 필요합니다. replica_groups가 비어 있지 않으면 shard_count는 각 복제본 그룹의 크기와 같아야 합니다.
• channel_id는 교차 모듈 통신에 사용됩니다. 동일한 channel_id를 사용하는 reduce-scatter 작업만 서로 통신할 수 있습니다.

출력 도형은 scatter_dimension를 shard_count배 작게 만든 입력 도형입니다. 예를 들어 복제본이 두 개 있고 두 복제본에서 피연산자가 각각 [1.0, 2.25] 및 [3.0, 5.25] 값을 갖는 경우 scatter_dim이 0인 이 연산의 출력 값은 첫 번째 복제본의 경우 [4.0]이고 두 번째 복제본의 경우 [7.5]입니다.

ReduceWindow

XlaBuilder::ReduceWindow도 참고하세요.

N차원 배열 시퀀스의 각 창에 있는 모든 요소에 감소 함수를 적용하여 단일 또는 N차원 배열의 튜플을 출력으로 생성합니다. 각 출력 배열에는 유효한 기간 위치 수와 동일한 수의 요소가 있습니다. 풀링 레이어는 ReduceWindow로 표현할 수 있습니다. Reduce와 마찬가지로 적용된 computation는 항상 왼쪽의 init_values를 전달합니다.

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

각 항목의 의미는 다음과 같습니다.

• N은 1 이상이어야 합니다.
• 모든 입력 배열의 크기가 같아야 합니다.
• N = 1이면 Collate(T)은 T입니다.
• N > 1인 경우 Collate(T_0, ..., T_{N-1})는 (T0,...T{N-1}) 유형의 N 요소 튜플입니다.

아래 코드와 그림은 ReduceWindow 사용의 예를 보여줍니다. 입력은 크기가 [4x6] 인 행렬이고 window_dimensions와 window_stride_dimensions는 모두 [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);

측정기준의 스트라이드가 1이면 측정기준의 창 위치가 인접한 창에서 1개 요소 떨어져 있음을 지정합니다. 창이 서로 겹치지 않도록 지정하려면 window_stride_dimensions가 window_dimensions와 같아야 합니다. 아래 그림은 두 가지 다른 스트라이드 값의 사용을 보여줍니다. 패딩은 입력의 각 측정기준에 적용되며 계산은 입력이 패딩 후의 측정기준으로 들어온 것과 동일합니다.

간단하지 않은 패딩 예로는 입력 배열 [10000, 1000, 100, 10, 1]에 대해 크기 3 및 스트라이드 2로 reduce-window 최솟값(초깃값은 MAX_FLOAT)을 계산하는 경우를 들 수 있습니다. 패딩 kValid는 두 개의 유효한 창([10000, 1000, 100] 및 [100, 10, 1])에서 최솟값을 계산하여 [100, 1]를 출력합니다. 패딩 kSame는 먼저 양쪽에 초기 요소를 추가하여 reduce-window 후의 모양이 stride 1의 입력과 동일하도록 배열을 패딩하여 [MAX_VALUE, 10000, 1000, 100, 10, 1, MAX_VALUE]를 가져옵니다. 패딩된 배열에 reduce-window를 실행하면 세 개의 창 [MAX_VALUE, 10000, 1000], [1000, 100, 10], [10, 1, MAX_VALUE]에서 작동하고 [1000, 10, 1]을 생성합니다.

감소 함수의 평가 순서는 임의이며 확정되지 않을 수 있습니다. 따라서 감소 함수는 재연결에 지나치게 민감해서는 안 됩니다. 자세한 내용은 Reduce 컨텍스트에서의 결합에 관한 토론을 참고하세요.

ReplicaId

XlaBuilder::ReplicaId도 참고하세요.

복제본의 고유 ID (U32 스칼라)를 반환합니다.

ReplicaId()

각 복제본의 고유 ID는 [0, N) 범위의 부호 없는 정수이며 여기서 N는 복제본 수입니다. 모든 복제본이 동일한 프로그램을 실행하므로 프로그램의 ReplicaId() 호출은 각 복제본에서 다른 값을 반환합니다.

재구성

XlaBuilder::Reshape 및 Collapse 작업도 참고하세요.

배열의 크기를 새 구성으로 변경합니다.

Reshape(operand, dimensions)

개념적으로 reshape는 먼저 배열을 데이터 값의 1차원 벡터로 평면화한 다음 이 벡터를 새 도형으로 미세 조정합니다. 입력 인수는 T 유형의 임의 배열, 차원 색인의 컴파일 시간 상수 벡터, 결과의 차원 크기 컴파일 시간 상수 벡터입니다. dimensions 벡터는 출력 배열의 크기를 결정합니다. dimensions의 색인 0에 있는 값은 크기 0의 크기이고, 색인 1에 있는 값은 크기 1의 크기입니다. dimensions 차원의 곱은 피연산자의 차원 크기 곱과 같아야 합니다. 축소된 배열을 dimensions로 정의된 다차원 배열로 미세 조정할 때 dimensions의 측정기준은 가장 느리게 변하는 측정기준 (가장 주요)부터 가장 빠르게 변하는 측정기준 (가장 하위)으로 정렬됩니다.

예를 들어 v가 24개 요소의 배열이라고 가정해 보겠습니다.

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

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

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

특수한 경우 reshape는 단일 요소 배열을 스칼라로 변환할 수 있으며 그 반대의 경우도 가능합니다. 예를 들면 다음과 같습니다.

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

Rev (역순)

XlaBuilder::Rev도 참고하세요.

Rev(operand, dimensions)

지정된 dimensions을 따라 operand 배열의 요소 순서를 반전하여 동일한 모양의 출력 배열을 생성합니다. 다차원 색인의 피연산자 배열의 각 요소는 변환된 색인의 출력 배열에 저장됩니다. 다차원 색인은 역순으로 변경할 각 측정기준의 색인을 역순으로 변경하여 변환됩니다. 즉, 크기가 N인 측정기준이 역순으로 변경할 측정기준 중 하나인 경우 색인 i가 N - 1 - i로 변환됩니다.

Rev 연산의 한 가지 용도는 신경망에서 경사 계산 중에 두 창 크기를 따라 컨볼루션 가중치 배열을 역전시키는 것입니다.

RngNormal

XlaBuilder::RngNormal도 참고하세요.

\(N(\mu, \sigma)\) 정규 분포에 따라 생성된 랜덤 숫자로 지정된 도형의 출력을 구성합니다. 매개변수 \(\mu\) 및 \(\sigma\)와 출력 형식은 부동 소수점 기본 유형이어야 합니다. 또한 매개변수는 스칼라 값이어야 합니다.

RngNormal(mu, sigma, shape)

RngUniform

XlaBuilder::RngUniform도 참고하세요.

\([a,b)\)간격에 걸쳐 균일 분포에 따라 생성된 랜덤 숫자로 지정된 도형의 출력을 구성합니다. 매개변수 및 출력 요소 유형은 불리언 유형, 정수 유형 또는 부동 소수점 유형이어야 하며 유형은 일관해야 합니다. CPU 및 GPU 백엔드는 현재 F64, F32, F16, BF16, S64, U64, S32, U32만 지원합니다. 또한 매개변수는 스칼라 값이어야 합니다. \(b <= a\) 이면 결과는 구현에 의해 정의됩니다.

RngUniform(a, b, shape)

RngBitGenerator

지정된 알고리즘 (또는 백엔드 기본값)을 사용하여 균일한 랜덤 비트로 채워진 지정된 도형의 출력을 생성하고 업데이트된 상태 (초기 상태와 동일한 도형)와 생성된 랜덤 데이터를 반환합니다.

초기 상태는 현재 랜덤 숫자 생성의 초기 상태입니다. 이 값과 필수 도형 및 유효 값은 사용되는 알고리즘에 따라 다릅니다.

출력은 초기 상태의 결정론적 함수이지만 백엔드와 다른 컴파일러 버전 간에 결정론적일 보장되지 않습니다.

RngBitGenerator(algorithm, key, shape)

algorithm에 사용할 수 있는 값은 다음과 같습니다.

• rng_default: 백엔드별 도형 요구사항이 있는 백엔드별 알고리즘입니다.

• rng_three_fry: ThreeFry 카운터 기반 PRNG 알고리즘입니다. initial_state 도형은 임의의 값을 가진 u64[2]입니다. Salmon et al. SC 2011. 병렬 난수: 쉽고 간단합니다.

• rng_philox: 난수를 병렬로 생성하는 Philox 알고리즘입니다. initial_state 도형은 임의의 값을 가진 u64[3]입니다. Salmon et al. SC 2011. 병렬 난수: 쉽고 간단합니다.

분산형

XLA 산란 연산은 입력 배열 operands의 값인 결과 시퀀스를 생성하며, update_computation를 사용하여 updates의 값 시퀀스로 업데이트된 여러 슬라이스 (scatter_indices로 지정된 색인)가 포함됩니다.

XlaBuilder::Scatter도 참고하세요.

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

각 항목의 의미는 다음과 같습니다.

• N은 1 이상이어야 합니다.
• operands[0], ..., operands[N-1] 의 크기가 모두 같아야 합니다.
• updates[0], ..., updates[N-1] 의 크기가 모두 같아야 합니다.
• N = 1이면 Collate(T)은 T입니다.
• N > 1인 경우 Collate(T_0, ..., T_N)는 T 유형의 N 요소 튜플입니다.

index_vector_dim가 scatter_indices.rank와 같으면 scatter_indices에 후행 1 크기가 있다고 암시적으로 간주됩니다.

ArraySlice<int64> 유형의 update_scatter_dims는 update_window_dims에 없는 updates 도형의 크기 집합으로, 오름차순으로 정의됩니다.

scatter의 인수는 다음 제약조건을 따라야 합니다.

• 각 updates 배열에는 update_window_dims.size + scatter_indices.rank - 1 크기가 있어야 합니다.

• 각 updates 배열의 i 측정기준 경계는 다음을 준수해야 합니다.

  • i가 update_window_dims에 있는 경우 (즉, 일부 k의 경우 update_window_dims[k] 와 같음) updates의 i 측정기준 경계는 inserted_window_dims를 고려한 후 operand의 해당 경계를 초과해서는 안 됩니다 (즉, adjusted_window_bounds[k], 여기서 adjusted_window_bounds에는 색인 inserted_window_dims의 경계가 삭제된 operand의 경계가 포함됨).
  • i가 update_scatter_dims에 있는 경우 (즉, 일부 k의 경우 update_scatter_dims[k] 와 같음) updates의 크기 i의 경계는 index_vector_dim를 건너뛰면서 scatter_indices의 상응하는 경계와 같아야 합니다 (즉, k < index_vector_dim인 경우 scatter_indices.shape.dims[k], 그렇지 않은 경우 scatter_indices.shape.dims[k+1]).

• update_window_dims는 오름차순이어야 하며, 반복되는 크기 번호가 없어야 하고, [0, updates.rank) 범위여야 합니다.

• inserted_window_dims는 오름차순이어야 하며, 반복되는 크기 번호가 없어야 하고, [0, operand.rank) 범위여야 합니다.

• operand.rank는 update_window_dims.size와 inserted_window_dims.size의 합계와 같아야 합니다.

• scatter_dims_to_operand_dims.size는 scatter_indices.shape.dims[index_vector_dim]과 같아야 하며 값은 [0, operand.rank) 범위 내에 있어야 합니다.

각 updates 배열의 지정된 색인 U의 경우 이 업데이트를 적용해야 하는 해당 operands 배열의 상응하는 색인 I는 다음과 같이 계산됩니다.

1. G = { U[k] for k in update_scatter_dims }라고 하자. G를 사용하여 scatter_indices 배열에서 색인 벡터 S를 조회합니다. 여기서 S[i] = scatter_indices[Combine(G, i)] 이며, Combine(A, b)는 index_vector_dim 위치에 b를 삽입하여 A에 추가합니다.
2. scatter_dims_to_operand_dims 맵을 사용하여 S를 흩뿌려 S를 사용하여 operand에 색인 Sin를 만듭니다. 더 엄밀하게 표현하면 다음과 같습니다.
   1. Sin[scatter_dims_to_operand_dims[k]] = S[k] if k < scatter_dims_to_operand_dims.size.
   2. S그렇지 않으면 _in[_] = 0입니다.
3. inserted_window_dims에 따라 U의 update_window_dims에 색인을 흩뿌려 각 operands 배열에 색인 Win를 만듭니다. 더 엄밀하게 표현하면 다음과 같습니다.
   1. Win[window_dims_to_operand_dims(k)] = U[k] if k is in update_window_dims, where window_dims_to_operand_dims is the monotonic function with domain [0, update_window_dims.size) and ranged [0, operand.rank) \ inserted_window_dims. (예를 들어 update_window_dims.size이 4이고 operand.rank이 6이고 inserted_window_dims이 {0, 2}이면 window_dims_to_operand_dims는 {0→1, 1→3, 2→4, 3→5}입니다.)
   2. W그렇지 않으면 _in[_] = 0입니다.
4. I는 Win + Sin입니다. 여기서 +는 요소별 덧셈입니다.

요약하면 산점 작업은 다음과 같이 정의할 수 있습니다.

• output를 operands로 초기화합니다. 즉, 모든 색인 J의 경우 operands[J] 배열의 모든 색인 O에 대해
  output[J][O] = operands[J][O]
• updates[J] 배열의 모든 색인 U와 operand[J] 배열의 해당 색인 O에 대해 O이 output의 유효한 색인인 경우
  (output[0][O], ..., output[N-1][O]) =update_computation(output[0][O], ..., ,output[N-1][O],updates[0][U], ...,updates[N-1][U])

업데이트가 적용되는 순서는 결정론적이지 않습니다. 따라서 updates의 여러 색인이 operands의 동일한 색인을 참조하는 경우 output의 해당 값은 비결정론적입니다.

update_computation에 전달되는 첫 번째 매개변수는 항상 output 배열의 현재 값이고 두 번째 매개변수는 항상 updates 배열의 값입니다. 이는 특히 update_computation가 교환 불가인 경우에 중요합니다.

indices_are_sorted가 true로 설정되면 XLA는 scatter_indices가 사용자가 정렬했다고 가정할 수 있습니다 (scatter_dims_to_operand_dims에 따라 값을 흩뿌린 후 오름차순으로 정렬됨). 그렇지 않으면 시맨틱은 구현에서 정의됩니다.

unique_indices가 true로 설정되면 XLA는 흩어진 모든 요소가 고유하다고 가정할 수 있습니다. 따라서 XLA는 비원자적 작업을 사용할 수 있습니다. unique_indices가 true로 설정되어 있고 분산되는 색인이 고유하지 않은 경우 시맨틱은 구현에 의해 정의됩니다.

비공식적으로는 scatter 연산을 gather 연산의 역연산으로 볼 수 있습니다. 즉, scatter 연산은 상응하는 gather 연산에 의해 추출된 입력의 요소를 업데이트합니다.

비공식적인 자세한 설명과 예시는 Gather의 '비공식 설명' 섹션을 참고하세요.

선택

XlaBuilder::Select도 참고하세요.

조건자 배열의 값을 기반으로 두 입력 배열의 요소에서 출력 배열을 구성합니다.

Select(pred, on_true, on_false)

배열 on_true와 on_false의 모양이 동일해야 합니다. 이는 출력 배열의 모양이기도 합니다. 배열 pred는 PRED 요소 유형을 사용하여 on_true 및 on_false와 동일한 크기를 가져야 합니다.

pred의 각 요소 P에 대해 출력 배열의 해당 요소는 P의 값이 true인 경우 on_true에서 가져오고 P의 값이 false인 경우 on_false에서 가져옵니다. 제한된 형태의 브로드캐스트인 pred는 PRED 유형의 스칼라일 수 있습니다. 이 경우 pred이 true이면 출력 배열은 on_true에서 완전히 가져오고 pred이 false이면 on_false에서 가져옵니다.

스칼라가 아닌 pred의 예:

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

스칼라 pred의 예:

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

튜플 간의 선택이 지원됩니다. 이 목적을 위해 튜플은 스칼라 유형으로 간주됩니다. on_true와 on_false가 동일한 모양을 가져야 하는 튜플인 경우 pred는 PRED 유형의 스칼라여야 합니다.

SelectAndScatter

XlaBuilder::SelectAndScatter도 참고하세요.

이 연산은 먼저 operand 배열에서 ReduceWindow를 계산하여 각 창에서 요소를 선택한 다음 선택된 요소의 색인에 source 배열을 흩어 연산자 배열과 동일한 모양의 출력 배열을 구성하는 복합 연산으로 간주할 수 있습니다. 바이너리 select 함수는 각 창에 적용하여 각 창에서 요소를 선택하는 데 사용되며, 첫 번째 매개변수의 색인 벡터가 두 번째 매개변수의 색인 벡터보다 사전순으로 작다는 속성으로 호출됩니다. select 함수는 첫 번째 매개변수가 선택된 경우 true을 반환하고 두 번째 매개변수가 선택된 경우 false을 반환하며, 선택된 요소가 특정 창에서 이동한 요소의 순서에 종속되지 않도록 함수가 전이성을 유지해야 합니다 (즉, select(a, b) 및 select(b, c)가 true이면 select(a, c)도 true임).

scatter 함수는 출력 배열의 각 선택된 인덱스에 적용됩니다. 두 개의 스칼라 매개변수를 사용합니다.

1. 출력 배열에서 선택한 색인의 현재 값
2. 선택한 색인에 적용되는 source의 산포 값

두 매개변수를 결합하고 출력 배열에서 선택한 색인의 값을 업데이트하는 데 사용되는 스칼라 값을 반환합니다. 처음에는 출력 배열의 모든 색인이 init_value로 설정됩니다.

출력 배열은 operand 배열과 모양이 같고 source 배열은 operand 배열에 ReduceWindow 연산을 적용한 결과와 모양이 같아야 합니다. SelectAndScatter는 신경망에서 풀링 레이어의 기울기 값을 백프로파게이션하는 데 사용할 수 있습니다.

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

아래 그림은 SelectAndScatter 사용 예를 보여줍니다. 여기서 select 함수는 매개변수 중 최대 값을 계산합니다. 아래 그림 (2)와 같이 창이 겹치면 operand 배열의 인덱스가 여러 창에서 여러 번 선택될 수 있습니다. 그림에서 값이 9인 요소가 상단 창 (파란색 및 빨간색) 모두에서 선택되고 바이너리 덧셈 scatter 함수는 값이 8 (2 + 6)인 출력 요소를 생성합니다.

scatter 함수의 평가 순서는 임의이며 확정되지 않을 수 있습니다. 따라서 scatter 함수는 재연결에 지나치게 민감해서는 안 됩니다. 자세한 내용은 Reduce 컨텍스트에서의 결합에 관한 토론을 참고하세요.

보내기

XlaBuilder::Send도 참고하세요.

Send(operand, channel_handle)

동일한 채널 핸들을 공유하는 다른 계산의 Recv 명령어에 지정된 피연산자 데이터를 전송합니다. 데이터를 반환하지 않습니다.

Recv 작업과 마찬가지로 Send 작업의 클라이언트 API는 동기 통신을 나타내며 비동기 데이터 전송을 사용 설정하기 위해 내부적으로 2개의 HLO 명령어(Send 및 SendDone)로 분해됩니다. HloInstruction::CreateSend 및 HloInstruction::CreateSendDone도 참고하세요.

Send(HloInstruction operand, int64 channel_id)

동일한 채널 ID로 Recv 명령어에 의해 할당된 리소스로 피연산자의 비동기 전송을 시작합니다. 다음 SendDone 명령어에서 데이터 전송 완료를 기다리는 데 사용하는 컨텍스트를 반환합니다. 컨텍스트는 {operand (shape), request identifier (U32)}의 튜플이며 SendDone 명령어에서만 사용할 수 있습니다.

SendDone(HloInstruction context)

Send 명령어로 생성된 컨텍스트를 사용하여 데이터 전송이 완료될 때까지 기다립니다. 이 명령어는 데이터를 반환하지 않습니다.

채널 안내 예약

각 채널의 4가지 명령어 (Recv, RecvDone, Send, SendDone)의 실행 순서는 다음과 같습니다.

• Recv가 Send 전에 발생합니다.
• Send가 RecvDone 전에 발생합니다.
• Recv가 RecvDone 전에 발생합니다.
• Send가 SendDone 전에 발생합니다.

백엔드 컴파일러가 채널 명령을 통해 통신하는 각 계산에 대해 선형 일정을 생성할 때 계산 간에 사이클이 없어야 합니다. 예를 들어 아래 일정은 교착 상태를 유발합니다.

명령어의 제약 조건은 런타임 시 TPU에만 적용됩니다. GPU에서 send 및 recv는 소스 기기와 대상 기기 간의 핸드셰이크가 완료될 때까지 차단되고 실제 데이터를 전송하지 않습니다.

슬라이스

XlaBuilder::Slice도 참고하세요.

슬라이싱은 입력 배열에서 하위 배열을 추출합니다. 하위 배열은 입력과 동일한 수의 측정기준을 가지며, 입력 배열 내에서 경계 상자의 측정기준과 색인이 슬라이스 작업에 인수로 제공되는 경계 상자 내의 값을 포함합니다.

Slice(operand, start_indices, limit_indices, strides)

1차원 예:

let a = {0.0, 1.0, 2.0, 3.0, 4.0}
Slice(a, {2}, {4}) produces:
  {2.0, 3.0}

2차원 예:

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

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

정렬

XlaBuilder::Sort도 참고하세요.

Sort(operands, comparator, dimension, is_stable)

피연산자가 하나만 제공되는 경우:

• 피연산자가 1차원 텐서 (배열)인 경우 결과는 정렬된 배열입니다. 배열을 오름차순으로 정렬하려면 비교자가 소수점 아래 값 비교를 실행해야 합니다. 공식적으로 배열이 정렬된 후에는 i < j이 comparator(value[i], value[j]) = comparator(value[j], value[i]) = false 또는 comparator(value[i], value[j]) = true인 모든 색인 위치 i, j에 대해 유지됩니다.

• 피연산자의 측정기준 수가 더 많은 경우 피연산자는 제공된 측정기준을 기준으로 정렬됩니다. 예를 들어 2차원 텐서 (행렬)의 경우 측정기준 값이 0이면 모든 열이 독립적으로 정렬되고 측정기준 값이 1이면 각 행이 독립적으로 정렬됩니다. 측정기준 번호를 제공하지 않으면 기본적으로 마지막 측정기준이 선택됩니다. 정렬된 측정기준의 경우 1차원 사례와 동일한 정렬 순서가 적용됩니다.

n > 1 피연산자가 제공된 경우:

• 모든 n 피연산자는 크기가 동일한 텐서여야 합니다. 텐서의 요소 유형은 다를 수 있습니다.

• 모든 피연산자는 개별적으로가 아니라 함께 정렬됩니다. 개념적으로 피연산자는 튜플로 취급됩니다. 색인 위치 i 및 j의 각 피연산자의 요소를 전환해야 하는지 확인할 때 비교기는 2 * n 스칼라 매개변수와 함께 호출됩니다. 여기서 매개변수 2 * k는 k-th 피연산자의 i 위치 값에 해당하고 매개변수 2 * k + 1는 k-th 피연산자의 j 위치 값에 해당합니다. 따라서 일반적으로 비교기는 2 * k 및 2 * k + 1 매개변수를 서로 비교하고 다른 매개변수 쌍을 동점 해제 조건으로 사용할 수 있습니다.

• 결과는 위와 같이 제공된 측정기준을 기준으로 정렬된 피연산자로 구성된 튜플입니다. 튜플의 i-th 피연산자는 Sort의 i-th 피연산자에 해당합니다.

예를 들어 피연산자 operand0 = [3, 1], operand1 = [42, 50], operand2 = [-3.0, 1.1]가 세 개 있고 비교자가 operand0의 값만 '미만'으로 비교하는 경우 정렬의 출력은 튜플 ([1, 3], [50, 42], [1.1, -3.0])입니다.

is_stable가 true로 설정되면 정렬이 안정적으로 보장됩니다. 즉, 비교자에 의해 동일한 것으로 간주되는 요소가 있는 경우 동일한 값의 상대 순서가 유지됩니다. 두 요소 e1와 e2는 comparator(e1, e2) = comparator(e2, e1) = false인 경우에만 동일합니다. 기본적으로 is_stable는 false로 설정됩니다.

TopK

XlaBuilder::TopK도 참고하세요.

TopK는 주어진 텐서의 마지막 차원에 대해 k개의 가장 크거나 가장 작은 요소의 값과 색인을 찾습니다.

TopK(operand, k, largest)

1차원 입력 텐서 (배열)의 경우 배열에서 가장 크거나 가장 작은 k 항목을 찾고 두 배열의 튜플 (values, indices)을 출력합니다. 따라서 values[j]는 operand에서 j번째로 크거나 작은 항목이며 색인은 indices[j]입니다.

차원이 2개 이상인 입력 텐서에서 마지막 차원별로 상위 k 항목을 계산하고 출력에서 다른 모든 차원 (행)을 보존합니다. 따라서 Q >= k인 모양 [A, B, ..., P, Q]의 피연산자의 경우 출력은 튜플 (values, indices)이며 여기서 다음이 적용됩니다.

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

행 내의 두 요소가 동일하면 인덱스가 낮은 요소가 먼저 표시됩니다.

전치행렬

tf.reshape 연산도 참고하세요.

Transpose(operand)

주어진 순열(예: ∀ i . 0 ≤ i < number of dimensions ⇒ input_dimensions[permutation[i]] = output_dimensions[i])을 사용하여 피연산자 크기를 순열합니다.

이는 Reshape(operand, permutation, Permute(permutation, operand.shape.dimensions))와 동일합니다.

TriangularSolve

XlaBuilder::TriangularSolve도 참고하세요.

전방 또는 후방 대입을 사용하여 아래쪽 또는 위쪽 대각 행렬 계수 행렬이 있는 연립일차방정식 풀이 이 루틴은 선행 크기를 따라 브로드캐스트하여 a 및 b가 주어질 때 변수 x의 행렬 시스템 op(a) * x = b 또는 x * op(a) = b 중 하나를 풉니다. 여기서 op(a)는 op(a) = a, op(a) = Transpose(a) 또는 op(a) = Conj(Transpose(a))입니다.

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

입력 데이터는 lower 값에 따라 a의 하위/상위 삼각형에서만 읽습니다. 다른 삼각형의 값은 무시됩니다. 출력 데이터는 동일한 삼각형으로 반환됩니다. 다른 삼각형의 값은 구현에 의해 정의되며 무엇이든 될 수 있습니다.

a 및 b의 크기가 2보다 크면 행렬의 일괄 처리로 취급되며, 여기서 보조 2개 크기를 제외한 모든 크기가 일괄 처리 크기입니다. a와 b의 배치 크기가 같아야 합니다.

튜플

XlaBuilder::Tuple도 참고하세요.

각 데이터 핸들의 모양이 서로 다른 가변 개수의 데이터 핸들을 포함하는 튜플입니다.

이는 C++의 std::tuple와 유사합니다. 개념적으로 다음과 같습니다.

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

튜플은 GetTupleElement 연산을 통해 역직렬화 (액세스)할 수 있습니다.

동안

XlaBuilder::While도 참고하세요.

While(condition, body, init)

condition가 실패할 때까지 body를 순차적으로 실행합니다. 이는 아래에 나열된 차이점과 제한사항을 제외하고 다른 많은 언어의 일반적인 while 루프와 유사합니다.

• While 노드는 body의 마지막 실행 결과인 T 유형의 값을 반환합니다.
• T 유형의 모양은 정적으로 결정되며 모든 반복에서 동일해야 합니다.

계산의 T 매개변수는 첫 번째 반복에서 init 값으로 초기화되며 이후 각 반복에서 body의 새 결과로 자동 업데이트됩니다.

While 노드의 주요 사용 사례 중 하나는 신경망에서 반복적인 학습 실행을 구현하는 것입니다. 아래에는 계산을 나타내는 그래프와 함께 간소화된 의사코드가 나와 있습니다. 코드는 while_test.cc에서 확인할 수 있습니다. 이 예에서 T 유형은 반복 횟수의 int32와 누산기의 vector[10]로 구성된 Tuple입니다. 1, 000번 반복하는 동안 루프는 누산기에 상수 벡터를 계속 추가합니다.

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