सोर्स से बनाएं

स्रोत से TensorFlow pip पैकेज बनाएं और इसे Ubuntu Linux और macOS पर इंस्टॉल करें। हालांकि ये निर्देश अन्य सिस्टमों पर भी काम कर सकते हैं, लेकिन इनका परीक्षण और समर्थन केवल Ubuntu और macOS के लिए ही किया गया है।

Linux और macOS के लिए सेटअप

अपने डेवलपमेंट एनवायरनमेंट को कॉन्फ़िगर करने के लिए निम्नलिखित बिल्ड टूल्स इंस्टॉल करें।

पाइथन और टेन्सरफ्लो पैकेज की आवश्यक शर्तें इंस्टॉल करें।

sudo apt install python3-dev python3-pip

brew install python

TensorFlow pip पैकेज की निर्भरताओं को इंस्टॉल करें (यदि वर्चुअल वातावरण का उपयोग कर रहे हैं, तो --user तर्क को छोड़ दें):

pip install -U --user pip

बेज़ेल इंस्टॉल करें

TensorFlow को बिल्ड करने के लिए, आपको Bazel इंस्टॉल करना होगा। Bazelisk, Bazel को इंस्टॉल करने का एक आसान तरीका है और यह TensorFlow के लिए सही Bazel वर्जन को अपने आप डाउनलोड कर लेता है। आसानी के लिए, Bazelisk को अपने PATH में bazel एक्जीक्यूटेबल के रूप में जोड़ें।

यदि Bazelisk उपलब्ध नहीं है, तो आप Bazel को मैन्युअल रूप से इंस्टॉल कर सकते हैं। TensorFlow की .bazelversion फ़ाइल से सही Bazel संस्करण इंस्टॉल करना सुनिश्चित करें।

Clang इंस्टॉल करें (अनुशंसित, केवल Linux के लिए)

क्लैंग एक C/C++/Objective-C कंपाइलर है जिसे LLVM पर आधारित C++ में कंपाइल किया जाता है। TensorFlow 2.13 से TensorFlow को बिल्ड करने के लिए यह डिफ़ॉल्ट कंपाइलर है। वर्तमान में समर्थित संस्करण LLVM/Clang 17 है।

LLVM डेबियन/उबंटू नाइटली पैकेज स्वचालित इंस्टॉलेशन स्क्रिप्ट और लिनक्स पर मैन्युअल इंस्टॉलेशन के लिए पैकेज प्रदान करते हैं। यदि आप अपने पैकेज स्रोतों में मैन्युअल रूप से llvm apt रिपॉजिटरी जोड़ते हैं, तो सुनिश्चित करें कि आप निम्न कमांड चलाएँ:

sudo apt-get update && sudo apt-get install -y llvm-17 clang-17

अब इस मामले में /usr/lib/llvm-17/bin/clang क्लैंग का वास्तविक पथ है।

वैकल्पिक रूप से, आप पहले से निर्मित Clang + LLVM 17 को डाउनलोड और अनपैक कर सकते हैं।

नीचे दिए गए उदाहरण में बताया गया है कि आप डाउनलोड किए गए Clang + LLVM 17 बाइनरी को डेबियन/उबंटू ऑपरेटिंग सिस्टम पर कैसे सेट अप कर सकते हैं:

1. वांछित डायरेक्टरी में जाएं: cd <desired directory>

2. एक आर्काइव फ़ाइल लोड करें और निकालें...(आपके आर्किटेक्चर के अनुसार):

   wget https://github.com/llvm/llvm-project/releases/download/llvmorg-17.0.2/clang+llvm-17.0.2-x86_64-linux-gnu-ubuntu-22.04.tar.xz
   
   tar -xvf clang+llvm-17.0.2-x86_64-linux-gnu-ubuntu-22.04.tar.xz
   

