เพิ่มประสิทธิภาพ TensorFlow โดยใช้ Profiler

คู่มือนี้สาธิตวิธีการใช้เครื่องมือที่มีอยู่ใน TensorFlow Profiler เพื่อติดตามประสิทธิภาพของโมเดล TensorFlow ของคุณ คุณจะได้เรียนรู้วิธีทำความเข้าใจว่าโมเดลของคุณทำงานอย่างไรบนโฮสต์ (CPU) อุปกรณ์ (GPU) หรือทั้งโฮสต์และอุปกรณ์ร่วมกัน

การทำโปรไฟล์ช่วยให้เข้าใจการใช้ทรัพยากรฮาร์ดแวร์ (เวลาและหน่วยความจำ) ของการดำเนินการ TensorFlow (ops) ต่างๆ ในแบบจำลองของคุณ และแก้ไขคอขวดด้านประสิทธิภาพ และทำให้โมเดลดำเนินการเร็วขึ้นในที่สุด

คู่มือนี้จะแนะนำคุณเกี่ยวกับวิธีการติดตั้ง Profiler เครื่องมือต่างๆ ที่มี โหมดต่างๆ ของวิธีที่ Profiler รวบรวมข้อมูลประสิทธิภาพ และแนวทางปฏิบัติที่ดีที่สุดบางส่วนที่แนะนำเพื่อปรับประสิทธิภาพของโมเดลให้เหมาะสมที่สุด

หากคุณต้องการรายละเอียดผลการดำเนินงานรูปแบบของคุณเกี่ยวกับ Cloud TPUs โปรดดูที่ คู่มือเมฆ TPU

ติดตั้งข้อกำหนดเบื้องต้นของ Profiler และ GPU

ติดตั้งปลั๊กอิน Profiler สำหรับ TensorBoard ด้วย pip โปรดทราบว่า Profiler ต้องใช้ TensorFlow และ TensorBoard เวอร์ชันล่าสุด (>=2.2)

pip install -U tensorboard_plugin_profile

ในการสร้างโปรไฟล์บน GPU คุณต้อง:

  1. พบไดรเวอร์NVIDIA® GPU และCUDA® Toolkit ข้อกำหนดที่ระบุไว้ใน TensorFlow GPU ต้องการซอฟต์แวร์สนับสนุน
  2. ตรวจสอบให้แน่ใจ NVIDIA®CUDA® Profiling เครื่องมืออินเตอร์เฟซ (CUPTI) ที่มีอยู่บนเส้นทางที่:

    /sbin/ldconfig -N -v $(sed 's/:/ /g' <<< $LD_LIBRARY_PATH) | \
    grep libcupti
    

หากคุณไม่ได้มี CUPTI บนเส้นทางที่ย่อหน้าไดเรกทอรีการติดตั้งไปยัง $LD_LIBRARY_PATH ตัวแปรสภาพแวดล้อมโดยการทำงาน:

export LD_LIBRARY_PATH=/usr/local/cuda/extras/CUPTI/lib64:$LD_LIBRARY_PATH

จากนั้นเรียกใช้ ldconfig คำสั่งดังกล่าวอีกครั้งเพื่อตรวจสอบว่าห้องสมุด CUPTI ที่พบ

แก้ไขปัญหาสิทธิพิเศษ

เมื่อคุณเรียก profiling กับCUDA®เครื่องมือในสภาพแวดล้อมที่หางหรือบน Linux คุณอาจพบปัญหาที่เกี่ยวข้องกับสิทธิพิเศษ CUPTI ไม่เพียงพอ ( CUPTI_ERROR_INSUFFICIENT_PRIVILEGES ) ไปที่ เอกสารของนักพัฒนาซอฟต์แวร์ NVIDIA เพื่อเรียนรู้เพิ่มเติมเกี่ยวกับวิธีการที่คุณสามารถแก้ไขปัญหาเหล่านี้บนลินุกซ์

ในการแก้ไขปัญหาสิทธิ์ CUPTI ในสภาพแวดล้อม Docker ให้เรียกใช้

docker run option '--privileged=true'

เครื่องมือสร้างโปรไฟล์

เข้า Profiler จากรายละเอียดแท็บใน TensorBoard ซึ่งจะปรากฏเฉพาะหลังจากที่คุณได้บันทึกข้อมูลแบบบาง

Profiler มีเครื่องมือให้เลือกมากมายเพื่อช่วยในการวิเคราะห์ประสิทธิภาพ:

  • หน้าภาพรวม
  • ตัววิเคราะห์ไปป์ไลน์อินพุต
  • สถิติเทนเซอร์โฟลว์
  • ตัวแสดงการติดตาม
  • สถิติเคอร์เนล GPU
  • เครื่องมือโปรไฟล์หน่วยความจำ
  • Pod Viewer

หน้าภาพรวม

หน้าภาพรวมให้มุมมองระดับบนสุดว่าโมเดลของคุณทำงานอย่างไรในระหว่างการรันโปรไฟล์ หน้านี้จะแสดงหน้าภาพรวมโดยรวมสำหรับโฮสต์และอุปกรณ์ทั้งหมดของคุณ และคำแนะนำบางประการในการปรับปรุงประสิทธิภาพการฝึกโมเดลของคุณ คุณยังสามารถเลือกโฮสต์แต่ละรายในรายการดรอปดาวน์ โฮสต์

หน้าภาพรวมแสดงข้อมูลดังนี้:

ภาพ

  • สรุปผลการดำเนินงาน: แสดงสรุประดับสูงของประสิทธิภาพการทำงานรูปแบบของคุณ สรุปผลการปฏิบัติงานมีสองส่วน:

    1. การแบ่งขั้นตอนเวลา: แบ่งเวลาขั้นตอนเฉลี่ยออกเป็นหลายประเภทที่ใช้เวลา:

      • การรวบรวม: เวลาที่ใช้ในการรวบรวมเมล็ด
      • อินพุต: เวลาที่ใช้ในการอ่านข้อมูลอินพุต
      • เอาต์พุต: เวลาที่ใช้ในการอ่านข้อมูลเอาต์พุต
      • การเปิดเคอร์เนล: เวลาที่โฮสต์ใช้ในการเปิดเมล็ด kernel
      • เวลาประมวลผลโฮสต์..
      • เวลาการสื่อสารระหว่างอุปกรณ์กับอุปกรณ์
      • เวลาคำนวณในอุปกรณ์
      • อื่นๆ ทั้งหมด รวมถึงค่าใช้จ่าย Python
    2. ความแม่นยำในการประมวลผลของอุปกรณ์ - รายงานเปอร์เซ็นต์ของเวลาในการประมวลผลของอุปกรณ์ที่ใช้การคำนวณแบบ 16 และ 32 บิต

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

  • การดำเนินงานสูงสุด 10 TensorFlow บนอุปกรณ์ (เช่น GPU): แสดงปฏิบัติการบนอุปกรณ์ที่วิ่งที่ยาวที่สุด

    แต่ละแถวจะแสดงเวลาของตนเองของ op (เป็นเปอร์เซ็นต์ของเวลาที่ใช้โดย ops ทั้งหมด) เวลาสะสม หมวดหมู่ และชื่อ

  • Run สิ่งแวดล้อม: แสดงสรุประดับสูงของสภาพแวดล้อมของรูปแบบการทำงานรวมไปถึง:

    • จำนวนโฮสต์ที่ใช้
    • ประเภทอุปกรณ์ (GPU/TPU)
    • จำนวนคอร์ของอุปกรณ์
  • คำแนะนำสำหรับขั้นตอนถัดไป: รายงานเมื่อรูปแบบการป้อนข้อมูลจะถูกผูกไว้และแนะนำเครื่องมือที่คุณสามารถใช้ในการค้นหาและรูปแบบการแก้ปัญหาคอขวดประสิทธิภาพ

เครื่องวิเคราะห์ไปป์ไลน์อินพุต

