Hermetic CUDA के बारे में खास जानकारी

Hermetic CUDA, उपयोगकर्ता के डिवाइस पर इंस्टॉल किए गए CUDA के बजाय, CUDA के डाउनलोड किए जा सकने वाले किसी खास वर्शन का इस्तेमाल करता है. Bazel, CUDA, CUDNN, और NCCL डिस्ट्रिब्यूशन डाउनलोड करेगा. इसके बाद, Bazel के अलग-अलग टारगेट में, CUDA लाइब्रेरी और टूल का इस्तेमाल डिपेंडेंसी के तौर पर करेगा. इससे Google ML प्रोजेक्ट और साथ काम करने वाले CUDA वर्शन के लिए, ज़्यादा बार बनाए जा सकने वाले बिल्ड मिलते हैं.

इस्तेमाल किए जा सकने वाले हर्मेटिक CUDA, CUDNN वर्शन

काम करने वाले CUDA वर्शन की जानकारी, CUDA_REDIST_JSON_DICT डिकशनरी, third_party/gpus/cuda/hermetic/cuda_redist_versions.bzl में दी गई है.

इस्तेमाल किए जा सकने वाले CUDNN वर्शन की जानकारी CUDNN_REDIST_JSON_DICT डिक्शनरी, third_party/gpus/cuda/hermetic/cuda_redist_versions.bzl में दी गई है.

अलग-अलग प्रोजेक्ट की .bazelrc फ़ाइलों में HERMETIC_CUDA_VERSION, HERMETIC_CUDNN_VERSION एनवायरमेंट वैरिएबल होते हैं. ये वैरिएबल, डिफ़ॉल्ट रूप से उन वर्शन पर सेट होते हैं जिनका इस्तेमाल तब किया जाता है, जब Bazel कमांड के विकल्पों में --config=cuda दिया जाता है.

एन्क्रिप्ट किए गए CUDA/CUDNN वर्शन को कंट्रोल करने वाले एनवायरमेंट वैरिएबल

HERMETIC_CUDA_VERSION एनवायरमेंट वैरिएबल में CUDA के मेजर, माइनर, और पैच वर्शन शामिल होने चाहिए, जैसे कि 12.3.2. HERMETIC_CUDNN_VERSION एनवायरमेंट वैरिएबल में CUDNN के मेजर, माइनर, और पैच वर्शन शामिल होने चाहिए, जैसे कि 9.1.1.

Bazel कमांड के लिए, एनवायरमेंट वैरिएबल सेट करने के तीन तरीके:

# Add an entry to your `.bazelrc` file
build:cuda --repo_env=HERMETIC_CUDA_VERSION="12.3.2"
build:cuda --repo_env=HERMETIC_CUDNN_VERSION="9.1.1"

# OR pass it directly to your specific build command
bazel build --config=cuda <target> \
--repo_env=HERMETIC_CUDA_VERSION="12.3.2" \
--repo_env=HERMETIC_CUDNN_VERSION="9.1.1"

# If .bazelrc doesn't have corresponding entries and the environment variables
# are not passed to bazel command, you can set them globally in your shell:
export HERMETIC_CUDA_VERSION="12.3.2"
export HERMETIC_CUDNN_VERSION="9.1.1"

अगर HERMETIC_CUDA_VERSION और HERMETIC_CUDNN_VERSION मौजूद नहीं हैं, तो हर्मेटिक CUDA/CUDN डेटा स्टोर करने की जगह के नियम TF_CUDA_VERSION और TF_CUDNN_VERSION एनवायरमेंट वैरिएबल की वैल्यू खोजेंगे. इसे, पुराने सिस्टम के साथ काम करने के लिए बनाया गया है.

डाउनलोड किए जाने वाले CUDA वर्शन और NCCL डिस्ट्रिब्यूशन वर्शन के बीच की मैपिंग, third_party/gpus/cuda/hermetic/cuda_redist_versions.bzl में दी गई है

