작업 시맨틱스

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

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

AfterAll

XlaBuilder::AfterAll도 참고하세요.

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

AfterAll(operands)

인수 유형 시맨틱
operands XlaOp 다양한 토큰 수

AllGather

XlaBuilder::AllGather도 참고하세요.

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

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

인수 유형 시맨틱
operand XlaOp 복제본 간에 연결할 배열
all_gather_dim int64 연결 측정기준
replica_groups int64의 벡터로 구성된 벡터 연결이 실행되는 그룹
channel_id 선택사항 int64 교차 모듈 통신을 위한 선택적 채널 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 XlaOp 여러 복제본의 수를 줄이기 위한 배열의 배열 또는 비어 있지 않은 튜플입니다
computation XlaComputation 감소 계산
replica_groups int64의 벡터로 구성된 벡터 감소가 실행되는 그룹
channel_id 선택사항 int64 교차 모듈 통신을 위한 선택적 채널 ID
  • operand가 배열의 튜플인 경우 튜플의 각 요소에 AllReduce가 수행됩니다.
  • replica_groups는 감소가 실행되는 복제본 그룹의 목록입니다(현재 복제본의 복제본 ID는 ReplicaId를 사용하여 검색할 수 있음). replica_groups는 비어 있거나(이 경우 모든 복제본이 단일 그룹에 속함) 복제본 수와 동일한 수의 요소를 포함해야 합니다. 예를 들어 replica_groups = {0, 2}, {1, 3}는 복제본 0와 2, 1와 3 간에 감소를 실행합니다.
  • channel_id는 교차 모듈 통신에 사용됩니다. 동일한 channel_id를 사용하는 all-reduce 작업만 서로 통신할 수 있습니다.

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

AllReduce 결과를 계산하려면 각 복제본의 입력이 1개 있어야 하므로 한 복제본이 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)

인수 유형 시맨틱
operand XlaOp n차원 입력 배열
split_dimension int64 피연산자가 분할되는 측정기준의 이름을 지정하는 [0, n) 간격의 값
concat_dimension int64 분할 블록이 연결되는 측정기준의 이름을 지정하는 [0, n) 간격의 값입니다.
split_count int64 이 작업에 참여하는 코어 수입니다. replica_groups가 비어 있으면 복제본 수여야 하며, 그렇지 않으면 각 그룹의 복제본 수와 같아야 합니다.
replica_groups ReplicaGroup 벡터 각 그룹에는 복제본 ID 목록이 포함됩니다.

아래는 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개 있습니다. 각 코어에서 피연산자는 0차원을 따라 4개 부분으로 분할되므로 각 부분의 모양은 f32[4,4]입니다. 4개 부분이 모든 코어에 분산되어 있습니다. 그런 다음 각 코어는 차원 1을 따라 수신된 부분을 코어 0~4의 순서로 연결합니다. 따라서 각 코어의 출력은 f32[16,4] 형식입니다.

BatchNormGrad

알고리즘에 대한 자세한 설명은 XlaBuilder::BatchNormGrad 및 원본 배치 정규화 문서를 참조하세요.

배치 표준의 경사를 계산합니다.

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

인수 유형 시맨틱
operand XlaOp 정규화할 n차원 배열(x)
scale XlaOp 1차원 배열(\(\gamma\))
mean XlaOp 1차원 배열(\(\mu\))
variance XlaOp 1차원 배열 (\(\sigma^2\))
grad_output XlaOp BatchNormTraining에 전달된 그라데이션 (\(\nabla y\))
epsilon float 엡실론 값 (\(\epsilon\))
feature_index int64 operand의 특성 측정기준 색인