เมื่อโปรแกรม TensorFlow อ่านข้อมูลจากไฟล์ โปรแกรม TensorFlow จะเริ่มต้นที่ด้านบนสุดของกราฟ TensorFlow ในลักษณะไพพ์ไลน์ กระบวนการอ่านแบ่งออกเป็นขั้นตอนการประมวลผลข้อมูลหลายขั้นตอนที่เชื่อมต่อกันเป็นชุด โดยที่เอาต์พุตของสเตจหนึ่งจะเป็นอินพุตไปยังสเตจถัดไป ระบบการอ่านข้อมูลนี้จะถูกเรียกว่าท่อป้อนข้อมูล

ไปป์ไลน์ทั่วไปสำหรับการอ่านเร็กคอร์ดจากไฟล์มีขั้นตอนต่อไปนี้:

  1. การอ่านไฟล์.
  2. การประมวลผลไฟล์ล่วงหน้า (ไม่บังคับ)
  3. การถ่ายโอนไฟล์จากโฮสต์ไปยังอุปกรณ์

ไปป์ไลน์อินพุตที่ไม่มีประสิทธิภาพอาจทำให้แอปพลิเคชันของคุณช้าลงอย่างมาก การป้อนข้อมูลสมัครจะถือว่าผูกพันเมื่อมันใช้เวลาเป็นส่วนสำคัญของเวลาในท่อป้อนข้อมูล ใช้ข้อมูลเชิงลึกที่ได้รับจากตัววิเคราะห์ไปป์ไลน์อินพุตเพื่อทำความเข้าใจว่าไปป์ไลน์อินพุทไม่มีประสิทธิภาพ

ตัววิเคราะห์ไปป์ไลน์อินพุตจะบอกคุณทันทีว่าโปรแกรมของคุณถูกผูกไว้กับอินพุตหรือไม่ และจะนำคุณไปสู่การวิเคราะห์ด้านอุปกรณ์และโฮสต์เพื่อดีบักปัญหาคอขวดด้านประสิทธิภาพในขั้นตอนใดๆ ในไพพ์ไลน์อินพุต

ตรวจสอบคำแนะนำเกี่ยวกับประสิทธิภาพของไปป์ไลน์อินพุตสำหรับแนวทางปฏิบัติที่ดีที่สุดที่แนะนำเพื่อเพิ่มประสิทธิภาพไปป์ไลน์อินพุตข้อมูลของคุณ

แดชบอร์ดไปป์ไลน์อินพุต

หากต้องการเปิดการวิเคราะห์การป้อนข้อมูลท่อเลือกโปรไฟล์แล้วเลือก input_pipeline_analyzer จากเครื่องมือแบบเลื่อนลง

ภาพ

แดชบอร์ดประกอบด้วยสามส่วน:

  1. สรุป: สรุปท่อป้อนข้อมูลโดยรวมที่มีข้อมูลเกี่ยวกับการไม่ว่าจะเป็นแอพลิเคชันของคุณจะถูกป้อนข้อมูลที่ถูกผูกไว้และถ้าเป็นเช่นนั้นโดยเท่าใด
  2. วิเคราะห์อุปกรณ์ด้าน: แสดงรายละเอียดผลการวิเคราะห์อุปกรณ์ข้างเคียงรวมทั้งอุปกรณ์ขั้นตอนเวลาและช่วงเวลาของอุปกรณ์ที่ใช้ในการรอคอยสำหรับการป้อนข้อมูลทั่วแกนในแต่ละขั้นตอน
  3. วิเคราะห์โฮสต์ด้านการแสดงการวิเคราะห์รายละเอียดในด้านเจ้าภาพรวมทั้งรายละเอียดของเวลาการประมวลผลข้อมูลเกี่ยวกับโฮสต์

สรุปไปป์ไลน์อินพุต

สรุปรายงานว่าโปรแกรมของคุณจะถูกป้อนข้อมูลที่ถูกผูกไว้โดยนำเสนอร้อยละของเวลาอุปกรณ์ที่ใช้ในการรอคอยสำหรับการป้อนข้อมูลจากโฮสต์ หากคุณกำลังใช้ไปป์ไลน์อินพุตมาตรฐานที่ได้รับเครื่องมือวัด เครื่องมือจะรายงานที่ซึ่งใช้เวลาประมวลผลอินพุตส่วนใหญ่

การวิเคราะห์ด้านอุปกรณ์

การวิเคราะห์ฝั่งอุปกรณ์ให้ข้อมูลเชิงลึกเกี่ยวกับเวลาที่ใช้ในอุปกรณ์เทียบกับบนโฮสต์ และเวลาที่ใช้อุปกรณ์ในการรอข้อมูลอินพุตจากโฮสต์

  1. เวลาขั้นตอนที่พล็อตกับจำนวนขั้นตอน: แสดงกราฟของเวลาขั้นตอนอุปกรณ์ (มิลลิวินาที) มากกว่าทุกขั้นตอนในการเก็บตัวอย่าง แต่ละขั้นตอนแบ่งออกเป็นหลายหมวดหมู่ (ด้วยสีที่ต่างกัน) ของที่ที่ใช้ไป พื้นที่สีแดงสอดคล้องกับส่วนของเวลาขั้นตอนที่อุปกรณ์ไม่ได้ใช้งานเพื่อรอข้อมูลอินพุตจากโฮสต์ พื้นที่สีเขียวแสดงเวลาที่อุปกรณ์ทำงานจริง
  2. สถิติเวลาขั้นตอน: รายงานค่าเฉลี่ยส่วนเบี่ยงเบนมาตรฐานและช่วง ([ต่ำสุดสูงสุด]) เวลาขั้นตอนอุปกรณ์

การวิเคราะห์ฝั่งเจ้าบ้าน

การวิเคราะห์เจ้าภาพด้านรายงานรายละเอียดของเวลาการประมวลผลอินพุต (เวลาที่ใช้ใน tf.data Ops API) บนโฮสต์เป็นหลายประเภท:

  • อ่านข้อมูลจากไฟล์บนความต้องการ: เวลาที่ใช้ในการอ่านข้อมูลจากไฟล์โดยไม่ต้องแคช prefetching และ interleaving
  • การอ่านข้อมูลจากแฟ้มล่วงหน้า: เวลาที่ใช้ในการอ่านไฟล์รวมทั้งแคช prefetching และ interleaving
  • preprocessing ข้อมูล: เวลาที่ใช้ในการปฏิบัติการ preprocessing เช่นการบีบอัดภาพ
  • Enqueuing ข้อมูลที่จะโอนไปยังอุปกรณ์: เวลาที่ใช้ในการใส่ข้อมูลลงในคิวป้อนเข้าก่อนที่จะถ่ายโอนข้อมูลไปยังอุปกรณ์

ขยายการป้อนข้อมูลสถิติแย้มยิ้มในการตรวจสอบสถิติของปฏิบัติการการป้อนข้อมูลของแต่ละบุคคลและประเภทของพวกเขาหักลงตามเวลาดำเนินการ

ภาพ

ตารางข้อมูลต้นฉบับจะปรากฏขึ้นพร้อมกับแต่ละรายการที่มีข้อมูลต่อไปนี้:

  1. Op อินพุต: แสดงชื่อสหกรณ์ TensorFlow ของสหกรณ์การป้อนข้อมูล
  2. นับ: แสดงจำนวนของกรณีของการดำเนินการสหกรณ์ในช่วงเวลาโปรไฟล์
  3. รวมเวลา (มิลลิวินาที): แสดงผลรวมสะสมของเวลาที่ใช้ในแต่ละกรณีที่
  4. รวมเวลาที่อยู่%: แสดงเวลาทั้งหมดที่ใช้ในการสหกรณ์เป็นส่วนของเวลาทั้งหมดที่ใช้ในการประมวลผลการป้อนข้อมูล
  5. รวมเวลาที่อยู่ด้วยตัวเอง (ในมิลลิวินาที): แสดงผลรวมสะสมของตัวเองเวลาที่ใช้ในแต่ละกรณีที่ เวลาตัวเองที่นี่วัดเวลาที่ใช้ภายในเนื้อหาของฟังก์ชัน ไม่รวมเวลาที่ใช้ในฟังก์ชันที่เรียกใช้
  6. รวมเวลาที่ตนเอง% แสดงเวลาตนเองทั้งหมดเป็นเศษเสี้ยวของเวลาทั้งหมดที่ใช้ในการประมวลผลข้อมูลเข้า
  7. หมวดหมู่ แสดงหมวดหมู่การประมวลผลของอินพุต op

