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

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

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

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

पायथन और TensorFlow पैकेज निर्भरताएँ स्थापित करें

sudo apt install python3-dev python3-pip

brew install python

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

pip install -U --user pip

बेज़ेल स्थापित करें

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

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

Clang स्थापित करें (अनुशंसित, केवल Linux)

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

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

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

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

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

नीचे कुछ चरणों का उदाहरण दिया गया है जिन्हें आप Debian/Ubuntu ऑपरेटिंग सिस्टम पर डाउनलोड किए गए 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. प्राप्त Clang + LLVM 17 बाइनरी संस्करण की जाँच करें:

   clang --version

5. अब चूँकि /usr/bin/clang आपके नए 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.

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

GPU समर्थन

संस्करण 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 —अधिकतर स्थिर, मोनोलिथिक बिल्ड के लिए कॉन्फ़िगरेशन।

पाइप पैकेज बनाएँ और स्थापित करें

बेज़ेल निर्माण विकल्प

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

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

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

पैकेज बनाएँ

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

टेंसरफ़्लो CPU पैकेज बनाने के लिए:

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

टेंसरफ़्लो GPU पैकेज बनाने के लिए:

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

टेंसरफ़्लो TPU पैकेज बनाने के लिए:

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

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

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 गाइड देखें।

नवीनतम विकास छवि डाउनलोड करें और एक 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 निर्देशिका में माउंट करता है, और होस्ट उपयोगकर्ता की जानकारी को एक पर्यावरण चर (अनुमतियों को सेट करने के लिए उपयोग किया जाता है—Docker इसे मुश्किल बना सकता है) के माध्यम से कंटेनर तक पहुँचाता है।

वैकल्पिक रूप से, किसी कंटेनर के भीतर 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. पाइप पैकेज बनाएं.
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

GPU समर्थन

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

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

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

जीपीयू