हर्मेटिक CUDA कॉन्फ़िगर करना

  1. XLA पर निर्भर डाउनस्ट्रीम प्रोजेक्ट में, WORKSPACE फ़ाइल के सबसे नीचे ये लाइनें जोड़ें:

    load(
   "@tsl//third_party/gpus/cuda/hermetic:cuda_json_init_repository.bzl",
   "cuda_json_init_repository",
)

cuda_json_init_repository()

load(
   "@cuda_redist_json//:distributions.bzl",
   "CUDA_REDISTRIBUTIONS",
   "CUDNN_REDISTRIBUTIONS",
)
load(
   "@tsl//third_party/gpus/cuda/hermetic:cuda_redist_init_repositories.bzl",
   "cuda_redist_init_repositories",
   "cudnn_redist_init_repository",
)

cuda_redist_init_repositories(
   cuda_redistributions = CUDA_REDISTRIBUTIONS,
)

cudnn_redist_init_repository(
   cudnn_redistributions = CUDNN_REDISTRIBUTIONS,
)

load(
   "@tsl//third_party/gpus/cuda/hermetic:cuda_configure.bzl",
   "cuda_configure",
)

cuda_configure(name = "local_config_cuda")

load(
   "@tsl//third_party/nccl/hermetic:nccl_redist_init_repository.bzl",
   "nccl_redist_init_repository",
)

nccl_redist_init_repository()

load(
   "@tsl//third_party/nccl/hermetic:nccl_configure.bzl",
   "nccl_configure",
)

nccl_configure(name = "local_config_nccl")

  2. Hermetic CUDA और CUDNN के खास वर्शन चुनने के लिए, HERMETIC_CUDA_VERSION और HERMETIC_CUDNN_VERSION एनवायरमेंट वैरिएबल को सेट करें. सिर्फ़ उन वर्शन का इस्तेमाल करें जो इसके साथ काम करते हैं. एनवायरमेंट वैरिएबल को सीधे अपने शेल या .bazelrc फ़ाइल में सेट करें, जैसा कि यहां दिखाया गया है:

    build:cuda --repo_env=HERMETIC_CUDA_VERSION="12.3.2"
build:cuda --repo_env=HERMETIC_CUDNN_VERSION="9.1.1"
build:cuda --repo_env=HERMETIC_CUDA_COMPUTE_CAPABILITIES="sm_50,sm_60,sm_70,sm_80,compute_90"

  3. जांच के दौरान या बैज से बाइनरी चलाते समय, हर्मेटिक सीयूडीए को चालू करने के लिए, अपने बेज़ल कमांड में --@local_config_cuda//cuda:include_cuda_libs=true फ़्लैग जोड़ना न भूलें. इसे सीधे शेल में या .bazelrc में दिया जा सकता है:

    build:cuda --@local_config_cuda//cuda:include_cuda_libs=true

    इस फ़्लैग की ज़रूरत इसलिए है, ताकि यह पक्का किया जा सके कि CUDA की डिपेंडेंसी, चलाए जा सकने वाले प्रोग्राम की जांच करने के लिए सही तरीके से दी गई हैं. Google की ओर से रिलीज़ किए गए Python wheel को CUDA बाइनरी के साथ अनचाहे तरीके से जोड़ने से बचने के लिए, यह फ़्लैग डिफ़ॉल्ट रूप से गलत होता है.

  4. CUDA फ़ॉरवर्ड करने की सुविधा वाला मोड लागू करने के लिए, अपने बेज़ल कमांड में --@cuda_driver//:enable_forward_compatibility=true फ़्लैग जोड़ें. इसे सीधे शेल में या .bazelrc में दिया जा सकता है:

    test:cuda --@cuda_driver//:enable_forward_compatibility=true

    फ़्लैग की डिफ़ॉल्ट वैल्यू false है.

    CUDA फ़ॉरवर्ड कम्पैटिबिलिटी मोड बंद होने पर, Bazel टारगेट, सिस्टम में पहले से इंस्टॉल किए गए यूज़र मोड और कर्नेल मोड ड्राइवर का इस्तेमाल करेंगे.

    CUDA फ़ॉरवर्ड कम्पैटिबिलिटी मोड चालू होने पर, Bazel टारगेट, Bazel कैश मेमोरी में डाउनलोड किए गए CUDA ड्राइवर के रीडिस्ट्रिब्यूशन से User Mode Driver का इस्तेमाल करेंगे. साथ ही, सिस्टम में पहले से इंस्टॉल किए गए Kernel Mode Driver का भी इस्तेमाल करेंगे. यह पुराने कर्नेल मोड ड्राइवर का इस्तेमाल करते समय, नई CUDA Toolkit सुविधाओं को चालू करने की अनुमति देता है.

    फ़ॉरवर्ड कम्पैटिबिलिटी मोड को सिर्फ़ तब लागू किया जाना चाहिए, जब यह सही हो - ज़्यादा जानकारी के लिए, NVIDIA दस्तावेज़ देखें.