이 연산은 특성 측정기준의 각 특성(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는 배치 및 공간 차원에서 모멘트 값을 나타냅니다.

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

출력 유형 시맨틱
grad_operand XlaOp 입력 operand ($\nabla x$)에 대한 경사
grad_scale XlaOp 입력 scale ($\nabla \gamma$)에 대한 경사
grad_offset XlaOp 입력 offset에 대한 기울기($\nabla \beta$)

BatchNormInference

알고리즘에 대한 자세한 설명은 XlaBuilder::BatchNormInference 및 원본 배치 정규화 문서를 참조하세요.

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

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

인수 유형 시맨틱
operand XlaOp 정규화할 n차원 배열
scale XlaOp 1차원 배열
offset XlaOp 1차원 배열
mean XlaOp 1차원 배열
variance XlaOp 1차원 배열
epsilon float 엡실론 값
feature_index int64 operand의 특성 측정기준 색인

특성 차원의 각 특성 (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)

인수 유형 시맨틱
operand XlaOp 정규화할 n차원 배열 (x)
scale XlaOp 1차원 배열 (\(\gamma\))
offset XlaOp 1차원 배열 (\(\beta\))
epsilon float 엡실론 값(\(\epsilon\))
feature_index int64 operand의 특성 측정기준 색인

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

이 알고리즘은 공간 차원 크기 (operand가 4차원 배열이라고 가정)가 w 및 h인 m 요소를 포함하는 operand \(x\) 의 각 배치에 대해 다음과 같이 작동합니다.

  • 특성 측정기준의 각 특성 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로 구성된 튜플입니다.

출력 유형 시맨틱
output XlaOp 입력 operand (y)와 동일한 형태의 n차원 배열
batch_mean XlaOp 1차원 배열 (\(\mu\))
batch_var XlaOp 1차원 배열 (\(\sigma^2\))

batch_mean 및 batch_var는 위의 수식을 사용하여 배치 및 공간 차원에서 계산된 순간입니다.

BitcastConvertType

XlaBuilder::BitcastConvertType도 참고하세요.

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

BitcastConvertType(operand, new_element_type)

인수 유형 시맨틱
operand XlaOp 크기가 D인 T 유형 배열
new_element_type PrimitiveType 유형 U

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

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

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

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)

인수 유형 시맨틱
operand XlaOp 복제할 배열입니다.
broadcast_sizes ArraySlice<int64> 새 측정기준의 크기

새 차원은 왼쪽에 삽입됩니다. 즉, 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)

인수 유형 시맨틱
operand XlaOp 복제할 배열
out_dim_size ArraySlice<int64> 대상 도형의 크기
broadcast_dimensions ArraySlice<int64> 피연산자 도형의 각 차원이 타겟 도형의 어느 차원에 해당하는지

Broadcast와 비슷하지만 어디에서나 크기를 추가하고 크기 1로 기존 크기를 확장할 수 있습니다.

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

통화

XlaBuilder::Call도 참고하세요.

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

Call(computation, args...)

인수 유형 시맨틱
computation XlaComputation 임의의 유형의 N개 매개변수를 사용한 T_0, T_1, ..., T_{N-1} -> S 유형 계산
args N개의 XlaOp 시퀀스 임의 유형의 N개 인수

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

Cholesky

XlaBuilder::Cholesky도 참고하세요.

대칭 (헤르미티안) 양의 정의 행렬 배치의 Cholesky 분해를 계산합니다.

Cholesky(a, lower)

인수 유형 시맨틱
a XlaOp 복소수 또는 부동 소수점 유형의 순위 > 2 배열입니다.
lower bool a의 상위 삼각형 또는 하위 삼각형을 사용할지 여부입니다.

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

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

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

a가 대칭 (Hermitian) 양의 정의가 아닌 경우 결과는 구현을 통해 정의됩니다.

죔쇠

XlaBuilder::Clamp도 참고하세요.

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

Clamp(min, operand, max)

인수 유형 시맨틱
min XlaOp T 유형의 배열
operand XlaOp 유형 T의 배열
max XlaOp T 유형의 배열

피연산자와 최솟값 및 최댓값을 주면 피연산자가 최솟값과 최댓값 사이의 범위에 있으면 피연산자를 반환하고, 그렇지 않으면 피연산자가 이 범위보다 낮으면 최솟값을 반환하고, 피연산자가 이 범위보다 높으면 최대값을 반환합니다. 즉, 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)

인수 유형 시맨틱
operand XlaOp 유형 T의 배열
dimensions int64 벡터 T의 측정기준 중 순서대로 연속된 하위 집합입니다.

축소는 피연산자 차원의 주어진 하위 집합을 단일 측정기준으로 대체합니다. 입력 인수는 유형 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)

인수 유형 시맨틱
operand XlaOp n차원 입력 배열
source_target_pairs <int64, int64> 벡터 (source_replica_id, target_replica_id) 쌍의 목록입니다. 각 쌍의 피연산자는 소스 복제본에서 대상 복제본으로 전송됩니다.

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

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

Concatenate

XlaBuilder::ConcatInDim도 참고하세요.

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

Concatenate(operands..., dimension)

인수 유형 시맨틱
operands N개의 XlaOp 시퀀스 크기가 [L0, L1, ...]인 T 유형의 배열 N개. N >= 1이 필요합니다.
dimension int64 operands 간에 연결할 측정기준의 이름을 지정하는 [0, N) 간격의 값입니다.

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 XlaOp PRED 유형의 스칼라
true_operand XlaOp \(T_0\)유형의 인수
true_computation XlaComputation 유형의 XlaComputation \(T_0 \to S\)
false_operand XlaOp 유형의 인수 \(T_1\)
false_computation XlaComputation 유형 \(T_1 \to S\)의 XlaComputation

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_index XlaOp S32 유형의 스칼라
branch_computations NXlaComputation의 시퀀스 \(T_0 \to S , T_1 \to S , ..., T_{N-1} \to S\)유형의 XlaComput
branch_operands N개의 XlaOp 시퀀스 \(T_0 , T_1 , ..., T_{N-1}\)유형의 인수

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 중 하나만 실행됩니다.