สถิติ TensorFlow

เครื่องมือ TensorFlow Stats จะแสดงประสิทธิภาพของทุก TensorFlow op (op) ที่ดำเนินการบนโฮสต์หรืออุปกรณ์ระหว่างเซสชันการทำโปรไฟล์

ภาพ

เครื่องมือจะแสดงข้อมูลประสิทธิภาพในสองบานหน้าต่าง:

  • บานหน้าต่างด้านบนแสดงแผนภูมิวงกลมสูงสุดสี่แผนภูมิ:

    1. การกระจายเวลาดำเนินการตนเองของแต่ละ op บนโฮสต์
    2. การกระจายเวลาดำเนินการด้วยตนเองของ op แต่ละประเภทบนโฮสต์
    3. การกระจายเวลาดำเนินการด้วยตนเองของแต่ละ op บนอุปกรณ์
    4. การกระจายเวลาดำเนินการด้วยตนเองของ op แต่ละประเภทบนอุปกรณ์
  • บานหน้าต่างด้านล่างแสดงตารางที่รายงานข้อมูลเกี่ยวกับ TensorFlow ops โดยมีหนึ่งแถวสำหรับแต่ละ op และหนึ่งคอลัมน์สำหรับข้อมูลแต่ละประเภท (จัดเรียงคอลัมน์โดยคลิกที่ส่วนหัวของคอลัมน์) คลิกที่ปุ่มส่งออกเป็น CSV บนด้านขวาของบานหน้าต่างด้านบนเพื่อส่งออกข้อมูลจากตารางนี้เป็นไฟล์ CSV

    โปรดทราบว่า:

    • หาก ops ใดมี ops ย่อย:

      • เวลา "สะสม" ทั้งหมดของ op รวมถึงเวลาที่ใช้ในปฏิบัติการย่อย

      • เวลา "ตนเอง" ทั้งหมดของ op ไม่รวมเวลาที่ใช้ในปฏิบัติการย่อย

    • หาก op ดำเนินการบนโฮสต์:

      • เปอร์เซ็นต์ของเวลาตัวเองทั้งหมดบนอุปกรณ์ที่เกิดขึ้นจากการดำเนินการจะเป็น 0
      • เปอร์เซ็นต์สะสมของเวลาตัวเองทั้งหมดบนอุปกรณ์จนถึงและรวมถึงการดำเนินการนี้จะเป็น 0
    • หาก op ทำงานบนอุปกรณ์:

      • เปอร์เซ็นต์ของเวลาตัวเองทั้งหมดบนโฮสต์ที่เกิดขึ้นโดยการดำเนินการนี้จะเป็น 0
      • เปอร์เซ็นต์สะสมของเวลาตัวเองทั้งหมดบนโฮสต์จนถึงและรวมถึงการดำเนินการนี้จะเป็น 0

คุณสามารถเลือกที่จะรวมหรือไม่รวมเวลาว่างในแผนภูมิวงกลมและตาราง

โปรแกรมดูการติดตาม T

โปรแกรมดูการติดตามแสดงไทม์ไลน์ที่แสดง:

  • ระยะเวลาสำหรับการดำเนินการที่ดำเนินการโดยโมเดล TensorFlow ของคุณ
  • ส่วนใดของระบบ (โฮสต์หรืออุปกรณ์) ที่ดำเนินการ op โดยปกติ โฮสต์จะดำเนินการป้อนข้อมูล ประมวลผลข้อมูลการฝึกอบรมล่วงหน้า และโอนไปยังอุปกรณ์ ในขณะที่อุปกรณ์ดำเนินการฝึกโมเดลจริง

โปรแกรมดูการติดตามช่วยให้คุณระบุปัญหาด้านประสิทธิภาพในแบบจำลองของคุณ จากนั้นทำตามขั้นตอนเพื่อแก้ไขปัญหา ตัวอย่างเช่น ในระดับสูง คุณสามารถระบุได้ว่าการป้อนข้อมูลหรือการฝึกโมเดลใช้เวลาส่วนใหญ่หรือไม่ การเจาะลึก คุณสามารถระบุได้ว่าการดำเนินการใดใช้เวลานานที่สุดในการดำเนินการ โปรดทราบว่าโปรแกรมดูการติดตามถูกจำกัดไว้ที่ 1 ล้านเหตุการณ์ต่ออุปกรณ์

อินเทอร์เฟซตัวแสดงการติดตาม

เมื่อคุณเปิดโปรแกรมดูการติดตาม ระบบจะแสดงการทำงานล่าสุดของคุณ:

ภาพ

หน้าจอนี้มีองค์ประกอบหลักดังต่อไปนี้:

  1. บานหน้าต่างระยะเวลา: แสดง Ops ว่าอุปกรณ์และเจ้าภาพดำเนินการในช่วงเวลา
  2. รายละเอียดบานหน้าต่าง: แสดงข้อมูลเพิ่มเติมสำหรับการปฏิบัติการที่เลือกในบานหน้าต่าง Timeline

บานหน้าต่างไทม์ไลน์ประกอบด้วยองค์ประกอบต่อไปนี้:

  1. แถบด้านบน: ประกอบด้วยการควบคุมเสริมต่างๆ
  2. เวลาแกน: แสดงเวลาเมื่อเทียบกับจุดเริ่มต้นของการตรวจสอบที่
  3. มาตราและติดตามป้ายกำกับ: แต่ละส่วนมีแทร็คและมีสามเหลี่ยมด้านซ้ายที่คุณสามารถคลิกเพื่อขยายและยุบส่วนที่ มีส่วนเดียวสำหรับทุกองค์ประกอบการประมวลผลในระบบ
  4. เครื่องมือเลือก: ประกอบด้วยเครื่องมือต่างๆสำหรับการโต้ตอบกับผู้ชมร่องรอยเช่นซูม, แพนเลือกและกำหนดเวลา ใช้เครื่องมือ Timing เพื่อทำเครื่องหมายช่วงเวลา
  5. เหตุการณ์เหล่านี้แสดงให้เห็นช่วงเวลาที่สหกรณ์ได้ดำเนินการหรือระยะเวลาของเมตาเหตุการณ์เช่นขั้นตอนการฝึกอบรม
ส่วนและแทร็ก

โปรแกรมดูการติดตามประกอบด้วยส่วนต่อไปนี้:

  • ส่วนหนึ่งสำหรับแต่ละโหนดอุปกรณ์ป้ายที่มีจำนวนของชิปอุปกรณ์และโหนดอุปกรณ์ภายในชิป (เช่น /device:GPU:0 (pid 0) ) ส่วนโหนดอุปกรณ์แต่ละส่วนมีแทร็กต่อไปนี้:
    • ขั้นตอน: แสดงระยะเวลาของขั้นตอนการฝึกอบรมที่กำลังทำงานอยู่บนอุปกรณ์
    • TensorFlow Ops: แสดงให้เห็น Ops รันบนอุปกรณ์
    • XLA Ops: แสดงให้เห็น XLA การดำเนินงาน (OPS) วิ่งบนอุปกรณ์ถ้า XLA เป็นคอมไพเลอร์ที่ใช้ (แต่ละ TensorFlow สหกรณ์ได้รับการแปลเป็นหนึ่งหรือ Ops XLA หลาย XLA เรียบเรียงแปล Ops XLA ลงในรหัสที่วิ่งบนอุปกรณ์.)
  • ส่วนหนึ่งสำหรับหัวข้อที่ทำงานบน CPU เครื่องโฮสต์ที่ระบุว่า "กระทู้โฮสต์" ส่วนนี้มีหนึ่งแทร็กสำหรับเธรด CPU แต่ละอัน โปรดทราบว่าคุณสามารถละเว้นข้อมูลที่แสดงข้างป้ายชื่อส่วนได้