हर्मेटिक CUDA/CUDNN वर्शन अपग्रेड करें

  1. third_party/gpus/cuda/hermetic/cuda_redist_versions.bzl में, अपडेट की गई CUDA_REDIST_JSON_DICT, CUDA_REDIST_JSON_DICT डिक्शनरी के साथ, पुश अनुरोध बनाएं और सबमिट करें.

    अगर ज़रूरी हो, तो third_party/gpus/cuda/hermetic/cuda_redist_versions.bzl में, CUDA_NCCL_WHEELS को अपडेट करें.

    अगर ज़रूरी हो, तो third_party/gpus/cuda/hermetic/cuda_redist_versions.bzl में REDIST_VERSIONS_TO_BUILD_TEMPLATES को अपडेट करें.

  2. हर Google ML प्रोजेक्ट के लिए, .bazelrc फ़ाइल में अपडेट किए गए HERMETIC_CUDA_VERSION और HERMETIC_CUDNN_VERSION के साथ एक अलग पुल रिक्वेस्ट बनाएं.

    PR को सबमिट करने से पहले की जाने वाली प्रोसेस में, bazel टेस्ट लॉन्च किए जाएंगे और हर्मेटिक CUDA/CUDNN डिस्ट्रिब्यूशन डाउनलोड किए जाएंगे. पक्का करें कि PR सबमिट करने से पहले, प्री-सबमिट जॉब पास हो गए हों.

लोकल फ़ाइल सिस्टम पर CUDA/CUDNN/NCCL के रीडिस्ट्रीब्यूशन की जानकारी

डेटा को फिर से उपलब्ध कराने के लिए, स्थानीय CUDA/CUDNN/NCCL का इस्तेमाल किया जा सकता है. यहां कुछ अतिरिक्त एनवायरमेंट वैरिएबल की ज़रूरत होती है:

LOCAL_CUDA_PATH
LOCAL_CUDNN_PATH
LOCAL_NCCL_PATH

उदाहरण:

# Add an entry to your `.bazelrc` file
build:cuda --repo_env=LOCAL_CUDA_PATH="/foo/bar/nvidia/cuda"
build:cuda --repo_env=LOCAL_CUDNN_PATH="/foo/bar/nvidia/cudnn"
build:cuda --repo_env=LOCAL_NCCL_PATH="/foo/bar/nvidia/nccl"

# OR pass it directly to your specific build command
bazel build --config=cuda <target> \
--repo_env=LOCAL_CUDA_PATH="/foo/bar/nvidia/cuda" \
--repo_env=LOCAL_CUDNN_PATH="/foo/bar/nvidia/cudnn" \
--repo_env=LOCAL_NCCL_PATH="/foo/bar/nvidia/nccl"

# If .bazelrc doesn't have corresponding entries and the environment variables
# are not passed to bazel command, you can set them globally in your shell:
export LOCAL_CUDA_PATH="/foo/bar/nvidia/cuda"
export LOCAL_CUDNN_PATH="/foo/bar/nvidia/cudnn"
export LOCAL_NCCL_PATH="/foo/bar/nvidia/nccl"

