Ngữ nghĩa hoạt động

Sau đây mô tả ngữ nghĩa của các thao tác được xác định trong giao diện XlaBuilder. Thông thường, các thao tác này sẽ liên kết một-một với các thao tác được xác định trong giao diện RPC trong xla_data.proto.

Lưu ý về quy tắc đặt tên: kiểu dữ liệu tổng quát mà XLA xử lý là một mảng N chiều chứa các phần tử thuộc một số kiểu đồng nhất (chẳng hạn như số thực 32 bit). Trong suốt tài liệu, mảng được dùng để biểu thị một mảng có số chiều tuỳ ý. Để thuận tiện, các trường hợp đặc biệt có tên cụ thể và quen thuộc hơn; ví dụ: vector là một mảng 1 chiều và matrix là một mảng 2 chiều.

Tìm hiểu thêm về cấu trúc của một Thao tác trong Hình dạng và bố cục và Bố cục dạng lát.

Cơ bụng

Xem thêm XlaBuilder::Abs.

Hàm abs theo phần tử x -> |x|.

Abs(operand)

Để biết thông tin về StableHLO, hãy xem StableHLO – abs.

Thêm

Xem thêm XlaBuilder::Add.

Thực hiện phép cộng từng phần tử của lhs và rhs.

Add(lhs, rhs)

Hình dạng của các đối số phải tương tự hoặc tương thích. Hãy xem tài liệu truyền tin để biết ý nghĩa của việc các hình dạng tương thích. Kết quả của một thao tác có hình dạng là kết quả của việc truyền hai mảng đầu vào. Trong biến thể này, các thao tác giữa các mảng có thứ hạng khác nhau không được hỗ trợ, trừ phi một trong các toán hạng là một đại lượng vô hướng.

Có một biến thể thay thế hỗ trợ truyền hình nhiều chiều cho Add:

Add(lhs,rhs, broadcast_dimensions)

Biến thể này của thao tác nên được dùng cho các phép toán số học giữa các mảng có thứ hạng khác nhau (chẳng hạn như thêm một ma trận vào một vectơ).

Toán hạng broadcast_dimensions bổ sung là một lát số nguyên chỉ định các phương diện cần dùng để truyền các toán hạng. Ngữ nghĩa được mô tả chi tiết trên trang phát sóng.

Để biết thông tin về StableHLO, hãy xem bài viết StableHLO – add.

AddDependency

Xem thêm HloInstruction::AddDependency.

AddDependency có thể xuất hiện trong các kết xuất HLO, nhưng người dùng cuối không nên tạo các kết xuất này theo cách thủ công.

AfterAll

Xem thêm XlaBuilder::AfterAll.

AfterAll nhận một số lượng mã thông báo thay đổi và tạo ra một mã thông báo duy nhất. Mã thông báo là các loại nguyên thuỷ có thể được liên kết giữa các thao tác gây tác dụng phụ để thực thi việc sắp xếp. AfterAll có thể được dùng làm một mã thông báo kết hợp để sắp xếp một thao tác sau một tập hợp các thao tác.

AfterAll(tokens)

Để biết thông tin về StableHLO, hãy xem StableHLO – after_all.

AllGather

Xem thêm XlaBuilder::AllGather.

Thực hiện việc nối trên các bản sao.

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

• replica_groups là danh sách các nhóm bản sao mà giữa đó quá trình nối được thực hiện (bạn có thể truy xuất mã nhận dạng bản sao cho bản sao hiện tại bằng cách sử dụng ReplicaId). Thứ tự của các bản sao trong mỗi nhóm sẽ xác định thứ tự mà các đầu vào của chúng nằm trong kết quả. replica_groups phải trống (trong trường hợp đó, tất cả các bản sao thuộc một nhóm duy nhất, được sắp xếp từ 0 đến N - 1) hoặc chứa cùng số lượng phần tử như số lượng bản sao. Ví dụ: replica_groups = {0, 2}, {1, 3} thực hiện việc nối giữa các bản sao 0 và 2, cũng như 1 và 3.
• shard_count là quy mô của mỗi nhóm bản sao. Chúng tôi cần thông tin này trong trường hợp replica_groups trống.
• channel_id được dùng để giao tiếp giữa các mô-đun: chỉ những thao tác all-gather có cùng channel_id mới có thể giao tiếp với nhau.
• use_global_device_ids Trả về true nếu các mã nhận dạng trong cấu hình ReplicaGroup biểu thị mã nhận dạng chung của (replica_id * partition_count + partition_id) thay vì mã nhận dạng bản sao. Điều này cho phép nhóm các thiết bị linh hoạt hơn nếu thao tác giảm tất cả này vừa là xuyên phân vùng vừa là xuyên bản sao.

Hình dạng đầu ra là hình dạng đầu vào với all_gather_dimension được tạo lớn hơn shard_count lần. Ví dụ: nếu có 2 bản sao và toán hạng có giá trị lần lượt là [1.0, 2.5] và [3.0, 5.25] trên 2 bản sao, thì giá trị đầu ra từ thao tác này, trong đó all_gather_dim là 0, sẽ là [1.0, 2.5, 3.0,5.25] trên cả 2 bản sao.

API của AllGather được phân tách nội bộ thành 2 chỉ dẫn HLO (AllGatherStart và AllGatherDone).

Xem thêm HloInstruction::CreateAllGatherStart.

AllGatherStart, AllGatherDone đóng vai trò là các thành phần cơ bản trong HLO. Các thao tác này có thể xuất hiện trong các kết xuất HLO, nhưng người dùng cuối không được phép tạo các thao tác này theo cách thủ công.

Để biết thông tin về StableHLO, hãy xem StableHLO – all_gather.

AllReduce

Xem thêm XlaBuilder::AllReduce.

Thực hiện một phép tính tuỳ chỉnh trên các bản sao.

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

• Khi operand là một bộ gồm các mảng, thao tác giảm tất cả sẽ được thực hiện trên từng phần tử của bộ.
• replica_groups là danh sách các nhóm bản sao mà quá trình giảm được thực hiện (bạn có thể truy xuất mã nhận dạng bản sao cho bản sao hiện tại bằng cách sử dụng ReplicaId). replica_groups phải trống (trong trường hợp tất cả các bản sao thuộc về một nhóm duy nhất) hoặc chứa cùng số lượng phần tử như số lượng bản sao. Ví dụ: replica_groups = {0, 2}, {1, 3} thực hiện thao tác giảm giữa các bản sao 0 và 2, cũng như 1 và 3.
• channel_id được dùng để giao tiếp giữa các mô-đun: chỉ những thao tác all-reduce có cùng channel_id mới có thể giao tiếp với nhau.
• shape_with_layout: buộc bố cục của AllReduce thành bố cục đã cho. Điều này được dùng để đảm bảo cùng một bố cục cho một nhóm các thao tác AllReduce được biên dịch riêng.
• use_global_device_ids Trả về true nếu các mã nhận dạng trong cấu hình ReplicaGroup biểu thị mã nhận dạng chung của (replica_id * partition_count + partition_id) thay vì mã nhận dạng bản sao. Điều này cho phép nhóm các thiết bị linh hoạt hơn nếu thao tác giảm tất cả này vừa là xuyên phân vùng vừa là xuyên bản sao.

Hình dạng đầu ra giống với hình dạng đầu vào. Ví dụ: nếu có 2 bản sao và toán hạng có giá trị lần lượt là [1.0, 2.5] và [3.0, 5.25] trên 2 bản sao, thì giá trị đầu ra từ phép tính tổng và op này sẽ là [4.0, 7.75] trên cả 2 bản sao. Nếu đầu vào là một bộ dữ liệu, thì đầu ra cũng là một bộ dữ liệu.

Để tính toán kết quả của AllReduce, bạn cần có một đầu vào từ mỗi bản sao. Vì vậy, nếu một bản sao thực thi một nút AllReduce nhiều lần hơn một bản sao khác, thì bản sao trước sẽ đợi mãi mãi. Vì tất cả các bản sao đều đang chạy cùng một chương trình, nên không có nhiều cách để điều đó xảy ra, nhưng điều này có thể xảy ra khi điều kiện của vòng lặp while phụ thuộc vào dữ liệu từ infeed và dữ liệu đó infeed khiến vòng lặp while lặp lại nhiều lần hơn trên một bản sao so với một bản sao khác.

API của AllReduce được phân tách nội bộ thành 2 chỉ dẫn HLO (AllReduceStart và AllReduceDone).

Xem thêm HloInstruction::CreateAllReduceStart.

AllReduceStart và AllReduceDone đóng vai trò là các thành phần cơ bản trong HLO. Các thao tác này có thể xuất hiện trong các kết xuất HLO, nhưng người dùng cuối không được phép tạo các thao tác này theo cách thủ công.

CrossReplicaSum

Xem thêm XlaBuilder::CrossReplicaSum.

Thực hiện AllReduce bằng phép tính tổng.

CrossReplicaSum(operand, replica_groups)

Trả về tổng giá trị của toán hạng trong mỗi nhóm con của các bản sao. Tất cả các bản sao sẽ cung cấp một đầu vào cho tổng và tất cả các bản sao sẽ nhận được tổng kết quả cho từng nhóm con.

AllToAll

Xem thêm XlaBuilder::AllToAll.

AllToAll là một thao tác tập thể gửi dữ liệu từ tất cả các lõi đến tất cả các lõi. Quy trình này có 2 giai đoạn:

1. Giai đoạn phân tán. Trên mỗi lõi, toán hạng được chia thành split_count số khối dọc theo split_dimensions và các khối được phân tán đến tất cả các lõi, ví dụ: khối thứ i được gửi đến lõi thứ i.
2. Giai đoạn thu thập. Mỗi lõi sẽ nối các khối nhận được dọc theo concat_dimension.

Bạn có thể định cấu hình các lõi tham gia bằng cách:

• replica_groups: mỗi ReplicaGroup chứa một danh sách mã nhận dạng bản sao tham gia vào quá trình tính toán (có thể truy xuất mã nhận dạng bản sao cho bản sao hiện tại bằng cách sử dụng ReplicaId). AllToAll sẽ được áp dụng trong các nhóm con theo thứ tự đã chỉ định. Ví dụ: replica_groups = { {1,2,3}, {4,5,0} } có nghĩa là AllToAll sẽ được áp dụng trong các bản sao {1, 2, 3} và trong giai đoạn thu thập, các khối nhận được sẽ được nối theo cùng một thứ tự là 1, 2, 3. Sau đó, một AllToAll khác sẽ được áp dụng trong các bản sao 4, 5, 0 và thứ tự nối cũng là 4, 5, 0. Nếu replica_groups trống, tất cả các bản sao sẽ thuộc về một nhóm, theo thứ tự nối của sự xuất hiện.

Điều kiện tiên quyết:

• Kích thước phương diện của toán hạng trên split_dimension có thể chia hết cho split_count.
• Hình dạng của toán hạng không phải là bộ.

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

Hãy xem xla::shapes để biết thêm thông tin về hình dạng và bố cục..

Để biết thông tin về StableHLO, hãy xem StableHLO – all_to_all.

AllToAll – Ví dụ 1.

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

Trong ví dụ trên, có 4 lõi tham gia vào Alltoall. Trên mỗi lõi, toán hạng được chia thành 4 phần dọc theo phương diện 1, do đó, mỗi phần có hình dạng f32[4,4]. 4 phần này được phân tán đến tất cả các lõi. Sau đó, mỗi lõi sẽ nối các phần đã nhận được dọc theo phương diện 0, theo thứ tự lõi 0-4. Vì vậy, đầu ra trên mỗi lõi có hình dạng f32[16,4].

AllToAll – Ví dụ 2 – StableHLO

Trong ví dụ trên, có 2 bản sao tham gia vào AllToAll. Trên mỗi bản sao, toán hạng có hình dạng f32[2,4]. Toán hạng được chia thành 2 phần dọc theo phương diện 1, vì vậy mỗi phần có hình dạng f32[2,2]. Sau đó, 2 phần này sẽ được trao đổi giữa các bản sao theo vị trí của chúng trong nhóm bản sao. Mỗi bản sao sẽ thu thập phần tương ứng của bản sao đó từ cả hai toán hạng và nối chúng dọc theo chiều 0. Do đó, đầu ra trên mỗi bản sao có hình dạng f32[4,2].

RaggedAllToAll

Xem thêm XlaBuilder::RaggedAllToAll.

RaggedAllToAll thực hiện một thao tác tập thể từ tất cả đến tất cả, trong đó đầu vào và đầu ra là các tensor không đồng đều.

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

Tensor thưa được xác định bằng một tập hợp gồm 3 tensor:

• data: datatensor là "không đều" dọc theo chiều ngoài cùng, dọc theo đó mỗi phần tử được lập chỉ mục có kích thước thay đổi.
• offsets: tensor offsets lập chỉ mục chiều ngoài cùng của tensor data và biểu thị độ lệch bắt đầu của từng phần tử không đồng đều của tensor data.
• sizes: tenxơ sizes biểu thị kích thước của từng phần tử không đồng đều của tenxơ data, trong đó kích thước được chỉ định theo đơn vị của các phần tử phụ. Phần tử phụ được xác định là hậu tố của hình dạng tenxơ "dữ liệu" thu được bằng cách xoá chiều "không đều" ngoài cùng.
• Các tensor offsets và sizes phải có cùng kích thước.

Ví dụ về một tensor thô:

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

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

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

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

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

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

output_offsets phải được phân đoạn theo cách mà mỗi bản sao có độ lệch trong góc nhìn đầu ra của bản sao đích.

Đối với độ lệch đầu ra thứ i, bản sao hiện tại sẽ gửi thông tin cập nhật input[input_offsets[i]:input_offsets[i]+input_sizes[i]] đến bản sao thứ i. Thông tin này sẽ được ghi vào output_i[output_offsets[i]:output_offsets[i]+send_sizes[i]] trong bản sao thứ i output.