กิจกรรม

กิจกรรมภายในไทม์ไลน์จะแสดงเป็นสีต่างๆ สีเองไม่ได้มีความหมายเฉพาะเจาะจง

โปรแกรมดูการติดตามสามารถแสดงการเรียกใช้ฟังก์ชัน Python ในโปรแกรม TensorFlow ของคุณได้ ถ้าคุณใช้ tf.profiler.experimental.start API คุณสามารถเปิดใช้งานหลามติดตามโดยใช้ ProfilerOptions namedtuple เมื่อเริ่มต้นโปรไฟล์ หรือถ้าคุณใช้โหมดการสุ่มตัวอย่างสำหรับ profiling คุณสามารถเลือกระดับของการติดตามโดยใช้ตัวเลือกแบบเลื่อนลงในกล่องโต้ตอบจับภาพโปรไฟล์

ภาพ

สถิติเคอร์เนล GPU

เครื่องมือนี้แสดงสถิติประสิทธิภาพและ op เริ่มต้นสำหรับเคอร์เนลที่เร่งความเร็ว GPU ทุกตัว

ภาพ

เครื่องมือจะแสดงข้อมูลในสองบานหน้าต่าง:

  • บานหน้าต่างด้านบนแสดงแผนภูมิวงกลมซึ่งแสดงเคอร์เนล CUDA ที่มีเวลารวมสูงสุดที่ผ่านไป

  • บานหน้าต่างด้านล่างแสดงตารางที่มีข้อมูลต่อไปนี้สำหรับคู่ kernel-op ที่ไม่ซ้ำกันแต่ละคู่:

    • อันดับจากมากไปน้อยของระยะเวลา GPU ที่ผ่านไปทั้งหมดจัดกลุ่มตามคู่ kernel-op
    • ชื่อของเคอร์เนลที่เรียกใช้
    • จำนวนการลงทะเบียน GPU ที่ใช้โดยเคอร์เนล
    • ขนาดรวมของหน่วยความจำที่ใช้ร่วมกัน (สแตติก + ไดนามิกที่ใช้ร่วมกัน) ที่ใช้เป็นไบต์
    • บล็อกมิติแสดงเป็น blockDim.x, blockDim.y, blockDim.z
    • ขนาดตารางแสดงเป็น gridDim.x, gridDim.y, gridDim.z
    • ไม่ว่าสหกรณ์มีสิทธิ์ที่จะใช้ Tensor Cores
    • เคอร์เนลมีคำสั่ง Tensor Core หรือไม่
    • ชื่อของ op ที่เปิดใช้เคอร์เนลนี้
    • จำนวนครั้งที่เกิดขึ้นของคู่ kernel-op นี้
    • เวลา GPU ที่ผ่านไปทั้งหมด หน่วยเป็นไมโครวินาที
    • เวลา GPU ที่ผ่านไปโดยเฉลี่ยในหน่วยไมโครวินาที
    • เวลา GPU ที่ผ่านไปขั้นต่ำในหน่วยไมโครวินาที
    • เวลา GPU ที่ผ่านไปสูงสุดในหน่วยไมโครวินาที

เครื่องมือโปรไฟล์หน่วยความจำ

รายละเอียดหน่วยความจำเครื่องมือตรวจสอบการใช้งานหน่วยความจำของอุปกรณ์ของคุณในระหว่างช่วงเวลาโปรไฟล์ คุณสามารถใช้เครื่องมือนี้เพื่อ:

  • แก้ปัญหาหน่วยความจำไม่เพียงพอ (OOM) โดยระบุการใช้หน่วยความจำสูงสุดและการจัดสรรหน่วยความจำที่สอดคล้องกับ TensorFlow ops นอกจากนี้คุณยังสามารถแก้ปัญหาปัญหา OOM ที่อาจเกิดขึ้นเมื่อคุณเรียกใช้ หลายครอบครอง- อนุมาน
  • ดีบักปัญหาการกระจายตัวของหน่วยความจำ

เครื่องมือโปรไฟล์หน่วยความจำแสดงข้อมูลในสามส่วน:

  1. สรุปโปรไฟล์หน่วยความจำ
  2. กราฟไทม์ไลน์หน่วยความจำ
  3. ตารางรายละเอียดหน่วยความจำ

สรุปโปรไฟล์หน่วยความจำ

ส่วนนี้จะแสดงข้อมูลสรุประดับสูงของโปรไฟล์หน่วยความจำของโปรแกรม TensorFlow ของคุณดังที่แสดงด้านล่าง:

สรุปโปรไฟล์หน่วยความจำมีหกช่อง:

  1. ID หน่วยความจำ: เลื่อนลงซึ่งจะแสดงรายการทุกระบบหน่วยความจำอุปกรณ์ที่มีอยู่ เลือกระบบหน่วยความจำที่คุณต้องการดูจากดรอปดาวน์
  2. #Allocation: จำนวนของการจัดสรรหน่วยความจำที่ทำในระหว่างช่วงเวลาโปรไฟล์
  3. #Deallocation: จำนวน deallocations หน่วยความจำในช่วงเวลา profiling
  4. ความจุหน่วยความจำ: ความจุรวม (ใน GiBs) ของระบบหน่วยความจำที่คุณเลือก
  5. การใช้งานสูงสุดกอง: การใช้งานหน่วยความจำสูงสุด (ใน GiBs) ตั้งแต่รุ่นเริ่มต้นทำงาน
  6. การใช้งานสูงสุดหน่วยความจำ: การใช้งานหน่วยความจำสูงสุด (ใน GiBs) ในช่วงโปรไฟล์ ฟิลด์นี้ประกอบด้วยฟิลด์ย่อยต่อไปนี้:
    1. การประทับเวลา: เวลาที่บันทึกเมื่อใช้หน่วยความจำสูงสุดที่เกิดขึ้นบนเส้นกราฟ
    2. สแต็คจองห้องพัก: จำนวนหน่วยความจำที่สงวนไว้ในกอง (ใน GiBs)
    3. กองการจัดสรร: จำนวนหน่วยความจำที่จัดสรรในกอง (ใน GiBs)
    4. หน่วยความจำฟรี: จำนวนหน่วยความจำฟรี (ใน GiBs) ความจุหน่วยความจำเป็นผลรวมของการสำรองสแต็ค การจัดสรรฮีป และหน่วยความจำว่าง
    5. การกระจายตัว: ร้อยละของการกระจายตัว (ลดลงจะดีกว่า) จะมีการคำนวณเป็นเปอร์เซ็นต์ของ (1 - Size of the largest chunk of free memory / Total free memory)

กราฟไทม์ไลน์หน่วยความจำ

ส่วนนี้แสดงพล็อตของการใช้หน่วยความจำ (เป็น GiB) และเปอร์เซ็นต์ของการแตกแฟรกเมนต์เทียบกับเวลา (เป็นมิลลิวินาที)

ภาพ

แกน X แสดงถึงไทม์ไลน์ (เป็นมิลลิวินาที) ของช่วงการทำโปรไฟล์ แกน Y ทางด้านซ้ายแสดงถึงการใช้หน่วยความจำ (ใน GiB) และแกน Y ทางด้านขวาแสดงถึงเปอร์เซ็นต์ของการแตกแฟรกเมนต์ ในแต่ละจุดของเวลาบนแกน X หน่วยความจำทั้งหมดจะแบ่งออกเป็นสามประเภท: สแต็ก (สีแดง) ฮีป (สีส้ม) และว่าง (สีเขียว) วางเมาส์เหนือการประทับเวลาเฉพาะเพื่อดูรายละเอียดเกี่ยวกับเหตุการณ์การจัดสรร/จัดสรรหน่วยความจำ ณ จุดนั้นดังด้านล่าง:

