ไปที่
v0.6.1
บทนำ | การอนุมาน | การฝึกอบรม | ความสามารถในการประกอบ | เคอร์เนลที่กำหนดเอง | คุณสมบัติอัลฟ่า | การติดตั้ง | บูรณาการ | วิดีโอ | ใบอนุญาต | การอ้างอิง
torchao: ไลบรารี PyTorch สำหรับประเภทข้อมูลที่กำหนดเองและการเพิ่มประสิทธิภาพ หาปริมาณและกระจายน้ำหนัก การไล่ระดับสี เครื่องมือเพิ่มประสิทธิภาพ และการเปิดใช้งานสำหรับการอนุมานและการฝึกอบรม
จากทีมงานที่นำซีรีย์เรื่องเร็วมาสู่คุณ
torchao ใช้งานได้กับ torch.compile() และ FSDP2 บนโมเดล PyTorch ส่วนใหญ่บน Huggingface เมื่อแกะกล่อง
การหาปริมาณและการกระจายโมเดลของคุณเป็น 1 ซับในที่ควรใช้กับโมเดลใดๆ ที่มี nn.Linear รวมถึงโมเดล HuggingFace ที่คุณชื่นชอบด้วย คุณสามารถดูคำแนะนำการใช้งานที่ครอบคลุมมากขึ้นได้ที่นี่ ความกระจัดกระจายที่นี่ และตัวอย่างการอนุมาน HuggingFace ที่นี่
สำหรับการอนุมาน เรามีทางเลือกคือ
from torchao . quantization . quant_api import (
quantize_ ,
int8_dynamic_activation_int8_weight ,
int4_weight_only ,
int8_weight_only
)
quantize_ ( m , int4_weight_only ()) สำหรับ gpt-fast int4_weight_only() เป็นตัวเลือกที่ดีที่สุดที่ bs=1 เนื่องจากเป็น 2x tok/s และลดข้อกำหนด VRAM ลงประมาณ 65% จากพื้นฐานที่คอมไพล์ด้วย torch.compiled
หากคุณมี VRAM ไม่เพียงพอที่จะหาปริมาณโมเดลทั้งหมดของคุณบน GPU และคุณพบว่าการหาปริมาณของ CPU ช้าเกินไป คุณสามารถใช้อาร์กิวเมนต์อุปกรณ์เช่น so quantize_(model, int8_weight_only(), device="cuda") ซึ่งจะส่ง และกำหนดปริมาณแต่ละเลเยอร์ให้กับ GPU ของคุณแยกกัน
หากคุณเห็นการชะลอตัวด้วยเทคนิคใดๆ เหล่านี้ หรือคุณไม่แน่ใจว่าควรใช้ตัวเลือกใด ให้พิจารณาใช้ autoquant ซึ่งจะโปรไฟล์เลเยอร์โดยอัตโนมัติ และเลือกวิธีที่ดีที่สุดในการนับจำนวนแต่ละเลเยอร์
model = torchao . autoquant ( torch . compile ( model , mode = 'max-autotune' ))นอกจากนี้เรายังมี API สำหรับนักพัฒนาเพื่อให้คุณสามารถใช้อัลกอริธึมการหาปริมาณของคุณเองได้ ดังนั้นโปรดใช้อัลกอริธึม HQQ ที่ยอดเยี่ยมเป็นตัวอย่างที่สร้างแรงบันดาลใจ
เราได้เพิ่มการหาปริมาณแคช kv และคุณสมบัติอื่นๆ เพื่อเปิดใช้งานการอนุมานบริบทที่มีความยาว (และจำเป็นต้องใช้หน่วยความจำอย่างมีประสิทธิภาพ)
ในทางปฏิบัติคุณสมบัติเหล่านี้ควบคู่ไปกับการวัดปริมาณเฉพาะน้ำหนัก int4 ทำให้เราสามารถ ลดหน่วยความจำสูงสุดลงได้ ~55% ซึ่งหมายความว่าเราสามารถอนุมาน Llama3.1-8B ด้วย ความยาวบริบท 130k โดยมีหน่วยความจำสูงสุดเพียง 18.9 GB รายละเอียดเพิ่มเติมสามารถพบได้ที่นี่
การหาปริมาณหลังการฝึกอบรมอาจส่งผลให้เกิดแบบจำลองที่รวดเร็วและกะทัดรัด แต่ยังอาจส่งผลให้ความแม่นยำลดลงอีกด้วย เราขอแนะนำให้สำรวจ Quantization Aware Training (QAT) เพื่อเอาชนะข้อจำกัดนี้ ด้วยความร่วมมือกับ Torchtune เราได้พัฒนาสูตร QAT ที่แสดงให้เห็นถึงการปรับปรุงความแม่นยำอย่างมีนัยสำคัญเมื่อเทียบกับ PTQ แบบดั้งเดิม โดยสามารถกู้คืน ความแม่นยำที่ลดลง 96% บน hellaswag และ 68% ของการลดความซับซ้อนของข้อความวิกิ สำหรับ Llama3 เมื่อเทียบกับการวัดปริมาณหลังการฝึกอบรม (PTQ) . และเราได้จัดเตรียมสูตรฉบับเต็มไว้ที่นี่
from torchao . quantization . qat import Int8DynActInt4WeightQATQuantizer
qat_quantizer = Int8DynActInt4WeightQATQuantizer ()
# Insert "fake quantize" operations into linear layers.
# These operations simulate quantization numerics
model = qat_quantizer . prepare ( model )
# Run Training...
# Convert fake quantize to actual quantize operations
model = qat_quantizer . convert ( model )torchao.float8 ใช้สูตรการฝึกอบรมด้วย float8 dtypes ที่ปรับขนาดตามที่ระบุไว้ใน https://arxiv.org/abs/2209.05433
เมื่อเปิด torch.compile ผลลัพธ์ปัจจุบันจะแสดงความเร็วการรับส่งข้อมูลสูงถึง 1.5 เท่าในงานฝึกล่วงหน้า 128 H100 GPU LLaMa 3 70B (รายละเอียด)
from torchao . float8 import convert_to_float8_training
convert_to_float8_training ( m , module_filter_fn = ...)และสำหรับสูตรการฝึกล่วงหน้าตั้งแต่ต้นจนจบด้วย float8 คุณสามารถดู torchtitan ได้
เราได้เพิ่มการรองรับการกระจายแบบกึ่งโครงสร้าง 2:4 พร้อม การเร่งความเร็วตั้งแต่ต้นทางถึงปลายทาง 6% บน ViT-L บล็อกเต็มที่นี่
การเปลี่ยนแปลงโค้ดเป็นเพียง 1 ซับในซึ่งมีตัวอย่างเต็มอยู่ที่นี่
swap_linear_with_semi_sparse_linear ( model , { "seq.0" : SemiSparseLinear })ADAM ใช้หน่วยความจำ 2 เท่าของพารามิเตอร์โมเดล เพื่อให้เราสามารถกำหนดปริมาณสถานะของเครื่องมือเพิ่มประสิทธิภาพให้เป็น 8 หรือ 4 บิตได้อย่างมีประสิทธิภาพ ซึ่งช่วยลดข้อกำหนด VRAM ของเครื่องมือเพิ่มประสิทธิภาพลง 2x หรือ 4x ตามลำดับบนพื้นฐาน fp16
from torchao . prototype . low_bit_optim import AdamW8bit , AdamW4bit , AdamWFp8
optim = AdamW8bit ( model . parameters ()) # replace with Adam4bit and AdamFp8 for the 4 / fp8 versionsในทางปฏิบัติ เราช้ากว่าเคอร์เนลที่เขียนโดยผู้เชี่ยวชาญเล็กน้อย แต่การใช้งานสำหรับเครื่องมือเพิ่มประสิทธิภาพเหล่านี้เขียนด้วย โค้ด PyTorch สองสามร้อยบรรทัด และคอมไพล์ ดังนั้นโปรดใช้หรือคัดลอกและวางสำหรับเครื่องมือเพิ่มประสิทธิภาพเชิงปริมาณของคุณ เกณฑ์มาตรฐานที่นี่
นอกจากนี้เรายังรองรับการถ่ายโอน CPU GPU ตัวเดียว โดยที่ทั้งการไล่ระดับสี (ขนาดเดียวกับน้ำหนัก) และตัวเพิ่มประสิทธิภาพจะถูกส่งไปยัง CPU อย่างมีประสิทธิภาพ เพียงอย่างเดียวนี้สามารถ ลดความต้องการ VRAM ของคุณได้ 60%
optim = CPUOffloadOptimizer ( model . parameters (), torch . optim . AdamW , fused = True )
optim . load_state_dict ( ckpt [ "optim" ])torch.compile : หลักการออกแบบที่สำคัญสำหรับเราคือความสามารถในการเขียนได้เช่นเดียวกับใน dtype หรือเลย์เอาต์ใหม่ใดๆ ที่เรามีให้เพื่อทำงานร่วมกับคอมไพเลอร์ของเรา ไม่สำคัญว่าเคอร์เนลจะเขียนด้วย PyTorch, CUDA, C++ หรือ Triton ล้วนๆ สิ่งต่างๆ ควรจะได้ผล! ดังนั้นเราจึงเขียน dtype, เลย์เอาต์ หรือตรรกะการบรรจุบิตใน PyTorch ล้วนๆ และเคอร์เนลที่มีประสิทธิภาพในการสร้างโค้ดตัวอย่างที่ดีที่สุดที่เราได้รวมความสามารถในการเขียนของ dtype บิตล่างเข้ากับการคอมไพล์และ fsdp คือ NF4 ซึ่งเราใช้เพื่อใช้อัลกอริธึม QLoRA ดังนั้น หากคุณกำลังค้นคว้าข้อมูลบริเวณสี่แยกของพื้นที่นี้ เรายินดีรับฟังจากคุณ
เราได้เพิ่มการรองรับสำหรับการเขียนและการปล่อย ops แบบกำหนดเองที่ไม่สร้างกราฟด้วย torch.compile() ดังนั้นหากคุณชอบการเขียนเคอร์เนล แต่ไม่ชอบการแพ็กเคอร์เนลเพื่อให้ทำงานได้กับระบบปฏิบัติการและเวอร์ชัน cuda ทั้งหมด เรายินดีที่จะยอมรับการสนับสนุนสำหรับ การดำเนินการที่กำหนดเองของคุณ เรามีตัวอย่างบางส่วนที่คุณสามารถปฏิบัติตามได้
quantize_(model, fpx_weight_only(3, 2))หากคุณเชื่อว่ามีเคอร์เนล CUDA อื่นๆ ที่เราควรจะพิจารณาอย่างละเอียด โปรดแสดงความคิดเห็นเกี่ยวกับปัญหานี้
สิ่งที่เราตื่นเต้นแต่ต้องใช้เวลาปรุงในเตาอบมากกว่านี้
quantize_(model, int8_weight_only_quantized_training()) งานนี้เป็นงานต้นแบบเนื่องจากการวัดประสิทธิภาพหน่วยความจำยังไม่น่าสนใจ torchao ใช้คุณสมบัติใหม่หลายอย่างใน Pytorch อย่างเสรี ขอแนะนำให้ใช้กับ PyTorch เวอร์ชันกลางคืนหรือเวอร์ชันเสถียรล่าสุดในปัจจุบัน
รุ่นเสถียรจาก Pypi ซึ่งจะมีค่าเริ่มต้นเป็น CUDA 12.1
pip install torchaoการเปิดตัวที่เสถียรจากดัชนี PyTorch
pip install torchao --extra-index-url https://download.pytorch.org/whl/cu121 # full options are cpu/cu118/cu121/cu124ปล่อยคืน
pip install --pre torchao --index-url https://download.pytorch.org/whl/nightly/cu121 # full options are cpu/cu118/cu121/cu124สำหรับนักพัฒนา ส่วนใหญ่ คุณอาจต้องการข้ามการสร้างส่วนขยาย C++/CUDA แบบกำหนดเองเพื่อการทำซ้ำที่เร็วขึ้น
USE_CPP=0 pip install -e . นอกจากนี้เรายังโชคดีที่ได้รวมเข้ากับไลบรารีโอเพ่นซอร์สชั้นนำบางแห่งรวมถึง
torchao ได้รับการเผยแพร่ภายใต้ใบอนุญาต BSD 3
หากคุณพบว่าห้องสมุด Torchao มีประโยชน์ โปรดอ้างอิงในงานของคุณดังต่อไปนี้
@software { torchao ,
title = { torchao: PyTorch native quantization and sparsity for training and inference } ,
author = { torchao maintainers and contributors } ,
url = { https//github.com/pytorch/torchao } ,
license = { BSD-3-Clause } ,
month = oct,
year = { 2024 }