CUDA डायर के अंदर फ़ोल्डर की संरचना इस तरह होनी चाहिए (जैसे कि संग्रहित किए गए फिर से डिस्ट्रिब्यूशन को एक ही जगह पर न पैक किया गया हो):

<LOCAL_CUDA_PATH>/
    include/
    bin/
    lib/
    nvvm/

CUDNN डायरेक्ट्री में मौजूद फ़ोल्डर का स्ट्रक्चर इस तरह का होना चाहिए:

<LOCAL_CUDNN_PATH>
    include/
    lib/

NCCL डायरेक्ट्री में मौजूद फ़ोल्डर का स्ट्रक्चर इस तरह होना चाहिए:

<LOCAL_NCCL_PATH>
    include/
    lib/

कस्टम CUDA/CUDNN संग्रह और NCCL व्हील

कस्टम CUDA/CUDNN वितरणों के उपयोग की अनुमति देने वाले तीन विकल्प हैं.

कस्टम CUDA/CUDNN के लिए, फिर से उपलब्ध कराए जाने वाले लाइसेंस की जानकारी देने वाली JSON फ़ाइलें

इस विकल्प की मदद से, Google के एमएल प्रोजेक्ट में CUDA/CUDNN की सभी डिपेंडेंसी के लिए कस्टम डिस्ट्रिब्यूशन का इस्तेमाल किया जा सकता है.

  1. cuda_redist.json और/या cudnn_redist.json फ़ाइलें बनाएं.

    cuda_redist.json शो, इस फ़ॉर्मैट में दिखाया जाता है:

    {
   "cuda_cccl": {
      "linux-x86_64": {
         "relative_path": "cuda_cccl-linux-x86_64-12.4.99-archive.tar.xz",
      },
      "linux-sbsa": {
         "relative_path": "cuda_cccl-linux-sbsa-12.4.99-archive.tar.xz",
      }
   },
}

    cudnn_redist.json शो, इस फ़ॉर्मैट में दिखाया जाता है:

    {
   "cudnn": {
      "linux-x86_64": {
         "cuda12": {
         "relative_path": "cudnn/linux-x86_64/cudnn-linux-x86_64-9.0.0.312_cuda12-archive.tar.xz",
         }
      },
      "linux-sbsa": {
         "cuda12": {
         "relative_path": "cudnn/linux-sbsa/cudnn-linux-sbsa-9.0.0.312_cuda12-archive.tar.xz",
         }
      }
   }
}

    relative_path फ़ील्ड को full_path से बदला जा सकता है. ऐसा उन पूरे यूआरएल और file:/// से शुरू होने वाले ऐब्सलूट लोकल पाथ के लिए किया जा सकता है.

  2. XLA पर निर्भर डाउनस्ट्रीम प्रोजेक्ट में, WORKSPACE फ़ाइल में मौजूद, हेर्मेटिक cuda JSON रिपॉज़िटरी कॉल को अपडेट करें. वेब लिंक और लोकल फ़ाइल पाथ, दोनों का इस्तेमाल किया जा सकता है. उदाहरण:

    _CUDA_JSON_DICT = {
   "12.4.0": [
      "file:///home/user/Downloads/redistrib_12.4.0_updated.json",
   ],
}

_CUDNN_JSON_DICT = {
   "9.0.0": [
      "https://developer.download.nvidia.com/compute/cudnn/redist/redistrib_9.0.0.json",
   ],
}

cuda_json_init_repository(
   cuda_json_dict = _CUDA_JSON_DICT,
   cudnn_json_dict = _CUDNN_JSON_DICT,
)

    अगर JSON फ़ाइलों में डिस्ट्रिब्यूशन के रिलेटिव पाथ शामिल हैं, तो पाथ प्रीफ़िक्स को cuda_redist_init_repositories() और cudnn_redist_init_repository() कॉल में अपडेट किया जाना चाहिए. उदाहरण

    cuda_redist_init_repositories(
   cuda_redistributions = CUDA_REDISTRIBUTIONS,
   cuda_redist_path_prefix = "file:///usr/Downloads/dists/",
)