전환수 (컨볼루션)

XlaBuilder::Conv도 참고하세요.

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

ConvWithGeneralPadding(컨볼루션)

XlaBuilder::ConvWithGeneralPadding도 참고하세요.

신경망에 사용되는 종류의 합성곱을 계산합니다. 여기서 컨볼루션은 N차원 기본 영역을 가로지르는 N차원 윈도우로 생각할 수 있으며, 윈도우의 가능한 각 위치에 대해 계산이 수행됩니다.

인수 유형 시맨틱
lhs XlaOp 입력의 순위 n+2 배열
rhs XlaOp 커널 가중치의 순위 n+2 배열
window_strides ArraySlice<int64> 커널 스트라이드의 n차원 배열
padding ArraySlice< pair<int64,int64>> (낮은, 높은) 패딩의 n차원 배열
lhs_dilation ArraySlice<int64> n-d lhs dilation factor array
rhs_dilation ArraySlice<int64> n-d rhs 확장 계수 배열
feature_group_count int64 특성 그룹 수
batch_group_count int64 일괄 그룹 수

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을 의미합니다.

RH 팽창은 아트로스 컨볼루션(Atrous Convolution)이라고도 합니다. 자세한 내용은 tf.nn.atrous_conv2d를 참고하세요. lhs의 확장은 전치 컨볼루션이라고도 합니다. 자세한 내용은 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개의 별도 컨볼루션으로 생각할 수 있습니다.

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

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)

인수 유형 시맨틱
operand XlaOp 크기가 D인 T 유형 배열
new_element_type PrimitiveType 유형 U

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

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)

인수 유형 시맨틱
target_name string 함수의 이름입니다. 이 기호 이름을 타겟팅하는 호출 안내가 내보내집니다.
args N개의 XlaOp 시퀀스 함수에 전달되는 임의 유형의 N개 인수입니다.
shape 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 XlaOp T 유형의 배열
rhs XlaOp T 유형의 배열

이 연산의 정확한 의미는 피연산자의 순위에 따라 다릅니다.

입력 출력 시맨틱
벡터 [n] dot 벡터 [n] 스칼라 벡터 내적
행렬 [m x k] dot 벡터 [k] 벡터 [m] 행렬-벡터 곱셈
행렬 [m x k] dot 행렬 [k x n] 행렬 [m x n] 행렬 곱셈

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

DotGeneral

XlaBuilder::DotGeneral도 참고하세요.

DotGeneral(lhs, rhs, dimension_numbers)

인수 유형 시맨틱
lhs XlaOp T 유형의 배열
rhs XlaOp T 유형의 배열
dimension_numbers DotDimensionNumbers 계약 및 배치 측정기준 번호

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

DotDimensionNumbers 필드 유형 시맨틱
lhs_contracting_dimensions int64 반복 lhs 축소된 측정기준 번호
rhs_contracting_dimensions repeated int64 rhs 축소된 측정기준 번호
lhs_batch_dimensions int64 반복 배치 측정기준 번호 lhs개
rhs_batch_dimensions repeated int64 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} } }
입력 출력 시맨틱
[b0, m, k] dot [b0, k, n] [b0, m, n] 일괄 matmul
[b0, b1, m, k] dot [b0, b1, k, n] [b0, b1, m, n] 배치 Matmul

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

DynamicSlice

XlaBuilder::DynamicSlice도 참고하세요.

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

DynamicSlice(operand, start_indices, size_indices)

인수 유형 시맨틱
operand XlaOp T 유형의 N차원 배열
start_indices N개의 XlaOp 시퀀스 각 차원에 대한 슬라이스의 시작 색인을 포함하는 N개의 스칼라 정수 목록입니다. 값은 0보다 크거나 같아야 합니다.
size_indices ArraySlice<int64> 각 차원의 슬라이스 크기를 포함하는 N개의 정수 목록입니다. 각 값은 0보다 크고, 시작 + 크기가 크기의 배수를 사용하여 래핑되지 않도록 크기보다 작거나 같아야 합니다.

유효 슬라이스 색인은 슬라이스를 실행하기 전에 [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)