ภาพ

หน้าต่างป๊อปอัปจะแสดงข้อมูลต่อไปนี้:

  • การประทับเวลา (มิลลิวินาที): สถานที่ตั้งของเหตุการณ์ที่เลือกบนไทม์ไลน์ที่
  • เหตุการณ์: ประเภทของเหตุการณ์ (การจัดสรรหรือ deallocation)
  • requested_size (GiBs): จำนวนหน่วยความจำที่ร้องขอ นี่จะเป็นจำนวนลบสำหรับเหตุการณ์การจัดสรรคืน
  • allocation_size (GiBs): จำนวนเงินที่แท้จริงของการจัดสรรหน่วยความจำ นี่จะเป็นจำนวนลบสำหรับเหตุการณ์การจัดสรรคืน
  • tf_op: สหกรณ์ TensorFlow ที่ร้องขอการจัดสรร / deallocation
  • step_id: ขั้นตอนการฝึกอบรมซึ่งเหตุการณ์นี้เกิดขึ้น
  • REGION_TYPE: ประเภทข้อมูลนิติบุคคลที่จัดสรรหน่วยความจำนี้สำหรับ ค่าที่เป็นไปได้ temp สำหรับชั่วคราว, output สำหรับการเปิดใช้งานและการไล่ระดับสีและ persist / dynamic สำหรับน้ำหนักและค่าคงที่
  • data_type: ประเภทองค์ประกอบเมตริกซ์ (เช่น uint8 สำหรับ 8 บิตจำนวนเต็มไม่ได้ลงนาม)
  • tensor_shape: รูปร่างของเมตริกซ์ที่ได้รับการจัดสรร / deallocated
  • memory_in_use (GiBs): หน่วยความจำทั้งหมดที่อยู่ในการใช้งานที่จุดเวลานี้

ตารางแบ่งหน่วยความจำ

ตารางนี้แสดงการจัดสรรหน่วยความจำที่ใช้งานอยู่ ณ จุดที่มีการใช้หน่วยความจำสูงสุดในช่วงเวลาการทำโปรไฟล์

ภาพ

มีหนึ่งแถวสำหรับแต่ละ TensorFlow Op และแต่ละแถวมีคอลัมน์ต่อไปนี้:

  • ชื่อสหกรณ์: ชื่อของสหกรณ์ TensorFlow ที่
  • ขนาดการจัดสรร (GiBs): จำนวนเงินทั้งหมดของหน่วยความจำที่จัดสรรให้กับสหกรณ์นี้
  • การขอขนาด (GiBs): จำนวนเงินทั้งหมดของหน่วยความจำขอ op นี้
  • เกิดขึ้น: จำนวนของการจัดสรรสำหรับสหกรณ์นี้
  • ประเภทภาค: ประเภทข้อมูลนิติบุคคลที่จัดสรรหน่วยความจำนี้สำหรับ ค่าที่เป็นไปได้ temp สำหรับชั่วคราว, output สำหรับการเปิดใช้งานและการไล่ระดับสีและ persist / dynamic สำหรับน้ำหนักและค่าคงที่
  • ชนิดข้อมูล: ประเภทองค์ประกอบเมตริกซ์
  • รูปร่าง: รูปทรงของเทนเซอร์จัดสรร

โปรแกรมดูพ็อด

เครื่องมือ Pod Viewer จะแสดงรายละเอียดของขั้นตอนการฝึกอบรมสำหรับผู้ปฏิบัติงานทั้งหมด

ภาพ

  • บานหน้าต่างด้านบนมีแถบเลื่อนสำหรับเลือกหมายเลขขั้นตอน
  • บานหน้าต่างด้านล่างแสดงแผนภูมิคอลัมน์แบบเรียงซ้อน นี่คือมุมมองระดับสูงของหมวดหมู่ขั้นตอนเวลาแยกย่อยที่วางทับกัน แต่ละคอลัมน์แบบเรียงซ้อนแสดงถึงผู้ปฏิบัติงานที่ไม่ซ้ำกัน
  • เมื่อคุณวางเมาส์เหนือคอลัมน์ที่เรียงซ้อนกัน การ์ดทางด้านซ้ายมือจะแสดงรายละเอียดเพิ่มเติมเกี่ยวกับการแจกแจงขั้นตอน

tf.data การวิเคราะห์คอขวด

tf.data เครื่องมือในการวิเคราะห์คอขวดโดยอัตโนมัติคอขวดใน tf.data ท่อป้อนข้อมูลในโปรแกรมของคุณและให้คำแนะนำเกี่ยวกับวิธีการแก้ไขได้ จะทำงานร่วมกับโปรแกรมใด ๆ โดยใช้ tf.data โดยไม่คำนึงถึงแพลตฟอร์ม (CPU / GPU / TPU) การวิเคราะห์และข้อเสนอแนะของมันอยู่บนพื้นฐานนี้ คู่มือ

ตรวจพบคอขวดโดยทำตามขั้นตอนเหล่านี้:

  1. ค้นหาโฮสต์ที่ถูกผูกไว้กับอินพุตมากที่สุด
  2. ค้นหาการดำเนินการที่ช้าที่สุดของ tf.data ท่อป้อนข้อมูล
  3. สร้างกราฟไปป์ไลน์อินพุตใหม่จากการติดตามตัวสร้างโปรไฟล์
  4. ค้นหาเส้นทางวิกฤตในกราฟไปป์ไลน์อินพุต
  5. ระบุการเปลี่ยนแปลงที่ช้าที่สุดบนเส้นทางวิกฤตว่าเป็นคอขวด

UI ที่จะแบ่งออกเป็นสามส่วน: การวิเคราะห์ผลการดำเนินงานสรุปบทสรุปของการป้อนข้อมูลทั้งหมดวางท่อและท่อส่งป้อนข้อมูลกราฟ

สรุปการวิเคราะห์ประสิทธิภาพ

ภาพ

ส่วนนี้ให้ข้อมูลสรุปการวิเคราะห์ รายงานเกี่ยวกับมันช้า tf.data ท่อป้อนข้อมูลการตรวจพบในรายละเอียด ส่วนนี้ยังแสดงโฮสต์ที่ถูกผูกไว้กับอินพุตมากที่สุดและไปป์ไลน์อินพุตที่ช้าที่สุดพร้อมเวลาแฝงสูงสุด สิ่งสำคัญที่สุดคือจะระบุว่าส่วนใดของไพพ์ไลน์อินพุตที่เป็นคอขวดและจะแก้ไขได้อย่างไร ข้อมูลคอขวดมีให้พร้อมกับประเภทตัววนซ้ำและชื่อยาว

วิธีอ่านชื่อยาวของ tf.data iterator

ชื่อยาวมีรูปแบบเป็น Iterator::<Dataset_1>::...::<Dataset_n> ในการชื่อยาว <Dataset_n> ตรงกับประเภท iterator และชุดข้อมูลอื่น ๆ ในชื่อยาวแทนการแปลงปลายน้ำ

ตัวอย่างเช่น พิจารณาชุดข้อมูลไปป์ไลน์อินพุตต่อไปนี้:

dataset = tf.data.Dataset.range(10).map(lambda x: x).repeat(2).batch(5)

ชื่อแบบยาวสำหรับตัววนซ้ำจากชุดข้อมูลด้านบนจะเป็น:

ประเภทตัววนซ้ำ ชื่อยาว
พิสัย Iterator::Batch::Repeat::Map::Range
แผนที่ Iterator::Batch::Repeat::Map
ทำซ้ำ Iterator::Batch::Repeat
แบทช์ ตัววนซ้ำ::Batch

สรุปท่ออินพุตทั้งหมด

ภาพ