Ví dụ: nếu chúng ta có 2 bản sao:

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

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

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

HLO không đồng đều từ tất cả đến tất cả có các đối số sau:

• input: tensor dữ liệu đầu vào không đồng đều.
• output: tensor dữ liệu đầu ra không đồng đều.
• input_offsets: tensor đầu vào có độ lệch không đều.
• send_sizes: tensor kích thước gửi không đều.
• output_offsets: mảng gồm các mức chênh lệch không đều trong đầu ra của bản sao đích.
• recv_sizes: tensor có kích thước recv không đồng đều.

Tất cả các tensor *_offsets và *_sizes đều phải có cùng hình dạng.

Hai hình dạng được hỗ trợ cho các tensor *_offsets và *_sizes:

• [num_devices] trong đó ragged-all-to-all có thể gửi tối đa một bản cập nhật cho mỗi thiết bị từ xa trong nhóm bản sao. Ví dụ:

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

• [num_devices, num_updates] trong đó ragged-all-to-all có thể gửi tối đa num_updates bản cập nhật cho cùng một thiết bị từ xa (mỗi bản cập nhật ở các độ lệch khác nhau), cho mỗi thiết bị từ xa trong nhóm bản sao.

Ví dụ:

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

và

Xem thêm XlaBuilder::And.

Thực hiện phép AND theo phần tử của hai tensor lhs và rhs.

And(lhs, rhs)

Hình dạng của các đối số phải tương tự hoặc tương thích. Hãy xem tài liệu truyền tin để biết ý nghĩa của việc các hình dạng tương thích. Kết quả của một thao tác có hình dạng là kết quả của việc truyền hai mảng đầu vào. Trong biến thể này, các thao tác giữa các mảng có thứ hạng khác nhau không được hỗ trợ, trừ phi một trong các toán hạng là một đại lượng vô hướng.

Một biến thể thay thế có hỗ trợ truyền hình nhiều chiều dành cho Android:

And(lhs,rhs, broadcast_dimensions)

Biến thể này của thao tác nên được dùng cho các phép toán số học giữa các mảng có thứ hạng khác nhau (chẳng hạn như thêm một ma trận vào một vectơ).

Toán hạng broadcast_dimensions bổ sung là một lát số nguyên chỉ định các phương diện cần dùng để truyền các toán hạng. Ngữ nghĩa được mô tả chi tiết trên trang phát sóng.

Để biết thông tin về StableHLO, hãy xem StableHLO – và.

Không đồng bộ

Xem thêm HloInstruction::CreateAsyncStart, HloInstruction::CreateAsyncUpdate, HloInstruction::CreateAsyncDone.

AsyncDone, AsyncStart và AsyncUpdate là các chỉ dẫn HLO nội bộ được dùng cho các hoạt động không đồng bộ và đóng vai trò là các thành phần cơ bản trong HLO. Các thao tác này có thể xuất hiện trong các kết xuất HLO nhưng người dùng cuối không được phép tạo các thao tác này theo cách thủ công.

Atan2

Xem thêm XlaBuilder::Atan2.

Thực hiện phép toán atan2 theo phần tử trên lhs và rhs.

Atan2(lhs, rhs)

Hình dạng của các đối số phải tương tự hoặc tương thích. Hãy xem tài liệu truyền tin để biết ý nghĩa của việc các hình dạng tương thích. Kết quả của một thao tác có hình dạng là kết quả của việc truyền hai mảng đầu vào. Trong biến thể này, các thao tác giữa các mảng có thứ hạng khác nhau không được hỗ trợ, trừ phi một trong các toán hạng là một đại lượng vô hướng.

Có một biến thể thay thế hỗ trợ truyền tin nhiều chiều cho Atan2:

Atan2(lhs,rhs, broadcast_dimensions)

Biến thể này của thao tác nên được dùng cho các phép toán số học giữa các mảng có thứ hạng khác nhau (chẳng hạn như thêm một ma trận vào một vectơ).

Toán hạng broadcast_dimensions bổ sung là một lát số nguyên chỉ định các phương diện cần dùng để truyền các toán hạng. Ngữ nghĩa được mô tả chi tiết trên trang phát sóng.

Để biết thông tin về StableHLO, hãy xem StableHLO – atan2.

BatchNormGrad

Xem thêm XlaBuilder::BatchNormGrad và bài viết gốc về chuẩn hoá theo lô để biết nội dung mô tả chi tiết về thuật toán này.

Tính toán độ dốc của chuẩn hoá theo lô.

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

Đối với mỗi đối tượng trong phương diện đối tượng (feature_index là chỉ mục cho phương diện đối tượng trong operand), thao tác này sẽ tính toán độ dốc liên quan đến operand, offset và scale trên tất cả các phương diện khác. feature_index phải là một chỉ mục hợp lệ cho phương diện đối tượng trong operand.

Ba độ dốc được xác định bằng các công thức sau (giả sử mảng 4 chiều là operand và có chỉ mục chiều của đối tượng l, kích thước lô m và kích thước không gian w và 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} \]

Đầu vào batch_mean và batch_var biểu thị các giá trị khoảnh khắc trên các phương diện theo lô và không gian.

Loại đầu ra là một bộ gồm 3 đối tượng xử lý:

Để biết thông tin về StableHLO, hãy xem StableHLO – batch_norm_grad.

BatchNormInference

Xem thêm XlaBuilder::BatchNormInference và bài viết gốc về chuẩn hoá theo lô để biết nội dung mô tả chi tiết về thuật toán này.

Chuẩn hoá một mảng trên các phương diện lô và không gian.

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

Đối với mỗi đối tượng trong phương diện đối tượng (feature_index là chỉ mục cho phương diện đối tượng trong operand), thao tác này sẽ tính toán giá trị trung bình và phương sai trên tất cả các phương diện khác, đồng thời sử dụng giá trị trung bình và phương sai để chuẩn hoá từng phần tử trong operand. feature_index phải là một chỉ mục hợp lệ cho phương diện đối tượng trong operand.

BatchNormInference tương đương với việc gọi BatchNormTraining mà không cần tính toán mean và variance cho từng lô. Thay vào đó, hàm này sử dụng mean và variance làm giá trị ước tính. Mục đích của thao tác này là giảm độ trễ trong suy luận, do đó có tên là BatchNormInference.

Đầu ra là một mảng n chiều, được chuẩn hoá có cùng hình dạng với đầu vào operand.

Để biết thông tin về StableHLO, hãy xem StableHLO – batch_norm_inference.

BatchNormTraining

Xem thêm XlaBuilder::BatchNormTraining và the original batch normalization paper để biết nội dung mô tả chi tiết về thuật toán.

Chuẩn hoá một mảng trên các phương diện lô và không gian.

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

Đối với mỗi đối tượng trong phương diện đối tượng (feature_index là chỉ mục cho phương diện đối tượng trong operand), thao tác này sẽ tính toán giá trị trung bình và phương sai trên tất cả các phương diện khác, đồng thời sử dụng giá trị trung bình và phương sai để chuẩn hoá từng phần tử trong operand. feature_index phải là một chỉ mục hợp lệ cho phương diện đối tượng trong operand.

Thuật toán diễn ra như sau cho mỗi lô trong operand \(x\) chứa các phần tử m có w và h là kích thước của các phương diện không gian (giả sử operand là một mảng 4 chiều):

• Tính toán giá trị trung bình của lô \(\mu_l\) cho từng đối tượng l trong phương diện đối tượng: \(\mu_l=\frac{1}{mwh}\sum_{i=1}^m\sum_{j=1}^w\sum_{k=1}^h x_{ijkl}\)