인수 유형 시맨틱
operand XlaOp T 유형의 N차원 배열
update XlaOp 슬라이스 업데이트를 포함하는 T 유형의 N차원 배열입니다. 업데이트 도형의 각 측정기준은 0보다 커야 하며, 시작 + 업데이트는 범위를 벗어난 업데이트 색인을 생성하지 않도록 각 측정기준의 피연산자 크기보다 작거나 같아야 합니다.
start_indices NXlaOp의 시퀀스 각 측정기준의 슬라이스의 시작 색인을 포함하는 N개의 스칼라 정수 목록입니다. 값은 0보다 크거나 같아야 합니다.

유효 슬라이스 색인은 슬라이스를 실행하기 전에 [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(실수와 허수 부분을 복소수로 결합) 중 하나입니다.

인수 유형 시맨틱
lhs XlaOp 왼쪽 피연산자: T 유형의 배열
rhs XlaOp 오른쪽 피연산자: T 유형의 배열

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

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을 적용하여 부동 소수점 수에 대한 총 순서를 추가로 지원한다는 점이 다릅니다.

인수 유형 시맨틱
lhs XlaOp 왼쪽 피연산자: T 유형의 배열
rhs XlaOp 오른쪽 피연산자: T 유형의 배열

인수의 도형은 유사하거나 호환되어야 합니다. 도형이 호환된다는 의미에 관한 자세한 내용은 브로드캐스트 문서를 참고하세요. 연산 결과에는 요소 유형이 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 XlaOp 함수의 피연산자

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

Fft

XLA FFT 연산은 실제 및 복잡한 입력/출력에 대해 정방향 및 역 푸리에 변환을 구현합니다. 최대 3축까지 다차원 FFT가 지원됩니다.

XlaBuilder::Fft도 참고하세요.

인수 유형 시맨틱
operand XlaOp 푸리에 변환할 배열입니다.
fft_type FftType 아래의 표를 참조하세요.
fft_length ArraySlice<int64> 변환되는 축의 시간 도메인 길이입니다. 이는 특히 IRFFT가 가장 안쪽 축의 크기를 조정하는 데 필요합니다. RFFT(fft_length=[16])가 RFFT(fft_length=[17])와 출력 형태가 동일하기 때문입니다.
FftType 시맨틱
FFT 복잡-복잡 정방향 FFT 도형이 변경되지 않았습니다.
IFFT 역 복잡-복잡 FFT입니다. 도형은 변경되지 않습니다.
RFFT 실수-복소수 FFT 전달 fft_length[-1]이 0이 아닌 값이면 가장 안쪽 축의 모양이 fft_length[-1] // 2 + 1로 감소하여 변환된 신호의 역 켤레 부분을 Nyquist 주파수를 넘어갑니다.
IRFFT 역 실숫값의 복소수 FFT입니다 (예: 복소수에서 실수를 반환). fft_length[-1]이 0이 아닌 값인 경우 가장 안쪽 축의 모양은 fft_length[-1]로 확장됩니다. 이는 1에서 fft_length[-1] // 2 + 1로의 역 켤레에서 Nyquist 주파수를 넘어 변환된 신호의 일부를 추론합니다.

다차원 FFT

2개 이상의 fft_length가 제공되는 경우 이는 가장 안쪽의 각 축에 계단식 FFT 연산을 적용하는 것과 같습니다. 실제->복잡하고 복잡한->실제 사례의 경우 가장 안쪽 축 변환이 (RFFT, IRFFT의 경우 마지막) 먼저 수행되므로 가장 안쪽 축이 크기를 변경하는 것입니다. 그러면 다른 축 변환은 복잡->복잡이 됩니다.

구현 세부정보

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

수집

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

일반 의미 체계

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

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

인수 유형 시맨틱
operand XlaOp 데이터를 수집하는 배열입니다.
start_indices XlaOp 수집한 슬라이스의 시작 색인이 포함된 배열입니다.
index_vector_dim int64 시작 인덱스를 '포함'하는 start_indices의 측정기준입니다. 자세한 내용은 아래를 참고하세요.
offset_dims ArraySlice<int64> 피연산자에서 슬라이스된 배열로 오프셋되는 출력 도형의 측정기준 집합입니다.
slice_sizes ArraySlice<int64> slice_sizes[i]는 측정기준 i의 슬라이스의 경계입니다.
collapsed_slice_dims ArraySlice<int64> 각 슬라이스의 축소된 측정기준 집합입니다. 이러한 측정기준은 크기 1이어야 합니다.
start_index_map ArraySlice<int64> start_indices의 인덱스를 연산자에 유효한 인덱스로 매핑하는 방법을 설명하는 맵입니다.
indices_are_sorted bool 호출자가 색인을 정렬할 수 있는지 여부입니다.

편의를 위해 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. batch_dims의 k에 대해 G = { Out[k] 라고 가정합니다. 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], 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. Oin[_] = 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는 O0 및 O1의 범위를 결정하는 [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]이 됩니다. 즉, 출력 색인 [G0,G1,O0]은 입력 색인 [GatherIndices[G0,G1,0],O0]에 매핑되어 tf.gather_nd의 시맨틱을 제공합니다.

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

GetDimensionSize

XlaBuilder::GetDimensionSize도 참고하세요.

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

GetDimensionSize(operand, dimension)

인수 유형 시맨틱
operand XlaOp n차원 입력 배열
dimension int64 크기를 지정하는 간격 [0, n)의 값

SetDimensionSize

XlaBuilder::SetDimensionSize도 참고하세요.

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

SetDimensionSize(operand, size, dimension)

인수 유형 시맨틱
operand XlaOp n차원 입력 배열입니다.
size XlaOp 런타임 동적 크기를 나타내는 int32입니다.
dimension int64 크기를 지정하는 [0, n) 간격의 값입니다.

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

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

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도 참고하세요.

Infeed

XlaBuilder::Infeed도 참고하세요.

Infeed(shape)

인수 유형 시맨틱
shape Shape 인피드 인터페이스에서 읽은 데이터의 형식입니다. 도형의 layout 필드는 기기에 전송된 데이터의 레이아웃과 일치하도록 설정해야 합니다. 그렇지 않으면 동작이 정의되지 않습니다.

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

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

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

중첩된 튜플 모양은 지원되지 않습니다. 빈 튜플 형태의 경우 인피드 작업은 사실상 노옵스(no-ops)이며 기기의 인피드에서 데이터를 읽지 않고 진행됩니다.

Iota

XlaBuilder::Iota도 참고하세요.

Iota(shape, iota_dimension)

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

인수 유형 시맨틱
shape Shape Iota()로 만든 배열의 모양
iota_dimension int64 증분할 측정기준입니다.

예를 들어 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 N개의 XlaOp 시퀀스 유형 T0..T{N-1}의 N 배열
computation XlaComputation T 유형의 N개 매개변수와 임의 유형의 M개를 사용하여 T_0, T_1, .., T_{N + M -1} -> S 유형을 계산합니다.
dimensions int64 배열 지도 크기 배열

지정된 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)