ส่วนนี้ให้ข้อมูลสรุปของไปป์ไลน์อินพุตทั้งหมดในทุกโฮสต์ โดยปกติจะมีหนึ่งไปป์ไลน์อินพุต เมื่อมีการใช้กลยุทธ์การกระจายที่มีท่อป้อนข้อมูลโฮสต์ทำงานของโปรแกรม tf.data รหัสและท่อป้อนข้อมูลอุปกรณ์หลายดึงข้อมูลจากท่อป้อนข้อมูลโฮสต์และถ่ายโอนไปยังอุปกรณ์

สำหรับแต่ละอินพุตไปป์ไลน์ จะแสดงสถิติของเวลาดำเนินการ การโทรจะถือว่าช้าหากใช้เวลานานกว่า 50 μs

กราฟไปป์ไลน์อินพุต

ภาพ

ส่วนนี้แสดงกราฟไปป์ไลน์อินพุตพร้อมข้อมูลเวลาดำเนินการ คุณสามารถใช้ "โฮสต์" และ "ไปป์ไลน์อินพุต" เพื่อเลือกโฮสต์และไปป์ไลน์อินพุตที่ต้องการดู การประหารชีวิตของท่อป้อนข้อมูลจะเรียงตามเวลาดำเนินการในลำดับถัดลงมาซึ่งคุณสามารถเลือกใช้แบบเลื่อนอันดับ

ภาพ

โหนดบนเส้นทางวิกฤติมีโครงร่างหนา โหนดคอขวด ซึ่งเป็นโหนดที่มีเวลาตนเองนานที่สุดบนเส้นทางวิกฤต มีโครงร่างสีแดง โหนดที่ไม่สำคัญอื่นๆ มีเส้นประสีเทา

ในแต่ละโหนดเวลาเริ่มต้นระบุเวลาเริ่มต้นของการดำเนินการ โหนดเดียวกันอาจจะดำเนินการหลายครั้งตัวอย่างเช่นถ้ามี Batch สหกรณ์ในท่อป้อนข้อมูล หากดำเนินการหลายครั้ง จะเป็นเวลาเริ่มต้นของการดำเนินการครั้งแรก

รวมระยะเวลานี้เป็นเวลาที่ผนังของการดำเนินการ หากถูกประหารชีวิตหลายครั้ง จะเท่ากับผลรวมของเวลากำแพงของการประหารชีวิตทั้งหมด

เวลาด้วยตนเองโดยไม่รวมเวลาที่อยู่ในเวลาที่คาบเกี่ยวกันกับโหนดลูกของมันทันที

"# Calls" คือจำนวนครั้งที่ดำเนินการไพพ์ไลน์อินพุต

รวบรวมข้อมูลประสิทธิภาพ

TensorFlow Profiler รวบรวมกิจกรรมโฮสต์และการติดตาม GPU ของโมเดล TensorFlow ของคุณ คุณสามารถกำหนดค่า Profiler เพื่อรวบรวมข้อมูลประสิทธิภาพผ่านโหมดโปรแกรมหรือโหมดสุ่มตัวอย่าง

การทำโปรไฟล์ APIs

คุณสามารถใช้ API ต่อไปนี้เพื่อทำโปรไฟล์ได้

  • โหมดการเขียนโปรแกรมโดยใช้ TensorBoard Keras โทรกลับ ( tf.keras.callbacks.TensorBoard )

    # Profile from batches 10 to 15
    tb_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir,
                                                 profile_batch='10, 15')
    
    # Train the model and use the TensorBoard Keras callback to collect
    # performance profiling data
    model.fit(train_data,
              steps_per_epoch=20,
              epochs=5,
              callbacks=[tb_callback])
    
  • โหมดการเขียนโปรแกรมโดยใช้ tf.profiler ฟังก์ชั่น API

    tf.profiler.experimental.start('logdir')
    # Train the model here
    tf.profiler.experimental.stop()
    
  • โหมดแบบเป็นโปรแกรมโดยใช้ตัวจัดการบริบท

    with tf.profiler.experimental.Profile('logdir'):
        # Train the model here
        pass
    

  • โหมดการสุ่มตัวอย่าง: ทำโปรไฟล์แบบ on-demand โดยใช้ tf.profiler.experimental.server.start ที่จะเริ่มต้นเซิร์ฟเวอร์ gRPC กับรูปแบบ TensorFlow ของคุณทำงานได้ หลังจากที่เริ่มต้นเซิร์ฟเวอร์ gRPC และทำงานรูปแบบของคุณคุณสามารถจับภาพรายละเอียดผ่านทางปุ่มจับภาพโปรไฟล์ในรายละเอียดปลั๊กอิน TensorBoard ใช้สคริปต์ในส่วนติดตั้งตัวสร้างโปรไฟล์ด้านบนเพื่อเปิดใช้อินสแตนซ์ TensorBoard หากยังไม่ได้ทำงาน

    ตัวอย่างเช่น,

    # Start a profiler server before your model runs.
    tf.profiler.experimental.server.start(6009)
    # (Model code goes here).
    #  Send a request to the profiler server to collect a trace of your model.
    tf.profiler.experimental.client.trace('grpc://localhost:6009',
                                          'gs://your_tb_logdir', 2000)
    

    ตัวอย่างการทำโปรไฟล์ผู้ปฏิบัติงานหลายคน:

    # E.g. your worker IP addresses are 10.0.0.2, 10.0.0.3, 10.0.0.4, and you
    # would like to profile for a duration of 2 seconds.
    tf.profiler.experimental.client.trace(
        'grpc://10.0.0.2:8466,grpc://10.0.0.3:8466,grpc://10.0.0.4:8466',
        'gs://your_tb_logdir',
        2000)
    

ใช้โต้ตอบจับรายละเอียดเพื่อระบุ:

  • รายการ URL บริการโปรไฟล์หรือชื่อ TPU ที่คั่นด้วยเครื่องหมายจุลภาค
  • ระยะเวลาการทำโปรไฟล์
  • ระดับของอุปกรณ์ โฮสต์ และการติดตามการเรียกใช้ฟังก์ชัน Python
  • จำนวนครั้งที่คุณต้องการให้ Profiler ลองจับภาพโปรไฟล์อีกครั้ง หากไม่สำเร็จในตอนแรก

การทำโปรไฟล์ลูปการฝึกแบบกำหนดเอง

ไปที่โปรไฟล์ลูปการฝึกอบรมที่กำหนดเองในรหัสของคุณ TensorFlow ตราสารห่วงการฝึกอบรมที่มี tf.profiler.experimental.Trace API เพื่อทำเครื่องหมายเขตแดนขั้นตอนสำหรับ Profiler

name อาร์กิวเมนต์ถูกนำมาใช้เป็นคำนำหน้าชื่อขั้นตอนให้ step_num โต้แย้งคำหลักต่อท้ายในชื่อขั้นตอนและ _r โต้แย้งคำหลักที่ทำให้เหตุการณ์ร่องรอยนี้ได้รับการประมวลผลเป็นเหตุการณ์ขั้นตอนโดย Profiler

ตัวอย่างเช่น,

for step in range(NUM_STEPS):
    with tf.profiler.experimental.Trace('train', step_num=step, _r=1):
        train_data = next(dataset)
        train_step(train_data)

สิ่งนี้จะเปิดใช้งานการวิเคราะห์ประสิทธิภาพตามขั้นตอนของ Profiler และทำให้เหตุการณ์ขั้นตอนแสดงในโปรแกรมดูการติดตาม

ตรวจสอบให้แน่ใจว่าคุณรวม iterator ชุดภายใน tf.profiler.experimental.Trace บริบทสำหรับการวิเคราะห์ที่ถูกต้องของท่อป้อนข้อมูล

ข้อมูลโค้ดด้านล่างเป็นรูปแบบการต่อต้าน:

for step, train_data in enumerate(dataset):
    with tf.profiler.experimental.Trace('train', step_num=step, _r=1):
        train_step(train_data)

กรณีการใช้งานโปรไฟล์