• Tính phương sai theo lô \(\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$

• Chuẩn hoá, điều chỉnh tỷ lệ và dịch chuyển: \(y_{ijkl}=\frac{\gamma_l(x_{ijkl}-\mu_l)}{\sqrt[2]{\sigma^2_l+\epsilon} }+\beta_l\)

Giá trị epsilon (thường là một số nhỏ) được thêm vào để tránh lỗi chia cho 0.

Loại đầu ra là một bộ gồm 3 XlaOp:

batch_mean và batch_var là những thời điểm được tính toán trên các phương diện theo lô và không gian bằng cách sử dụng các công thức ở trên.

Để biết thông tin về StableHLO, hãy xem StableHLO – batch_norm_training.

Bitcast

Xem thêm HloInstruction::CreateBitcast.

Bitcast có thể xuất hiện trong các kết xuất HLO, nhưng người dùng cuối không nên tự tạo các kết xuất này theo cách thủ công.

BitcastConvertType

Xem thêm XlaBuilder::BitcastConvertType.

Tương tự như tf.bitcast trong TensorFlow, thực hiện thao tác bitcast theo phần tử từ một hình dạng dữ liệu đến một hình dạng đích. Kích thước đầu vào và đầu ra phải khớp: ví dụ: s32 phần tử trở thành f32 phần tử thông qua quy trình bitcast và một phần tử s32 sẽ trở thành 4 phần tử s8. Bitcast được triển khai dưới dạng một truyền cấp thấp, vì vậy, các máy có nhiều cách biểu diễn số thực sẽ cho ra các kết quả khác nhau.

BitcastConvertType(operand, new_element_type)

Kích thước của toán hạng và hình dạng mục tiêu phải khớp, ngoài kích thước cuối cùng sẽ thay đổi theo tỷ lệ kích thước nguyên thuỷ trước và sau khi chuyển đổi.

Loại phần tử nguồn và đích không được là bộ giá trị.

Để biết thông tin về StableHLO, hãy xem StableHLO – bitcast_convert.

Bitcast – chuyển đổi sang kiểu nguyên thuỷ có độ rộng khác

BitcastConvert Lệnh HLO hỗ trợ trường hợp kích thước của loại phần tử đầu ra T' không bằng kích thước của phần tử đầu vào T. Vì toàn bộ thao tác này về cơ bản là một bitcast và không thay đổi các byte cơ bản, nên hình dạng của phần tử đầu ra phải thay đổi. Đối với B = sizeof(T), B' = sizeof(T'), có 2 trường hợp có thể xảy ra.

Trước tiên, khi B > B', hình dạng đầu ra sẽ có một thứ nguyên phụ mới có kích thước nhỏ nhất là B/B'. Ví dụ:

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

Quy tắc này vẫn giữ nguyên đối với các đại lượng vô hướng hiệu quả:

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

Ngoài ra, đối với B' > B, hướng dẫn yêu cầu chiều logic cuối cùng của hình dạng đầu vào phải bằng B'/B và chiều này sẽ bị loại bỏ trong quá trình chuyển đổi:

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

Xin lưu ý rằng các lượt chuyển đổi giữa các độ rộng bit khác nhau không phải là theo từng phần tử.

Phát đi thông báo

Xem thêm XlaBuilder::Broadcast.

Thêm phương diện vào một mảng bằng cách sao chép dữ liệu trong mảng.

Broadcast(operand, broadcast_sizes)

Các phương diện mới được chèn vào bên trái, tức là nếu broadcast_sizes có các giá trị {a0, ..., aN} và hình dạng toán hạng có các phương diện {b0, ..., bM} thì hình dạng của đầu ra sẽ có các phương diện {a0, ..., aN, b0, ..., bM}.

Chỉ mục kích thước mới vào các bản sao của toán hạng, tức là

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

Ví dụ: nếu operand là một đại lượng vô hướng f32 có giá trị 2.0f và broadcast_sizes là {2, 3}, thì kết quả sẽ là một mảng có hình dạng f32[2, 3] và tất cả các giá trị trong kết quả sẽ là 2.0f.

Để biết thông tin về StableHLO, hãy xem StableHLO – broadcast.

BroadcastInDim

Xem thêm XlaBuilder::BroadcastInDim.

Mở rộng kích thước và số lượng phương diện của một mảng bằng cách sao chép dữ liệu trong mảng.

BroadcastInDim(operand, out_dim_size, broadcast_dimensions)

Tương tự như Broadcast, nhưng cho phép thêm phương diện ở bất kỳ vị trí nào và mở rộng các phương diện hiện có có kích thước là 1.

operand được truyền đến hình dạng do out_dim_size mô tả. broadcast_dimensions ánh xạ các phương diện của operand đến các phương diện của hình dạng đích, tức là phương diện thứ i của toán hạng được ánh xạ đến phương diện thứ broadcast_dimension[i] của hình dạng đầu ra. Phương diện của operand phải có kích thước là 1 hoặc có cùng kích thước với phương diện trong hình dạng đầu ra mà chúng được ánh xạ đến. Các phương diện còn lại được điền bằng các phương diện có kích thước là 1. Sau đó, hoạt động truyền tin suy biến sẽ truyền tin dọc theo các chiều suy biến này để đạt được hình dạng đầu ra. Ngữ nghĩa được mô tả chi tiết trên trang truyền tin.

Cuộc gọi

Xem thêm XlaBuilder::Call.

Gọi một phép tính bằng các đối số đã cho.

Call(computation, operands...)

Số lượng và các loại operands phải khớp với các tham số của computation. Bạn có thể không có operands.

CompositeCall

Xem thêm XlaBuilder::CompositeCall.

Đóng gói một thao tác được tạo thành từ các thao tác StableHLO khác, nhận dữ liệu đầu vào và composite_attributes, đồng thời tạo ra kết quả. Ngữ nghĩa của thao tác được triển khai bằng thuộc tính phân tách. Bạn có thể thay thế thao tác kết hợp bằng thao tác phân tách mà không thay đổi ngữ nghĩa của chương trình. Trong trường hợp việc nội tuyến phân tách không cung cấp cùng một ngữ nghĩa hoạt động, hãy ưu tiên sử dụng custom_call.

Trường phiên bản (mặc định là 0) được dùng để biểu thị thời điểm ngữ nghĩa của một thành phần thay đổi.

Thao tác này được triển khai dưới dạng kCall có thuộc tính is_composite=true. Trường decomposition được chỉ định bằng thuộc tính computation. Các thuộc tính giao diện người dùng lưu trữ các thuộc tính còn lại có tiền tố là composite..

Ví dụ về thao tác CompositeCall:

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

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

decomposition của một thao tác không phải là một trường được gọi, mà thay vào đó xuất hiện dưới dạng thuộc tính to_apply trỏ đến hàm chứa việc triển khai ở cấp thấp hơn, tức là to_apply=%funcname

Bạn có thể xem thêm thông tin về thành phần và phân tách trong Quy cách StableHLO.

Cbrt

Xem thêm XlaBuilder::Cbrt.

Phép toán căn bậc ba theo phần tử x -> cbrt(x).

Cbrt(operand)

Cbrt cũng hỗ trợ đối số result_accuracy không bắt buộc:

Cbrt(operand, result_accuracy)

Để biết thêm thông tin về result_accuracy, hãy xem phần Độ chính xác của kết quả.

Để biết thông tin về StableHLO, hãy xem StableHLO – cbrt.

Trần

Xem thêm XlaBuilder::Ceil.

Hàm ceil theo phần tử x -> ⌈x⌉.

Ceil(operand)

Để biết thông tin về StableHLO, hãy xem StableHLO – ceil.

Cholesky

Xem thêm XlaBuilder::Cholesky.

Tính toán phân tích Cholesky của một lô ma trận xác định dương đối xứng (Hermitian).

Cholesky(a, lower)

Nếu lower là true, hãy tính toán ma trận tam giác dưới l sao cho $a = l . l^T$. Nếu lower là false, hãy tính toán các ma trận tam giác trên u sao cho\(a = u^T . u\).

Dữ liệu đầu vào chỉ được đọc từ tam giác dưới/trên của a, tuỳ thuộc vào giá trị của lower. Các giá trị từ tam giác còn lại sẽ bị bỏ qua. Dữ liệu đầu ra được trả về trong cùng một tam giác; các giá trị trong tam giác còn lại do quá trình triển khai xác định và có thể là bất kỳ giá trị nào.

Nếu a có hơn 2 phương diện, thì a được coi là một lô ma trận, trong đó tất cả trừ 2 phương diện phụ đều là phương diện lô.

Nếu a không đối xứng (Hermitian) xác định dương, thì kết quả sẽ do quá trình triển khai xác định.

Để biết thông tin về StableHLO, hãy xem StableHLO – cholesky.

Giới hạn giá trị trong một khoảng

Xem thêm XlaBuilder::Clamp.

Kẹp một toán hạng trong phạm vi giữa giá trị tối thiểu và tối đa.

Clamp(min, operand, max)

Cho trước một toán hạng và giá trị tối thiểu và tối đa, hàm này sẽ trả về toán hạng nếu toán hạng nằm trong phạm vi giữa giá trị tối thiểu và tối đa, nếu không, hàm này sẽ trả về giá trị tối thiểu nếu toán hạng nằm dưới phạm vi này hoặc giá trị tối đa nếu toán hạng nằm trên phạm vi này. Tức là clamp(a, x, b) = min(max(a, x), b).

Cả ba mảng phải có cùng hình dạng. Ngoài ra, dưới dạng một hình thức truyền tin bị hạn chế, min và/hoặc max có thể là một đại lượng vô hướng thuộc loại T.

Ví dụ về min và max vô hướng:

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

Để biết thông tin về StableHLO, hãy xem StableHLO – clamp.

Thu gọn

Xem thêm XlaBuilder::Collapse. và thao tác tf.reshape.

Thu gọn các phương diện của một mảng thành một phương diện.

Collapse(operand, dimensions)

Collapse thay thế tập hợp con đã cho của các phương diện của toán hạng bằng một phương diện duy nhất. Các đối số đầu vào là một mảng tuỳ ý thuộc loại T và một vectơ hằng số thời gian biên dịch của chỉ mục thứ nguyên. Chỉ mục phương diện phải là một tập hợp con liên tiếp theo thứ tự (số phương diện từ thấp đến cao) của các phương diện của T. Do đó, {0, 1, 2}, {0, 1} hoặc {1, 2} đều là các tập hợp phương diện hợp lệ, nhưng {1, 0} hoặc {0, 2} thì không. Các phương diện này được thay thế bằng một phương diện mới duy nhất, ở cùng vị trí trong chuỗi phương diện như các phương diện mà chúng thay thế, với kích thước phương diện mới bằng tích của các kích thước phương diện ban đầu. Số phương diện thấp nhất trong dimensions là phương diện thay đổi chậm nhất (quan trọng nhất) trong nhóm lồng nhau sẽ thu gọn các phương diện này, còn số phương diện cao nhất là phương diện thay đổi nhanh nhất (ít quan trọng nhất). Hãy xem toán tử tf.reshape nếu bạn cần thêm thứ tự thu gọn chung.

Ví dụ: giả sử v là một mảng gồm 24 phần tử:

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

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

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

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

Clz

Xem thêm XlaBuilder::Clz.

Đếm số lượng số 0 ở đầu theo từng phần tử.

Clz(operand)

CollectiveBroadcast

Xem thêm XlaBuilder::CollectiveBroadcast.

Phát dữ liệu trên các bản sao. Dữ liệu được gửi từ mã nhận dạng bản sao đầu tiên trong mỗi nhóm đến các mã nhận dạng khác trong cùng nhóm. Nếu mã nhận dạng bản sao không nằm trong nhóm bản sao nào, thì đầu ra trên bản sao đó là một tensor bao gồm 0 trong shape.

CollectiveBroadcast(operand, replica_groups, channel_id)

Để biết thông tin về StableHLO, hãy xem StableHLO – collective_broadcast.

CollectivePermute

Xem thêm XlaBuilder::CollectivePermute.

CollectivePermute là một thao tác tập thể gửi và nhận dữ liệu trên các bản sao.

CollectivePermute(operand, source_target_pairs, channel_id, inplace)

Xin lưu ý rằng source_target_pairs có các hạn chế sau:

• Không có hai cặp nào được có cùng mã nhận dạng bản sao đích và chúng không được có cùng mã nhận dạng bản sao nguồn.
• Nếu mã nhận dạng bản sao không phải là đích đến trong bất kỳ cặp nào, thì đầu ra trên bản sao đó là một tensor bao gồm 0(s) có cùng hình dạng với đầu vào.

API của thao tác CollectivePermute được phân tách nội bộ thành 2 chỉ dẫn HLO (CollectivePermuteStart và CollectivePermuteDone).

Xem thêm HloInstruction::CreateCollectivePermuteStart.

CollectivePermuteStart và CollectivePermuteDone đóng vai trò là các thành phần cơ bản trong HLO. Các thao tác này có thể xuất hiện trong các kết xuất HLO, nhưng người dùng cuối không nên tự tạo các thao tác này theo cách thủ công.

Để biết thông tin về StableHLO, hãy xem StableHLO – collective_permute.

So sánh

Xem thêm XlaBuilder::Compare.

Thực hiện so sánh từng phần tử của lhs và rhs theo cách sau:

Eq

Xem thêm XlaBuilder::Eq.

Thực hiện phép so sánh bằng theo phần tử của lhs và rhs.

\(lhs = rhs\)

Eq(lhs, rhs)

Hình dạng của các đối số phải tương tự hoặc tương thích. Hãy xem tài liệu truyền tin để biết ý nghĩa của việc các hình dạng tương thích. Kết quả của một thao tác có hình dạng là kết quả của việc truyền hai mảng đầu vào. Trong biến thể này, các thao tác giữa các mảng có thứ hạng khác nhau không được hỗ trợ, trừ phi một trong các toán hạng là một đại lượng vô hướng.

Một biến thể thay thế có hỗ trợ truyền tin nhiều chiều tồn tại cho Eq:

Eq(lhs,rhs, broadcast_dimensions)

Biến thể này của thao tác nên được dùng cho các phép toán số học giữa các mảng có thứ hạng khác nhau (chẳng hạn như thêm một ma trận vào một vectơ).

Toán hạng broadcast_dimensions bổ sung là một lát số nguyên chỉ định các phương diện cần dùng để truyền các toán hạng. Ngữ nghĩa được mô tả chi tiết trên trang phát sóng.

Hỗ trợ tổng số đơn đặt hàng trên số thực tồn tại cho Eq, bằng cách thực thi:

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

EqTotalOrder(lhs,rhs, broadcast_dimensions)

Để biết thông tin về StableHLO, hãy xem StableHLO – so sánh.

Ne

Xem thêm XlaBuilder::Ne.

Thực hiện phép so sánh không bằng theo từng phần tử của lhs và rhs.

\(lhs != rhs\)

Ne(lhs, rhs)

Hình dạng của các đối số phải tương tự hoặc tương thích. Hãy xem tài liệu truyền tin để biết ý nghĩa của việc các hình dạng tương thích. Kết quả của một thao tác có hình dạng là kết quả của việc truyền hai mảng đầu vào. Trong biến thể này, các thao tác giữa các mảng có thứ hạng khác nhau không được hỗ trợ, trừ phi một trong các toán hạng là một đại lượng vô hướng.

Ne có một biến thể thay thế hỗ trợ phát sóng nhiều chiều:

Ne(lhs,rhs, broadcast_dimensions)

Biến thể này của thao tác nên được dùng cho các phép toán số học giữa các mảng có thứ hạng khác nhau (chẳng hạn như thêm một ma trận vào một vectơ).

Toán hạng broadcast_dimensions bổ sung là một lát số nguyên chỉ định các phương diện cần dùng để truyền các toán hạng. Ngữ nghĩa được mô tả chi tiết trên trang phát sóng.

Hỗ trợ tổng giá trị đơn đặt hàng trên số dấu phẩy động cho Ne, bằng cách thực thi:

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

NeTotalOrder(lhs,rhs, broadcast_dimensions)

Để biết thông tin về StableHLO, hãy xem StableHLO – so sánh.

Ge

Xem thêm XlaBuilder::Ge.

Thực hiện phép so sánh greater-or-equal-than theo phần tử của lhs và rhs.

\(lhs >= rhs\)

Ge(lhs, rhs)

Hình dạng của các đối số phải tương tự hoặc tương thích. Hãy xem tài liệu truyền tin để biết ý nghĩa của việc các hình dạng tương thích. Kết quả của một thao tác có hình dạng là kết quả của việc truyền hai mảng đầu vào. Trong biến thể này, các thao tác giữa các mảng có thứ hạng khác nhau không được hỗ trợ, trừ phi một trong các toán hạng là một đại lượng vô hướng.

Có một biến thể thay thế hỗ trợ truyền hình nhiều chiều cho Ge:

Ge(lhs,rhs, broadcast_dimensions)

Biến thể này của thao tác nên được dùng cho các phép toán số học giữa các mảng có thứ hạng khác nhau (chẳng hạn như thêm một ma trận vào một vectơ).

Toán hạng broadcast_dimensions bổ sung là một lát số nguyên chỉ định các phương diện cần dùng để truyền các toán hạng. Ngữ nghĩa được mô tả chi tiết trên trang phát sóng.

Hỗ trợ tổng số đơn đặt hàng trên số thực dấu phẩy động tồn tại cho Gt, bằng cách thực thi:

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

GtTotalOrder(lhs,rhs, broadcast_dimensions)

Để biết thông tin về StableHLO, hãy xem StableHLO – so sánh.

Gt

Xem thêm XlaBuilder::Gt.

Thực hiện phép so sánh lớn hơn theo phần tử của lhs và rhs.

\(lhs > rhs\)

Gt(lhs, rhs)

Hình dạng của các đối số phải tương tự hoặc tương thích. Hãy xem tài liệu truyền tin để biết ý nghĩa của việc các hình dạng tương thích. Kết quả của một thao tác có hình dạng là kết quả của việc truyền hai mảng đầu vào. Trong biến thể này, các thao tác giữa các mảng có thứ hạng khác nhau không được hỗ trợ, trừ phi một trong các toán hạng là một đại lượng vô hướng.

Gt có một biến thể thay thế hỗ trợ truyền tin nhiều chiều:

Gt(lhs,rhs, broadcast_dimensions)

Biến thể này của thao tác nên được dùng cho các phép toán số học giữa các mảng có thứ hạng khác nhau (chẳng hạn như thêm một ma trận vào một vectơ).

Toán hạng broadcast_dimensions bổ sung là một lát số nguyên chỉ định các phương diện cần dùng để truyền các toán hạng. Ngữ nghĩa được mô tả chi tiết trên trang phát sóng.

Để biết thông tin về StableHLO, hãy xem StableHLO – so sánh.

Le

Xem thêm XlaBuilder::Le.

Thực hiện phép so sánh less-or-equal-than theo từng phần tử của lhs và rhs.

\(lhs <= rhs\)

Le(lhs, rhs)

Hình dạng của các đối số phải tương tự hoặc tương thích. Hãy xem tài liệu truyền tin để biết ý nghĩa của việc các hình dạng tương thích. Kết quả của một thao tác có hình dạng là kết quả của việc truyền hai mảng đầu vào. Trong biến thể này, các thao tác giữa các mảng có thứ hạng khác nhau không được hỗ trợ, trừ phi một trong các toán hạng là một đại lượng vô hướng.

Đối với Le, có một biến thể thay thế hỗ trợ truyền tin nhiều chiều:

Le(lhs,rhs, broadcast_dimensions)

Biến thể này của thao tác nên được dùng cho các phép toán số học giữa các mảng có thứ hạng khác nhau (chẳng hạn như thêm một ma trận vào một vectơ).

Toán hạng broadcast_dimensions bổ sung là một lát số nguyên chỉ định các phương diện cần dùng để truyền các toán hạng. Ngữ nghĩa được mô tả chi tiết trên trang phát sóng.

Hỗ trợ tổng đơn đặt hàng trên số dấu phẩy động cho Le, bằng cách thực thi:

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

LeTotalOrder(lhs,rhs, broadcast_dimensions)

Để biết thông tin về StableHLO, hãy xem StableHLO – so sánh.

Lt

Xem thêm XlaBuilder::Lt.

Thực hiện phép so sánh nhỏ hơn theo phần tử của lhs và rhs.

\(lhs < rhs\)

Lt(lhs, rhs)

Hình dạng của các đối số phải tương tự hoặc tương thích. Hãy xem tài liệu truyền tin để biết ý nghĩa của việc các hình dạng tương thích. Kết quả của một thao tác có hình dạng là kết quả của việc truyền hai mảng đầu vào. Trong biến thể này, các thao tác giữa các mảng có thứ hạng khác nhau không được hỗ trợ, trừ phi một trong các toán hạng là một đại lượng vô hướng.

Một biến thể thay thế có hỗ trợ truyền hình nhiều chiều cho Lt:

Lt(lhs,rhs, broadcast_dimensions)

Biến thể này của thao tác nên được dùng cho các phép toán số học giữa các mảng có thứ hạng khác nhau (chẳng hạn như thêm một ma trận vào một vectơ).

Toán hạng broadcast_dimensions bổ sung là một lát số nguyên chỉ định các phương diện cần dùng để truyền các toán hạng. Ngữ nghĩa được mô tả chi tiết trên trang phát sóng.

Hỗ trợ tổng đơn đặt hàng trên số dấu phẩy động tồn tại cho Lt, bằng cách thực thi:

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

LtTotalOrder(lhs,rhs, broadcast_dimensions)

Để biết thông tin về StableHLO, hãy xem StableHLO – so sánh.

Phức tạp

Xem thêm XlaBuilder::Complex.

Thực hiện chuyển đổi từng phần tử thành một giá trị phức từ một cặp giá trị thực và giá trị ảo, lhs và rhs.

Complex(lhs, rhs)

Hình dạng của các đối số phải tương tự hoặc tương thích. Hãy xem tài liệu truyền tin để biết ý nghĩa của việc các hình dạng tương thích. Kết quả của một thao tác có hình dạng là kết quả của việc truyền hai mảng đầu vào. Trong biến thể này, các thao tác giữa các mảng có thứ hạng khác nhau không được hỗ trợ, trừ phi một trong các toán hạng là một đại lượng vô hướng.

Complex có một biến thể thay thế hỗ trợ truyền tin nhiều chiều:

Complex(lhs,rhs, broadcast_dimensions)

Biến thể này của thao tác nên được dùng cho các phép toán số học giữa các mảng có thứ hạng khác nhau (chẳng hạn như thêm một ma trận vào một vectơ).

Toán hạng broadcast_dimensions bổ sung là một lát số nguyên chỉ định các phương diện cần dùng để truyền các toán hạng. Ngữ nghĩa được mô tả chi tiết trên trang phát sóng.

Để biết thông tin về StableHLO, hãy xem StableHLO – complex.

ConcatInDim (Nối)

Xem thêm XlaBuilder::ConcatInDim.

Hàm nối tạo một mảng từ nhiều toán hạng mảng. Mảng có cùng số chiều với mỗi toán hạng mảng đầu vào (phải có cùng số chiều với nhau) và chứa các đối số theo thứ tự được chỉ định.

Concatenate(operands..., dimension)

Ngoại trừ dimension, tất cả phương diện phải giống nhau. Điều này là do XLA không hỗ trợ mảng "không đồng đều". Cũng lưu ý rằng bạn không thể nối các giá trị 0 chiều (vì không thể đặt tên cho phương diện mà theo đó quá trình nối diễn ra).

Ví dụ về 1 chiều:

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

Ví dụ về 2 chiều:

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

let b = { {7, 8} };

Concat({a, b}, 0)

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

Sơ đồ:

Để biết thông tin về StableHLO, hãy xem StableHLO – nối.

Câu lệnh có điều kiện

Xem thêm XlaBuilder::Conditional.

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

Thực thi true_computation nếu predicate là true, false_computation nếu predicate là false và trả về kết quả.

true_computation phải nhận một đối số duy nhất thuộc loại \(T_0\) và sẽ được gọi bằng true_operand (phải thuộc cùng loại). false_computation phải nhận một đối số duy nhất thuộc loại \(T_1\) và sẽ được gọi bằng false_operand (phải thuộc cùng một loại). Loại giá trị trả về của true_computation và false_computation phải giống nhau.

Xin lưu ý rằng chỉ một trong true_computation và false_computation sẽ được thực thi tuỳ thuộc vào giá trị của predicate.

Conditional(branch_index, branch_computations, branch_operands)

Thực thi branch_computations[branch_index] và trả về kết quả. Nếu branch_index là một S32 nhỏ hơn 0 hoặc lớn hơn hoặc bằng N, thì branch_computations[N-1] sẽ được thực thi dưới dạng nhánh mặc định.

Mỗi branch_computations[b] phải nhận một đối số duy nhất thuộc loại \(T_b\) và sẽ được gọi bằng branch_operands[b] (phải thuộc cùng loại). Loại giá trị được trả về của mỗi branch_computations[b] phải giống nhau.

Xin lưu ý rằng chỉ một trong các branch_computations sẽ được thực thi tuỳ thuộc vào giá trị của branch_index.

Để biết thông tin về StableHLO, hãy xem StableHLO – if.

Hằng số

Xem thêm XlaBuilder::ConstantLiteral.

Tạo ra một output từ một literal hằng số.

Constant(literal)

Để biết thông tin về StableHLO, hãy xem StableHLO – hằng số.

ConvertElementType

Xem thêm XlaBuilder::ConvertElementType.

Tương tự như static_cast theo phần tử trong C++, ConvertElementType thực hiện một thao tác chuyển đổi theo phần tử từ một hình dạng dữ liệu sang một hình dạng mục tiêu. Các phương diện phải khớp và quá trình chuyển đổi là quá trình chuyển đổi theo từng phần tử; ví dụ: các phần tử s32 trở thành các phần tử f32 thông qua một quy trình chuyển đổi từ s32 sang f32.

ConvertElementType(operand, new_element_type)

Kích thước của toán hạng và hình dạng mục tiêu phải khớp nhau. Loại phần tử nguồn và đích không được là bộ giá trị.

Một lượt chuyển đổi như T=s32 thành U=f32 sẽ thực hiện một quy trình chuyển đổi int sang float chuẩn hoá, chẳng hạn như làm tròn đến số chẵn gần nhất.

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

Để biết thông tin về StableHLO, hãy xem StableHLO – convert.

Conv (Tích chập)

Xem thêm XlaBuilder::Conv.

Tính toán một phép tích chập thuộc loại được dùng trong mạng nơ-ron. Ở đây, phép tích chập có thể được coi là một cửa sổ n chiều di chuyển trên một vùng cơ sở n chiều và một phép tính được thực hiện cho từng vị trí có thể có của cửa sổ.

Conv Xếp hàng một chỉ dẫn tích chập vào quá trình tính toán, sử dụng các số chiều tích chập mặc định mà không có độ giãn nở.

Khoảng đệm được chỉ định theo cách viết tắt là SAME hoặc VALID. SAME (GIỐNG NHAU) sẽ thêm các số 0 vào đầu vào (lhs) để đầu ra có cùng hình dạng với đầu vào khi không tính đến bước sải. Khoảng đệm HỢP LỆ chỉ đơn giản là không có khoảng đệm.

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

Conv có các cấp độ kiểm soát sau:

• ConvWithGeneralPadding
• ConvWithGeneralDimensions
• ConvGeneral
• ConvGeneralDilated

Giả sử n là số lượng chiều không gian. Đối số lhs là một mảng (n+2) chiều mô tả vùng cơ sở. Đây được gọi là đầu vào, mặc dù tất nhiên rhs cũng là đầu vào. Trong mạng nơ-ron, đây là các hoạt động đầu vào. n+2 phương diện theo thứ tự như sau:

• batch: Mỗi toạ độ trong phương diện này biểu thị một đầu vào độc lập mà quá trình tích chập được thực hiện.
• z/depth/features: Mỗi vị trí (y,x) trong vùng cơ sở đều có một vectơ được liên kết với vị trí đó, vectơ này sẽ đi vào phương diện này.
• spatial_dims: Mô tả các phương diện không gian n xác định vùng cơ sở mà cửa sổ di chuyển qua.

Đối số rhs là một mảng (n+2) chiều mô tả bộ lọc/hạt nhân/cửa sổ tích chập. Các phương diện theo thứ tự như sau:

• output-z: Phương diện z của đầu ra.
• input-z: Kích thước của phương diện này nhân với feature_group_count phải bằng kích thước của phương diện z ở phía bên trái.
• spatial_dims: Mô tả các phương diện không gian n xác định cửa sổ n chiều di chuyển trên vùng cơ sở.

Đối số window_strides chỉ định bước của cửa sổ tích chập theo các phương diện không gian. Ví dụ: nếu bước sải chân trong chiều không gian đầu tiên là 3, thì cửa sổ chỉ có thể được đặt ở những toạ độ mà chỉ mục không gian đầu tiên chia hết cho 3.

Đối số padding chỉ định lượng khoảng đệm bằng 0 sẽ được áp dụng cho vùng cơ sở. Lượng khoảng đệm có thể là số âm – giá trị tuyệt đối của khoảng đệm âm cho biết số lượng phần tử cần loại bỏ khỏi phương diện đã chỉ định trước khi thực hiện phép tích chập. padding[0] chỉ định khoảng đệm cho phương diện y và padding[1] chỉ định khoảng đệm cho phương diện x. Mỗi cặp có khoảng đệm thấp là phần tử đầu tiên và khoảng đệm cao là phần tử thứ hai. Khoảng đệm thấp được áp dụng theo hướng chỉ mục thấp hơn, trong khi khoảng đệm cao được áp dụng theo hướng chỉ mục cao hơn. Ví dụ: nếu padding[1] là (2,3) thì sẽ có một khoảng đệm gồm 2 số 0 ở bên trái và 3 số 0 ở bên phải trong chiều không gian thứ hai. Việc sử dụng khoảng đệm tương đương với việc chèn các giá trị 0 tương tự vào đầu vào (lhs) trước khi thực hiện phép tích chập.

Các đối số lhs_dilation và rhs_dilation chỉ định hệ số giãn nở sẽ được áp dụng cho lhs và rhs, tương ứng, trong mỗi chiều không gian. Nếu hệ số giãn nở trong một phương diện không gian là d, thì d-1 lỗ sẽ được đặt ngầm giữa mỗi mục trong phương diện đó, làm tăng kích thước của mảng. Các lỗ hổng được lấp đầy bằng giá trị không hoạt động, đối với tích chập có nghĩa là các số 0.

Việc giãn nở rhs còn được gọi là phép tích chập atrous. Để biết thêm thông tin, hãy xem tf.nn.atrous_conv2d. Sự giãn nở của lhs còn được gọi là phép tích chập chuyển vị. Để biết thêm thông tin, hãy xem tf.nn.conv2d_transpose.

Bạn có thể dùng đối số feature_group_count (giá trị mặc định là 1) cho các phép tích chập theo nhóm. feature_group_count phải là số chia của cả phương diện tính năng đầu vào và đầu ra. Nếu feature_group_count lớn hơn 1, điều đó có nghĩa là về mặt khái niệm, kích thước đối tượng đầu vào và đầu ra cũng như kích thước đối tượng đầu ra rhs được chia đều thành nhiều nhóm feature_group_count, mỗi nhóm bao gồm một chuỗi con liên tiếp của các đối tượng. Phương diện đối tượng đầu vào của rhs cần bằng với phương diện đối tượng đầu vào lhs chia cho feature_group_count (vì vậy, phương diện này đã có kích thước của một nhóm đối tượng đầu vào). Các nhóm thứ i được dùng cùng nhau để tính toán feature_group_count cho nhiều phép tích chập riêng biệt. Kết quả của các phép tích chập này được nối với nhau trong phương diện đối tượng đầu ra.

Đối với phép tích chập theo chiều sâu, đối số feature_group_count sẽ được đặt thành phương diện tính năng đầu vào và bộ lọc sẽ được định hình lại từ [filter_height, filter_width, in_channels, channel_multiplier] thành [filter_height, filter_width, 1, in_channels * channel_multiplier]. Để biết thêm thông tin chi tiết, hãy xem tf.nn.depthwise_conv2d.

Bạn có thể dùng đối số batch_group_count (giá trị mặc định là 1) cho các bộ lọc được nhóm trong quá trình truyền ngược. batch_group_count phải là số chia của kích thước của phương diện lô lhs (đầu vào). Nếu batch_group_count lớn hơn 1, tức là kích thước lô đầu ra phải có kích thước input batch / batch_group_count. batch_group_count phải là số chia của kích thước đối tượng đầu ra.

Hình dạng đầu ra có các phương diện sau, theo thứ tự này:

• batch: Kích thước của phương diện này nhân với batch_group_count phải bằng kích thước của phương diện batch ở phía bên trái.
• z: Có cùng kích thước với output-z trên nhân (rhs).
• spatial_dims: Một giá trị cho mỗi vị trí hợp lệ của cửa sổ tích chập.

Hình trên cho thấy cách hoạt động của trường batch_group_count. Trên thực tế, chúng ta chia mỗi lô lhs thành batch_group_count nhóm và làm tương tự cho các đặc điểm đầu ra. Sau đó, đối với mỗi nhóm này, chúng ta sẽ thực hiện các phép tích chập theo cặp và nối đầu ra dọc theo chiều của đối tượng đầu ra. Ngữ nghĩa hoạt động của tất cả các phương diện khác (đặc điểm và không gian) vẫn giữ nguyên.

Các vị trí hợp lệ của cửa sổ tích chập được xác định bằng các bước sải và kích thước của vùng cơ sở sau khi đệm.

Để mô tả chức năng của một phép tích chập, hãy xem xét một phép tích chập 2d và chọn một số toạ độ batch, z, y, x cố định trong đầu ra. Sau đó, (y,x) là vị trí của một góc cửa sổ trong khu vực cơ sở (ví dụ: góc trên bên trái, tuỳ thuộc vào cách bạn diễn giải các phương diện không gian). Giờ đây, chúng ta có một cửa sổ 2d, lấy từ vùng cơ sở, trong đó mỗi điểm 2d được liên kết với một vectơ 1d, vì vậy chúng ta sẽ có một hộp 3d. Từ hạt tích chập, vì chúng ta đã cố định toạ độ đầu ra z, nên chúng ta cũng có một hộp 3D. Hai hộp này có cùng kích thước, vì vậy, chúng ta có thể lấy tổng của các tích theo phần tử giữa hai hộp (tương tự như tích vô hướng). Đó là giá trị đầu ra.

Xin lưu ý rằng nếu output-z là ví dụ: 5, sau đó mỗi vị trí của cửa sổ sẽ tạo ra 5 giá trị trong đầu ra thành phương diện z của đầu ra. Các giá trị này khác nhau ở phần nào của nhân tích chập được sử dụng – có một hộp giá trị 3d riêng biệt được dùng cho mỗi toạ độ output-z. Vì vậy, bạn có thể coi đây là 5 phép tích chập riêng biệt với một bộ lọc khác nhau cho mỗi phép tích chập.

Sau đây là mã giả cho một phép tích chập 2d có khoảng đệm và bước sải:

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

precision_config được dùng để cho biết cấu hình độ chính xác. Cấp độ này quyết định xem phần cứng có nên cố gắng tạo thêm các chỉ dẫn mã máy để cung cấp hoạt động mô phỏng dtype chính xác hơn khi cần (tức là mô phỏng f32 trên TPU chỉ hỗ trợ bf16 matmul) hay không. Giá trị có thể là DEFAULT, HIGH, HIGHEST. Thông tin chi tiết bổ sung trong các phần MXU.

preferred_element_type là một phần tử vô hướng của các loại đầu ra có độ chính xác cao/thấp hơn được dùng để tích luỹ. preferred_element_type đề xuất loại tích luỹ cho thao tác đã cho, tuy nhiên, điều này không được đảm bảo. Điều này cho phép một số phần phụ trợ phần cứng tích luỹ trong một loại khác và chuyển đổi sang loại đầu ra ưu tiên.

Để biết thông tin về StableHLO, hãy xem StableHLO – convolution.

ConvWithGeneralPadding

Xem thêm XlaBuilder::ConvWithGeneralPadding.

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

Tương tự như Conv khi cấu hình khoảng đệm là rõ ràng.

ConvWithGeneralDimensions

Xem thêm XlaBuilder::ConvWithGeneralDimensions.

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

Tương tự như Conv trong đó số phương diện là số rõ ràng.

ConvGeneral

Xem thêm XlaBuilder::ConvGeneral.

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

Tương tự như Conv, trong đó số chiều và cấu hình khoảng đệm được xác định rõ ràng

ConvGeneralDilated

Xem thêm XlaBuilder::ConvGeneralDilated.

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

Tương tự như Conv, trong đó cấu hình khoảng đệm, hệ số giãn nở và số lượng phương diện là rõ ràng.

Sao chép

Xem thêm HloInstruction::CreateCopyStart.

Copy được phân tách nội bộ thành 2 chỉ dẫn HLO CopyStart và CopyDone. Copy cùng với CopyStart và CopyDone đóng vai trò là các thành phần cơ bản trong HLO. Các thao tác này có thể xuất hiện trong các kết xuất HLO, nhưng người dùng cuối không được phép tạo các thao tác này theo cách thủ công.

Cos

Xem thêm XlaBuilder::Cos.

Cô-sin theo phần tử x -> cos(x).

Cos(operand)

Cos cũng hỗ trợ đối số result_accuracy không bắt buộc:

Cos(operand, result_accuracy)

Để biết thêm thông tin về result_accuracy, hãy xem phần Độ chính xác của kết quả.

Để biết thông tin về StableHLO, hãy xem StableHLO – cosine.

Cosh

Xem thêm XlaBuilder::Cosh.

Hàm cos hyperbol theo phần tử x -> cosh(x).

Cosh(operand)

Hàm Cosh cũng hỗ trợ đối số result_accuracy không bắt buộc:

Cosh(operand, result_accuracy)

Để biết thêm thông tin về result_accuracy, hãy xem phần Độ chính xác của kết quả.

CustomCall

Xem thêm XlaBuilder::CustomCall.

Gọi một hàm do người dùng cung cấp trong quá trình tính toán.

Tài liệu về CustomCall có trong phần Thông tin chi tiết về nhà phát triển – Lệnh gọi tuỳ chỉnh XLA

Để biết thông tin về StableHLO, hãy xem StableHLO – custom_call.

TTB

Xem thêm XlaBuilder::Div.

Thực hiện phép chia từng phần tử của số bị chia lhs và số chia rhs.

Div(lhs, rhs)

Tràn số nguyên khi chia (chia/dư số có dấu/không dấu cho 0 hoặc chia/dư số có dấu của INT_SMIN cho -1) sẽ tạo ra một giá trị do quá trình triển khai xác định.

Hình dạng của các đối số phải tương tự hoặc tương thích. Hãy xem tài liệu truyền tin để biết ý nghĩa của việc các hình dạng tương thích. Kết quả của một thao tác có hình dạng là kết quả của việc truyền hai mảng đầu vào. Trong biến thể này, các thao tác giữa các mảng có thứ hạng khác nhau không được hỗ trợ, trừ phi một trong các toán hạng là một đại lượng vô hướng.

Một biến thể thay thế có hỗ trợ truyền hình đa chiều cho Div:

Div(lhs,rhs, broadcast_dimensions)

Biến thể này của thao tác nên được dùng cho các phép toán số học giữa các mảng có thứ hạng khác nhau (chẳng hạn như thêm một ma trận vào một vectơ).

Toán hạng broadcast_dimensions bổ sung là một lát số nguyên chỉ định các phương diện cần dùng để truyền các toán hạng. Ngữ nghĩa được mô tả chi tiết trên trang phát sóng.

Để biết thông tin về StableHLO, hãy xem StableHLO – divide.

Lâu đài

Xem thêm HloInstruction::CreateDomain.

Domain có thể xuất hiện trong các kết xuất HLO, nhưng người dùng cuối không nên tự tạo Domain theo cách thủ công.

Chấm

Xem thêm XlaBuilder::Dot.

Dot(lhs, rhs, precision_config, preferred_element_type)

Ngữ nghĩa chính xác của thao tác này phụ thuộc vào thứ hạng của các toán hạng:

Thao tác này thực hiện tổng của các tích trên phương diện thứ hai của lhs (hoặc phương diện đầu tiên nếu có 1 phương diện) và phương diện đầu tiên của rhs. Đây là các phương diện "được thu gọn". Các phương diện được thu gọn của lhs và rhs phải có cùng kích thước. Trên thực tế, bạn có thể dùng hàm này để thực hiện các phép tính tích vô hướng giữa các vectơ, phép nhân vectơ/ma trận hoặc phép nhân ma trận/ma trận.

precision_config được dùng để cho biết cấu hình độ chính xác. Cấp độ này quyết định xem phần cứng có nên cố gắng tạo thêm các chỉ dẫn mã máy để cung cấp hoạt động mô phỏng dtype chính xác hơn khi cần (tức là mô phỏng f32 trên TPU chỉ hỗ trợ bf16 matmul) hay không. Giá trị có thể là DEFAULT, HIGH, HIGHEST. Thông tin chi tiết bổ sung trong các phần MXU.

preferred_element_type là một phần tử vô hướng của các loại đầu ra có độ chính xác cao/thấp hơn được dùng để tích luỹ. preferred_element_type đề xuất loại tích luỹ cho thao tác đã cho, tuy nhiên, điều này không được đảm bảo. Điều này cho phép một số phần phụ trợ phần cứng tích luỹ trong một loại khác và chuyển đổi sang loại đầu ra ưu tiên.

Để biết thông tin về StableHLO, hãy xem StableHLO – dot.

DotGeneral

Xem thêm XlaBuilder::DotGeneral.

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

Tương tự như Dot, nhưng cho phép chỉ định các số đo kích thước theo lô và số đo kích thước theo lô cho cả lhs và rhs.

DotGeneral thực hiện tổng các sản phẩm trên các phương diện thu hẹp được chỉ định trong dimension_numbers.

Các số đo kích thước hợp đồng liên kết từ lhs và rhs không cần phải giống nhau nhưng phải có cùng kích thước.

Ví dụ về số đo kích thước thu hẹp:

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

Các số phương diện theo lô được liên kết từ lhs và rhs phải có cùng kích thước phương diện.

Ví dụ về số lượng theo phương diện lô (kích thước lô là 2, ma trận 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} } }