कस्टम CUDA/CUDNN डिस्ट्रिब्यूशन

इस विकल्प की मदद से, Google के एमएल प्रोजेक्ट में CUDA/CUDNN की कुछ डिपेंडेंसी के लिए, कस्टम डिस्ट्रिब्यूशन का इस्तेमाल किया जा सकता है.

  1. XLA पर निर्भर डाउनस्ट्रीम प्रोजेक्ट में, नीचे दी गई लाइनें हटाएं:

    <...>
   "CUDA_REDIST_JSON_DICT",
<...>
   "CUDNN_REDIST_JSON_DICT",
<...>

cuda_json_init_repository(
   cuda_json_dict = CUDA_REDIST_JSON_DICT,
   cudnn_json_dict = CUDNN_REDIST_JSON_DICT,
)

load(
   "@cuda_redist_json//:distributions.bzl",
   "CUDA_REDISTRIBUTIONS",
   "CUDNN_REDISTRIBUTIONS",
)

  2. उसी WORKSPACE फ़ाइल में, डिस्ट्रिब्यूशन पाथ वाली डिक्शनरी बनाएं.

    CUDA डिस्ट्रिब्यूशन वाली डिक्शनरी, नीचे दिए गए फ़ॉर्मैट में दिखती है:

    _CUSTOM_CUDA_REDISTRIBUTIONS = {
   "cuda_cccl": {
      "linux-x86_64": {
         "relative_path": "cuda_cccl-linux-x86_64-12.4.99-archive.tar.xz",
      },
      "linux-sbsa": {
         "relative_path": "cuda_cccl-linux-sbsa-12.4.99-archive.tar.xz",
      }
   },
}

    CUDNN वितरण वाले शब्दकोश में नीचे दिए गए प्रारूप का पालन दिखाया गया है:

    _CUSTOM_CUDNN_REDISTRIBUTIONS = {
   "cudnn": {
      "linux-x86_64": {
         "cuda12": {
         "relative_path": "cudnn/linux-x86_64/cudnn-linux-x86_64-9.0.0.312_cuda12-archive.tar.xz",
         }
      },
      "linux-sbsa": {
         "cuda12": {
         "relative_path": "cudnn/linux-sbsa/cudnn-linux-sbsa-9.0.0.312_cuda12-archive.tar.xz",
         }
      }
   }
}

    file:/// से शुरू होने वाले पूरे यूआरएल और ऐब्सलूट लोकल पाथ के लिए, relative_path फ़ील्ड को full_path से बदला जा सकता है.

  3. उसी WORKSPACE फ़ाइल में, बनाई गई डिक्शनरी को रिपॉज़िटरी के नियम में पास करें. अगर डिक्शनरी में डिस्ट्रिब्यूशन के रिलेटिव पाथ शामिल हैं, तो पाथ के प्रीफ़िक्स को cuda_redist_init_repositories() और cudnn_redist_init_repository() कॉल में अपडेट किया जाना चाहिए.

    cuda_redist_init_repositories(
   cuda_redistributions = _CUSTOM_CUDA_REDISTRIBUTIONS,
   cuda_redist_path_prefix = "file:///home/usr/Downloads/dists/",
)

cudnn_redist_init_repository(
   cudnn_redistributions = _CUSTOM_CUDNN_REDISTRIBUTIONS,
   cudnn_redist_path_prefix = "file:///home/usr/Downloads/dists/cudnn/"
)

    ऊपर दिए गए विकल्पों का कॉम्बिनेशन

नीचे दिए गए उदाहरण में, CUDA_REDIST_JSON_DICT को _CUDA_JSON_DICT में कस्टम JSON डेटा के साथ मर्ज किया गया है और CUDNN_REDIST_JSON_DICT को _CUDNN_JSON_DICT के साथ मर्ज किया गया है.