ตัวสร้างโปรไฟล์ครอบคลุมกรณีการใช้งานจำนวนมากตามสี่แกนที่แตกต่างกัน ขณะนี้ชุดค่าผสมบางส่วนได้รับการสนับสนุนและชุดค่าผสมอื่น ๆ จะถูกเพิ่มในอนาคต บางกรณีการใช้งานคือ:

  • เทียบกับท้องถิ่นที่ห่างไกลโปรไฟล์: เหล่านี้มีสองวิธีการทั่วไปของการตั้งค่าสภาพแวดล้อมที่โปรไฟล์ของคุณ ในการทำโปรไฟล์ในเครื่องนั้น API การทำโปรไฟล์จะถูกเรียกบนเครื่องเดียวกับที่โมเดลของคุณดำเนินการอยู่ ตัวอย่างเช่น เวิร์กสเตชันในพื้นที่ที่มี GPU ในการจัดทำโปรไฟล์ระยะไกล ระบบจะเรียก API การทำโปรไฟล์บนเครื่องอื่นที่ไม่ใช่ตำแหน่งที่โมเดลของคุณดำเนินการ เช่น บน Cloud TPU
  • โปรไฟล์แรงงานหลาย: คุณสามารถโปรไฟล์หลายเครื่องเมื่อใช้ความสามารถในการฝึกอบรมการกระจายของ TensorFlow
  • แพลตฟอร์มฮาร์ดแวร์: ซีพียูโปรไฟล์ GPUs และ TPUs

ตารางด้านล่างแสดงภาพรวมโดยย่อของกรณีการใช้งานที่รองรับ TensorFlow ที่กล่าวถึงข้างต้น:

การทำโปรไฟล์ API ท้องถิ่น รีโมท คนงานหลายคน แพลตฟอร์มฮาร์ดแวร์
TensorBoard Keras Callback ได้รับการสนับสนุน ไม่รองรับ ไม่รองรับ ซีพียู, GPU
tf.profiler.experimental START / STOP API ได้รับการสนับสนุน ไม่รองรับ ไม่รองรับ ซีพียู, GPU
tf.profiler.experimental client.trace API ได้รับการสนับสนุน ได้รับการสนับสนุน ได้รับการสนับสนุน CPU, GPU, TPU
ตัวจัดการบริบท API ได้รับการสนับสนุน ไม่รองรับ ไม่รองรับ ซีพียู, GPU

แนวทางปฏิบัติที่ดีที่สุดสำหรับประสิทธิภาพของแบบจำลองที่เหมาะสมที่สุด

ใช้คำแนะนำต่อไปนี้ตามความเหมาะสมสำหรับรุ่น TensorFlow ของคุณเพื่อให้ได้ประสิทธิภาพสูงสุด

โดยทั่วไป ให้ดำเนินการแปลงทั้งหมดบนอุปกรณ์ และตรวจสอบให้แน่ใจว่าคุณใช้ไลบรารีเวอร์ชันล่าสุดที่เข้ากันได้ เช่น cuDNN และ Intel MKL สำหรับแพลตฟอร์มของคุณ

เพิ่มประสิทธิภาพไปป์ไลน์ข้อมูลอินพุต