인수 유형 시맨틱
operand XlaOp T 유형의 배열
padding_value XlaOp 추가 패딩을 채우는 T 유형의 스칼라
padding_config PaddingConfig 양쪽 가장자리(낮음, 높음) 및 각 크기의 요소 간의 패딩 수량

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

PaddingConfig는 PaddingConfigDimension의 반복되는 필드로, 각 측정기준에 대해 3개의 필드(edge_padding_low, edge_padding_high, interior_padding)를 포함합니다.

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

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

가장자리 패딩 쌍이 모두 (0, 0)이고 내부 패딩 값이 모두 0이면 이 연산은 노옵스(no-ops)입니다. 아래 그림은 2차원 배열의 다양한 edge_padding 및 interior_padding 값의 예를 보여줍니다.

Recv

XlaBuilder::Recv도 참고하세요.

Recv(shape, channel_handle)

인수 유형 시맨틱
shape Shape 수신하기 위한 데이터의 형태
channel_handle ChannelHandle 각 송수신 쌍의 고유 식별자

동일한 채널 핸들을 공유하는 다른 계산의 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 명령어로 생성된 컨텍스트를 사용하여 데이터 전송이 완료될 때까지 기다렸다가 수신된 데이터를 반환합니다.

축소

XlaBuilder::Reduce도 참고하세요.

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

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

인수 유형 시맨틱
operands N개의 XlaOp 시퀀스 T_0, ..., T_{N-1} 유형의 배열 N개
init_values N개의 XlaOp 시퀀스 T_0, ..., T_{N-1} 유형의 스칼라 N개
computation XlaComputation T_0, ..., T_{N-1}, T_0, ..., T_{N-1} -> Collate(T_0, ..., T_{N-1}) 유형의 계산입니다.
dimensions int64 배열 축소할 차원의 순서가 지정되지 않은 배열입니다.

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

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

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

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

예

값이 [10, 11, 12, 13]인 단일 1차원 배열에서 한 차원으로 축소하는 경우 축소 함수 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 rank of the result
for r0 in range(result_shape[0]), r1 in range(result_shape[1]), ...:
  # Initialize this result element
  result[r0, r1...] <- 0

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

다음은 2D 배열(행렬)을 줄이는 예입니다. 도형의 순위는 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가 생성됩니다.