Theo đó, số thứ nguyên kết quả bắt đầu bằng thứ nguyên lô, sau đó là thứ nguyên lhs không thu hẹp/không theo lô và cuối cùng là thứ nguyên rhs không thu hẹp/không theo lô.

precision_config được dùng để cho biết cấu hình độ chính xác. Cấp độ này quyết định xem phần cứng có nên cố gắng tạo thêm các chỉ dẫn mã máy để cung cấp hoạt động mô phỏng dtype chính xác hơn khi cần (tức là mô phỏng f32 trên TPU chỉ hỗ trợ bf16 matmul) hay không. Giá trị có thể là DEFAULT, HIGH, HIGHEST. Bạn có thể xem thêm thông tin chi tiết trong các phần về MXU.

preferred_element_type là một phần tử vô hướng của các loại đầu ra có độ chính xác cao/thấp hơn được dùng để tích luỹ. preferred_element_type đề xuất loại tích luỹ cho thao tác đã cho, tuy nhiên, điều này không được đảm bảo. Điều này cho phép một số phần phụ trợ phần cứng tích luỹ trong một loại khác và chuyển đổi sang loại đầu ra ưu tiên.

Để biết thông tin về StableHLO, hãy xem StableHLO – dot_general.

ScaledDot

Xem thêm XlaBuilder::ScaledDot.

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