_CUDA_DIST_DICT में डिस्ट्रिब्यूशन डेटा, नतीजे के तौर पर मिलने वाली CUDA JSON फ़ाइल के कॉन्टेंट को बदल देता है. साथ ही, _CUDNN_DIST_DICT में डिस्ट्रिब्यूशन डेटा, नतीजे के तौर पर मिलने वाली CUDNN JSON फ़ाइल के कॉन्टेंट को बदल देता है. एनसीसीएल के पहियों का डेटा, CUDA_NCCL_WHEELS और _NCCL_WHEEL_DICT से मर्ज किया गया है.

load(
    //third_party/gpus/cuda/hermetic:cuda_redist_versions.bzl",
    "CUDA_REDIST_PATH_PREFIX",
    "CUDA_NCCL_WHEELS",
    "CUDA_REDIST_JSON_DICT",
    "CUDNN_REDIST_PATH_PREFIX",
    "CUDNN_REDIST_JSON_DICT",
)

_CUDA_JSON_DICT = {
   "12.4.0": [
      "file:///usr/Downloads/redistrib_12.4.0_updated.json",
   ],
}

_CUDNN_JSON_DICT = {
   "9.0.0": [
      "https://developer.download.nvidia.com/compute/cudnn/redist/redistrib_9.0.0.json",
   ],
}

cuda_json_init_repository(
   cuda_json_dict = CUDA_REDIST_JSON_DICT | _CUDA_JSON_DICT,
   cudnn_json_dict = CUDNN_REDIST_JSON_DICT | _CUDNN_JSON_DICT,
)

load(
   "@cuda_redist_json//:distributions.bzl",
   "CUDA_REDISTRIBUTIONS",
   "CUDNN_REDISTRIBUTIONS",
)

load(
   "//third_party/gpus/cuda/hermetic:cuda_redist_init_repositories.bzl",
   "cuda_redist_init_repositories",
   "cudnn_redist_init_repository",
)

_CUDA_DIST_DICT = {
   "cuda_cccl": {
      "linux-x86_64": {
            "relative_path": "cuda_cccl-linux-x86_64-12.4.99-archive.tar.xz",
      },
      "linux-sbsa": {
            "relative_path": "cuda_cccl-linux-sbsa-12.4.99-archive.tar.xz",
      },
   },
   "libcusolver": {
      "linux-x86_64": {
            "full_path": "file:///usr/Downloads/dists/libcusolver-linux-x86_64-11.6.0.99-archive.tar.xz",
      },
      "linux-sbsa": {
         "relative_path": "libcusolver-linux-sbsa-11.6.0.99-archive.tar.xz",
      },
   },
}

_CUDNN_DIST_DICT = {
   "cudnn": {
      "linux-x86_64": {
            "cuda12": {
               "relative_path": "cudnn-linux-x86_64-9.0.0.312_cuda12-archive.tar.xz",
            },
      },
      "linux-sbsa": {
            "cuda12": {
               "relative_path": "cudnn-linux-sbsa-9.0.0.312_cuda12-archive.tar.xz",
            },
      },
   },
}

cudnn_redist_init_repositories(
   cuda_redistributions = CUDA_REDISTRIBUTIONS | _CUDA_DIST_DICT,
   cuda_redist_path_prefix = "file:///usr/Downloads/dists/",
)

cudnn_redist_init_repository(
   cudnn_redistributions = CUDNN_REDISTRIBUTIONS | _CUDNN_DIST_DICT,
   cudnn_redist_path_prefix = "file:///usr/Downloads/dists/cudnn/"
)

load(
    "//third_party/nccl/hermetic:nccl_redist_init_repository.bzl",
    "nccl_redist_init_repository",
)