Variadic 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-D 입력 배열 V = Float[N], K = Int[N] 및 init 값 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)

인수 유형 시맨틱
operand XlaOp 부동 소수점 유형 T의 배열입니다.
exponent_bits int32 낮은 정밀도 형식의 지수 비트 수
mantissa_bits int32 낮은 정밀도 형식의 가수 비트 수

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

저정밀도 형식은 (가수와 가수가 모두 0이므로 무한대와 0 값을 구분하기 위해) 최소 하나의 지수 비트를 가져야 하며 가수 비트 수가 음수가 아니어야 합니다. 지수 또는 가수 비트 수가 유형 T의 해당 값을 초과할 수 있습니다. 그러면 해당 변환 부분은 단순히 노옵스(no-ops)입니다.

ReduceScatter

XlaBuilder::ReduceScatter도 참고하세요.

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

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

인수 유형 시맨틱
operand XlaOp 복제본 간에 줄일 배열 또는 비어 있지 않은 배열의 튜플입니다.
computation XlaComputation 감소 계산
scatter_dimension int64 산포할 측정기준입니다.
shard_count int64 scatter_dimension을 분할할 블록 수
replica_groups int64의 벡터로 구성된 벡터 축소가 수행되는 그룹
channel_id 선택사항 int64 교차 모듈 통신을 위한 선택적 채널 ID
  • operand가 배열의 튜플인 경우 튜플의 각 요소에 감소-분산기가 실행됩니다.
  • 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)

인수 유형 시맨틱
operands N XlaOps 각각 창이 배치되는 기본 영역을 나타내는 T_0,..., T_{N-1} 유형의 N차원 배열의 시퀀스입니다.
init_values N XlaOps 감소의 시작 값 N개(N개의 피연산자마다 하나씩)입니다. 자세한 내용은 감소를 참고하세요.
computation XlaComputation 모든 입력 피연산자의 각 윈도우에 있는 요소에 적용되는 T_0, ..., T_{N-1}, T_0, ..., T_{N-1} -> Collate(T_0, ..., T_{N-1}) 유형의 감소 함수입니다.
window_dimensions ArraySlice<int64> 기간 측정기준 값의 정수 배열
window_strides ArraySlice<int64> 창 스트라이드 값의 정수 배열
base_dilations ArraySlice<int64> 기본 확장 값의 정수 배열
window_dilations ArraySlice<int64> 창 확장 값의 정수 배열
padding Padding 창의 패딩 유형입니다. Padding::kSame은 스트라이드가 1인 경우 입력과 동일한 출력 도형을 갖도록 패딩하고, Padding::kValid는 패딩을 사용하지 않고 더 이상 맞지 않으면 창을 '중지'합니다.

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

  • 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로 감소 창 최솟값(초깃값은 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, new_sizes) Reshape(operand, dimensions, new_sizes)

인수 유형 시맨틱
operand XlaOp 유형 T의 배열
dimensions int64 벡터 크기가 접히는 순서
new_sizes int64 벡터 새로운 차원의 크기의 벡터

개념적으로 reshape는 먼저 배열을 데이터 값의 1차원 벡터로 평면화한 다음 이 벡터를 새 도형으로 미세 조정합니다. 입력 인수는 T 유형의 임의 배열, 차원 색인의 컴파일 시간 상수 벡터, 결과의 차원 크기 컴파일 시간 상수 벡터입니다. dimension 벡터의 값(제공된 경우)은 T의 모든 측정기준의 순열이어야 합니다. 지정되지 않은 경우 기본값은 {0, ..., rank - 1}입니다. dimensions의 크기 순서는 입력 배열을 단일 크기로 축소하는 루프 중첩에서 가장 느리게 변하는 크기(가장 큰 크기)에서 가장 빠르게 변하는 크기(가장 작은 크기)로 지정됩니다. new_sizes 벡터는 출력 배열의 크기를 결정합니다. new_sizes의 색인 0에 있는 값은 크기 0의 크기이고, 색인 1에 있는 값은 크기 1의 크기입니다. new_size 차원의 곱은 피연산자의 차원 크기 곱과 같아야 합니다. 축소된 배열을 new_sizes로 정의된 다차원 배열로 미세 조정할 때 new_sizes의 측정기준은 가장 느리게 변하는 측정기준(가장 주요)부터 가장 빠르게 변하는 측정기준(가장 하위)으로 정렬됩니다.

예를 들어 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} } };

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

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

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

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


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

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

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

Rev(역방향)

XlaBuilder::Rev도 참고하세요.

Rev(operand, dimensions)