Tương tự như DotGeneral.

Tạo một thao tác chấm được chia tỷ lệ với các toán hạng "lhs", "lhs_scale", "rhs" và "rhs_scale", với các chiều thu hẹp và hàng loạt được chỉ định trong "dimension_numbers".

RaggedDot

Xem thêm XlaBuilder::RaggedDot.

Để biết thông tin chi tiết về cách tính toán RaggedDot, hãy xem StableHLO – chlo.ragged_dot

DynamicReshape

Xem thêm XlaBuilder::DynamicReshape.

Thao tác này có chức năng giống hệt với reshape, nhưng hình dạng kết quả được chỉ định linh hoạt thông qua output_shape.

DynamicReshape(operand, dim_sizes, new_size_bounds, dims_are_dynamic)

Để biết thông tin về StableHLO, hãy xem StableHLO – dynamic_reshape.

DynamicSlice

Xem thêm XlaBuilder::DynamicSlice.

DynamicSlice trích xuất một mảng con từ mảng đầu vào tại start_indices động. Kích thước của lát cắt trong mỗi phương diện được truyền trong size_indices, chỉ định điểm cuối của các khoảng lát cắt loại trừ trong mỗi phương diện: [start, start + size). Hình dạng của start_indices phải là 1 chiều, có kích thước chiều bằng với số chiều của operand.

DynamicSlice(operand, start_indices, slice_sizes)

Các chỉ mục lát hiệu quả được tính bằng cách áp dụng phép biến đổi sau cho mỗi chỉ mục i trong [1, N) trước khi thực hiện lát:

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

Điều này đảm bảo rằng lát cắt được trích xuất luôn nằm trong phạm vi liên quan đến mảng toán hạng. Nếu lát cắt nằm trong phạm vi trước khi áp dụng phép biến đổi, thì phép biến đổi sẽ không có tác dụng.

Ví dụ về 1 chiều:

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

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

Ví dụ về 2 chiều:

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

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

Để biết thông tin về StableHLO, hãy xem StableHLO – dynamic_slice.

DynamicUpdateSlice

Xem thêm XlaBuilder::DynamicUpdateSlice.

DynamicUpdateSlice tạo ra một kết quả là giá trị của mảng đầu vào operand, với một lát update được ghi đè tại start_indices. Hình dạng của update xác định hình dạng của mảng con trong kết quả được cập nhật. Hình dạng của start_indices phải là 1 chiều, với kích thước chiều bằng số chiều của operand.

DynamicUpdateSlice(operand, update, start_indices)

Các chỉ mục lát hiệu quả được tính bằng cách áp dụng phép biến đổi sau cho mỗi chỉ mục i trong [1, N) trước khi thực hiện lát:

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

Điều này đảm bảo rằng phần cập nhật luôn nằm trong phạm vi liên quan đến mảng toán hạng. Nếu lát cắt nằm trong phạm vi trước khi áp dụng phép biến đổi, thì phép biến đổi sẽ không có tác dụng.

Ví dụ về 1 chiều:

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

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

Ví dụ về 2 chiều:

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

let s = {1, 1}

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

Để biết thông tin về StableHLO, hãy xem StableHLO – dynamic_update_slice.

Erf

Xem thêm XlaBuilder::Erf.

Hàm sai số theo phần tử x -> erf(x), trong đó:

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

Erf(operand)

Erf cũng hỗ trợ đối số result_accuracy không bắt buộc:

Erf(operand, result_accuracy)

Để biết thêm thông tin về result_accuracy, hãy xem phần Độ chính xác của kết quả.