3. निकाले गए कंटेंट्स (डायरेक्टरी और फ़ाइलें) को /usr में कॉपी करें (आपको sudo परमिशन की आवश्यकता हो सकती है, और सही डायरेक्टरी डिस्ट्रीब्यूशन के अनुसार अलग-अलग हो सकती है)। इससे Clang और LLVM इंस्टॉल हो जाते हैं और पाथ में जुड़ जाते हैं। आपको कुछ भी बदलने की आवश्यकता नहीं होगी, सिवाय इसके कि यदि आपके पास पहले से कोई इंस्टॉलेशन है, तो आपको फ़ाइलों को बदलना होगा:

   cp -r clang+llvm-17.0.2-x86_64-linux-gnu-ubuntu-22.04/* /usr

4. प्राप्त क्लैंग + एलएलवीएम 17 बाइनरी के संस्करण की जाँच करें:

   clang --version

5. अब /usr/bin/clang आपके नए क्लैंग का वास्तविक पथ है। आप ./configure स्क्रिप्ट चला सकते हैं या मैन्युअल रूप से CC और BAZEL_COMPILER पर्यावरण चरों को इस पथ पर सेट कर सकते हैं।

GPU सपोर्ट इंस्टॉल करें (वैकल्पिक, केवल Linux के लिए)

macOS के लिए GPU सपोर्ट उपलब्ध नहीं है।

GPU पर TensorFlow चलाने के लिए आवश्यक ड्राइवर और अतिरिक्त सॉफ़्टवेयर इंस्टॉल करने के लिए GPU सपोर्ट गाइड पढ़ें।

TensorFlow का सोर्स कोड डाउनलोड करें

TensorFlow रिपॉजिटरी को क्लोन करने के लिए Git का उपयोग करें:

git clone https://github.com/tensorflow/tensorflow.git
cd tensorflow

रिपॉजिटरी डिफ़ॉल्ट रूप से master डेवलपमेंट ब्रांच पर सेट होती है। आप बिल्ड करने के लिए रिलीज़ ब्रांच भी चेकआउट कर सकते हैं:

git checkout branch_name  # r2.2, r2.3, etc.

बिल्ड को कॉन्फ़िगर करें

TensorFlow बिल्ड को रिपॉजिटरी की रूट डायरेक्टरी में मौजूद .bazelrc फ़ाइल द्वारा कॉन्फ़िगर किया जाता है। सामान्य सेटिंग्स को समायोजित करने के लिए ./configure या ./configure.py स्क्रिप्ट का उपयोग किया जा सकता है।

कृपया रिपॉजिटरी के रूट डायरेक्टरी से ./configure स्क्रिप्ट चलाएँ। यह स्क्रिप्ट आपसे TensorFlow डिपेंडेंसी की लोकेशन पूछेगी और अतिरिक्त बिल्ड कॉन्फ़िगरेशन विकल्प (उदाहरण के लिए, कंपाइलर फ़्लैग) भी पूछेगी। विवरण के लिए सैंपल सेशन सेक्शन देखें।

./configure

इस स्क्रिप्ट का एक पायथन संस्करण भी है, ./configure.py । यदि आप वर्चुअल एनवायरनमेंट का उपयोग कर रहे हैं, तो python configure.py एनवायरनमेंट के अंदर के पाथ को प्राथमिकता देता है, जबकि ./configure एनवायरनमेंट के बाहर के पाथ को प्राथमिकता देता है। दोनों ही मामलों में आप डिफ़ॉल्ट सेटिंग बदल सकते हैं।

नमूना सत्र

नीचे ./configure स्क्रिप्ट का एक नमूना दिखाया गया है (आपके सत्र में यह भिन्न हो सकता है):

./configure
You have bazel 6.1.0 installed.
Please specify the location of python. [Default is /Library/Frameworks/Python.framework/Versions/3.9/bin/python3]: 


Found possible Python library paths:
  /Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages
Please input the desired Python library path to use.  Default is [/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages]

Do you wish to build TensorFlow with ROCm support? [y/N]:
No ROCm support will be enabled for TensorFlow.

Do you wish to build TensorFlow with CUDA support? [y/N]:
No CUDA support will be enabled for TensorFlow.

Do you want to use Clang to build TensorFlow? [Y/n]:
Clang will be used to compile TensorFlow.

Please specify the path to clang executable. [Default is /usr/lib/llvm-16/bin/clang]:

You have Clang 16.0.4 installed.

Please specify optimization flags to use during compilation when bazel option "--config=opt" is specified [Default is -Wno-sign-compare]:


Would you like to interactively configure ./WORKSPACE for Android builds? [y/N]: n
Not configuring the WORKSPACE for Android builds.

Do you wish to build TensorFlow with iOS support? [y/N]: n
No iOS support will be enabled for TensorFlow.

Preconfigured Bazel build configs. You can use any of the below by adding "--config=<>" to your build command. See .bazelrc for more details.
    --config=mkl            # Build with MKL support.
    --config=mkl_aarch64    # Build with oneDNN and Compute Library for the Arm Architecture (ACL).
    --config=monolithic     # Config for mostly static monolithic build.
    --config=numa           # Build with NUMA support.
    --config=dynamic_kernels    # (Experimental) Build kernels into separate shared objects.
    --config=v1             # Build with TensorFlow 1 API instead of TF 2 API.
Preconfigured Bazel build configs to DISABLE default on features:
    --config=nogcp          # Disable GCP support.
    --config=nonccl         # Disable NVIDIA NCCL support.

कॉन्फ़िगरेशन विकल्प

जीपीयू समर्थन

v.2.18.0 से

GPU सपोर्ट के लिए, कॉन्फ़िगरेशन के दौरान cuda=Y सेट करें और यदि आवश्यक हो तो CUDA और cuDNN के संस्करण निर्दिष्ट करें। Bazel स्वचालित रूप से CUDA और CUDNN पैकेज डाउनलोड करेगा या यदि आवश्यक हो तो स्थानीय फ़ाइल सिस्टम पर CUDA/CUDNN/NCCL पुनर्वितरणों को इंगित करेगा।

v.2.18.0 से पहले

GPU सपोर्ट के लिए, कॉन्फ़िगरेशन के दौरान cuda=Y सेट करें और CUDA और cuDNN के वर्शन निर्दिष्ट करें। यदि आपके सिस्टम में CUDA या cuDNN के कई वर्शन इंस्टॉल हैं, तो डिफ़ॉल्ट वर्शन पर निर्भर रहने के बजाय स्पष्ट रूप से वर्शन सेट करें। ./configure आपके सिस्टम की CUDA लाइब्रेरीज़ के लिए सिंबॉलिक लिंक बनाता है—इसलिए यदि आप अपने CUDA लाइब्रेरी पाथ को अपडेट करते हैं, तो बिल्ड करने से पहले इस कॉन्फ़िगरेशन चरण को फिर से चलाना होगा।

अनुकूलन

संकलन अनुकूलन फ़्लैग के लिए, डिफ़ॉल्ट ( -march=native ) आपके मशीन के CPU प्रकार के लिए जेनरेट किए गए कोड को अनुकूलित करता है। हालाँकि, यदि आप किसी भिन्न CPU प्रकार के लिए TensorFlow बना रहे हैं, तो अधिक विशिष्ट अनुकूलन फ़्लैग का उपयोग करें। उदाहरणों के लिए GCC मैनुअल देखें।

पूर्व-निर्धारित कॉन्फ़िगरेशन

कुछ पूर्व-निर्धारित बिल्ड कॉन्फ़िगरेशन उपलब्ध हैं जिन्हें bazel build कमांड में जोड़ा जा सकता है, उदाहरण के लिए:

• --config=dbg — डीबग जानकारी के साथ बिल्ड करें। विवरण के लिए CONTRIBUTING.md देखें।
• --config=mkl —Intel® MKL-DNN के लिए समर्थन।
• --config=monolithic — मुख्य रूप से स्थिर, मोनोलिथिक बिल्ड के लिए कॉन्फ़िगरेशन।

pip पैकेज को बिल्ड और इंस्टॉल करें

बेज़ेल बिल्ड विकल्प

बिल्ड विकल्पों के लिए बेज़ेल कमांड-लाइन संदर्भ देखें।

स्रोत से TensorFlow का निर्माण करने में बहुत अधिक RAM का उपयोग हो सकता है। यदि आपके सिस्टम में मेमोरी की कमी है, तो Bazel के RAM उपयोग को इस प्रकार सीमित करें: --local_ram_resources=2048 ।

आधिकारिक TensorFlow पैकेज Clang टूलचेन के साथ बनाए गए हैं जो manylinux2014 पैकेज मानक का अनुपालन करता है।

पैकेज बनाएं

pip पैकेज बनाने के लिए, आपको --repo_env=WHEEL_NAME फ़्लैग निर्दिष्ट करना होगा। दिए गए नाम के आधार पर, पैकेज बनाया जाएगा, उदाहरण के लिए:

टेन्सरफ्लो सीपीयू पैकेज बनाने के लिए:

bazel build //tensorflow/tools/pip_package:wheel --repo_env=USE_PYWRAP_RULES=1 --repo_env=WHEEL_NAME=tensorflow_cpu

टेन्सरफ्लो जीपीयू पैकेज बनाने के लिए:

bazel build //tensorflow/tools/pip_package:wheel --repo_env=USE_PYWRAP_RULES=1 --repo_env=WHEEL_NAME=tensorflow --config=cuda --config=cuda_wheel

टेन्सरफ्लो टीपीयू पैकेज बनाने के लिए:

bazel build //tensorflow/tools/pip_package:wheel --repo_env=USE_PYWRAP_RULES=1 --repo_env=WHEEL_NAME=tensorflow_tpu --config=tpu

नाइटली पैकेज बनाने के लिए, tensorflow के स्थान पर tf_nightly सेट करें, उदाहरण के लिए सीपीयू नाइटली पैकेज बनाने के लिए:

bazel build //tensorflow/tools/pip_package:wheel --repo_env=USE_PYWRAP_RULES=1 --repo_env=WHEEL_NAME=tf_nightly_cpu

परिणामस्वरूप, उत्पन्न पहिया निम्नलिखित स्थान पर स्थित होगा:

bazel-bin/tensorflow/tools/pip_package/wheel_house/

पैकेज इंस्टॉल करें

जनरेट की गई .whl फ़ाइल का फ़ाइलनाम TensorFlow संस्करण और आपके प्लेटफ़ॉर्म पर निर्भर करता है। पैकेज इंस्टॉल करने के लिए pip install उपयोग करें, उदाहरण के लिए:

pip install bazel-bin/tensorflow/tools/pip_package/wheel_house/tensorflow-version-tags.whl

डॉकर लिनक्स बिल्ड

TensorFlow के Docker डेवलपमेंट इमेज, Linux पैकेज को सोर्स से बिल्ड करने के लिए एक आसान एनवायरनमेंट सेटअप करने का तरीका हैं। इन इमेज में TensorFlow को बिल्ड करने के लिए आवश्यक सोर्स कोड और डिपेंडेंसी पहले से ही मौजूद होती हैं। इंस्टॉलेशन निर्देशों और उपलब्ध इमेज टैग की सूची के लिए TensorFlow Docker गाइड देखें।

सीपीयू केवल

निम्नलिखित उदाहरण नवीनतम TensorFlow स्रोत कोड से केवल CPU पर चलने वाला पैकेज बनाने के लिए :devel इमेज का उपयोग करता है। उपलब्ध TensorFlow -devel टैग के लिए Docker गाइड देखें।

नवीनतम डेवलपमेंट इमेज डाउनलोड करें और एक डॉकर कंटेनर शुरू करें जिसका उपयोग आप pip पैकेज बनाने के लिए करेंगे:

docker pull tensorflow/tensorflow:devel
docker run -it -w /tensorflow_src -v $PWD:/mnt -e HOST_PERMS="$(id -u):$(id -g)" \
    tensorflow/tensorflow:devel bash

git pull  # within the container, download the latest source code

उपरोक्त docker run कमांड /tensorflow_src डायरेक्टरी (स्रोत ट्री का रूट) में एक शेल शुरू करता है। यह होस्ट की वर्तमान डायरेक्टरी को कंटेनर की /mnt डायरेक्टरी में माउंट करता है, और होस्ट उपयोगकर्ता की जानकारी को एक पर्यावरण चर (अनुमतियों को सेट करने के लिए उपयोग किया जाता है - डॉकर इसे जटिल बना सकता है) के माध्यम से कंटेनर को पास करता है।

वैकल्पिक रूप से, किसी कंटेनर के भीतर TensorFlow की होस्ट कॉपी बनाने के लिए, होस्ट सोर्स ट्री को कंटेनर के /tensorflow डायरेक्टरी में माउंट करें:

docker run -it -w /tensorflow -v /path/to/tensorflow:/tensorflow -v $PWD:/mnt \
    -e HOST_PERMS="\\((id -u):\\)(id -g)" tensorflow/tensorflow:devel bash

सोर्स ट्री तैयार हो जाने के बाद, कंटेनर के वर्चुअल वातावरण के भीतर TensorFlow पैकेज बनाएं:

1. वैकल्पिक: बिल्ड को कॉन्फ़िगर करें—यह उपयोगकर्ता को बिल्ड कॉन्फ़िगरेशन प्रश्नों के उत्तर देने के लिए प्रेरित करता है।
2. pip पैकेज का निर्माण करें।
3. कंटेनर के बाहर फ़ाइल के स्वामित्व की अनुमतियों को समायोजित करें।

./configure  # if necessary


bazel build //tensorflow/tools/pip_package:wheel \
--repo_env=USE_PYWRAP_RULES=1 --repo_env=WHEEL_NAME=tensorflow_cpu --config=opt

`
chown $HOST_PERMS bazel-bin/tensorflow/tools/pip_package/wheel_house/tensorflow-version-tags.whl

कंटेनर के भीतर पैकेज को स्थापित करें और सत्यापित करें:

pip uninstall tensorflow  # remove current version

pip install bazel-bin/tensorflow/tools/pip_package/wheel_house/tensorflow-version-tags.whl
cd /tmp  # don't import from source directory
python -c "import tensorflow as tf; print(tf.__version__)"

आपके होस्ट मशीन पर, TensorFlow pip पैकेज वर्तमान डायरेक्टरी में है (होस्ट उपयोगकर्ता अनुमतियों के साथ) ./tensorflow- version - tags .whl

जीपीयू समर्थन

TensorFlow के लिए GPU सपोर्ट बनाने का सबसे आसान तरीका Docker है, क्योंकि होस्ट मशीन को केवल NVIDIA® ड्राइवर की आवश्यकता होती है ( NVIDIA® CUDA® टूलकिट को इंस्टॉल करने की आवश्यकता नहीं होती)। nvidia-docker (केवल Linux के लिए) सेट अप करने के लिए GPU सपोर्ट गाइड और TensorFlow Docker गाइड देखें।

निम्नलिखित उदाहरण TensorFlow :devel-gpu इमेज को डाउनलोड करता है और GPU-सक्षम कंटेनर को चलाने के लिए nvidia-docker उपयोग करता है। यह डेवलपमेंट इमेज GPU सपोर्ट के साथ pip पैकेज बनाने के लिए कॉन्फ़िगर की गई है:

docker pull tensorflow/tensorflow:devel-gpu
docker run --gpus all -it -w /tensorflow -v $PWD:/mnt -e HOST_PERMS="$(id -u):$(id -g)" \
    tensorflow/tensorflow:devel-gpu bash
git pull  # within the container, download the latest source code

फिर, कंटेनर के वर्चुअल वातावरण के भीतर, GPU सपोर्ट के साथ TensorFlow पैकेज बनाएं:

./configure  # if necessary


bazel build //tensorflow/tools/pip_package:wheel \
--repo_env=USE_PYWRAP_RULES=1 --repo_env=WHEEL_NAME=tensorflow --config=cuda \
--config=cuda_wheel --config=opt


chown $HOST_PERMS bazel-bin/tensorflow/tools/pip_package/wheel_house/tensorflow-version-tags.whl

कंटेनर के अंदर पैकेज को इंस्टॉल और वेरिफाई करें और जीपीयू की जांच करें:

pip uninstall tensorflow  # remove current version

pip install bazel-bin/tensorflow/tools/pip_package/wheel_house/tensorflow-version-tags.whl
cd /tmp  # don't import from source directory
python -c "import tensorflow as tf; print(\"Num GPUs Available: \", len(tf.config.list_physical_devices('GPU')))"

परीक्षणित बिल्ड कॉन्फ़िगरेशन

लिनक्स

CPU

जीपीयू

मैक ओएस

CPU

जीपीयू