koila
1.0.0
Koila แก้
CUDA error: out of memory errorอย่างไม่เจ็บปวด แก้ไขด้วยรหัสเพียงบรรทัดเดียวและลืมมันไป
สาขาหลักเป็นโครงสร้างใหม่ที่สมบูรณ์ของโครงการ (ซึ่งส่วนใหญ่ว่างเปล่าเนื่องจากฉันไม่มีเวลาเพียงพอที่จะทำให้เสร็จ) หากต้องการดูรหัสการทำงานให้ชำระเงินแท็ก v0.1.1 เพื่อพิสูจน์แนวคิด (ซึ่งไม่ได้รับการสนับสนุนอย่างเต็มที่จากการดำเนินงานทั้งหมดและไม่เหมาะสำหรับการผลิต) หากต้องการใช้งานให้ดาวน์โหลด release v0.1.1 ที่นี่
- ป้องกัน CUDA error: out of memory error ด้วยรหัสเดียวบรรทัดเดียว
⚗สะสมการไล่ระดับสีโดยอัตโนมัติเมื่อขนาดแบทช์มีขนาดใหญ่เกินไป
- ประเมินรหัส pytorch อย่างเกียจคร้านเพื่อประหยัดกำลังการคำนวณ
✂แยกตามมิติแบทช์โดยอัตโนมัติเป็นตัวเลขที่เป็นมิตรกับ GPU (พลังของ 2) เพื่อเพิ่มความเร็วในการดำเนินการ
- API ขั้นต่ำ (การห่ออินพุตทั้งหมดจะเพียงพอ)
เคยพบ RuntimeError: CUDA error: out of memory ไม่? เราทุกคนรัก PyTorch เพราะความเร็วประสิทธิภาพและความโปร่งใส แต่นั่นหมายความว่ามันไม่ได้ทำสิ่งพิเศษ สิ่งต่าง ๆ เช่นการป้องกันข้อผิดพลาดที่พบบ่อยมากซึ่งรบกวนผู้ใช้จำนวนมากตั้งแต่ปี 2560
ห้องสมุดนี้มีจุดมุ่งหมายเพื่อป้องกันไม่ให้เป็นเสื้อคลุมน้ำหนักเบาเหนือ PyTorch พื้นเมือง เมื่อมีการห่อเทนเซอร์ไลบรารี จะคำนวณปริมาณหน่วยความจำ GPU ที่เหลืออยู่โดยอัตโนมัติและใช้ขนาดแบทช์ที่เหมาะสมโดย อัตโนมัติช่วยให้ทุกคนไม่ต้องปรับขนาดแบทช์ด้วยตนเองเมื่อใดก็ตามที่ใช้โมเดล
นอกจากนี้ห้องสมุดยังใช้ขนาดแบทช์ที่เหมาะสมกับ GPU โดยอัตโนมัติ คุณรู้หรือไม่ว่าการใช้แบทช์ที่ใหญ่กว่านั้นไม่ได้เร่งการประมวลผลเสมอไป? มันได้รับการจัดการโดยอัตโนมัติในห้องสมุดนี้ด้วย
เนื่องจากรหัส Koila เป็นรหัส PyTorch เนื่องจากมันทำงาน PyTorch ใต้ฮูดคุณสามารถใช้ทั้งสองอย่างด้วยกันโดยไม่ต้องกังวลกับความเข้ากันได้
โอ้และทั้งหมดที่อยู่ใน 1 บรรทัดของรหัส! -
Koila มีอยู่ใน PYPI ในการติดตั้งให้เรียกใช้คำสั่งต่อไปนี้
pip install koila การใช้งานง่ายตาย ตัวอย่างเช่นคุณมีรหัส PyTorch ต่อไปนี้ (คัดลอกจากบทช่วยสอนของ PyTorch )
กำหนดอินพุตฉลากและรุ่น:
# A batch of MNIST image
input = torch . randn ( 8 , 28 , 28 )
# A batch of labels
label = torch . randn ( 0 , 10 , [ 8 ])
class NeuralNetwork ( Module ):
def __init__ ( self ):
super ( NeuralNetwork , self ). __init__ ()
self . flatten = Flatten ()
self . linear_relu_stack = Sequential (
Linear ( 28 * 28 , 512 ),
ReLU (),
Linear ( 512 , 512 ),
ReLU (),
Linear ( 512 , 10 ),
)
def forward ( self , x ):
x = self . flatten ( x )
logits = self . linear_relu_stack ( x )
return logitsกำหนดฟังก์ชั่นการสูญเสียคำนวณเอาต์พุตและการสูญเสีย
loss_fn = CrossEntropyLoss ()
# Calculate losses
out = nn ( t )
loss = loss_fn ( out , label )
# Backward pass
nn . zero_grad ()
loss . backward () ตกลง. จะปรับรหัสเพื่อใช้คุณสมบัติของ Koila ได้อย่างไร?
คุณเพิ่มบรรทัดของรหัสนี้ (เป็นของ v0.1.1):
# Wrap the input tensor and label tensor.
# If a batch argument is provided, that dimension of the tensor would be treated as the batch.
# In this case, the first dimension (dim=0) is used as batch's dimension.
( input , label ) = lazy ( input , label , batch = 0 )เสร็จแล้ว. คุณจะไม่หมดหน่วยความจำอีกแล้ว
CUDA error: out of memory จะเกิดขึ้นในการส่งต่อไปข้างหน้าเนื่องจากตัวแปรชั่วคราวจะต้องถูกบันทึกไว้ในหน่วยความจำ
Koila เป็นเสื้อคลุมบาง ๆ รอบ PyTorch มันได้รับแรงบันดาลใจจากการประเมินแบบคงที่/ขี้เกียจของ Tensorflow โดยการสร้างกราฟก่อนและเรียกใช้โมเดลเฉพาะเมื่อจำเป็นต้องใช้โมเดลสามารถเข้าถึงข้อมูลทั้งหมดจำเป็นต้องกำหนดจำนวนทรัพยากรที่จำเป็นในการคำนวณแบบจำลอง
ในแง่ของการใช้หน่วยความจำ จำเป็นต้องมีเพียงรูปร่างของตัวแปรชั่วคราวเพื่อคำนวณการใช้หน่วยความจำของตัวแปรเหล่านั้นที่ใช้ในโมเดล ตัวอย่างเช่น + ใช้สองเทนเซอร์ที่มีขนาดเท่ากันและส่งออกเทนเซอร์ที่มีขนาดเท่ากับขนาดอินพุตและ log จะใช้ในเทนเซอร์เดียวและส่งออกเทนเซอร์อื่นที่มีรูปร่างเดียวกัน การออกอากาศทำให้มันซับซ้อนกว่านั้นเล็กน้อย แต่ความคิดทั่วไปเหมือนกัน โดยการติดตามรูปร่างเหล่านี้ทั้งหมดสามารถบอกได้อย่างง่ายดายว่าใช้หน่วยความจำในการส่งต่อ และเลือกขนาดแบทช์ที่เหมาะสมตามลำดับ
เลขที่ . อันที่จริงการคำนวณรูปร่างและการคำนวณขนาดและการใช้หน่วยความจำเสียงเหมือนงานมาก อย่างไรก็ตามโปรดทราบว่าแม้แต่รุ่นมหึมาเช่น GPT-3 ซึ่งมี 96 ชั้นมีเพียงไม่กี่ร้อยโหนดในกราฟการคำนวณ เนื่องจากอัลกอริทึมของ Koila ทำงานในเวลาเชิงเส้นคอมพิวเตอร์ที่ทันสมัยจะสามารถจัดการกราฟเช่นนี้ได้ทันที
การคำนวณส่วนใหญ่ใช้ในการคำนวณแต่ละเทนเซอร์และถ่ายโอนเทนเซอร์ข้ามอุปกรณ์ และโปรดจำไว้ว่าการตรวจสอบเหล่านั้นเกิดขึ้นใน Vanilla PyTorch ต่อไป ดังนั้นไม่ไม่ช้าเลย
โครงการนี้มีชื่อว่า Koala ซึ่งเป็นสายพันธุ์ที่ขี้เกียจที่สุดในโลกและโครงการนี้เกี่ยวกับการประเมินเทนเซอร์ที่ขี้เกียจ อย่างไรก็ตามเมื่อชื่อนั้นถูกนำไปใช้ใน PYPI ฉันไม่มีทางเลือกนอกจากใช้ชื่ออื่น Koila เป็นคำที่สร้างขึ้นโดยฉันออกเสียงคล้ายกับ voila (มันเป็นคำภาษาฝรั่งเศส) ดังนั้นจึงฟังดูเหมือนโคอาล่า
หากคุณชอบสิ่งที่คุณเห็นโปรดพิจารณาให้ดาวนี้ (★)!
ทำไมฉันถึงต้องเผชิญกับปัญหาและสร้างโครงการนี้แม้จะมีห้องสมุดที่คล้ายกันมากมายบนอินเทอร์เน็ต?
การค้นหาขนาดแบทช์ไม่ใช่เรื่องใหม่ ในความเป็นจริงสายฟ้าที่เป็นที่นิยมอย่างยิ่งใหญ่มี
การค้นหาขนาดแบทช์ของ Lightning นั้นถูกรวมเข้ากับระบบนิเวศของตัวเองอย่างลึกซึ้ง คุณต้องใช้ DataLoader subclass จากโมเดลของพวกเขาและฝึกอบรมโมเดลของคุณตามนั้น ในขณะที่การปรับโครงสร้างการเรียนรู้ที่มีการควบคุมดูแลเพื่อใช้ฟ้าผ่านั้นค่อนข้างง่าย แต่มันก็เจ็บปวดมากที่จะทำเช่นเดียวกันกับฐานรหัสการเรียนรู้เสริมแรงซึ่งการมีปฏิสัมพันธ์กับสภาพแวดล้อมเป็นสิ่งจำเป็น
ในการเปรียบเทียบเนื่องจาก Koila เป็น wrapper pytorch ที่มีน้ำหนักเบาสุด ๆ มันทำงานได้เมื่อ Pytorch ทำงานได้ดังนั้นจึงให้ความยืดหยุ่นสูงสุดและการเปลี่ยนแปลงที่น้อยที่สุดกับรหัสที่มีอยู่
อย่างไรก็ตามโปรดทราบว่าในกรณีที่คุณกำลังเขียนโค้ดใหม่ขอแนะนำให้สายฟ้าเนื่องจากมันบังคับใช้รูปแบบของรูปแบบรหัสที่ดีขึ้นซึ่งจะเป็นประโยชน์ต่อโมดูลในระยะยาว
ในทำนองเดียวกันการผ่านเทนเซอร์ที่ว่างเปล่าเพื่อสร้างกราฟการคำนวณ ( กราฟคงที่หรือที่เรียกว่ากราฟคงที่ ) ไม่ใช่ความคิดใหม่ แต่สำรวจอย่างละเอียดในห้องสมุด PyTorch ยอดนิยม ห้องสมุดเหล่านี้ประสบกับข้อเท็จจริงที่ว่าการดีบักโปรแกรมในนั้นมีความซับซ้อนโดยไม่จำเป็น ตัวอย่างเช่น TensorFlow เป็นที่รู้จักกันดีในการปรับใช้ แต่ความเจ็บปวดในการพัฒนาจนถึงจุดที่ผู้ใช้เปลี่ยนมาใช้ PyTorch ในระหว่างการดีบักผู้คนชอบดูว่ามีอะไร อยู่ใน ตัวแปรเพื่อดูว่ามีค่าที่ไม่ถูกต้องหรือไม่ อย่างไรก็ตามเนื่องจากกราฟคงที่เพียงกำหนดความสัมพันธ์ค่าไม่ได้คำนวณจึงทำให้การดีบักยาก
Koila แก้ปัญหาโดยการประเมินอย่างกระตือรือร้นเมื่อถูกแปลงเป็นสตริงจำนวนเต็มหรือค่างูหลามใด ๆ สิ่งนี้ช่วยให้การดีบักไร้รอยต่อในขณะที่ยังคงความสามารถในการจัดการหน่วยความจำที่ไม่สามารถใช้งานได้สำหรับโปรแกรม PyTorch ไปข้างหน้ามากขึ้นซึ่งเป็นแบบไดนามิก (เมื่อจำเป็น) จัดสรรและปลดปล่อยหน่วยความจำทันที
Tensor S และ LazyTensor S) รหัสใช้งานได้หลายกรณี แต่ก็ยังอยู่ระหว่างดำเนินการอยู่ นี่ไม่ใช่ (ยัง) ห้องสมุดที่เข้า PyTorch ได้อย่างเต็มที่เนื่องจากเวลา จำกัด หลีกเลี่ยงการใช้ในสภาพแวดล้อมการผลิต!
การเปิดกว้างและความละม้ายคล้ายคลึงกันอย่างจริงจัง รหัสมีอยู่ภายใต้ใบอนุญาต Apache โปรดปฏิบัติตามจรรยาบรรณต่อไปนี้