Hết hạn

Xem thêm XlaBuilder::Exp.

Hàm mũ tự nhiên theo phần tử x -> e^x.

Exp(operand)

Exp cũng hỗ trợ đối số result_accuracy không bắt buộc:

Exp(operand, result_accuracy)

Để biết thêm thông tin về result_accuracy, hãy xem phần Độ chính xác của kết quả.

Để biết thông tin về StableHLO, hãy xem StableHLO – hàm mũ.

Expm1

Xem thêm XlaBuilder::Expm1.

Hàm mũ tự nhiên trừ đi một theo phần tử x -> e^x - 1.

Expm1(operand)

Expm1 cũng hỗ trợ đối số result_accuracy không bắt buộc:

Expm1(operand, result_accuracy)

Để biết thêm thông tin về result_accuracy, hãy xem phần Độ chính xác của kết quả.

Để biết thông tin về StableHLO, hãy xem StableHLO – exponential_minus_one.

Fft

Xem thêm XlaBuilder::Fft.

Thao tác FFT XLA triển khai Biến đổi Fourier thuận và nghịch cho các đầu vào/đầu ra thực và phức. FFT đa chiều trên tối đa 3 trục được hỗ trợ.

Fft(operand, ftt_type, fft_length)

Để biết thông tin về StableHLO, hãy xem StableHLO – fft.

FFT đa chiều

Khi có nhiều fft_length, điều này tương đương với việc áp dụng một loạt các thao tác FFT cho từng trục trong cùng. Xin lưu ý rằng đối với các trường hợp thực->phức tạp và phức tạp->thực, phép biến đổi trục trong cùng (trên thực tế) được thực hiện trước (RFFT; cuối cùng đối với IRFFT), đó là lý do tại sao trục trong cùng là trục thay đổi kích thước. Các phép biến đổi trục khác sẽ là complex->complex.

Thông tin chi tiết về việc triển khai

CPU FFT được hỗ trợ bởi TensorFFT của Eigen. GPU FFT sử dụng cuFFT.

Tầng

Xem thêm XlaBuilder::Floor.

Sàn theo phần tử x -> ⌊x⌋.

Floor(operand)

Để biết thông tin về StableHLO, hãy xem StableHLO – floor.

Món ăn hỗn hợp

Xem thêm HloInstruction::CreateFusion.

Thao tác Fusion biểu thị các chỉ dẫn HLO và đóng vai trò là một nguyên tắc cơ bản trong HLO. Thao tác này có thể xuất hiện trong các kết xuất HLO nhưng người dùng cuối không nên tạo thao tác này theo cách thủ công.

Gather

Thao tác thu thập XLA kết hợp nhiều lát (mỗi lát có độ lệch thời gian chạy có thể khác nhau) của một mảng đầu vào.

Để biết thông tin về StableHLO, hãy xem StableHLO – gather.

Ngữ nghĩa chung

Xem thêm XlaBuilder::Gather. Để biết nội dung mô tả trực quan hơn, hãy xem phần "Nội dung mô tả không chính thức" bên dưới.

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

Để thuận tiện, chúng tôi gắn nhãn các phương diện trong mảng đầu ra không có trong offset_dims là batch_dims.

Kết quả là một mảng có batch_dims.size + offset_dims.size chiều.

operand.rank phải bằng tổng của offset_dims.size và collapsed_slice_dims.size. Ngoài ra, slice_sizes.size phải bằng operand.rank.

Nếu index_vector_dim bằng start_indices.rank, chúng ta sẽ ngầm coi start_indices có một phương diện 1 theo sau (tức là nếu start_indices có hình dạng [6,7] và index_vector_dim là 2 thì chúng ta sẽ ngầm coi hình dạng của start_indices là [6,7,1]).

Các ranh giới cho mảng đầu ra dọc theo phương diện i được tính như sau:

1. Nếu i có trong batch_dims (tức là bằng batch_dims[k] đối với một số k), thì chúng ta sẽ chọn ranh giới phương diện tương ứng trong start_indices.shape, bỏ qua index_vector_dim (tức là chọn start_indices.shape.dims[k] nếu k < index_vector_dim và start_indices.shape.dims[k+1] nếu không).

2. Nếu i có trong offset_dims (tức là bằng offset_dims[k] đối với một số k), thì chúng ta sẽ chọn giới hạn tương ứng trong slice_sizes sau khi tính đến collapsed_slice_dims (tức là chúng ta chọn adjusted_slice_sizes[k] trong đó adjusted_slice_sizes là slice_sizes với các giới hạn tại chỉ mục collapsed_slice_dims đã bị xoá).

Theo nguyên tắc, chỉ mục toán hạng In tương ứng với một chỉ mục đầu ra nhất định Out được tính như sau:

1. Đặt G = { Out[k] cho k trong batch_dims }. Sử dụng G để cắt một vectơ S sao cho S[i] = start_indices[Combine(G, i)] trong đó Combine(A, b) chèn b vào vị trí index_vector_dim trong A. Xin lưu ý rằng điều này được xác định rõ ngay cả khi G trống: Nếu G trống thì S = start_indices.

2. Tạo một chỉ mục bắt đầu, Sin, thành operand bằng cách sử dụng S bằng cách phân tán S bằng start_index_map. Cụ thể hơn:

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

   2. Sin[_] = 0 nếu không.

3. Tạo một chỉ mục Oin vào operand bằng cách phân tán các chỉ mục tại các phương diện bù trong Out theo tập hợp collapsed_slice_dims. Cụ thể hơn:

   1. Oin[remapped_offset_dims(k)] = Out[offset_dims[k]] nếu k < offset_dims.size (remapped_offset_dims được xác định bên dưới).

   2. Oin[_] = 0 nếu không.

4. In là Oin + Sin trong đó + là phép cộng theo phần tử.

remapped_offset_dims là một hàm đơn điệu có miền [0, offset_dims.size) và phạm vi [0, operand.rank) \ collapsed_slice_dims. Ví dụ: offset_dims.size là 4, operand.rank là 6 và collapsed_slice_dims là {0, 2} thì remapped_offset_dims là {0→1, 1→3, 2→4, 3→5}.

Nếu indices_are_sorted được đặt thành true, thì XLA có thể giả định rằng start_indices được người dùng sắp xếp (theo thứ tự tăng dần, sau khi phân tán các giá trị theo start_index_map). Nếu không, ngữ nghĩa sẽ được xác định theo cách triển khai.

Nội dung mô tả và ví dụ không chính thức

Một cách không chính thức, mọi chỉ mục Out trong mảng đầu ra đều tương ứng với một phần tử E trong mảng toán hạng, được tính như sau:

• Chúng ta sẽ sử dụng các phương diện theo lô trong Out để tra cứu chỉ mục bắt đầu từ start_indices.

• Chúng ta dùng start_index_map để ánh xạ chỉ mục bắt đầu (có thể có kích thước nhỏ hơn operand.rank) thành chỉ mục bắt đầu "đầy đủ" trong operand.

• Chúng ta sẽ cắt động một lát có kích thước slice_sizes bằng cách sử dụng chỉ mục bắt đầu đầy đủ.

• Chúng ta định hình lại lát cắt bằng cách thu gọn các phương diện collapsed_slice_dims. Vì tất cả các phương diện lát được thu gọn đều phải có giới hạn là 1, nên việc định hình lại này luôn hợp lệ.

• Chúng ta sử dụng các phương diện bù trong Out để lập chỉ mục vào lát này nhằm lấy phần tử đầu vào E tương ứng với chỉ mục đầu ra Out.

index_vector_dim được đặt thành start_indices.rank – 1 trong tất cả các ví dụ sau. Các giá trị thú vị hơn cho index_vector_dim không thay đổi cơ bản hoạt động, nhưng khiến việc biểu diễn trực quan trở nên rườm rà hơn.

Để có được cảm nhận về cách tất cả những điều trên phù hợp với nhau, hãy xem một ví dụ thu thập 5 lát hình dạng [8,6] từ một mảng [16,11]. Vị trí của một lát cắt trong mảng [16,11] có thể được biểu thị dưới dạng một vectơ chỉ mục có hình dạng S64[2], vì vậy, tập hợp 5 vị trí có thể được biểu thị dưới dạng một mảng S64[5,2].

Sau đó,bạn có thể mô tả hành vi của thao tác thu thập dưới dạng một phép biến đổi chỉ mục lấy [G,O0,O1], một chỉ mục trong hình dạng đầu ra và ánh xạ chỉ mục đó đến một phần tử trong mảng đầu vào theo cách sau:

Trước tiên, chúng ta chọn một vectơ (X,Y) từ mảng chỉ mục tập hợp bằng cách sử dụng G. Phần tử trong mảng đầu ra tại chỉ mục [G,O0,O1] sau đó là phần tử trong mảng đầu vào tại chỉ mục [X+O0,Y+O1].

slice_sizes là [8,6], quyết định phạm vi của O₀ và O₁, từ đó quyết định ranh giới của lát cắt.

Thao tác thu thập này hoạt động như một lát cắt động theo lô với G là phương diện lô.

Các chỉ mục thu thập có thể là đa chiều. Ví dụ: phiên bản chung chung hơn của ví dụ trên sử dụng mảng "gather indices" có hình dạng [4,5,2] sẽ dịch các chỉ mục như sau:

Một lần nữa, điều này đóng vai trò là một lát cắt động theo lô G0 và G1 làm kích thước lô. Kích thước của lát vẫn là [8,6].

Thao tác thu thập trong XLA khái quát hoá ngữ nghĩa không chính thức được nêu ở trên theo những cách sau:

1. Chúng ta có thể định cấu hình phương diện nào trong hình dạng đầu ra là phương diện bù (phương diện chứa O0, O1 trong ví dụ cuối cùng). Các phương diện lô đầu ra (phương diện chứa G0, G1 trong ví dụ cuối cùng) được xác định là các phương diện đầu ra không phải là phương diện bù.

2. Số lượng phương diện bù đầu ra có trong hình dạng đầu ra có thể nhỏ hơn số lượng phương diện đầu vào. Các phương diện "bị thiếu" này (được liệt kê rõ ràng là collapsed_slice_dims) phải có kích thước lát cắt là 1. Vì chúng có kích thước lát là 1 nên chỉ số hợp lệ duy nhất cho chúng là 0 và việc bỏ qua chúng không gây ra sự mơ hồ.

3. Lát cắt được trích xuất từ mảng "Gather Indices" ((X, Y) trong ví dụ cuối cùng) có thể có ít phần tử hơn số lượng phương diện của mảng đầu vào và một ánh xạ rõ ràng sẽ quy định cách chỉ mục phải được mở rộng để có cùng số lượng phương diện như đầu vào.

Ví dụ cuối cùng, chúng ta sẽ sử dụng (2) và (3) để triển khai tf.gather_nd:

G0 và G1 thường được dùng để cắt chỉ mục bắt đầu từ mảng chỉ mục thu thập, ngoại trừ chỉ mục bắt đầu chỉ có một phần tử, X. Tương tự, chỉ có một chỉ mục độ lệch đầu ra có giá trị O0. Tuy nhiên, trước khi được dùng làm chỉ mục trong mảng đầu vào, các chỉ mục này sẽ được mở rộng theo "Gather Index Mapping" (Ánh xạ chỉ mục thu thập) (start_index_map trong nội dung mô tả chính thức) và "Offset Mapping" (Ánh xạ độ lệch) (remapped_offset_dims trong nội dung mô tả chính thức) thành [X,0] và [0,O0] tương ứng, cộng lại thành [X,O0]. Nói cách khác, chỉ mục đầu ra [G0,G1,O0] ánh xạ đến chỉ mục đầu vào [GatherIndices[G0,G1,0],O0] cho chúng ta ngữ nghĩa cho tf.gather_nd.

slice_sizes cho trường hợp này là [1,11]. Theo trực giác, điều này có nghĩa là mọi chỉ mục X trong mảng chỉ mục thu thập sẽ chọn toàn bộ một hàng và kết quả là sự nối kết của tất cả các hàng này.

GetDimensionSize

Xem thêm XlaBuilder::GetDimensionSize.

Trả về kích thước của phương diện đã cho của toán hạng. Toán hạng phải có dạng mảng.

GetDimensionSize(operand, dimension)

Để biết thông tin về StableHLO, hãy xem StableHLO – get_dimension_size.

GetTupleElement

Xem thêm XlaBuilder::GetTupleElement.

Chỉ mục vào một bộ giá trị có giá trị hằng số thời gian biên dịch.

Giá trị phải là một hằng số thời gian biên dịch để suy luận hình dạng có thể xác định loại giá trị kết quả.

Điều này tương tự như std::get<int N>(t) trong C++. Về mặt khái niệm:

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.

Xem thêm tf.tuple.

GetTupleElement(tuple_data, index)

Để biết thông tin về StableHLO, hãy xem StableHLO – get_tuple_element.

Imag

Xem thêm XlaBuilder::Imag.

Phần ảo theo phần tử của một hình dạng phức tạp (hoặc thực). x -> imag(x). Nếu toán hạng là kiểu dấu phẩy động, thì hàm sẽ trả về 0.

Imag(operand)

Để biết thông tin về StableHLO, hãy xem StableHLO – imag.

Trong nguồn cấp dữ liệu

Xem thêm XlaBuilder::Infeed.

Infeed(shape, config)

Đọc một mục dữ liệu duy nhất từ giao diện truyền phát In-feed ngầm ẩn của thiết bị, diễn giải dữ liệu dưới dạng hình dạng và bố cục đã cho, đồng thời trả về một XlaOp của dữ liệu. Bạn có thể dùng nhiều thao tác Infeed trong một phép tính, nhưng phải có tổng số thứ tự giữa các thao tác Infeed. Ví dụ: 2 Infeed trong đoạn mã dưới đây có tổng thứ tự vì có một phần phụ thuộc giữa các vòng lặp while.

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

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