ใช้ข้อมูลจาก [#input_pipeline_analyzer] เพื่อเพิ่มประสิทธิภาพไปป์ไลน์การป้อนข้อมูลของคุณ ไปป์ไลน์การป้อนข้อมูลที่มีประสิทธิภาพสามารถปรับปรุงความเร็วของการดำเนินการโมเดลของคุณได้อย่างมากโดยลดเวลาที่ไม่ได้ใช้งานของอุปกรณ์ พยายามที่จะรวมปฏิบัติที่ดีที่สุดรายละเอียดใน การปฏิบัติงานที่ดีขึ้นด้วย tf.data ของ API คู่มือและด้านล่างจะทำให้ท่อส่งข้อมูลเข้าของคุณมีประสิทธิภาพมากขึ้น

  • โดยทั่วไป การขนาน ops ใด ๆ ที่ไม่จำเป็นต้องดำเนินการตามลำดับสามารถเพิ่มประสิทธิภาพไปป์ไลน์การป้อนข้อมูลได้อย่างมาก

  • ในหลายกรณี การเปลี่ยนลำดับของการโทรบางรายการหรือปรับอาร์กิวเมนต์เพื่อให้ทำงานได้ดีที่สุดสำหรับโมเดลของคุณ ขณะปรับไปป์ไลน์ข้อมูลอินพุตให้เหมาะสม ให้เปรียบเทียบเฉพาะตัวโหลดข้อมูลที่ไม่มีขั้นตอนการฝึกอบรมและการเผยแพร่ย้อนหลัง เพื่อหาปริมาณผลกระทบของการปรับให้เหมาะสมอย่างอิสระ

  • ลองเรียกใช้แบบจำลองของคุณด้วยข้อมูลสังเคราะห์เพื่อตรวจสอบว่าไปป์ไลน์อินพุตเป็นคอขวดด้านประสิทธิภาพหรือไม่

  • ใช้ tf.data.Dataset.shard สำหรับการฝึกอบรม multi-GPU ตรวจสอบให้แน่ใจว่าคุณแบ่งส่วนข้อมูลตั้งแต่ต้นในลูปอินพุตเพื่อป้องกันปริมาณงานลดลง เมื่อทำงานกับ TFRecords ตรวจสอบให้แน่ใจว่าคุณแยกส่วนรายการ TFRecords ไม่ใช่เนื้อหาของ TFRecords

  • คู่ขนานหลาย Ops โดยการตั้งค่าแบบไดนามิกค่าของ num_parallel_calls ใช้ tf.data.AUTOTUNE

  • พิจารณาการ จำกัด การใช้งานของ tf.data.Dataset.from_generator ขณะที่มันจะช้าลงเมื่อเทียบกับ Ops TensorFlow บริสุทธิ์

  • พิจารณาการ จำกัด การใช้งานของ tf.py_function เพราะไม่สามารถต่อเนื่องและไม่ได้รับการสนับสนุนในการทำงานใน TensorFlow กระจาย

  • ใช้ tf.data.Options เพื่อควบคุมการเพิ่มประสิทธิภาพคงที่ท่อป้อนข้อมูล

นอกจากนี้ยังอ่าน tf.data การวิเคราะห์ประสิทธิภาพ คู่มือ สำหรับคำแนะนำเพิ่มเติมเกี่ยวกับการเพิ่มประสิทธิภาพท่อป้อนข้อมูลของคุณ

เพิ่มประสิทธิภาพการเสริมข้อมูล

เมื่อทำงานร่วมกับข้อมูลภาพให้คุณ เสริมข้อมูลที่ มีประสิทธิภาพมากขึ้นโดยการหล่อกับชนิดข้อมูลที่แตกต่างหลังจากการใช้การเปลี่ยนแปลงเชิงพื้นที่เช่นพลิก, การปลูกพืชหมุน ฯลฯ

ใช้ NVIDIA® DALI

ในบางกรณี เช่น เมื่อคุณมีระบบที่มีอัตราส่วน GPU ต่อ CPU สูง การเพิ่มประสิทธิภาพทั้งหมดข้างต้นอาจไม่เพียงพอที่จะขจัดปัญหาคอขวดในตัวโหลดข้อมูลที่เกิดจากข้อจำกัดของรอบ CPU

หากคุณกำลังใช้NVIDIA® GPU รุ่นใหม่สำหรับคอมพิวเตอร์วิสัยทัศน์และโปรแกรมการเรียนรู้ลึกเสียงให้พิจารณาใช้การโหลดข้อมูลห้องสมุด ( DALI ) เพื่อเร่งท่อส่งข้อมูล

ตรวจสอบ NVIDIA® DALI: การดำเนินงาน เอกสารสำหรับรายชื่อของการสนับสนุนปฏิบัติการต้าหลี่

ใช้เธรดและการดำเนินการแบบขนาน

เรียกใช้ปฏิบัติการในหัวข้อหลาย CPU กับ tf.config.threading API เพื่อดำเนินการให้เร็วขึ้น

TensorFlow จะกำหนดจำนวนเธรดแบบขนานโดยอัตโนมัติตามค่าเริ่มต้น เธรดพูลที่พร้อมใช้งานสำหรับการรัน TensorFlow ops ขึ้นอยู่กับจำนวนเธรดของ CPU ที่พร้อมใช้งาน

ควบคุมการเร่งความเร็วสูงสุดขนานสำหรับสหกรณ์เดียวโดยใช้ tf.config.threading.set_intra_op_parallelism_threads โปรดทราบว่าหากคุณเรียกใช้ ops หลายรายการพร้อมกัน ทั้งหมดจะแชร์พูลเธรดที่มีอยู่ทั้งหมด

ถ้าคุณมี Ops ไม่ปิดกั้นอิสระ (Ops ที่ไม่มีเส้นทางกำกับระหว่างพวกเขาในกราฟ) ใช้ tf.config.threading.set_inter_op_parallelism_threads ที่จะเรียกพวกเขาไปพร้อม ๆ กันโดยใช้สระว่ายน้ำที่มีอยู่ด้าย

เบ็ดเตล็ด

เมื่อทำงานร่วมกับรุ่นเล็กNVIDIA® GPU ที่คุณสามารถตั้งค่า tf.compat.v1.ConfigProto.force_gpu_compatible=True เพื่อบังคับเทนเซอร์ CPU ทุกคนที่จะได้รับการจัดสรรหน่วยความจำตรึง CUDA เพื่อให้เพิ่มอย่างมีนัยสำคัญต่อประสิทธิภาพการทำงานรูปแบบ อย่างไรก็ตาม โปรดใช้ความระมัดระวังในขณะที่ใช้ตัวเลือกนี้สำหรับรุ่นที่ไม่รู้จัก/มีขนาดใหญ่มาก เนื่องจากอาจส่งผลเสียต่อประสิทธิภาพของโฮสต์ (CPU)

ปรับปรุงประสิทธิภาพของอุปกรณ์

ตามวิธีปฏิบัติที่ดีที่สุดรายละเอียดที่นี่และใน คู่มือการเพิ่มประสิทธิภาพของ GPU เพื่อเพิ่มประสิทธิภาพในการปฏิบัติงานอุปกรณ์รุ่น TensorFlow

หากคุณกำลังใช้ NVIDIA GPU ให้บันทึกการใช้งาน GPU และหน่วยความจำลงในไฟล์ CSV โดยเรียกใช้:

nvidia-smi
--query-gpu=utilization.gpu,utilization.memory,memory.total,
memory.free,memory.used --format=csv

กำหนดค่าเค้าโครงข้อมูล

เมื่อทำงานกับข้อมูลที่มีข้อมูลช่องสัญญาณ (เช่น ภาพ) ให้ปรับรูปแบบการจัดวางข้อมูลให้เหมาะสมเพื่อให้มีอายุการใช้งานยาวนานกว่า (NHWC มากกว่า NCHW)

ช่องสุดท้ายรูปแบบข้อมูลที่ปรับปรุง เทนเซอร์หลักของ การใช้ประโยชน์และให้ปรับปรุงประสิทธิภาพการทำงานอย่างมีนัยสำคัญโดยเฉพาะอย่างยิ่งในรูปแบบความสับสนเมื่อคู่กับแอมป์ เลย์เอาต์ข้อมูล NCHW ยังคงใช้งานได้โดย Tensor Cores แต่เพิ่มโอเวอร์เฮดเพิ่มเติมเนื่องจากการดำเนินการทรานสโพสอัตโนมัติ

คุณสามารถเพิ่มประสิทธิภาพการจัดวางข้อมูลที่ต้องการรูปแบบ NHWC โดยการตั้งค่า data_format="channels_last" สำหรับชั้นเช่น tf.keras.layers.Conv2D , tf.keras.layers.Conv3D และ tf.keras.layers.experimental.preprocessing.RandomRotation

ใช้ tf.keras.backend.set_image_data_format การตั้งค่ารูปแบบการจัดวางข้อมูลเริ่มต้นสำหรับแบ็กเอนด์ API Keras

เพิ่มแคช L2 สูงสุด

When working with NVIDIA® GPUs, execute the code snippet below before the training loop to max out the L2 fetch granularity to 128 bytes.

import ctypes

_libcudart = ctypes.CDLL('libcudart.so')
# Set device limit on the current device
# cudaLimitMaxL2FetchGranularity = 0x05
pValue = ctypes.cast((ctypes.c_int*1)(), ctypes.POINTER(ctypes.c_int))
_libcudart.cudaDeviceSetLimit(ctypes.c_int(0x05), ctypes.c_int(128))
_libcudart.cudaDeviceGetLimit(pValue, ctypes.c_int(0x05))
assert pValue.contents.value == 128

Configure GPU thread usage

The GPU thread mode decides how GPU threads are used.

Set the thread mode to gpu_private to make sure that preprocessing does not steal all the GPU threads. This will reduce the kernel launch delay during training. You can also set the number of threads per GPU. Set these values using environment variables.

import os

os.environ['TF_GPU_THREAD_MODE']='gpu_private'
os.environ['TF_GPU_THREAD_COUNT']='1'

Configure GPU memory options

In general, increase the batch size and scale the model to better utilize GPUs and get higher throughput. Note that increasing the batch size will change the model's accuracy so the model needs to be scaled by tuning hyperparameters like the learning rate to meet the target accuracy.

Also, use tf.config.experimental.set_memory_growth to allow GPU memory to grow to prevent all the available memory from being fully allocated to ops that require only a fraction of the memory. This allows other processes which consume GPU memory to run on the same device.

To learn more, check out the Limiting GPU memory growth guidance in the GPU guide to learn more.

Miscellaneous

  • Increase the training mini-batch size (number of training samples used per device in one iteration of the training loop) to the maximum amount that fits without an out of memory (OOM) error on the GPU. Increasing the batch size impacts the model's accuracy—so make sure you scale the model by tuning hyperparameters to meet the target accuracy.

  • Disable reporting OOM errors during tensor allocation in production code. Set report_tensor_allocations_upon_oom=False in tf.compat.v1.RunOptions .

  • For models with convolution layers, remove bias addition if using batch normalization. Batch normalization shifts values by their mean and this removes the need to have a constant bias term.

  • Use TF Stats to find out how efficiently on-device ops run.

  • Use tf.function to perform computations and optionally, enable the jit_compile=True flag ( tf.function(jit_compile=True ). To learn more, go to Use XLA tf.function .

  • Minimize host Python operations between steps and reduce callbacks. Calculate metrics every few steps instead of at every step.

  • Keep the device compute units busy.

  • Send data to multiple devices in parallel.

  • Consider using 16-bit numerical representations , such as fp16 —the half-precision floating point format specified by IEEE—or the Brain floating-point bfloat16 format.

Additional resources

Known limitations

Profiling multiple GPUs on TensorFlow 2.2 and TensorFlow 2.3

TensorFlow 2.2 and 2.3 support multiple GPU profiling for single host systems only; multiple GPU profiling for multi-host systems is not supported. To profile multi-worker GPU configurations, each worker has to be profiled independently. From TensorFlow 2.4 multiple workers can be profiled using the tf.profiler.experimental.client.trace API.

CUDA® Toolkit 10.2 or later is required to profile multiple GPUs. As TensorFlow 2.2 and 2.3 support CUDA® Toolkit versions only up to 10.1, you need to create symbolic links to libcudart.so.10.1 and libcupti.so.10.1 :

sudo ln -s /usr/local/cuda/lib64/libcudart.so.10.2 /usr/local/cuda/lib64/libcudart.so.10.1
sudo ln -s /usr/local/cuda/extras/CUPTI/lib64/libcupti.so.10.2 /usr/local/cuda/extras/CUPTI/lib64/libcupti.so.10.1