สร้างจากซอร์ส

สร้างแพ็ก เกจ TensorFlow จากซอร์สโค้ดโดยใช้ pip และติดตั้งบน Ubuntu Linux และ macOS แม้ว่าคำแนะนำอาจใช้ได้กับระบบอื่นๆ แต่ได้รับการทดสอบและรองรับเฉพาะ Ubuntu และ macOS เท่านั้น

การตั้งค่าสำหรับ Linux และ macOS

ติดตั้งเครื่องมือสร้างต่อไปนี้เพื่อกำหนดค่าสภาพแวดล้อมการพัฒนาของคุณ

ติดตั้ง Python และแพ็คเกจที่จำเป็นของ TensorFlow

sudo apt install python3-dev python3-pip

brew install python

ติดตั้งแพ็คเกจ pip ที่จำเป็นสำหรับ TensorFlow (หากใช้สภาพแวดล้อมเสมือน ให้ละเว้นอาร์กิวเมนต์ --user ):

pip install -U --user pip

ติดตั้ง Bazel

ในการสร้าง TensorFlow คุณจะต้องติดตั้ง Bazel ก่อน Bazelisk เป็นวิธีที่ง่ายในการติดตั้ง Bazel และจะดาวน์โหลดเวอร์ชัน Bazel ที่ถูกต้องสำหรับ TensorFlow โดยอัตโนมัติ เพื่อความสะดวกในการใช้งาน ให้เพิ่ม Bazelisk เป็นไฟล์ปฏิบัติการ bazel ใน PATH ของคุณ

หาก Bazelisk ไม่พร้อมใช้งาน คุณสามารถ ติดตั้ง Bazel ด้วยตนเองได้ โปรดตรวจสอบให้แน่ใจว่าได้ติดตั้ง Bazel เวอร์ชันที่ถูกต้องจากไฟล์ . bazelversion ของ TensorFlow

ติดตั้ง Clang (แนะนำให้ติดตั้ง สำหรับ Linux เท่านั้น)

Clang เป็นคอมไพเลอร์สำหรับภาษา C/C++/Objective-C ที่คอมไพล์ด้วยภาษา C++ โดยใช้ LLVM เป็นพื้นฐาน เป็นคอมไพเลอร์เริ่มต้นสำหรับการสร้าง TensorFlow ตั้งแต่เวอร์ชัน 2.13 เป็นต้นไป เวอร์ชันที่รองรับในปัจจุบันคือ LLVM/Clang 17

แพ็คเกจ LLVM Debian/Ubuntu nightly มีสคริปต์การติดตั้งอัตโนมัติและแพ็คเกจสำหรับการติดตั้งด้วยตนเองบน Linux โปรดตรวจสอบให้แน่ใจว่าได้เรียกใช้คำสั่งต่อไปนี้หากคุณต้องการเพิ่มที่เก็บ apt ของ llvm ลงในแหล่งแพ็คเกจของคุณด้วยตนเอง:

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

ในกรณีนี้ /usr/lib/llvm-17/bin/clang คือเส้นทางจริงไปยัง clang

อีกทางเลือกหนึ่ง คุณสามารถดาวน์โหลดและแตกไฟล์ Clang + LLVM 17 ที่สร้างไว้ล่วงหน้าได้

ด้านล่างนี้คือตัวอย่างขั้นตอนที่คุณสามารถทำตามได้เพื่อติดตั้งไบนารี Clang + LLVM 17 ที่ดาวน์โหลดมาบนระบบปฏิบัติการ Debian/Ubuntu:

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 และเพิ่มลงใน PATH คุณไม่จำเป็นต้องแทนที่อะไร เว้นแต่ว่าคุณเคยติดตั้งไว้ก่อนหน้านี้แล้ว ในกรณีนั้น คุณควรแทนที่ไฟล์ต่างๆ:

   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

ใช้ Git เพื่อโคลน repository ของ TensorFlow :

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

โดยค่าเริ่มต้น repository จะใช้ branch master สำหรับการพัฒนา คุณสามารถเลือก branch release เพื่อสร้าง build ได้เช่นกัน:

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

กำหนดค่าการสร้าง

การตั้งค่าการสร้าง TensorFlow จะทำผ่านไฟล์ .bazelrc ที่อยู่ในไดเร็กทอรีหลักของ repository สามารถใช้สคริปต์ ./configure หรือ ./configure.py เพื่อปรับการตั้งค่าทั่วไปได้

โปรดเรียกใช้สคริปต์ ./configure จากไดเร็กทอรีหลักของที่เก็บโค้ด สคริปต์นี้จะแจ้งให้คุณระบุตำแหน่งของส่วนประกอบ TensorFlow และขอตัวเลือกการกำหนดค่าการสร้างเพิ่มเติม (เช่น แฟล็กคอมไพเลอร์) โปรดดูส่วนตัว อย่างการใช้งาน สำหรับรายละเอียดเพิ่มเติม

./configure

นอกจากนี้ยังมีสคริปต์เวอร์ชัน Python ด้วย คือ . ./configure.py หากใช้สภาพแวดล้อมเสมือน (virtual environment) 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 บนระบบไฟล์ในเครื่องหากจำเป็น

ก่อนเวอร์ชัน 2.18.0

สำหรับ การรองรับ GPU ให้ตั้งค่า cuda=Y ระหว่างการกำหนดค่า และระบุเวอร์ชันของ CUDA และ cuDNN หากระบบของคุณมี CUDA หรือ cuDNN หลายเวอร์ชันติดตั้งอยู่ ให้ตั้งค่าเวอร์ชันอย่างชัดเจนแทนที่จะใช้ค่าเริ่มต้น คำสั่ง . ./configure จะสร้างลิงก์สัญลักษณ์ไปยังไลบรารี CUDA ของระบบของคุณ ดังนั้นหากคุณอัปเดตเส้นทางไลบรารี CUDA คุณจะต้องเรียกใช้ขั้นตอนการกำหนดค่านี้อีกครั้งก่อนที่จะสร้างโปรเจกต์

