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

संग्रह की मदद से व्यवस्थित रहें अपनी प्राथमिकताओं के आधार पर, कॉन्टेंट को सेव करें और कैटगरी में बांटें.

Hermetic CUDA, उपयोगकर्ता के डिवाइस पर इंस्टॉल किए गए CUDA के बजाय, CUDA के डाउनलोड किए जा सकने वाले किसी खास वर्शन का इस्तेमाल करता है. Bazel, CUDA, CUDNN, और NCCL डिस्ट्रिब्यूशन डाउनलोड करेगा. इसके बाद, Bazel के अलग-अलग टारगेट में, CUDA लाइब्रेरी और टूल का इस्तेमाल डिपेंडेंसी के तौर पर करेगा. इससे, Google के एमएल प्रोजेक्ट और काम करने वाले 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/CUDNN रिपॉज़िटरी के नियम, TF_CUDA_VERSION और TF_CUDNN_VERSION एनवायरमेंट वैरिएबल की वैल्यू खोजेंगे. इसे, पुराने सिस्टम के साथ काम करने के लिए बनाया गया है.

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

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

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

   load(
      "@xla//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(
      "@xla//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(
      "@xla//third_party/gpus/cuda/hermetic:cuda_configure.bzl",
      "cuda_configure",
   )
   
   cuda_configure(name = "local_config_cuda")
   
   load(
      "@xla//third_party/nccl/hermetic:nccl_redist_init_repository.bzl",
      "nccl_redist_init_repository",
   )
   
   nccl_redist_init_repository()
   
   load(
      "@xla//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. टेस्ट के दौरान या bazel के ज़रिए बाइनरी चलाते समय, हेर्मेटिक CUDA को चालू करने के लिए, अपने bazel कमांड में --@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 फ़ोरवर्ड कम्पैटिबिलिटी मोड लागू करने के लिए, अपने bazel कमांड में --@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 का भी इस्तेमाल करेंगे. इससे पुराने Kernel Mode Driver का इस्तेमाल करते समय, CUDA टूलकिट की नई सुविधाओं को चालू करने की अनुमति मिलती है.

   फ़ॉरवर्ड कम्पैटिबिलिटी मोड को सिर्फ़ तब लागू किया जाना चाहिए, जब यह सही हो - ज़्यादा जानकारी के लिए, 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 को अपडेट करें.

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

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

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

लोकल फ़ाइल सिस्टम पर 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",
            }
         }
      }
   }
   

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

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("@xla//third_party/gpus:cuda_configure.bzl", "cuda_configure")
   cuda_configure(name = "local_config_cuda")
   load("@xla//third_party/nccl:nccl_configure.bzl", "nccl_configure")
   nccl_configure(name = "local_config_nccl")
   

   Tensorflow के लिए:

   load("@local_xla//third_party/gpus:cuda_configure.bzl", "cuda_configure")
   cuda_configure(name = "local_config_cuda")
   load("@local_xla//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 के लिए, Bazel कमांड के विकल्पों में --override_repository=local_tsl=<tsl_path> फ़्लैग का इस्तेमाल करें.