Không hỗ trợ các hình dạng bộ dữ liệu lồng nhau. Đối với một hình dạng bộ dữ liệu trống, thao tác Infeed về cơ bản là một thao tác không hoạt động và tiếp tục mà không cần đọc bất kỳ dữ liệu nào từ Infeed của thiết bị.

Để biết thông tin về StableHLO, hãy xem StableHLO – infeed.

Iôta

Xem thêm XlaBuilder::Iota.

Iota(shape, iota_dimension)

Tạo một giá trị cố định trên thiết bị thay vì một lượt chuyển máy chủ lưu trữ có thể lớn. Tạo một mảng có hình dạng đã chỉ định và giữ các giá trị bắt đầu từ 0 và tăng thêm 1 theo chiều đã chỉ định. Đối với các loại dấu phẩy động, mảng được tạo tương đương với ConvertElementType(Iota(...)) trong đó Iota thuộc loại số nguyên và quá trình chuyển đổi là sang loại dấu phẩy động.

Ví dụ: Iota(s32[4, 8], 0) trả về

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

Trả lại hàng với mức phí 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 ]]

Để biết thông tin về StableHLO, hãy xem StableHLO – iota.

IsFinite

Xem thêm XlaBuilder::IsFinite.

Kiểm tra xem mỗi phần tử của operand có hữu hạn hay không, tức là không phải là vô cực dương hoặc âm và không phải là NaN. Trả về một mảng các giá trị PRED có cùng hình dạng với đầu vào, trong đó mỗi phần tử là true nếu và chỉ nếu phần tử đầu vào tương ứng là hữu hạn.

IsFinite(operand)

Để biết thông tin về StableHLO, hãy xem StableHLO – is_finite.

Nhật ký

Xem thêm XlaBuilder::Log.

Lôgarit tự nhiên theo phần tử x -> ln(x).

Log(operand)

Hàm log cũng hỗ trợ đối số result_accuracy không bắt buộc:

Log(operand, result_accuracy)

Để biết thêm thông tin về result_accuracy, hãy xem phần Độ chính xác của kết quả.

Để biết thông tin về StableHLO, hãy xem StableHLO – log.

Log1p

Xem thêm XlaBuilder::Log1p.

Lôgarit tự nhiên được dịch chuyển theo từng phần tử x -> ln(1+x).

Log1p(operand)

Log1p cũng hỗ trợ đối số result_accuracy không bắt buộc:

Log1p(operand, result_accuracy)

Để biết thêm thông tin về result_accuracy, hãy xem phần Độ chính xác của kết quả.

Để biết thông tin về StableHLO, hãy xem StableHLO – log_plus_one.

Logistic

Xem thêm XlaBuilder::Logistic.

Phép tính hàm logistic theo phần tử x -> logistic(x).

Logistic(operand)

Logistic cũng hỗ trợ đối số result_accuracy không bắt buộc:

Logistic(operand, result_accuracy)

Để biết thêm thông tin về result_accuracy, hãy xem phần Độ chính xác của kết quả.

Để biết thông tin về StableHLO, hãy xem StableHLO – logistic.

Bản đồ

Xem thêm XlaBuilder::Map.

Map(operands..., computation, dimensions)

Áp dụng một hàm vô hướng trên các mảng operands đã cho, tạo ra một mảng có cùng kích thước, trong đó mỗi phần tử là kết quả của hàm được ánh xạ áp dụng cho các phần tử tương ứng trong mảng đầu vào.

Hàm được ánh xạ là một phép tính tuỳ ý với hạn chế là hàm này có N đầu vào thuộc loại vô hướng T và một đầu ra thuộc loại S. Đầu ra có cùng kích thước với toán hạng, ngoại trừ việc loại phần tử T được thay thế bằng S.

Ví dụ: Map(op1, op2, op3, computation, par1) ánh xạ elem_out <- computation(elem1, elem2, elem3, par1) tại mỗi chỉ mục (nhiều chiều) trong mảng đầu vào để tạo ra mảng đầu ra.

Để biết thông tin về StableHLO, hãy xem StableHLO – bản đồ.

Tối đa

Xem thêm XlaBuilder::Max.

Thực hiện phép toán max theo phần tử trên các tensor lhs và rhs.

Max(lhs, rhs)

Hình dạng của các đối số phải tương tự hoặc tương thích. Hãy xem tài liệu truyền tin để biết ý nghĩa của việc các hình dạng tương thích. Kết quả của một thao tác có hình dạng là kết quả của việc truyền hai mảng đầu vào. Trong biến thể này, các thao tác giữa các mảng có thứ hạng khác nhau không được hỗ trợ, trừ phi một trong các toán hạng là một đại lượng vô hướng.

Max có một phiên bản thay thế hỗ trợ truyền hình nhiều chiều:

Max(lhs,rhs, broadcast_dimensions)

Biến thể này của thao tác nên được dùng cho các phép toán số học giữa các mảng có thứ hạng khác nhau (chẳng hạn như thêm một ma trận vào một vectơ).

Toán hạng broadcast_dimensions bổ sung là một lát số nguyên chỉ định các phương diện cần dùng để truyền các toán hạng. Ngữ nghĩa được mô tả chi tiết trên trang phát sóng.

Để biết thông tin về StableHLO, hãy xem StableHLO – tối đa.

Phút

Xem thêm XlaBuilder::Min.

Thực hiện phép toán min theo phần tử trên lhs và rhs.

Min(lhs, rhs)

Hình dạng của các đối số phải tương tự hoặc tương thích. Hãy xem tài liệu truyền tin để biết ý nghĩa của việc các hình dạng tương thích. Kết quả của một thao tác có hình dạng là kết quả của việc truyền hai mảng đầu vào. Trong biến thể này, các thao tác giữa các mảng có thứ hạng khác nhau không được hỗ trợ, trừ phi một trong các toán hạng là một đại lượng vô hướng.

Một biến thể thay thế có hỗ trợ truyền tin nhiều chiều tồn tại cho Min:

Min(lhs,rhs, broadcast_dimensions)

Biến thể này của thao tác nên được dùng cho các phép toán số học giữa các mảng có thứ hạng khác nhau (chẳng hạn như thêm một ma trận vào một vectơ).

Toán hạng broadcast_dimensions bổ sung là một lát số nguyên chỉ định các phương diện cần dùng để truyền các toán hạng. Ngữ nghĩa được mô tả chi tiết trên trang phát sóng.

Để biết thông tin về StableHLO, hãy xem phần StableHLO – tối thiểu.

Mul

Xem thêm XlaBuilder::Mul.

Thực hiện phép nhân theo phần tử của lhs và rhs.

Mul(lhs, rhs)

Hình dạng của các đối số phải tương tự hoặc tương thích. Hãy xem tài liệu truyền tin để biết ý nghĩa của việc các hình dạng tương thích. Kết quả của một thao tác có hình dạng là kết quả của việc truyền hai mảng đầu vào. Trong biến thể này, các thao tác giữa các mảng có thứ hạng khác nhau không được hỗ trợ, trừ phi một trong các toán hạng là một đại lượng vô hướng.

Mul có một biến thể thay thế hỗ trợ truyền hình nhiều chiều:

Mul(lhs,rhs, broadcast_dimensions)

Biến thể này của thao tác nên được dùng cho các phép toán số học giữa các mảng có thứ hạng khác nhau (chẳng hạn như thêm một ma trận vào một vectơ).

Toán hạng broadcast_dimensions bổ sung là một lát số nguyên chỉ định các phương diện cần dùng để truyền các toán hạng. Ngữ nghĩa được mô tả chi tiết trên trang phát sóng.

Để biết thông tin về StableHLO, hãy xem StableHLO – multiply.

Neg

Xem thêm XlaBuilder::Neg.

Phép phủ định theo phần tử x -> -x.

Neg(operand)

Để biết thông tin về StableHLO, hãy xem StableHLO – phủ định

Không

Xem thêm XlaBuilder::Not.

Phủ định logic theo phần tử x -> !(x).

Not(operand)

Để biết thông tin về StableHLO, hãy xem StableHLO – not.

OptimizationBarrier

Xem thêm XlaBuilder::OptimizationBarrier.

Chặn mọi lượt tối ưu hoá di chuyển các phép tính qua rào cản.

OptimizationBarrier(operand)

Đảm bảo rằng tất cả các đầu vào đều được đánh giá trước mọi thao tác viên phụ thuộc vào đầu ra của rào cản.

Để biết thông tin về StableHLO, hãy xem StableHLO – optimization_barrier.

Hoặc

Xem thêm XlaBuilder::Or.

Thực hiện phép OR theo phần tử của lhs và rhs .

Or(lhs, rhs)

Hình dạng của các đối số phải tương tự hoặc tương thích. Hãy xem tài liệu truyền tin để biết ý nghĩa của việc các hình dạng tương thích. Kết quả của một thao tác có hình dạng là kết quả của việc truyền hai mảng đầu vào. Trong biến thể này, các thao tác giữa các mảng có thứ hạng khác nhau không được hỗ trợ, trừ phi một trong các toán hạng là một đại lượng vô hướng.

Or có một biến thể thay thế hỗ trợ truyền hình nhiều chiều:

Or(lhs,rhs, broadcast_dimensions)

Biến thể này của thao tác nên được dùng cho các phép toán số học giữa các mảng có thứ hạng khác nhau (chẳng hạn như thêm một ma trận vào một vectơ).

Toán hạng broadcast_dimensions bổ sung là một lát số nguyên chỉ định các phương diện cần dùng để truyền các toán hạng. Ngữ nghĩa được mô tả chi tiết trên trang phát sóng.

Để biết thông tin về StableHLO, hãy xem StableHLO – hoặc.

Outfeed

Xem thêm XlaBuilder::Outfeed.

Ghi dữ liệu đầu vào vào nguồn cấp dữ liệu đầu ra.

Outfeed(operand, shape_with_layout, outfeed_config)

shape_with_layout truyền đạt hình dạng được bố trí mà chúng ta muốn xuất.

Để biết thông tin về StableHLO, hãy xem StableHLO – outfeed.

Miếng đệm

Xem thêm XlaBuilder::Pad.

Pad(operand, padding_value, padding_config)

Mở rộng mảng operand đã cho bằng cách thêm khoảng đệm xung quanh mảng cũng như giữa các phần tử của mảng bằng padding_value đã cho. padding_config chỉ định lượng khoảng đệm cạnh và khoảng đệm bên trong cho từng phương diện.

PaddingConfig là một trường lặp lại của PaddingConfigDimension, chứa 3 trường cho mỗi phương diện: edge_padding_low, edge_padding_high và interior_padding.

edge_padding_low và edge_padding_high chỉ định lượng khoảng đệm được thêm vào ở đầu dưới (bên cạnh chỉ mục 0) và đầu trên (bên cạnh chỉ mục cao nhất) của mỗi phương diện tương ứng. Lượng khoảng đệm cạnh có thể là số âm – giá trị tuyệt đối của khoảng đệm âm cho biết số lượng phần tử cần xoá khỏi phương diện được chỉ định.

interior_padding chỉ định lượng khoảng đệm được thêm giữa hai phần tử bất kỳ trong mỗi phương diện; giá trị này không được là số âm. Khoảng đệm bên trong xuất hiện một cách hợp lý trước khoảng đệm cạnh, vì vậy, trong trường hợp khoảng đệm cạnh âm, các phần tử sẽ bị xoá khỏi toán hạng được đệm bên trong.

Thao tác này không có tác dụng nếu tất cả các cặp khoảng đệm cạnh đều là (0, 0) và tất cả các giá trị khoảng đệm bên trong đều là 0. Hình dưới đây cho thấy ví dụ về các giá trị edge_padding và interior_padding khác nhau cho một mảng hai chiều.

Để biết thông tin về StableHLO, hãy xem StableHLO – pad.

Tham số

Xem thêm XlaBuilder::Parameter.

Parameter biểu thị một đối số đầu vào cho một phép tính.

PartitionID

Xem thêm XlaBuilder::BuildPartitionId.

Tạo partition_id của quy trình hiện tại.

PartitionID(shape)

PartitionID có thể xuất hiện trong các kết xuất HLO nhưng người dùng cuối không nên tự tạo.

Để biết thông tin về StableHLO, hãy xem StableHLO – partition_id.

PopulationCount

Xem thêm XlaBuilder::PopulationCount.

Tính số lượng bit được đặt trong mỗi phần tử của operand.

PopulationCount(operand)

Để biết thông tin về StableHLO, hãy xem StableHLO – popcnt.

Pow

Xem thêm XlaBuilder::Pow.

Thực hiện phép luỹ thừa theo phần tử của lhs theo rhs.

Pow(lhs, rhs)

Hình dạng của các đối số phải tương tự hoặc tương thích. Hãy xem tài liệu truyền tin để biết ý nghĩa của việc các hình dạng tương thích. Kết quả của một thao tác có hình dạng là kết quả của việc truyền hai mảng đầu vào. Trong biến thể này, các thao tác giữa các mảng có thứ hạng khác nhau không được hỗ trợ, trừ phi một trong các toán hạng là một đại lượng vô hướng.

Pow có một biến thể thay thế hỗ trợ truyền hình nhiều chiều:

Pow(lhs,rhs, broadcast_dimensions)

Biến thể này của thao tác nên được dùng cho các phép toán số học giữa các mảng có thứ hạng khác nhau (chẳng hạn như thêm một ma trận vào một vectơ).

Toán hạng broadcast_dimensions bổ sung là một lát số nguyên chỉ định các phương diện cần dùng để truyền các toán hạng. Ngữ nghĩa được mô tả chi tiết trên trang phát sóng.

Để biết thông tin về StableHLO, hãy xem StableHLO – power.

Real

Xem thêm XlaBuilder::Real.

