คู่มือนี้สาธิตวิธีการใช้เครื่องมือที่มีอยู่ใน TensorFlow Profiler เพื่อติดตามประสิทธิภาพของโมเดล TensorFlow ของคุณ คุณจะได้เรียนรู้วิธีทำความเข้าใจว่าโมเดลของคุณทำงานอย่างไรบนโฮสต์ (CPU) อุปกรณ์ (GPU) หรือทั้งโฮสต์และอุปกรณ์ร่วมกัน
การทำโปรไฟล์ช่วยให้เข้าใจการใช้ทรัพยากรฮาร์ดแวร์ (เวลาและหน่วยความจำ) ของการดำเนินการ TensorFlow (ops) ต่างๆ ในแบบจำลองของคุณ และแก้ไขคอขวดด้านประสิทธิภาพ และทำให้โมเดลดำเนินการเร็วขึ้นในที่สุด
คู่มือนี้จะแนะนำคุณเกี่ยวกับวิธีการติดตั้ง Profiler เครื่องมือต่างๆ ที่มี โหมดต่างๆ ของวิธีที่ Profiler รวบรวมข้อมูลประสิทธิภาพ และแนวทางปฏิบัติที่ดีที่สุดบางส่วนที่แนะนำเพื่อปรับประสิทธิภาพของโมเดลให้เหมาะสมที่สุด
หากคุณต้องการโปรไฟล์ประสิทธิภาพโมเดลของคุณบน Cloud TPU โปรดดูคู่มือ Cloud TPU
ติดตั้งข้อกำหนดเบื้องต้นของ Profiler และ GPU
ติดตั้งปลั๊กอิน Profiler สำหรับ TensorBoard ด้วย pip โปรดทราบว่า Profiler ต้องใช้ TensorFlow และ TensorBoard เวอร์ชันล่าสุด (>=2.2)
pip install -U tensorboard_plugin_profile
ในการสร้างโปรไฟล์บน GPU คุณต้อง:
- ตรงตามข้อกำหนดของไดรเวอร์ NVIDIA® GPU และ CUDA® Toolkit ที่ระบุไว้ใน ข้อกำหนดซอฟต์แวร์สนับสนุน TensorFlow GPU
ตรวจสอบให้แน่ใจว่า NVIDIA® CUDA® Profiling Tools Interface (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 หรือไม่
แก้ไขปัญหาสิทธิพิเศษ
เมื่อคุณเรียกใช้การทำโปรไฟล์ด้วย CUDA® Toolkit ในสภาพแวดล้อม Docker หรือบน Linux คุณอาจพบปัญหาที่เกี่ยวข้องกับสิทธิ์ CUPTI ไม่เพียงพอ ( CUPTI_ERROR_INSUFFICIENT_PRIVILEGES ) ไปที่ NVIDIA Developer Docs เพื่อเรียนรู้เพิ่มเติมเกี่ยวกับวิธีการแก้ไขปัญหาเหล่านี้บน Linux
ในการแก้ไขปัญหาสิทธิ์ CUPTI ในสภาพแวดล้อม Docker ให้เรียกใช้
docker run option '--privileged=true'
เครื่องมือสร้างโปรไฟล์
เข้าถึง Profiler จากแท็บ Profile ใน TensorBoard ซึ่งจะปรากฏขึ้นหลังจากที่คุณได้บันทึกข้อมูลโมเดลบางส่วนเท่านั้น
Profiler มีเครื่องมือให้เลือกมากมายเพื่อช่วยในการวิเคราะห์ประสิทธิภาพ:
- หน้าภาพรวม
- ตัววิเคราะห์ไปป์ไลน์อินพุต
- สถิติเทนเซอร์โฟลว์
- ตัวแสดงการติดตาม
- สถิติเคอร์เนล GPU
- เครื่องมือโปรไฟล์หน่วยความจำ
- Pod Viewer
หน้าภาพรวม
หน้าภาพรวมให้มุมมองระดับบนสุดว่าโมเดลของคุณทำงานอย่างไรในระหว่างการรันโปรไฟล์ หน้านี้จะแสดงหน้าภาพรวมโดยรวมสำหรับโฮสต์และอุปกรณ์ทั้งหมดของคุณ และคำแนะนำบางประการในการปรับปรุงประสิทธิภาพการฝึกโมเดลของคุณ คุณยังสามารถเลือกโฮสต์แต่ละรายในรายการดรอปดาวน์ โฮสต์
หน้าภาพรวมแสดงข้อมูลดังนี้:
สรุปประสิทธิภาพ : แสดงสรุประดับสูงของประสิทธิภาพของแบบจำลองของคุณ สรุปผลการปฏิบัติงานมีสองส่วน:
การแบ่งขั้นตอนเวลา: แบ่งเวลาขั้นตอนเฉลี่ยออกเป็นหลายประเภทที่ใช้เวลา:
- การรวบรวม: เวลาที่ใช้ในการรวบรวมเมล็ด
- อินพุต: เวลาที่ใช้ในการอ่านข้อมูลอินพุต
- เอาต์พุต: เวลาที่ใช้ในการอ่านข้อมูลเอาต์พุต
- การเปิดเคอร์เนล: เวลาที่โฮสต์ใช้ในการเปิดเมล็ด
- เวลาประมวลผลโฮสต์..
- เวลาการสื่อสารระหว่างอุปกรณ์กับอุปกรณ์
- เวลาคำนวณในอุปกรณ์
- อื่นๆ ทั้งหมด รวมถึงค่าใช้จ่าย Python
ความแม่นยำในการประมวลผลของอุปกรณ์ - รายงานเปอร์เซ็นต์ของเวลาในการประมวลผลของอุปกรณ์ที่ใช้การคำนวณแบบ 16 และ 32 บิต
กราฟขั้นตอนเวลา : แสดงกราฟเวลาขั้นตอนอุปกรณ์ (เป็นมิลลิวินาที) ของขั้นตอนทั้งหมดที่สุ่มตัวอย่าง แต่ละขั้นตอนแบ่งออกเป็นหลายหมวดหมู่ (ด้วยสีที่ต่างกัน) ของที่ที่ใช้ไป พื้นที่สีแดงสอดคล้องกับส่วนของเวลาขั้นตอนที่อุปกรณ์ไม่ได้ใช้งานเพื่อรอข้อมูลอินพุตจากโฮสต์ พื้นที่สีเขียวแสดงเวลาที่อุปกรณ์ทำงานจริง
การทำงาน 10 อันดับแรกของ TensorFlow บนอุปกรณ์ (เช่น GPU) : แสดงการทำงานบนอุปกรณ์ที่ทำงานนานที่สุด
แต่ละแถวจะแสดงเวลาของตนเองของ op (เป็นเปอร์เซ็นต์ของเวลาที่ใช้โดย ops ทั้งหมด) เวลาสะสม หมวดหมู่ และชื่อ
Run Environment : แสดงสรุประดับสูงของสภาพแวดล้อมการรันโมเดล รวมถึง:
- จำนวนโฮสต์ที่ใช้
- ประเภทอุปกรณ์ (GPU/TPU)
- จำนวนคอร์ของอุปกรณ์
คำแนะนำสำหรับขั้นตอนต่อไป : รายงานเมื่อโมเดลถูกผูกไว้กับอินพุตและแนะนำเครื่องมือที่คุณสามารถใช้เพื่อระบุตำแหน่งและแก้ไขคอขวดของประสิทธิภาพของโมเดล
เครื่องวิเคราะห์ไปป์ไลน์อินพุต
เมื่อโปรแกรม TensorFlow อ่านข้อมูลจากไฟล์ โปรแกรม TensorFlow จะเริ่มต้นที่ด้านบนสุดของกราฟ TensorFlow ในลักษณะไพพ์ไลน์ กระบวนการอ่านแบ่งออกเป็นขั้นตอนการประมวลผลข้อมูลหลายขั้นตอนที่เชื่อมต่อกันเป็นชุด โดยที่เอาต์พุตของสเตจหนึ่งจะเป็นอินพุตไปยังสเตจถัดไป ระบบการอ่านข้อมูลนี้เรียกว่า ท่อส่งอินพุต
ไปป์ไลน์ทั่วไปสำหรับการอ่านเร็กคอร์ดจากไฟล์มีขั้นตอนต่อไปนี้:
- การอ่านไฟล์.
- การประมวลผลไฟล์ล่วงหน้า (ไม่บังคับ)
- การถ่ายโอนไฟล์จากโฮสต์ไปยังอุปกรณ์
ไปป์ไลน์อินพุตที่ไม่มีประสิทธิภาพอาจทำให้แอปพลิเคชันของคุณช้าลงอย่างมาก แอปพลิเคชันถือเป็น อินพุตที่ถูกผูกไว้ เมื่อใช้เวลาส่วนใหญ่ในไปป์ไลน์อินพุต ใช้ข้อมูลเชิงลึกที่ได้รับจากตัววิเคราะห์ไปป์ไลน์อินพุตเพื่อทำความเข้าใจว่าไปป์ไลน์อินพุทไม่มีประสิทธิภาพ
ตัววิเคราะห์ไปป์ไลน์อินพุตจะบอกคุณทันทีว่าโปรแกรมของคุณถูกผูกไว้กับอินพุตหรือไม่ และจะนำคุณไปสู่การวิเคราะห์ด้านอุปกรณ์และโฮสต์เพื่อดีบักปัญหาคอขวดด้านประสิทธิภาพในขั้นตอนใดๆ ในไพพ์ไลน์อินพุต
ตรวจสอบคำแนะนำเกี่ยวกับประสิทธิภาพของไปป์ไลน์อินพุตสำหรับแนวทางปฏิบัติที่ดีที่สุดที่แนะนำเพื่อเพิ่มประสิทธิภาพไปป์ไลน์อินพุตข้อมูลของคุณ
แดชบอร์ดไปป์ไลน์อินพุต
หากต้องการเปิดตัววิเคราะห์ไพพ์ไลน์อินพุต เลือก Profile จากนั้นเลือก input_pipeline_analyzer จากดรอปดาวน์ เครื่องมือ
แดชบอร์ดประกอบด้วยสามส่วน:
- สรุป : สรุปอินพุตไปป์ไลน์โดยรวมพร้อมข้อมูลว่าแอปพลิเคชันของคุณถูกผูกไว้หรือไม่ และถ้าใช่ จะใช้เท่าใด
- การวิเคราะห์ฝั่งอุปกรณ์ : แสดงผลการวิเคราะห์ฝั่งอุปกรณ์โดยละเอียด รวมถึงขั้นตอนของอุปกรณ์และช่วงเวลาของอุปกรณ์ที่ใช้ในการรอข้อมูลอินพุตข้ามคอร์ในแต่ละขั้นตอน
- การวิเคราะห์ฝั่งโฮสต์ : แสดงการวิเคราะห์โดยละเอียดเกี่ยวกับฝั่งโฮสต์ รวมถึงการแจกแจงเวลาในการประมวลผลอินพุตบนโฮสต์
สรุปไปป์ไลน์อินพุต
สรุป รายงานหากโปรแกรมของคุณถูกผูกไว้โดยแสดงเปอร์เซ็นต์ของเวลาอุปกรณ์ที่ใช้ในการรออินพุตจากโฮสต์ หากคุณกำลังใช้ไปป์ไลน์อินพุตมาตรฐานที่ได้รับเครื่องมือวัด เครื่องมือจะรายงานที่ซึ่งใช้เวลาประมวลผลอินพุตส่วนใหญ่
การวิเคราะห์ด้านอุปกรณ์
การวิเคราะห์ฝั่งอุปกรณ์ให้ข้อมูลเชิงลึกเกี่ยวกับเวลาที่ใช้ในอุปกรณ์เทียบกับบนโฮสต์ และเวลาที่ใช้อุปกรณ์ในการรอข้อมูลอินพุตจากโฮสต์
- เวลาขั้นตอนที่พล็อตเทียบกับหมายเลขขั้นตอน : แสดงกราฟเวลาขั้นตอนอุปกรณ์ (เป็นมิลลิวินาที) ของขั้นตอนทั้งหมดที่สุ่มตัวอย่าง แต่ละขั้นตอนแบ่งออกเป็นหลายหมวดหมู่ (ด้วยสีที่ต่างกัน) ของที่ที่ใช้ไป พื้นที่สีแดงสอดคล้องกับส่วนของเวลาขั้นตอนที่อุปกรณ์ไม่ได้ใช้งานเพื่อรอข้อมูลอินพุตจากโฮสต์ พื้นที่สีเขียวแสดงเวลาที่อุปกรณ์ทำงานจริง
- สถิติขั้นตอน : รายงานค่าเฉลี่ย ส่วนเบี่ยงเบนมาตรฐาน และช่วง ([ขั้นต่ำ สูงสุด]) ของเวลาขั้นตอนอุปกรณ์
การวิเคราะห์ฝั่งเจ้าบ้าน
การวิเคราะห์ฝั่งโฮสต์รายงานรายละเอียดของเวลาในการประมวลผลอินพุต (เวลาที่ใช้กับ tf.data API ops) บนโฮสต์ออกเป็นหลายประเภท:
- การอ่านข้อมูลจากไฟล์แบบออนดีมานด์ : เวลาที่ใช้ในการอ่านข้อมูลจากไฟล์โดยไม่ต้องแคช ดึงข้อมูลล่วงหน้า และแทรกระหว่างกัน
- การอ่านข้อมูลจากไฟล์ล่วงหน้า : เวลาที่ใช้ในการอ่านไฟล์ รวมถึงการแคช การดึงข้อมูลล่วงหน้า และการแทรกระหว่างกัน
- การประมวลผลข้อมูลล่วงหน้า : เวลาที่ใช้ในการประมวลผลล่วงหน้า เช่น การคลายการบีบอัดรูปภาพ
- การจัดคิวข้อมูลที่จะถ่ายโอนไปยังอุปกรณ์ : เวลาที่ใช้ในการใส่ข้อมูลลงในคิวการป้อนข้อมูลก่อนถ่ายโอนข้อมูลไปยังอุปกรณ์
ขยาย Input Op Statistics เพื่อตรวจสอบสถิติสำหรับ Input Ops แต่ละรายการและหมวดหมู่ของ Input Op Statistics ตามเวลาดำเนินการ
ตารางข้อมูลต้นฉบับจะปรากฏขึ้นพร้อมกับแต่ละรายการที่มีข้อมูลต่อไปนี้:
- Input Op : แสดงชื่อ op ของ TensorFlow ของอินพุต op
- Count : แสดงจำนวนอินสแตนซ์ทั้งหมดของการดำเนินการ op ในช่วงระยะเวลาการทำโปรไฟล์
- เวลาทั้งหมด (เป็นมิลลิวินาที) : แสดงผลรวมของเวลาที่ใช้ไปในแต่ละอินสแตนซ์เหล่านั้น
- % เวลาทั้งหมด : แสดงเวลาทั้งหมดที่ใช้ในการดำเนินการเป็นเศษส่วนของเวลาทั้งหมดที่ใช้ในการประมวลผลข้อมูลเข้า
- เวลาตนเองทั้งหมด (เป็นมิลลิวินาที) : แสดงผลรวมสะสมของเวลาตนเองที่ใช้ไปในแต่ละกรณีเหล่านั้น เวลาตัวเองที่นี่วัดเวลาที่ใช้ภายในเนื้อหาของฟังก์ชัน ไม่รวมเวลาที่ใช้ในฟังก์ชันที่เรียกใช้
- รวมเวลาตัวเอง% แสดงเวลาตนเองทั้งหมดเป็นเศษเสี้ยวของเวลาทั้งหมดที่ใช้ในการประมวลผลข้อมูลเข้า
- หมวดหมู่ . แสดงหมวดหมู่การประมวลผลของอินพุต op
สถิติ TensorFlow
เครื่องมือ TensorFlow Stats จะแสดงประสิทธิภาพของทุก TensorFlow op (op) ที่ดำเนินการบนโฮสต์หรืออุปกรณ์ระหว่างเซสชันการทำโปรไฟล์
เครื่องมือแสดงข้อมูลประสิทธิภาพในสองบานหน้าต่าง:
บานหน้าต่างด้านบนแสดงแผนภูมิวงกลมสูงสุดสี่แผนภูมิ:
- การกระจายเวลาดำเนินการตนเองของแต่ละ op บนโฮสต์
- การกระจายเวลาดำเนินการด้วยตนเองของ op แต่ละประเภทบนโฮสต์
- การกระจายเวลาดำเนินการด้วยตนเองของแต่ละ op บนอุปกรณ์
- การกระจายเวลาดำเนินการด้วยตนเองของ op แต่ละประเภทบนอุปกรณ์
บานหน้าต่างด้านล่างแสดงตารางที่รายงานข้อมูลเกี่ยวกับ TensorFlow ops โดยมีหนึ่งแถวสำหรับแต่ละ op และหนึ่งคอลัมน์สำหรับข้อมูลแต่ละประเภท (จัดเรียงคอลัมน์โดยคลิกที่ส่วนหัวของคอลัมน์) คลิกปุ่ม ส่งออกเป็น CSV ที่ด้านขวาของบานหน้าต่างด้านบนเพื่อส่งออกข้อมูลจากตารางนี้เป็นไฟล์ CSV
โปรดทราบว่า:
หาก ops ใดมี ops ย่อย:
- เวลา "สะสม" ทั้งหมดของ op รวมถึงเวลาที่ใช้ในปฏิบัติการย่อย
- เวลา "ตนเอง" ทั้งหมดของ op ไม่รวมเวลาที่ใช้ในปฏิบัติการย่อย
หาก op ดำเนินการบนโฮสต์:
- เปอร์เซ็นต์ของเวลาตัวเองทั้งหมดบนอุปกรณ์ที่เกิดขึ้นจากการดำเนินการจะเป็น 0
- เปอร์เซ็นต์สะสมของเวลาตัวเองทั้งหมดบนอุปกรณ์จนถึงและรวมถึงการดำเนินการนี้จะเป็น 0
หาก op ทำงานบนอุปกรณ์:
- เปอร์เซ็นต์ของเวลาตัวเองทั้งหมดบนโฮสต์ที่เกิดขึ้นโดยการดำเนินการนี้จะเป็น 0
- เปอร์เซ็นต์สะสมของเวลาตัวเองทั้งหมดบนโฮสต์จนถึงและรวมถึงการดำเนินการนี้จะเป็น 0
คุณสามารถเลือกที่จะรวมหรือไม่รวมเวลาว่างในแผนภูมิวงกลมและตาราง
โปรแกรมดูการติดตาม
โปรแกรมดูการติดตามแสดงไทม์ไลน์ที่แสดง:
- ระยะเวลาสำหรับการดำเนินการที่ดำเนินการโดยโมเดล TensorFlow ของคุณ
- ส่วนใดของระบบ (โฮสต์หรืออุปกรณ์) ที่ดำเนินการ op โดยปกติ โฮสต์จะดำเนินการป้อนข้อมูล ประมวลผลข้อมูลการฝึกอบรมล่วงหน้า และโอนไปยังอุปกรณ์ ในขณะที่อุปกรณ์ดำเนินการฝึกโมเดลจริง
โปรแกรมดูการติดตามช่วยให้คุณระบุปัญหาด้านประสิทธิภาพในแบบจำลองของคุณ จากนั้นทำตามขั้นตอนเพื่อแก้ไขปัญหา ตัวอย่างเช่น ในระดับสูง คุณสามารถระบุได้ว่าการป้อนข้อมูลหรือการฝึกโมเดลใช้เวลาส่วนใหญ่หรือไม่ การเจาะลึก คุณสามารถระบุได้ว่าการดำเนินการใดใช้เวลานานที่สุดในการดำเนินการ โปรดทราบว่าโปรแกรมดูการติดตามถูกจำกัดไว้ที่ 1 ล้านเหตุการณ์ต่ออุปกรณ์
อินเทอร์เฟซตัวแสดงการติดตาม
เมื่อคุณเปิดโปรแกรมดูการติดตาม ระบบจะแสดงการทำงานล่าสุดของคุณ:
หน้าจอนี้มีองค์ประกอบหลักดังต่อไปนี้:
- บานหน้าต่างไทม์ไลน์ : แสดง ops ที่อุปกรณ์และโฮสต์ดำเนินการเมื่อเวลาผ่านไป
- บานหน้าต่างรายละเอียด : แสดงข้อมูลเพิ่มเติมสำหรับการดำเนินการที่เลือกในบานหน้าต่างไทม์ไลน์
บานหน้าต่างไทม์ไลน์ประกอบด้วยองค์ประกอบต่อไปนี้:
- แถบ ด้านบน : ประกอบด้วยส่วนควบคุมเสริมต่างๆ
- แกนเวลา : แสดงเวลาที่สัมพันธ์กับจุดเริ่มต้นของการติดตาม
- ป้ายกำกับของ ส่วนและแทร็ก : แต่ละส่วนประกอบด้วยแทร็กหลายแทร็กและมีรูปสามเหลี่ยมทางด้านซ้ายซึ่งคุณสามารถคลิกเพื่อขยายและยุบส่วนได้ มีส่วนเดียวสำหรับทุกองค์ประกอบการประมวลผลในระบบ
- ตัวเลือกเครื่องมือ : ประกอบด้วยเครื่องมือต่างๆ สำหรับการโต้ตอบกับโปรแกรมดูการติดตาม เช่น ซูม แพน เลือก และกำหนดเวลา ใช้เครื่องมือ Timing เพื่อทำเครื่องหมายช่วงเวลา
- เหตุการณ์ : แสดงเวลาที่ดำเนินการ op หรือระยะเวลาของ meta-event เช่น ขั้นตอนการฝึกซ้อม
ส่วนและแทร็ก
โปรแกรมดูการติดตามประกอบด้วยส่วนต่อไปนี้:
- ส่วนหนึ่งสำหรับแต่ละโหนดอุปกรณ์ ซึ่งระบุหมายเลขชิปอุปกรณ์และโหนดอุปกรณ์ภายในชิป (เช่น
/device:GPU:0 (pid 0)) ส่วนโหนดอุปกรณ์แต่ละส่วนมีแทร็กต่อไปนี้:- ขั้นตอน : แสดงระยะเวลาของขั้นตอนการฝึกที่กำลังทำงานบนอุปกรณ์
- TensorFlow Ops : แสดง ops ที่ดำเนินการบนอุปกรณ์
- XLA Ops : แสดงการทำงานของ XLA (ops) ที่ทำงานบนอุปกรณ์หาก XLA เป็นคอมไพเลอร์ที่ใช้ (แต่ละ op ของ TensorFlow ถูกแปลเป็น XLA ops หนึ่งหรือหลายตัว คอมไพเลอร์ XLA แปล XLA ops เป็นโค้ดที่ทำงานบนอุปกรณ์)
- ส่วนหนึ่งสำหรับเธรดที่ทำงานบน CPU ของเครื่องโฮสต์ที่ มีป้ายกำกับว่า "Host Threads" ส่วนนี้มีหนึ่งแทร็กสำหรับเธรด CPU แต่ละอัน โปรดทราบว่าคุณสามารถละเว้นข้อมูลที่แสดงข้างป้ายชื่อส่วนได้
กิจกรรม
กิจกรรมภายในไทม์ไลน์จะแสดงเป็นสีต่างๆ สีเองไม่ได้มีความหมายเฉพาะเจาะจง
โปรแกรมดูการติดตามยังสามารถแสดงการเรียกใช้ฟังก์ชัน Python ในโปรแกรม TensorFlow ของคุณได้ หากคุณใช้ tf.profiler.experimental.start API คุณสามารถเปิดใช้งานการติดตาม Python ได้โดยใช้ ProfilerOptions ที่ชื่อtuple เมื่อเริ่มต้นการทำโปรไฟล์ หรือถ้าคุณใช้โหมดสุ่มตัวอย่างสำหรับการทำโปรไฟล์ คุณสามารถเลือกระดับของการติดตามได้โดยใช้ตัวเลือกแบบเลื่อนลงในกล่องโต้ตอบการ จับภาพโปรไฟล์
สถิติเคอร์เนล GPU
เครื่องมือนี้แสดงสถิติประสิทธิภาพและ op เริ่มต้นสำหรับเคอร์เนลที่เร่งความเร็ว GPU ทุกตัว
เครื่องมือจะแสดงข้อมูลในสองบานหน้าต่าง:
บานหน้าต่างด้านบนแสดงแผนภูมิวงกลมซึ่งแสดงเคอร์เนล CUDA ที่มีเวลารวมสูงสุดที่ผ่านไป
บานหน้าต่างด้านล่างแสดงตารางที่มีข้อมูลต่อไปนี้สำหรับคู่ kernel-op ที่ไม่ซ้ำกันแต่ละคู่:
- อันดับจากมากไปน้อยของระยะเวลา GPU ที่ผ่านไปทั้งหมดจัดกลุ่มตามคู่ kernel-op
- ชื่อของเคอร์เนลที่เรียกใช้
- จำนวนการลงทะเบียน GPU ที่ใช้โดยเคอร์เนล
- ขนาดรวมของหน่วยความจำที่ใช้ร่วมกัน (สแตติก + ไดนามิกที่ใช้ร่วมกัน) ที่ใช้เป็นไบต์
- ขนาดบล็อกที่แสดงเป็น
blockDim.x, blockDim.y, blockDim.z - ขนาดกริดที่แสดงเป็น
gridDim.x, gridDim.y, gridDim.z - op มีสิทธิ์ใช้ Tensor Cores หรือไม่
- เคอร์เนลมีคำสั่ง Tensor Core หรือไม่
- ชื่อของ op ที่เปิดใช้เคอร์เนลนี้
- จำนวนครั้งที่เกิดขึ้นของคู่ kernel-op นี้
- เวลา GPU ที่ผ่านไปทั้งหมด หน่วยเป็นไมโครวินาที
- เวลา GPU ที่ผ่านไปโดยเฉลี่ยในหน่วยไมโครวินาที
- เวลา GPU ที่ผ่านไปขั้นต่ำในหน่วยไมโครวินาที
- เวลา GPU ที่ผ่านไปสูงสุดในหน่วยไมโครวินาที
เครื่องมือโปรไฟล์หน่วยความจำ
เครื่องมือ โปรไฟล์หน่วยความจำ จะตรวจสอบการใช้หน่วยความจำของอุปกรณ์ของคุณในช่วงเวลาการทำโปรไฟล์ คุณสามารถใช้เครื่องมือนี้เพื่อ:
- แก้ปัญหาหน่วยความจำไม่เพียงพอ (OOM) โดยระบุการใช้หน่วยความจำสูงสุดและการจัดสรรหน่วยความจำที่สอดคล้องกับ TensorFlow ops คุณยังสามารถดีบักปัญหา OOM ที่อาจเกิดขึ้นเมื่อคุณเรียกใช้การอนุมาน แบบหลายผู้เช่า
- ดีบักปัญหาการกระจายตัวของหน่วยความจำ
เครื่องมือโปรไฟล์หน่วยความจำแสดงข้อมูลในสามส่วน:
- สรุปโปรไฟล์หน่วยความจำ
- กราฟไทม์ไลน์หน่วยความจำ
- ตารางรายละเอียดหน่วยความจำ
สรุปโปรไฟล์หน่วยความจำ
ส่วนนี้จะแสดงข้อมูลสรุประดับสูงของโปรไฟล์หน่วยความจำของโปรแกรม TensorFlow ของคุณดังที่แสดงด้านล่าง:
สรุปโปรไฟล์หน่วยความจำมีหกช่อง:
- รหัสหน่วยความจำ : ดรอปดาวน์ซึ่งแสดงรายการระบบหน่วยความจำอุปกรณ์ที่มีอยู่ทั้งหมด เลือกระบบหน่วยความจำที่คุณต้องการดูจากดรอปดาวน์
- #Allocation : จำนวนการจัดสรรหน่วยความจำที่ทำขึ้นระหว่างช่วงเวลาการทำโปรไฟล์
- #Deallocation : จำนวนการจัดสรรคืนหน่วยความจำในช่วงเวลาการทำโปรไฟล์
- ความจุหน่วยความจำ : ความจุ ทั้งหมด (เป็น GiB) ของระบบหน่วยความจำที่คุณเลือก
- การใช้งาน Peak Heap : การใช้หน่วยความจำสูงสุด (ใน GiB) ตั้งแต่รุ่นเริ่มทำงาน
- การใช้หน่วยความจำสูงสุด : การใช้หน่วยความจำสูงสุด (เป็น GiB) ในช่วงเวลาการทำโปรไฟล์ ฟิลด์นี้ประกอบด้วยฟิลด์ย่อยต่อไปนี้:
- การ ประทับเวลา : การประทับเวลาเมื่อมีการใช้หน่วยความจำสูงสุดบนกราฟเส้นเวลา
- Stack Reservation : จำนวนหน่วยความจำที่สงวนไว้บนสแต็ก (เป็น GiB)
- การจัดสรรฮีป : จำนวนหน่วยความจำที่จัดสรรบนฮีป (เป็น GiB)
- หน่วยความจำว่าง : จำนวนหน่วยความจำว่าง (เป็น GiB) ความจุหน่วยความจำเป็นผลรวมของการสำรองสแต็ค การจัดสรรฮีป และหน่วยความจำว่าง
- Fragmentation : เปอร์เซ็นต์ของการกระจายตัว (ต่ำกว่าดีกว่า) คำนวณเป็นเปอร์เซ็นต์ของ
(1 - Size of the largest chunk of free memory / Total free memory)
กราฟไทม์ไลน์หน่วยความจำ
ส่วนนี้แสดงพล็อตของการใช้หน่วยความจำ (เป็น GiB) และเปอร์เซ็นต์ของการแตกแฟรกเมนต์เทียบกับเวลา (เป็นมิลลิวินาที)
แกน X แสดงถึงไทม์ไลน์ (เป็นมิลลิวินาที) ของช่วงการทำโปรไฟล์ แกน Y ทางด้านซ้ายแสดงถึงการใช้หน่วยความจำ (ใน GiB) และแกน Y ทางด้านขวาแสดงถึงเปอร์เซ็นต์ของการแตกแฟรกเมนต์ ในแต่ละจุดของเวลาบนแกน X หน่วยความจำทั้งหมดจะแบ่งออกเป็นสามประเภท: สแต็ก (สีแดง) ฮีป (สีส้ม) และว่าง (สีเขียว) วางเมาส์เหนือการประทับเวลาเฉพาะเพื่อดูรายละเอียดเกี่ยวกับเหตุการณ์การจัดสรร/จัดสรรหน่วยความจำ ณ จุดนั้นดังด้านล่าง:
หน้าต่างป๊อปอัปจะแสดงข้อมูลต่อไปนี้:
- timestamp(ms) : ตำแหน่งของเหตุการณ์ที่เลือกบนไทม์ไลน์
- เหตุการณ์ : ประเภทของเหตุการณ์ (การจัดสรรหรือการจัดสรรคืน)
- request_size(GiBs) : จำนวนหน่วยความจำที่ร้องขอ นี่จะเป็นจำนวนลบสำหรับเหตุการณ์การจัดสรรคืน
- allocation_size(GiBs) : จำนวนหน่วยความจำจริงที่จัดสรร นี่จะเป็นจำนวนลบสำหรับเหตุการณ์การจัดสรรคืน
- tf_op : op ของ TensorFlow ที่ร้องขอการจัดสรร/จัดสรร
- step_id : ขั้นตอนการฝึกที่เกิดเหตุการณ์นี้
- region_type : ประเภทเอนทิตีข้อมูลที่หน่วยความจำที่จัดสรรนี้มีไว้สำหรับ ค่าที่เป็นไปได้คือ
tempชั่วคราวoutputสำหรับการเปิดใช้งานและการไล่ระดับสี และค่าpersist/dynamicสำหรับน้ำหนักและค่าคงที่ - data_type : ประเภทองค์ประกอบเทนเซอร์ (เช่น uint8 สำหรับจำนวนเต็ม 8 บิตที่ไม่ได้ลงนาม)
- tensor_shape : รูปร่างของเทนเซอร์ที่ถูกจัดสรร/จัดสรรใหม่
- memory_in_use(GiBs) : หน่วยความจำทั้งหมดที่ใช้ ณ เวลานี้
ตารางแบ่งหน่วยความจำ
ตารางนี้แสดงการจัดสรรหน่วยความจำที่ใช้งานอยู่ ณ จุดที่มีการใช้หน่วยความจำสูงสุดในช่วงเวลาการทำโปรไฟล์
มีหนึ่งแถวสำหรับแต่ละ TensorFlow Op และแต่ละแถวมีคอลัมน์ต่อไปนี้:
- ชื่อ Op : ชื่อของ TensorFlow op
- ขนาดการจัดสรร (GiB) : จำนวนหน่วยความจำทั้งหมดที่จัดสรรให้กับ op นี้
- ขนาดที่ร้องขอ (GiB) : จำนวนหน่วยความจำทั้งหมดที่ร้องขอสำหรับ op นี้
- Occurrences : จำนวนการจัดสรรสำหรับ op นี้
- ชนิดภูมิภาค : ชนิดเอนทิตีข้อมูลที่หน่วยความจำที่จัดสรรนี้มีไว้สำหรับ ค่าที่เป็นไปได้คือ
tempชั่วคราวoutputสำหรับการเปิดใช้งานและการไล่ระดับสี และค่าpersist/dynamicสำหรับน้ำหนักและค่าคงที่ - ชนิดข้อมูล : ชนิดองค์ประกอบเทนเซอร์
- รูปร่าง : รูปร่างของเทนเซอร์ที่จัดสรร
โปรแกรมดูพ็อด
เครื่องมือ Pod Viewer จะแสดงรายละเอียดของขั้นตอนการฝึกอบรมสำหรับผู้ปฏิบัติงานทั้งหมด
- บานหน้าต่างด้านบนมีแถบเลื่อนสำหรับเลือกหมายเลขขั้นตอน
- บานหน้าต่างด้านล่างแสดงแผนภูมิคอลัมน์แบบเรียงซ้อน นี่คือมุมมองระดับสูงของหมวดหมู่ขั้นตอนเวลาแยกย่อยที่วางทับกัน แต่ละคอลัมน์แบบเรียงซ้อนแสดงถึงผู้ปฏิบัติงานที่ไม่ซ้ำกัน
- เมื่อคุณวางเมาส์เหนือคอลัมน์ที่เรียงซ้อนกัน การ์ดทางด้านซ้ายมือจะแสดงรายละเอียดเพิ่มเติมเกี่ยวกับการแจกแจงขั้นตอน
tf.data การวิเคราะห์คอขวด
เครื่องมือวิเคราะห์คอขวด tf.data จะตรวจจับปัญหาคอขวดในไปป์ไลน์อินพุต tf.data ในโปรแกรมของคุณโดยอัตโนมัติ และให้คำแนะนำเกี่ยวกับวิธีการแก้ไข ใช้งานได้กับทุกโปรแกรมที่ใช้ tf.data โดยไม่คำนึงถึงแพลตฟอร์ม (CPU/GPU/TPU) การวิเคราะห์และคำแนะนำเป็นไปตาม คู่มือ นี้
ตรวจพบคอขวดโดยทำตามขั้นตอนเหล่านี้:
- ค้นหาโฮสต์ที่ถูกผูกไว้กับอินพุตมากที่สุด
- ค้นหาการดำเนินการที่ช้าที่สุดของไปป์ไลน์อินพุต
tf.data - สร้างกราฟไปป์ไลน์อินพุตใหม่จากการติดตามตัวสร้างโปรไฟล์
- ค้นหาเส้นทางวิกฤตในกราฟไปป์ไลน์อินพุต
- ระบุการเปลี่ยนแปลงที่ช้าที่สุดบนเส้นทางวิกฤตว่าเป็นคอขวด
UI แบ่งออกเป็นสามส่วน: สรุปการวิเคราะห์ประสิทธิภาพ สรุป ไปป์ไลน์อินพุตทั้งหมด และ กราฟไปป์ไลน์อินพุต
สรุปการวิเคราะห์ประสิทธิภาพ
ส่วนนี้ให้ข้อมูลสรุปการวิเคราะห์ รายงานเกี่ยวกับไปป์ไลน์อินพุต tf.data ที่ช้าที่ตรวจพบในโปรไฟล์ ส่วนนี้ยังแสดงโฮสต์ที่ถูกผูกไว้กับอินพุตมากที่สุดและไปป์ไลน์อินพุตที่ช้าที่สุดพร้อมเวลาแฝงสูงสุด สิ่งสำคัญที่สุดคือจะระบุว่าส่วนใดของไพพ์ไลน์อินพุตที่เป็นคอขวดและจะแก้ไขได้อย่างไร ข้อมูลคอขวดมีให้พร้อมกับประเภทตัววนซ้ำและชื่อยาว
วิธีอ่านชื่อยาวของ tf.data iterator
ชื่อแบบยาวถูกจัดรูปแบบเป็น Iterator::<Dataset_1>::...::<Dataset_n> ในชื่อแบบยาว <Dataset_n> จะจับคู่ประเภทตัววนซ้ำและชุดข้อมูลอื่นๆ ในชื่อแบบยาวแสดงถึงการแปลงแบบดาวน์สตรีม
ตัวอย่างเช่น พิจารณาชุดข้อมูลไปป์ไลน์อินพุตต่อไปนี้:
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 op ในไพพ์ไลน์อินพุต หากดำเนินการหลายครั้ง จะเป็นเวลาเริ่มต้นของการดำเนินการครั้งแรก
Total Duration คือระยะเวลาในการดำเนินการ หากถูกประหารชีวิตหลายครั้ง จะเท่ากับผลรวมของเวลากำแพงของการประหารชีวิตทั้งหมด
Self Time คือ เวลาทั้งหมด โดยไม่มีเวลาที่ทับซ้อนกันกับโหนดย่อยในทันที
"# Calls" คือจำนวนครั้งที่ดำเนินการไพพ์ไลน์อินพุต
รวบรวมข้อมูลประสิทธิภาพ
TensorFlow Profiler รวบรวมกิจกรรมโฮสต์และการติดตาม GPU ของโมเดล TensorFlow ของคุณ คุณสามารถกำหนดค่า Profiler เพื่อรวบรวมข้อมูลประสิทธิภาพผ่านโหมดโปรแกรมหรือโหมดสุ่มตัวอย่าง
การทำโปรไฟล์ APIs
คุณสามารถใช้ API ต่อไปนี้เพื่อทำโปรไฟล์ได้
โหมดแบบเป็นโปรแกรมโดยใช้ TensorBoard Keras Callback (
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.profilerAPItf.profiler.experimental.start('logdir') # Train the model here tf.profiler.experimental.stop()โหมดแบบเป็นโปรแกรมโดยใช้ตัวจัดการบริบท
with tf.profiler.experimental.Profile('logdir'): # Train the model here pass
โหมดสุ่มตัวอย่าง: ดำเนินการสร้างโปรไฟล์ตามความต้องการโดยใช้
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)
ใช้กล่องโต้ตอบ Capture Profile เพื่อระบุ:
- รายการ 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 และทำให้เหตุการณ์ขั้นตอนแสดงในโปรแกรมดูการติดตาม
ตรวจสอบให้แน่ใจว่าคุณรวม dataset 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
- แพลตฟอร์มฮาร์ดแวร์ : โปรไฟล์ CPU, GPU และ TPU
ตารางด้านล่างแสดงภาพรวมโดยย่อของกรณีการใช้งานที่รองรับ 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] เพื่อเพิ่มประสิทธิภาพไปป์ไลน์การป้อนข้อมูลของคุณ ไปป์ไลน์การป้อนข้อมูลที่มีประสิทธิภาพสามารถปรับปรุงความเร็วของการดำเนินการโมเดลของคุณได้อย่างมากโดยลดเวลาที่ไม่ได้ใช้งานของอุปกรณ์ พยายามรวมแนวทางปฏิบัติที่ดีที่สุดที่มีรายละเอียดใน Better performance ด้วยคู่มือ tf.data API และด้านล่างเพื่อทำให้ไปป์ไลน์การป้อนข้อมูลของคุณมีประสิทธิภาพมากขึ้น
โดยทั่วไป การขนาน ops ใด ๆ ที่ไม่จำเป็นต้องดำเนินการตามลำดับสามารถเพิ่มประสิทธิภาพไปป์ไลน์การป้อนข้อมูลได้อย่างมาก
ในหลายกรณี การเปลี่ยนลำดับของการโทรบางรายการหรือปรับอาร์กิวเมนต์เพื่อให้ทำงานได้ดีที่สุดสำหรับโมเดลของคุณ ขณะปรับไปป์ไลน์ข้อมูลอินพุตให้เหมาะสม ให้เปรียบเทียบเฉพาะตัวโหลดข้อมูลที่ไม่มีขั้นตอนการฝึกอบรมและการเผยแพร่ย้อนหลัง เพื่อหาปริมาณผลกระทบของการปรับให้เหมาะสมอย่างอิสระ
ลองเรียกใช้แบบจำลองของคุณด้วยข้อมูลสังเคราะห์เพื่อตรวจสอบว่าไปป์ไลน์อินพุตเป็นคอขวดด้านประสิทธิภาพหรือไม่
ใช้
tf.data.Dataset.shardสำหรับการฝึกอบรม GPU หลายตัว ตรวจสอบให้แน่ใจว่าคุณแบ่งส่วนข้อมูลตั้งแต่ต้นในลูปอินพุตเพื่อป้องกันปริมาณงานลดลง เมื่อทำงานกับ TFRecords ตรวจสอบให้แน่ใจว่าคุณแยกส่วนรายการ TFRecords ไม่ใช่เนื้อหาของ TFRecordsขนานหลาย ops โดยการตั้งค่าแบบไดนามิกของ
num_parallel_callsโดยใช้tf.data.AUTOTUNEพิจารณาจำกัดการใช้งาน
tf.data.Dataset.from_generatorเนื่องจากจะช้ากว่าเมื่อเปรียบเทียบกับ TensorFlow ops ล้วนๆพิจารณาจำกัดการใช้งาน
tf.py_functionเนื่องจากไม่สามารถทำให้เป็นอนุกรมได้ และไม่รองรับการทำงานใน TensorFlow แบบกระจายใช้
tf.data.Optionsเพื่อควบคุมการเพิ่มประสิทธิภาพแบบคงที่ไปยังไปป์ไลน์อินพุต
อ่าน คู่มือ การวิเคราะห์ประสิทธิภาพ tf.data สำหรับคำแนะนำเพิ่มเติมเกี่ยวกับการเพิ่มประสิทธิภาพไปป์ไลน์อินพุตของคุณ
เพิ่มประสิทธิภาพการเสริมข้อมูล
เมื่อทำงานกับข้อมูลรูปภาพ ให้ เพิ่มข้อมูล ของคุณอย่างมีประสิทธิภาพมากขึ้นโดยส่งไปยังประเภทข้อมูลต่างๆ หลังจาก ใช้การแปลงเชิงพื้นที่ เช่น การพลิก การครอบตัด การหมุน ฯลฯ
ใช้ NVIDIA® DALI
ในบางกรณี เช่น เมื่อคุณมีระบบที่มีอัตราส่วน GPU ต่อ CPU สูง การเพิ่มประสิทธิภาพทั้งหมดข้างต้นอาจไม่เพียงพอที่จะขจัดปัญหาคอขวดในตัวโหลดข้อมูลที่เกิดจากข้อจำกัดของรอบ CPU
หากคุณกำลังใช้ NVIDIA® GPU สำหรับคอมพิวเตอร์วิทัศน์และแอปพลิเคชันการเรียนรู้เชิงลึกด้านเสียง ให้พิจารณาใช้ Data Loading Library ( DALI ) เพื่อเร่งความเร็วของไปป์ไลน์ข้อมูล
ตรวจสอบเอกสาร NVIDIA® DALI: Operations สำหรับรายการ DALI ops ที่รองรับ
ใช้เธรดและการดำเนินการแบบขนาน
เรียกใช้ ops บนเธรด CPU หลายตัวด้วย tf.config.threading API เพื่อดำเนินการเร็วขึ้น
TensorFlow จะกำหนดจำนวนเธรดแบบขนานโดยอัตโนมัติตามค่าเริ่มต้น เธรดพูลที่พร้อมใช้งานสำหรับการรัน TensorFlow ops ขึ้นอยู่กับจำนวนเธรดของ CPU ที่พร้อมใช้งาน
ควบคุมการเพิ่มความเร็วแบบขนานสูงสุดสำหรับ op เดียวโดยใช้ 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)
รูปแบบข้อมูลล่าสุดของแชนเนลช่วยปรับปรุงการใช้ Tensor Core และให้การปรับปรุงประสิทธิภาพที่สำคัญโดยเฉพาะอย่างยิ่งในแบบจำลองการบิดเมื่อใช้ร่วมกับ AMP เลย์เอาต์ข้อมูล NCHW ยังคงใช้งานได้โดย Tensor Cores แต่เพิ่มโอเวอร์เฮดเพิ่มเติมเนื่องจากการดำเนินการทรานสโพสอัตโนมัติ
คุณสามารถปรับเลย์เอาต์ข้อมูลให้เหมาะสมกับเลย์เอาต์ NHWC โดยการตั้งค่า data_format="channels_last" สำหรับเลเยอร์ เช่น tf.keras.layers.Conv2D , tf.keras.layers.Conv3D และ tf.keras.layers.RandomRotation
ใช้ tf.keras.backend.set_image_data_format เพื่อตั้งค่ารูปแบบเค้าโครงข้อมูลเริ่มต้นสำหรับ Keras แบ็กเอนด์ API
เพิ่มแคช 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=Falseintf.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.functionto perform computations and optionally, enable thejit_compile=Trueflag (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
- The TensorFlow Profiler: Profile model performance tutorial with Keras and TensorBoard where you can apply the advice in this guide.
- The Performance profiling in TensorFlow 2 talk from the TensorFlow Dev Summit 2020.
- The TensorFlow Profiler demo from the TensorFlow Dev Summit 2020.
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