StableHLO अनुवादक

StableHLO अनुवादक का मुख्य मकसद है StableHLO ऑपसेट के सिमैंटिक्स को लागू करना स्पेसिफ़िकेशन. दूसरा लक्ष्य होता है कि विज्ञापनों को सही तरीके से लागू करना ताकि परफ़ॉर्मेंस की तुलना में, प्रॉडक्ट को आसानी से पढ़ा जा सके. यहां तक कि Convolution जैसे सबसे अहम ऑपरेशन के सिमेंटिक्स तक, Gather/Scatter और DotGeneral.

फ़िलहाल, OpenXLA में 96 में से 91 वर्शन का इस्तेमाल किया जा सकता है StableHLO ऑपरेशन बाकी तीन ऑपरेशन (FftOp, RngOp, RngBitGeneratorOp) के दस्तावेज़ में उनके सिमैंटिक्स को दस्तावेज़ में शामिल किया गया spec.md के साथ-साथ शुरुआती जांच पूरी की (देखें कि आगे क्या करना है) status.md ऑपरेशन की पूरी सूची और इसकी मौजूदा स्थिति देखने के लिए). ये फ़ाइनल इन सुविधाओं को समुदाय की ज़रूरत के हिसाब से लागू किया जाएगा.

दायरा

हमने StableHLO ऑपसेट को 11 कैटगरी में रखा है. इनमें 118 ऑपरेशन शामिल हैं कुल (अपेंडिक्स देखें). रेफ़रंस फ़ाइल को लागू करना वर्कस्ट्रीम वीडियो में, अनुवादक को लागू करने से जुड़े काम को व्यवस्थित किया जाता है के लिए 100% StableHLO ऑपरेशन का इस्तेमाल किया जाएगा. हम इस वर्कस्ट्रीम के सभी या ज़्यादातर काम को StableHLO में पूरा करने की योजना है वर्शन 1.0. वर्तमान में विशिष्टता वाले 96 ऑपरेशन में से हम 91 ऑपरेशन के OpenXLA (बाकी 5 के लिए खास मामले देखें).

खास जानकारी

अनुवादक के लिए मुख्य शर्त यह है कि वह स्पेसिफ़िकेशन. इस स्पेसिफ़िकेशन की मदद से, मिलते-जुलते ऑपरेशन के लिए इंटरप्रेटर को स्टैंडर्ड तय किया जा सकता है इससे अनुवादक को मॉड्यूलर और अच्छी क्वालिटी में लागू किया जा सकता है.

खास मामले

अन्य सूचनाएं

इस कैटगरी में ऐसे ऑपरेशन हैं जिन्हें डिकोड किया जा सकता है और फ़िलहाल, यह साफ़ तौर पर नहीं बताया गया है. यह लीजिए इस कैटगरी में तीन खास ऑपरेशन हैं, जिनका इस्तेमाल अनुवादक क्षण:

• FftOp
• RngOp
• RngBitGeneratorOp

FftOp को मिसलेनियस की कैटगरी में रखा गया है. हालांकि, इस कैटगरी में अन्य ऑपरेशन से अलग, इस op का कोई विस्तारक पास नहीं है और StableHLO में इसका समर्थन करने डब्ल्यूआईपी.

RngOp और RngBitGeneratorOp को MHLO ऑपरेशन में डिकंपोज़ किया जा सकता है, लेकिन अपघटन से जुड़ा एक XlaRngGetAndUpdateStateOp है, जो कि एक MHLO खास है सेशन इन दो ऑपरेशन की व्याख्या एक WIP है.

इस कैटगरी में बचे हुए ऑपरेशन को StableHLO ऑपरेशन में बदलने वाला टूल अनुवादक, hlo_expand_main.cc में मौजूद होता है.

HLO में नहीं है

तय किए गए ऑपरेशन के अलावा, इस कैटगरी में आठ ऐसे ऑपरेशन शामिल हैं जिनकी जानकारी नहीं है (देखें StableHLO ऑपरेशन कैटगरी) जिन्हें StableHLO से बाहर ले जाया गया. इनमें से ज़्यादातर ऑपरेशन के पास mhlo से उन्हें StableHLO के बराबर के ऑपरेशन में बदल दिया जाएगा.

इस कैटगरी में बचे हुए ऑपरेशन को StableHLO Ops के बराबर में बदलने वाला टूल यह जानकारी mlir-hlo-opt.cc में मौजूद होती है.

क्वांटाइज़ेशन

क्वांटाइज़्ड टाइप वाली stablehlo.constant कार्रवाई के लिए, अनुवादक सहायता उपलब्ध है सुविधा उपलब्ध नहीं है और के ज़रिए ट्रैक की गई #1691.

इस्तेमाल के लिए निर्देश

रेफ़रंस इंटरप्रेटर बनाना

अनुवादक को Baze या CMake (पसंदीदा) की मदद से बनाया और टेस्ट किया जा सकता है. फ़ुल टाइम निर्देश के लिए, README.md देखें.

बेज़ल:

bazel build //...

सीमेक:

mkdir -p build && cd build

cmake .. -GNinja \
  -DLLVM_ENABLE_LLD="$LLVM_ENABLE_LLD" \
  -DCMAKE_BUILD_TYPE=Release \
  -DLLVM_ENABLE_ASSERTIONS=On \
  -DMLIR_DIR=${PWD}/../llvm-build/lib/cmake/mlir

अनुवादक को चलाने के लिए, हमारे पास StableHLO प्रोग्राम को समझने के लिए एक अनुवाद टूल है MLIR में लिखा गया है.

stablehlo-translate --interpret <path/to/program>