การเพิ่มประสิทธิภาพ

สำหรับแฟล็กการเพิ่มประสิทธิภาพการคอมไพล์ ค่าเริ่มต้น ( -march=native ) จะเพิ่มประสิทธิภาพโค้ดที่สร้างขึ้นสำหรับประเภท CPU ของเครื่องของคุณ อย่างไรก็ตาม หากคุณกำลังสร้าง TensorFlow สำหรับประเภท CPU ที่แตกต่างกัน ควรพิจารณาใช้แฟล็กการเพิ่มประสิทธิภาพที่เฉพาะเจาะจงมากขึ้น ตรวจสอบ คู่มือ GCC สำหรับตัวอย่าง

การกำหนดค่าที่ตั้งไว้ล่วงหน้า

มีการตั้งค่าการสร้างที่กำหนดไว้ล่วงหน้าบางส่วนที่สามารถเพิ่มลงในคำสั่ง bazel build ได้ ตัวอย่างเช่น:

• --config=dbg —สร้างด้วยข้อมูลการดีบัก โปรดดูรายละเอียดเพิ่มเติม ใน CONTRIBUTING.md
• --config=mkl —รองรับ Intel® MKL-DNN
• --config=monolithic — การกำหนดค่าสำหรับการสร้างแบบโมโนลิธิกที่ส่วนใหญ่เป็นแบบคงที่

สร้างและติดตั้งแพ็คเกจ pip

ตัวเลือกการสร้าง Bazel

โปรดดู เอกสารอ้างอิงคำสั่งบรรทัดคำสั่ง ของ Bazel สำหรับ ตัวเลือกการสร้าง

การคอมไพล์ TensorFlow จากซอร์สโค้ดอาจใช้ RAM จำนวนมาก หากระบบของคุณมีหน่วยความจำจำกัด ให้จำกัดการใช้ RAM ของ Bazel ด้วยคำสั่ง: --local_ram_resources=2048

แพ็กเกจ TensorFlow อย่างเป็นทางการ สร้างขึ้นโดยใช้ชุดเครื่องมือ Clang ซึ่งเป็นไปตามมาตรฐานแพ็กเกจ manylinux2014

สร้างแพ็กเกจ

ในการสร้างแพ็คเกจ pip คุณต้องระบุแฟล็ก --repo_env=WHEEL_NAME โดยแพ็คเกจจะถูกสร้างขึ้นตามชื่อที่ระบุ เช่น:

วิธีการสร้างแพ็คเกจ TensorFlow สำหรับ CPU:

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

วิธีการสร้างแพ็คเกจ TensorFlow สำหรับ GPU:

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

วิธีการสร้างแพ็คเกจ TensorFlow TPU:

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

ในการสร้างแพ็กเกจ nightly ให้ตั้ง tf_nightly แทน tensorflow เช่น ในการสร้างแพ็กเกจ 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

การสร้าง Docker Linux

อิมเมจ Docker สำหรับการพัฒนาของ TensorFlow เป็นวิธีที่ง่ายในการตั้งค่าสภาพแวดล้อมเพื่อสร้างแพ็กเกจ Linux จากซอร์สโค้ด อิมเมจเหล่านี้มีซอร์สโค้ดและส่วนประกอบที่จำเป็นในการสร้าง TensorFlow อยู่แล้ว โปรดดู คู่มือ TensorFlow Docker สำหรับคำแนะนำในการติดตั้งและ รายการแท็กอิมเมจที่มีอยู่

ซีพียูเท่านั้น

ตัวอย่างต่อไปนี้ใช้ภาพ :devel เพื่อสร้างแพ็กเกจสำหรับใช้งานกับ CPU เท่านั้นจากซอร์สโค้ด TensorFlow เวอร์ชันล่าสุด โปรดตรวจสอบ คู่มือ Docker สำหรับแท็ก -devel ของ TensorFlow ที่ใช้งานได้

ดาวน์โหลดอิมเมจสำหรับการพัฒนาเวอร์ชันล่าสุดและเริ่มต้นคอนเทนเนอร์ 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. สร้างแพ็กเกจ 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

การรองรับ GPU

Docker เป็นวิธีที่ง่ายที่สุดในการสร้างการรองรับ GPU สำหรับ TensorFlow เนื่องจากเครื่อง โฮสต์ ต้องการเพียง ไดรเวอร์ NVIDIA® เท่านั้น (ไม่จำเป็นต้องติดตั้ง NVIDIA® CUDA® Toolkit ) โปรดดู คู่มือการรองรับ GPU และ คู่มือ TensorFlow Docker เพื่อตั้งค่า nvidia-docker (สำหรับ Linux เท่านั้น)

ตัวอย่างต่อไปนี้ดาวน์โหลดอิมเมจ TensorFlow :devel-gpu และใช้ nvidia-docker เพื่อรันคอนเทนเนอร์ที่เปิดใช้งาน GPU อิมเมจสำหรับการพัฒนานี้ได้รับการกำหนดค่าให้สร้างแพ็คเกจ pip ที่รองรับ GPU:

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

จากนั้น ภายในสภาพแวดล้อมเสมือนของคอนเทนเนอร์ ให้สร้างแพ็กเกจ TensorFlow ที่รองรับ GPU:

./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')))"

การกำหนดค่าการสร้างที่ผ่านการทดสอบ

ลินุกซ์

ซีพียู

จีพี

ระบบปฏิบัติการ macOS

ซีพียู

จีพี