_NCCL_WHEEL_DICT = {
   "12.4.0": {
      "x86_64-unknown-linux-gnu": {
            "url": "https://files.pythonhosted.org/packages/38/00/d0d4e48aef772ad5aebcf70b73028f88db6e5640b36c38e90445b7a57c45/nvidia_nccl_cu12-2.19.3-py3-none-manylinux1_x86_64.whl",
      },
   },
}

nccl_redist_init_repository(
   cuda_nccl_wheels = CUDA_NCCL_WHEELS | _NCCL_WHEEL_DICT,
)

अब काम नहीं करता: CUDA/CUDNN का गैर-हर्मेटिक इस्तेमाल

हालांकि, नॉन-हर्मेटिक CUDA/CUDNN का इस्तेमाल अब नहीं किया जा सकता, लेकिन इसका इस्तेमाल उन कुछ प्रयोगों के लिए किया जा सकता है जो फ़िलहाल आधिकारिक तौर पर काम नहीं करते. उदाहरण के लिए, CUDA की मदद से Windows पर वेहिकल बनाना.

Google के एमएल प्रोजेक्ट में, स्थानीय तौर पर इंस्टॉल किए गए नॉन-हर्मेटिक CUDA का इस्तेमाल करने का तरीका यहां बताया गया है:

  1. XLA पर निर्भर प्रोजेक्ट की WORKSPACE फ़ाइल से, हेर्मेटिक CUDA रिपॉज़िटरी के नियमों को कॉल करने वाले निर्देश मिटाएं.

  2. WORKSPACE फ़ाइल में सबसे नीचे, नॉन-हर्मेटिक CUDA रिपॉज़िटरी के नियमों के लिए कॉल जोड़ें.

    XLA और JAX के लिए:

    load("@tsl//third_party/gpus:cuda_configure.bzl", "cuda_configure")
cuda_configure(name = "local_config_cuda")
load("@tsl//third_party/nccl:nccl_configure.bzl", "nccl_configure")
nccl_configure(name = "local_config_nccl")

    Tensorflow के लिए:

    load("@local_tsl//third_party/gpus:cuda_configure.bzl", "cuda_configure")
cuda_configure(name = "local_config_cuda")
load("@local_tsl//third_party/nccl:nccl_configure.bzl", "nccl_configure")
nccl_configure(name = "local_config_nccl")

  3. नीचे दिए गए एनवायरमेंट वैरिएबल को सीधे अपने शेल या .bazelrc फ़ाइल में सेट करें:

    build:cuda --action_env=TF_CUDA_VERSION=<locally installed cuda version>
build:cuda --action_env=TF_CUDNN_VERSION=<locally installed cudnn version>
build:cuda --action_env=TF_CUDA_COMPUTE_CAPABILITIES=<CUDA compute capabilities>
build:cuda --action_env=LD_LIBRARY_PATH=<CUDA/CUDNN libraries folder locations divided by “:” sign>
build:cuda --action_env=CUDA_TOOLKIT_PATH=<preinstalled CUDA folder location>
build:cuda --action_env=TF_CUDA_PATHS=<preinstalled CUDA/CUDNN folder locations divided by “,” sign>
build:cuda --action_env=NCCL_INSTALL_PATH=<preinstalled NCCL library folder location>

    ध्यान दें कि TF_CUDA_VERSION और TF_CUDNN_VERSION में सिर्फ़ मुख्य और छोटे वर्शन होने चाहिए. उदाहरण के लिए, CUDA के लिए 12.3 और CUDNN के लिए 9.1.

  4. अब स्थानीय तौर पर इंस्टॉल किए गए CUDA और CUDNN का इस्तेमाल करने के लिए, bazel कमांड चलाया जा सकता है.

    XLA के लिए, कमांड के विकल्पों में कोई बदलाव करने की ज़रूरत नहीं है.

    JAX के लिए, Bazel कमांड के विकल्पों में --override_repository=tsl=<tsl_path> फ़्लैग का इस्तेमाल करें.

    Tensorflow के लिए, बैजल कमांड विकल्पों में --override_repository=local_tsl=<tsl_path> फ़्लैग का इस्तेमाल करें.