인수 유형 시맨틱
operand XlaOp T 유형의 배열
dimensions ArraySlice<int64> 역전할 크기

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

Rev 연산의 한 가지 용도는 신경망의 기울기 계산 중에 컨볼루션 가중치 배열을 두 윈도우 차원에 따라 반전하는 것입니다.

RngNormal

XlaBuilder::RngNormal도 참고하세요.

\(N(\mu, \sigma)\) 정규 분포에 따라 생성된 난수를 사용하여 지정된 도형의 출력을 생성합니다. 매개변수 \(\mu\) 및 \(\sigma\)와 출력 도형은 부동 소수점 기본 유형이어야 합니다. 또한 매개변수는 스칼라 값이어야 합니다.

RngNormal(mu, sigma, shape)

인수 유형 시맨틱
mu XlaOp 생성된 숫자의 평균을 지정하는 T 유형의 스칼라
sigma XlaOp 생성된 표준 편차를 지정하는 T 유형의 스칼라입니다.
shape Shape 유형 T의 출력 셰이프

RngUniform

XlaBuilder::RngUniform도 참고하세요.

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

RngUniform(a, b, shape)

인수 유형 시맨틱
a XlaOp 간격의 하한을 지정하는 T 유형의 스칼라
b XlaOp 간격의 상한을 지정하는 T 유형의 스칼라
shape Shape T 유형의 출력 셰이프

RngBitGenerator

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

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

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

RngBitGenerator(algorithm, key, shape)

인수 유형 시맨틱
algorithm RandomAlgorithm 사용할 PRNG 알고리즘입니다.
initial_state XlaOp PRNG 알고리즘의 초기 상태입니다.
shape Shape 생성된 데이터의 출력 셰이프입니다.

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

분산형

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

XlaBuilder::Scatter도 참고하세요.

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

인수 유형 시맨틱
operands N XlaOp의 수열 분산할 T_0, ..., T_N 유형의 N 배열입니다.
scatter_indices XlaOp 분산되어야 하는 슬라이스의 시작 색인이 포함된 배열입니다.
updates N XlaOp의 수열 T_0, ..., T_N 유형의 배열 N개 updates[i]에는 operands[i] 분산에 사용해야 하는 값이 포함되어 있습니다.
update_computation XlaComputation 입력 배열의 기존 값과 산포 중에 업데이트된 값을 결합하는 데 사용되는 계산입니다. 이 계산은 T_0, ..., T_N, T_0, ..., T_N -> Collate(T_0, ..., T_N) 유형이어야 합니다.
index_vector_dim int64 시작 인덱스가 포함된 scatter_indices의 측정기준입니다.
update_window_dims ArraySlice<int64> 창 크기인 updates 도형의 치수 집합입니다.
inserted_window_dims ArraySlice<int64> updates 도형에 삽입해야 하는 창 크기 세트입니다.
scatter_dims_to_operand_dims ArraySlice<int64> 측정기준 매핑은 분산형 색인에서 피연산자 색인 공간으로 매핑됩니다. 이 배열은 i를 scatter_dims_to_operand_dims[i]에 매핑하는 것으로 해석됩니다. 일대일로 진행해야 합니다.
indices_are_sorted bool 호출자에 의한 색인 정렬이 보장되는지 여부입니다.
unique_indices bool 호출자에 의해 색인이 고유한지 여부를 보장하는지 여부입니다.

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

  • 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. k < scatter_dims_to_operand_dims.size이면 Sin[scatter_dims_to_operand_dims[k]] = S[k].
    2. Sin[_] = 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. Win[_] = 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로 설정되어 있고 분산되는 색인이 고유하지 않으면 시맨틱이 구현됩니다.

비공식적으로 분산 작업은 수집 작업의 역으로 볼 수 있습니다. 즉, 분산형 작업은 해당 수집 작업에서 추출한 입력의 요소를 업데이트합니다.

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

선택

XlaBuilder::Select도 참고하세요.

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

Select(pred, on_true, on_false)

인수 유형 시맨틱
pred XlaOp PRED 유형의 배열
on_true XlaOp T 유형의 배열
on_false XlaOp T 유형의 배열

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

인수 유형 시맨틱
operand XlaOp 창이 슬라이드되는 T 유형의 배열
select XlaComputation 각 윈도우의 모든 요소에 적용할 T, T -> PRED 유형의 이진 계산. 첫 번째 매개변수가 선택되면 true을 반환하고 두 번째 매개변수가 선택되면 false를 반환합니다.
window_dimensions ArraySlice<int64> 기간 측정기준 값의 정수 배열
window_strides ArraySlice<int64> 윈도우 스트라이드 값의 정수 배열
padding Padding 창의 패딩 유형 (Padding::kSame 또는 Padding::kValid)
source XlaOp 분산할 값이 포함된 T 유형의 배열
init_value XlaOp 출력 배열의 초깃값에 관한 T 유형의 스칼라 값
scatter XlaComputation 각 분산형 소스 요소를 대상 요소와 함께 적용하기 위한 T, T -> T 유형의 이진 계산

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