अनुवादक की भाषा

Interpreter भाषा में अनुवादक. खास तौर पर, interpreter.run_parallel (देखें InterpreterOps.td op सिमेंटिक्स और उदाहरण उपयोग के लिए) op, डिस्ट्रिब्यूशन ऑपरेशन की व्याख्या करने देता है और बहुत कुछ यूटिलिटी में समुदाय की ज़रूरतों के हिसाब से, उन्हें जोड़ा जाएगा.

चेक भाषा

Check बोली का इस्तेमाल अनुवादक रनटाइम मानों की तुलना उम्मीद के मुताबिक करने के लिए किया जाता है वैल्यू. StableHLO प्रोग्राम के आउटपुट की जांच, अलग-अलग चेक ऑपरेशन के ज़रिए की जा सकती है. (यहां देखें CheckOps.td और उदाहरण के इस्तेमाल के लिए).

टेस्ट प्रोग्राम लिखना

हम एलएलवीएम के लिट टूल का इस्तेमाल करते हैं, ताकि जनरेट की गई फ़ाइल की तुलना अनुवादक के आउटपुट से फ़र्क़ करने के लिए (stablehlo/tests/interpret उदाहरण के लिए, टेस्ट).

AddOp की टेस्टिंग की जा रही है (इसका सैंपल: interpret_add.mlir):

// RUN: stablehlo-translate --interpret %s

func.func @add_op_scalar() {
  %0 = stablehlo.constant dense<2> : tensor<i4>
  %1 = stablehlo.constant dense<3> : tensor<i4>
  %2 = stablehlo.add %0, %1 : tensor<i4>
  check.expect_eq_const %2, dense<5> : tensor<i4>
  func.return
}

वितरण श्रेणी में ऑपरेशन का परीक्षण करने के लिए उसे इसके माध्यम से चलाना interpreter.run_parallel यूटिलिटी ऑप.

AllReduceOp की टेस्टिंग की जा रही है (इसका सैंपल: all_reduce.mlir):

// RUN: stablehlo-translate --interpret %s

module @cross_replica {
  func.func public @all_reduce(%operand : tensor<4xi64>) -> tensor<4xi64> {
    %result = "stablehlo.all_reduce"(%operand) ({
      ^bb0(%arg0: tensor<i64>, %arg1: tensor<i64>):
        %0 = stablehlo.add %arg0, %arg1 : tensor<i64>
        stablehlo.return %0 : tensor<i64>
    }) {
      replica_groups = dense<[[0, 1]]> : tensor<1x2xi64>,
      channel_handle = #stablehlo.channel_handle<handle = 0, type = 0>
    } : (tensor<4xi64>) -> tensor<4xi64>
    return %result : tensor<4xi64>
  }
  func.func public @main() {
    %inputs0 = stablehlo.constant dense<[1, 2, 3, 4]> : tensor<4xi64>
    %inputs1 = stablehlo.constant dense<[5, 6, 7, 8]> : tensor<4xi64>
    %results:2 = "interpreter.run_parallel"(%inputs0, %inputs1) {
      programs=[[@all_reduce], [@all_reduce]]
    } : (tensor<4xi64>, tensor<4xi64>) -> (tensor<4xi64>, tensor<4xi64>)
    check.expect_eq_const %results#0, dense<[6, 8, 10, 12]> : tensor<4xi64>
    check.expect_eq_const %results#1, dense<[6, 8, 10, 12]> : tensor<4xi64>
    func.return
  }
}

StableHLO डीबग करना

StableHLO बिल्ड के चरणों को फ़ॉलो करते हुए, StableHLO बाइनरी stablehlo/tools में /build/bin होना चाहिए. डीबग करने के लिए आम तौर पर इस्तेमाल होने वाले टूल, जैसे कि कोड पर जाने के लिए GDB का इस्तेमाल किया जा सकता है:

gdb --args ./build/bin/stablehlo-translate -allow-unregistered-dialect --interpret ./stablehlo/tests/interpret/<test>.mlir

अन्य जानकारी

मिसलेनियस ऑपरेशन को बदलें

# batch_norm_grad
hlo-expand --batch_norm_grad_expander <path/to/hlo_module>

# batch_norm_inference
hlo-expand --batch_norm_inference_expander <path/to/hlo_module>

# batch_norm_training
hlo-expand --batch_norm_training_expander <path/to/hlo_module>

# cholesky
hlo-expand --cholesky_expander <path/to/hlo_module>

# constant
# Supported in StableHLO interpreter.

# fft
# TBD

# iota
# Supported in StableHLO interpreter.

# rng
# TBD

# rng_bit_generator
# TBD

# triangular_solve
hlo-expand --triangular_solve_expander <path/to/hlo_module>

HLO ऑपरेशन में नहीं बदलें

# broadcast
mlir-hlo-opt -mhlo-legalize-broadcast-to-broadcast-in-dim <path/to/input>

# create_token
mlir-hlo-opt -mhlo-legalize-create-token-to-after-all <path/to/input>

# cross-replica-sum
mlir-hlo-opt -mhlo-legalize-cross-replica-sum-to-all-reduce <path/to/input>

# dot
mlir-hlo-opt -mhlo-legalize-dot-to-dot-general <path/to/input>

# einsum
mlir-hlo-opt -mhlo-legalize-einsum-to-dot-general <path/to/input>

# torch_index_select
mlir-hlo-opt -mhlo-legalize-torch-index-select-to-gather <path/to/input>

# unary_einsum
mlir-hlo-opt --canonicalize -mhlo-legalize-einsum-to-dot-general <path/to/input>

StableHLO ऑपरेशन कैटगरी