Phần thực theo phần tử của một hình dạng phức tạp (hoặc thực). x -> real(x). Nếu toán hạng là kiểu số thực, Real sẽ trả về cùng một giá trị.

Real(operand)

Để biết thông tin về StableHLO, hãy xem StableHLO – real.

Recv

Xem thêm XlaBuilder::Recv.

Recv, RecvWithTokens và RecvToHost là các thao tác đóng vai trò là các nguyên tắc giao tiếp trong HLO. Các thao tác này thường xuất hiện trong các kết xuất HLO dưới dạng một phần của hoạt động đầu vào/đầu ra cấp thấp hoặc hoạt động truyền dữ liệu trên nhiều thiết bị, nhưng người dùng cuối không được phép tạo các thao tác này theo cách thủ công.

Recv(shape, handle)

Nhận dữ liệu của hình dạng đã cho từ một chỉ dẫn Send trong một phép tính khác dùng chung cùng một mã nhận dạng kênh. Trả về một XlaOp cho dữ liệu nhận được.

Để biết thông tin về StableHLO, hãy xem StableHLO – recv.

RecvDone

Xem thêm HloInstruction::CreateRecv và HloInstruction::CreateRecvDone.

Tương tự như Send, API ứng dụng của thao tác Recv biểu thị hoạt động giao tiếp đồng bộ. Tuy nhiên, hướng dẫn này được phân tách nội bộ thành 2 hướng dẫn HLO (Recv và RecvDone) để cho phép truyền dữ liệu không đồng bộ.

Recv(const Shape& shape, int64 channel_id)

Phân bổ các tài nguyên cần thiết để nhận dữ liệu từ một chỉ dẫn Send có cùng channel_id. Trả về một ngữ cảnh cho các tài nguyên được phân bổ, được dùng bởi chỉ dẫn RecvDone sau đây để chờ hoàn tất quá trình truyền dữ liệu. Ngữ cảnh là một bộ {nhận bộ đệm (hình dạng), mã nhận dạng yêu cầu (U32)} và chỉ có thể được dùng bằng một chỉ dẫn RecvDone.

Với một bối cảnh do chỉ dẫn Recv tạo ra, hãy đợi quá trình truyền dữ liệu hoàn tất và trả về dữ liệu đã nhận.

Giảm bớt

Xem thêm XlaBuilder::Reduce.

Áp dụng hàm rút gọn cho một hoặc nhiều mảng song song.

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

Trong trường hợp:

• N phải lớn hơn hoặc bằng 1.
• Phép tính phải có tính kết hợp "tương đối" (xem bên dưới).
• Tất cả các mảng đầu vào phải có cùng kích thước.
• Tất cả các giá trị ban đầu phải tạo thành một giá trị nhận dạng trong computation.
• Nếu N = 1, Collate(T) là T.
• Nếu N > 1, Collate(T_0, ..., T_{N-1}) là một bộ gồm các phần tử N thuộc loại T.

Thao tác này sẽ giảm một hoặc nhiều phương diện của mỗi mảng đầu vào thành các đại lượng vô hướng. Số lượng phương diện của mỗi mảng được trả về là number_of_dimensions(operand) - len(dimensions). Đầu ra của thao tác này là Collate(Q_0, ..., Q_N), trong đó Q_i là một mảng thuộc loại T_i, kích thước của mảng này được mô tả bên dưới.

Các chương trình phụ trợ khác nhau được phép liên kết lại phép tính giảm. Điều này có thể dẫn đến sự khác biệt về số, vì một số hàm giảm như phép cộng không có tính kết hợp đối với số thực. Tuy nhiên, nếu phạm vi của dữ liệu bị hạn chế, thì phép cộng số thực dấu phẩy động sẽ đủ gần để kết hợp cho hầu hết các mục đích sử dụng thực tế.

Để biết thông tin về StableHLO, hãy xem StableHLO – reduce.

Ví dụ

Khi giảm trên một chiều trong một mảng 1D duy nhất có các giá trị [10, 11, 12, 13], với hàm giảm f (đây là computation), thì hàm đó có thể được tính là

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

nhưng cũng có nhiều khả năng khác, chẳng hạn như

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

Sau đây là ví dụ về mã giả sơ bộ về cách có thể triển khai thao tác rút gọn, sử dụng phép tính tổng làm phép tính rút gọn với giá trị ban đầu là 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]

Sau đây là ví dụ về cách giảm mảng 2 chiều (ma trận). Hình dạng có 2 phương diện, phương diện 0 có kích thước 2 và phương diện 1 có kích thước 3:

Kết quả của việc giảm kích thước 0 hoặc 1 bằng hàm "add":

Xin lưu ý rằng cả hai kết quả rút gọn đều là mảng 1 chiều. Sơ đồ này cho thấy một cột và một hàng chỉ để thuận tiện cho việc hình dung.

Để có ví dụ phức tạp hơn, sau đây là một mảng 3 chiều. Số lượng phương diện của nó là 3, phương diện 0 có kích thước 4, phương diện 1 có kích thước 2 và phương diện 2 có kích thước 3. Để đơn giản, các giá trị từ 1 đến 6 được sao chép trên phương diện 0.

Tương tự như ví dụ 2D, chúng ta có thể giảm chỉ một phương diện. Ví dụ: nếu giảm chiều 0, chúng ta sẽ nhận được một mảng 2 chiều, trong đó tất cả các giá trị trên chiều 0 được gộp thành một đại lượng vô hướng:

|  4   8  12 |
| 16  20  24 |

Nếu giảm phương diện 2, chúng ta cũng sẽ nhận được một mảng 2 chiều, trong đó tất cả các giá trị trên phương diện 2 được gộp thành một giá trị vô hướng:

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

Xin lưu ý rằng thứ tự tương đối giữa các phương diện còn lại trong dữ liệu đầu vào được giữ nguyên trong dữ liệu đầu ra, nhưng một số phương diện có thể được chỉ định số mới (vì số lượng phương diện thay đổi).

Chúng ta cũng có thể giảm nhiều phương diện. Việc giảm phương diện 0 và 1 sẽ tạo ra mảng 1 chiều [20, 28, 36].

Việc giảm mảng 3D trên tất cả các phương diện sẽ tạo ra đại lượng vô hướng 84.

Giảm số lượng biến

Khi N > 1, việc giảm ứng dụng hàm sẽ phức tạp hơn một chút, vì hàm này được áp dụng đồng thời cho tất cả các đầu vào. Các toán hạng được cung cấp cho phép tính theo thứ tự sau:

• Giá trị giảm dần cho toán hạng đầu tiên
• ...
• Đang chạy giá trị giảm cho toán hạng thứ N
• Giá trị đầu vào cho toán hạng đầu tiên
• ...
• Giá trị đầu vào cho toán hạng thứ N

Ví dụ: hãy xem xét hàm giảm sau đây. Hàm này có thể dùng để tính giá trị tối đa và argmax của một mảng 1 chiều song song:

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

Đối với mảng đầu vào 1 chiều V = Float[N], K = Int[N] và các giá trị init I_V = Float, I_K = Int, kết quả f_(N-1) của việc giảm trên chiều đầu vào duy nhất tương đương với ứng dụng đệ quy sau:

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

Khi áp dụng thao tác giảm này cho một mảng giá trị và một mảng chỉ mục tuần tự (tức là iota), thao tác này sẽ cùng lặp lại trên các mảng và trả về một bộ chứa giá trị tối đa và chỉ mục phù hợp.

ReducePrecision

Xem thêm XlaBuilder::ReducePrecision.

Mô hình hoá hiệu ứng của việc chuyển đổi các giá trị dấu phẩy động sang định dạng có độ chính xác thấp hơn (chẳng hạn như IEEE-FP16) và quay lại định dạng ban đầu. Bạn có thể tuỳ ý chỉ định số lượng bit của số mũ và phần định trị trong định dạng có độ chính xác thấp, mặc dù không phải tất cả các kích thước bit đều được hỗ trợ trên mọi cách triển khai phần cứng.

ReducePrecision(operand, exponent_bits, mantissa_bits)

Kết quả là một mảng thuộc loại T. Các giá trị đầu vào được làm tròn đến giá trị gần nhất có thể biểu thị bằng số lượng bit phần định trị đã cho (sử dụng ngữ nghĩa "làm tròn đến số chẵn"), đồng thời mọi giá trị vượt quá phạm vi được chỉ định theo số lượng bit số mũ đều được giới hạn ở vô cực dương hoặc âm. Các giá trị NaN được giữ lại, mặc dù có thể được chuyển đổi thành các giá trị NaN chuẩn.

Định dạng có độ chính xác thấp phải có ít nhất một bit số mũ (để phân biệt giá trị 0 với vô cực, vì cả hai đều có phần định trị bằng 0) và phải có số lượng bit phần định trị không âm. Số lượng bit số mũ hoặc phần định trị có thể vượt quá giá trị tương ứng cho loại T; phần tương ứng của lượt chuyển đổi chỉ đơn giản là không hoạt động.

Để biết thông tin về StableHLO, hãy xem StableHLO – reduce_precision.

ReduceScatter

Xem thêm XlaBuilder::ReduceScatter.

ReduceScatter là một thao tác tập thể thực hiện AllReduce một cách hiệu quả, sau đó phân tán kết quả bằng cách chia kết quả thành shard_count khối dọc theo scatter_dimension và bản sao i trong nhóm bản sao sẽ nhận được phân đoạn ith.

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

• Khi operand là một bộ gồm các mảng, thao tác giảm phân tán sẽ được thực hiện trên từng phần tử của bộ.
• replica_groups là danh sách các nhóm bản sao mà giữa đó sẽ thực hiện thao tác giảm (có thể truy xuất mã nhận dạng bản sao cho bản sao hiện tại bằng cách sử dụng ReplicaId). Thứ tự của các bản sao trong mỗi nhóm sẽ xác định thứ tự mà kết quả giảm tất cả sẽ được phân tán. replica_groups phải trống (trong trường hợp đó, tất cả các bản sao thuộc một nhóm duy nhất) hoặc chứa cùng số lượng phần tử như số lượng bản sao. Khi có nhiều nhóm bản sao, tất cả các nhóm đó phải có cùng kích thước. Ví dụ: replica_groups = {0, 2}, {1, 3} thực hiện thao tác giảm giữa các bản sao 0 và 2, 1 và 3, sau đó phân tán kết quả.
• shard_count là quy mô của mỗi nhóm bản sao. Chúng tôi cần thông tin này trong trường hợp replica_groups trống. Nếu replica_groups không trống, thì shard_count phải bằng kích thước của mỗi nhóm bản sao.
• channel_id được dùng để giao tiếp giữa các mô-đun: chỉ các thao tác reduce-scatter có cùng channel_id mới có thể giao tiếp với nhau.
• layout Xem xla::shapes để biết thêm thông tin về bố cục.
• use_global_device_ids là một cờ do người dùng chỉ định. Khi false(mặc định) các số trong replica_groups là ReplicaId khi true replica_groups biểu thị một mã nhận dạng chung của (ReplicaID*partition_count + partition_id). Ví dụ:
  • Với 2 bản sao và 4 phân vùng,
  • replica_groups={ {0,1,4,5},{2,3,6,7} } and use_global_device_ids=true
  • group[0] = (0,0), (0,1), (1,0), (1,1)
  • group[1] = (0,2), (0,3), (1,2), (1,3)
  • trong đó mỗi cặp là (replica_id, partition_id).

Hình dạng đầu ra là hình dạng đầu vào có kích thước nhỏ hơn scatter_dimension lần.shard_count Ví dụ: nếu có 2 bản sao và toán hạng có giá trị lần lượt là [1.0, 2.25] và [3.0, 5.25] trên 2 bản sao, thì giá trị đầu ra từ thao tác này (trong đó scatter_dim là 0) sẽ là [4.0] cho bản sao đầu tiên và [7.5] cho bản sao thứ hai.

Để biết thông tin về StableHLO, hãy xem StableHLO – reduce_scatter.

ReduceScatter – Ví dụ 1 – StableHLO

Trong ví dụ trên, có 2 bản sao tham gia vào ReduceScatter. Trên mỗi bản sao, toán hạng có hình dạng f32[2,4]. Một thao tác giảm tất cả (tổng) được thực hiện trên các bản sao, tạo ra một giá trị đã giảm có hình dạng f32[2,4] trên mỗi bản sao. Sau đó, giá trị rút gọn này được chia thành 2 phần dọc theo chiều 1, sao cho mỗi phần có hình dạng f32[2,2]. Mỗi bản sao trong nhóm quy trình sẽ nhận được phần tương ứng với vị trí của bản sao đó trong nhóm. Do đó, đầu ra trên mỗi bản sao có hình dạng f32[2,2].

ReduceWindow

Xem thêm XlaBuilder::ReduceWindow.

Áp dụng một hàm rút gọn cho tất cả các phần tử trong mỗi cửa sổ của một chuỗi gồm N mảng đa chiều, tạo ra một hoặc một bộ gồm N mảng đa chiều làm đầu ra. Mỗi mảng đầu ra có số phần tử bằng với số vị trí hợp lệ của cửa sổ. Bạn có thể biểu thị một lớp gộp dưới dạng ReduceWindow. Tương tự như Reduce, computation được áp dụng luôn được truyền init_values ở phía bên trái.

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

Trong trường hợp:

• N phải lớn hơn hoặc bằng 1.
• Tất cả các mảng đầu vào phải có cùng kích thước.
• Nếu N = 1, Collate(T) là T.
• Nếu N > 1, Collate(T_0, ..., T_{N-1}) là một bộ gồm các phần tử N thuộc loại (T0,...T{N-1}).

Để biết thông tin về StableHLO, hãy xem StableHLO – reduce_window.

ReduceWindow – Ví dụ 1

Đầu vào là một ma trận có kích thước [4x6] và cả window_dimensions và window_stride_dimensions đều là [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);