scatter 함수의 평가 순서는 임의이며 확정되지 않을 수 있습니다. 따라서 scatter 함수는 재연결에 지나치게 민감하지 않아야 합니다. 자세한 내용은 Reduce 맥락의 결합성에 관한 설명을 참고하세요.

보내기

XlaBuilder::Send도 참고하세요.

Send(operand, channel_handle)

인수 유형 시맨틱
operand XlaOp 전송할 데이터(유형 T의 배열)
channel_handle ChannelHandle 각 전송/수신 쌍의 고유 식별자

지정된 피연산자 데이터를 동일한 채널 핸들을 공유하는 다른 계산의 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 명령어로 생성된 컨텍스트를 사용하여 데이터 전송이 완료될 때까지 기다립니다. 명령어는 데이터를 반환하지 않습니다.

채널 안내 일정 예약

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

  • Recv이(가) Send 전에 발생합니다.
  • Send가 RecvDone 전에 발생함
  • Recv가 RecvDone 전에 발생합니다.
  • Send가 SendDone 전에 발생함

백엔드 컴파일러가 채널 명령을 통해 통신하는 각 계산에 선형 일정을 생성하는 경우 계산 간에 주기가 없어야 합니다. 예를 들어 아래 일정은 교착 상태로 이어집니다.

슬라이스

XlaBuilder::Slice도 참고하세요.

슬라이싱은 입력 배열에서 하위 배열을 추출합니다. 하위 배열은 입력과 동일한 순위이며 입력 배열 내 경계 상자 내 값을 포함합니다. 여기서 경계 상자의 크기와 색인은 슬라이스 작업에 인수로 제공됩니다.

Slice(operand, start_indices, limit_indices, strides)

인수 유형 시맨틱
operand XlaOp T 유형의 N차원 배열
start_indices ArraySlice<int64> 각 차원에 대한 슬라이스의 시작 색인을 포함하는 N개의 정수 목록입니다. 값은 0 이상이어야 합니다.
limit_indices ArraySlice<int64> 각 차원 슬라이스의 끝 색인 (제외)을 포함하는 N개의 정수 목록입니다. 각 값은 측정기준의 각 start_indices 값보다 크거나 같고, 측정기준의 크기보다 작거나 같아야 합니다.
strides ArraySlice<int64> 슬라이스의 입력 스트라이드를 결정하는 N개의 정수 목록입니다. 슬라이스는 측정기준 d의 모든 strides[d] 요소를 선택합니다.

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)

인수 유형 시맨틱
operands ArraySlice<XlaOp> 정렬할 피연산자입니다.
comparator XlaComputation 사용할 비교기 계산입니다.
dimension int64 정렬할 측정기준입니다.
is_stable bool 안정적인 정렬 사용 여부입니다.

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

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

  • 피연산자의 순위가 더 높은 경우 제공된 측정기준을 기준으로 피연산자가 정렬됩니다. 예를 들어 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로 설정됩니다.

전치행렬

tf.reshape 작업도 참고하세요.

Transpose(operand)

인수 유형 시맨틱
operand XlaOp 전치할 피연산자입니다.
permutation ArraySlice<int64> 측정기준을 순열하는 방법

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

이는 Reshape(operand, pervariant, Permute(permute, 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)

인수 유형 시맨틱
a XlaOp 도형이 [..., M, M]인 복합 또는 부동 소수점 유형의 순위 > 2 배열입니다.
b XlaOp left_side가 true인 경우 셰이프 [..., M, K]인 동일한 유형의 순위 > 2 배열, 그렇지 않으면 [..., K, M].
left_side bool op(a) * x = b(true) 또는 x * op(a) = b(false) 형식의 시스템을 풀지 여부를 나타냅니다.
lower bool a의 위쪽 삼각형을 사용할지 아니면 아래쪽 삼각형을 사용할지 여부입니다.
unit_diagonal bool true인 경우 a의 대각선 요소는 1로 가정되고 액세스되지 않습니다.
transpose_a 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 XlaComputation 루프의 종료 조건을 정의하는 T -> PRED 유형의 XlaComputation입니다.
body XlaComputation 루프의 본문을 정의하는 T -> T 유형의 XlaComputation입니다.
init T condition 및 body 매개변수의 초기 값입니다.

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